Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Driver for Microchip USB251xB USB 2.0 Hi-Speed Hub Controller
0004  * Configuration via SMBus.
0005  *
0006  * Copyright (c) 2017 SKIDATA AG
0007  *
0008  * This work is based on the USB3503 driver by Dongjin Kim and
0009  * a not-accepted patch by Fabien Lahoudere, see:
0010  * https://patchwork.kernel.org/patch/9257715/
0011  */
0012 
0013 #include <linux/delay.h>
0014 #include <linux/gpio/consumer.h>
0015 #include <linux/gpio/driver.h>
0016 #include <linux/i2c.h>
0017 #include <linux/module.h>
0018 #include <linux/nls.h>
0019 #include <linux/of_device.h>
0020 #include <linux/regulator/consumer.h>
0021 #include <linux/slab.h>
0022 
0023 /* Internal Register Set Addresses & Default Values acc. to DS00001692C */
0024 #define USB251XB_ADDR_VENDOR_ID_LSB 0x00
0025 #define USB251XB_ADDR_VENDOR_ID_MSB 0x01
0026 #define USB251XB_DEF_VENDOR_ID      0x0424
0027 
0028 #define USB251XB_ADDR_PRODUCT_ID_LSB    0x02
0029 #define USB251XB_ADDR_PRODUCT_ID_MSB    0x03
0030 
0031 #define USB251XB_ADDR_DEVICE_ID_LSB 0x04
0032 #define USB251XB_ADDR_DEVICE_ID_MSB 0x05
0033 #define USB251XB_DEF_DEVICE_ID      0x0BB3
0034 
0035 #define USB251XB_ADDR_CONFIG_DATA_1 0x06
0036 #define USB251XB_DEF_CONFIG_DATA_1  0x9B
0037 #define USB251XB_ADDR_CONFIG_DATA_2 0x07
0038 #define USB251XB_DEF_CONFIG_DATA_2  0x20
0039 #define USB251XB_ADDR_CONFIG_DATA_3 0x08
0040 #define USB251XB_DEF_CONFIG_DATA_3  0x02
0041 
0042 #define USB251XB_ADDR_NON_REMOVABLE_DEVICES 0x09
0043 #define USB251XB_DEF_NON_REMOVABLE_DEVICES  0x00
0044 
0045 #define USB251XB_ADDR_PORT_DISABLE_SELF 0x0A
0046 #define USB251XB_DEF_PORT_DISABLE_SELF  0x00
0047 #define USB251XB_ADDR_PORT_DISABLE_BUS  0x0B
0048 #define USB251XB_DEF_PORT_DISABLE_BUS   0x00
0049 
0050 #define USB251XB_ADDR_MAX_POWER_SELF    0x0C
0051 #define USB251XB_DEF_MAX_POWER_SELF 0x01
0052 #define USB251XB_ADDR_MAX_POWER_BUS 0x0D
0053 #define USB251XB_DEF_MAX_POWER_BUS  0x32
0054 
0055 #define USB251XB_ADDR_MAX_CURRENT_SELF  0x0E
0056 #define USB251XB_DEF_MAX_CURRENT_SELF   0x01
0057 #define USB251XB_ADDR_MAX_CURRENT_BUS   0x0F
0058 #define USB251XB_DEF_MAX_CURRENT_BUS    0x32
0059 
0060 #define USB251XB_ADDR_POWER_ON_TIME 0x10
0061 #define USB251XB_DEF_POWER_ON_TIME  0x32
0062 
0063 #define USB251XB_ADDR_LANGUAGE_ID_HIGH  0x11
0064 #define USB251XB_ADDR_LANGUAGE_ID_LOW   0x12
0065 #define USB251XB_DEF_LANGUAGE_ID    0x0000
0066 
0067 #define USB251XB_STRING_BUFSIZE         62
0068 #define USB251XB_ADDR_MANUFACTURER_STRING_LEN   0x13
0069 #define USB251XB_ADDR_MANUFACTURER_STRING   0x16
0070 #define USB251XB_DEF_MANUFACTURER_STRING    "Microchip"
0071 
0072 #define USB251XB_ADDR_PRODUCT_STRING_LEN    0x14
0073 #define USB251XB_ADDR_PRODUCT_STRING        0x54
0074 
0075 #define USB251XB_ADDR_SERIAL_STRING_LEN     0x15
0076 #define USB251XB_ADDR_SERIAL_STRING     0x92
0077 #define USB251XB_DEF_SERIAL_STRING      ""
0078 
0079 #define USB251XB_ADDR_BATTERY_CHARGING_ENABLE   0xD0
0080 #define USB251XB_DEF_BATTERY_CHARGING_ENABLE    0x00
0081 
0082 #define USB251XB_ADDR_BOOST_UP  0xF6
0083 #define USB251XB_DEF_BOOST_UP   0x00
0084 #define USB251XB_ADDR_BOOST_57  0xF7
0085 #define USB251XB_DEF_BOOST_57   0x00
0086 #define USB251XB_ADDR_BOOST_14  0xF8
0087 #define USB251XB_DEF_BOOST_14   0x00
0088 
0089 #define USB251XB_ADDR_PORT_SWAP 0xFA
0090 #define USB251XB_DEF_PORT_SWAP  0x00
0091 
0092 #define USB251XB_ADDR_PORT_MAP_12   0xFB
0093 #define USB251XB_DEF_PORT_MAP_12    0x00
0094 #define USB251XB_ADDR_PORT_MAP_34   0xFC
0095 #define USB251XB_DEF_PORT_MAP_34    0x00 /* USB251{3B/i,4B/i,7/i} only */
0096 #define USB251XB_ADDR_PORT_MAP_56   0xFD
0097 #define USB251XB_DEF_PORT_MAP_56    0x00 /* USB2517/i only */
0098 #define USB251XB_ADDR_PORT_MAP_7    0xFE
0099 #define USB251XB_DEF_PORT_MAP_7     0x00 /* USB2517/i only */
0100 
0101 #define USB251XB_ADDR_STATUS_COMMAND        0xFF
0102 #define USB251XB_STATUS_COMMAND_SMBUS_DOWN  0x04
0103 #define USB251XB_STATUS_COMMAND_RESET       0x02
0104 #define USB251XB_STATUS_COMMAND_ATTACH      0x01
0105 
0106 #define USB251XB_I2C_REG_SZ 0x100
0107 #define USB251XB_I2C_WRITE_SZ   0x10
0108 
0109 #define DRIVER_NAME "usb251xb"
0110 #define DRIVER_DESC "Microchip USB 2.0 Hi-Speed Hub Controller"
0111 
0112 struct usb251xb {
0113     struct device *dev;
0114     struct i2c_client *i2c;
0115     struct regulator *vdd;
0116     u8 skip_config;
0117     struct gpio_desc *gpio_reset;
0118     u16 vendor_id;
0119     u16 product_id;
0120     u16 device_id;
0121     u8  conf_data1;
0122     u8  conf_data2;
0123     u8  conf_data3;
0124     u8  non_rem_dev;
0125     u8  port_disable_sp;
0126     u8  port_disable_bp;
0127     u8  max_power_sp;
0128     u8  max_power_bp;
0129     u8  max_current_sp;
0130     u8  max_current_bp;
0131     u8  power_on_time;
0132     u16 lang_id;
0133     u8 manufacturer_len;
0134     u8 product_len;
0135     u8 serial_len;
0136     char manufacturer[USB251XB_STRING_BUFSIZE];
0137     char product[USB251XB_STRING_BUFSIZE];
0138     char serial[USB251XB_STRING_BUFSIZE];
0139     u8  bat_charge_en;
0140     u8  boost_up;
0141     u8  boost_57;
0142     u8  boost_14;
0143     u8  port_swap;
0144     u8  port_map12;
0145     u8  port_map34;
0146     u8  port_map56;
0147     u8  port_map7;
0148     u8  status;
0149 };
0150 
0151 struct usb251xb_data {
0152     u16 product_id;
0153     u8 port_cnt;
0154     bool led_support;
0155     bool bat_support;
0156     char product_str[USB251XB_STRING_BUFSIZE / 2]; /* ASCII string */
0157 };
0158 
0159 static const struct usb251xb_data usb2422_data = {
0160     .product_id = 0x2422,
0161     .port_cnt = 2,
0162     .led_support = false,
0163     .bat_support = true,
0164     .product_str = "USB2422",
0165 };
0166 
0167 static const struct usb251xb_data usb2512b_data = {
0168     .product_id = 0x2512,
0169     .port_cnt = 2,
0170     .led_support = false,
0171     .bat_support = true,
0172     .product_str = "USB2512B",
0173 };
0174 
0175 static const struct usb251xb_data usb2512bi_data = {
0176     .product_id = 0x2512,
0177     .port_cnt = 2,
0178     .led_support = false,
0179     .bat_support = true,
0180     .product_str = "USB2512Bi",
0181 };
0182 
0183 static const struct usb251xb_data usb2513b_data = {
0184     .product_id = 0x2513,
0185     .port_cnt = 3,
0186     .led_support = false,
0187     .bat_support = true,
0188     .product_str = "USB2513B",
0189 };
0190 
0191 static const struct usb251xb_data usb2513bi_data = {
0192     .product_id = 0x2513,
0193     .port_cnt = 3,
0194     .led_support = false,
0195     .bat_support = true,
0196     .product_str = "USB2513Bi",
0197 };
0198 
0199 static const struct usb251xb_data usb2514b_data = {
0200     .product_id = 0x2514,
0201     .port_cnt = 4,
0202     .led_support = false,
0203     .bat_support = true,
0204     .product_str = "USB2514B",
0205 };
0206 
0207 static const struct usb251xb_data usb2514bi_data = {
0208     .product_id = 0x2514,
0209     .port_cnt = 4,
0210     .led_support = false,
0211     .bat_support = true,
0212     .product_str = "USB2514Bi",
0213 };
0214 
0215 static const struct usb251xb_data usb2517_data = {
0216     .product_id = 0x2517,
0217     .port_cnt = 7,
0218     .led_support = true,
0219     .bat_support = false,
0220     .product_str = "USB2517",
0221 };
0222 
0223 static const struct usb251xb_data usb2517i_data = {
0224     .product_id = 0x2517,
0225     .port_cnt = 7,
0226     .led_support = true,
0227     .bat_support = false,
0228     .product_str = "USB2517i",
0229 };
0230 
0231 #ifdef CONFIG_GPIOLIB
0232 static int usb251xb_check_dev_children(struct device *dev, void *child)
0233 {
0234     if (dev->type == &i2c_adapter_type) {
0235         return device_for_each_child(dev, child,
0236                          usb251xb_check_dev_children);
0237     }
0238 
0239     return (dev == child);
0240 }
0241 
0242 static int usb251x_check_gpio_chip(struct usb251xb *hub)
0243 {
0244     struct gpio_chip *gc = gpiod_to_chip(hub->gpio_reset);
0245     struct i2c_adapter *adap = hub->i2c->adapter;
0246     int ret;
0247 
0248     if (!hub->gpio_reset)
0249         return 0;
0250 
0251     if (!gc)
0252         return -EINVAL;
0253 
0254     ret = usb251xb_check_dev_children(&adap->dev, gc->parent);
0255     if (ret) {
0256         dev_err(hub->dev, "Reset GPIO chip is at the same i2c-bus\n");
0257         return -EINVAL;
0258     }
0259 
0260     return 0;
0261 }
0262 #else
0263 static int usb251x_check_gpio_chip(struct usb251xb *hub)
0264 {
0265     return 0;
0266 }
0267 #endif
0268 
0269 static void usb251xb_reset(struct usb251xb *hub)
0270 {
0271     if (!hub->gpio_reset)
0272         return;
0273 
0274     i2c_lock_bus(hub->i2c->adapter, I2C_LOCK_SEGMENT);
0275 
0276     gpiod_set_value_cansleep(hub->gpio_reset, 1);
0277     usleep_range(1, 10);    /* >=1us RESET_N asserted */
0278     gpiod_set_value_cansleep(hub->gpio_reset, 0);
0279 
0280     /* wait for hub recovery/stabilization */
0281     usleep_range(500, 750); /* >=500us after RESET_N deasserted */
0282 
0283     i2c_unlock_bus(hub->i2c->adapter, I2C_LOCK_SEGMENT);
0284 }
0285 
0286 static int usb251xb_connect(struct usb251xb *hub)
0287 {
0288     struct device *dev = hub->dev;
0289     int err, i;
0290     char i2c_wb[USB251XB_I2C_REG_SZ];
0291 
0292     memset(i2c_wb, 0, USB251XB_I2C_REG_SZ);
0293 
0294     if (hub->skip_config) {
0295         dev_info(dev, "Skip hub configuration, only attach.\n");
0296         i2c_wb[0] = 0x01;
0297         i2c_wb[1] = USB251XB_STATUS_COMMAND_ATTACH;
0298 
0299         usb251xb_reset(hub);
0300 
0301         err = i2c_smbus_write_i2c_block_data(hub->i2c,
0302                 USB251XB_ADDR_STATUS_COMMAND, 2, i2c_wb);
0303         if (err) {
0304             dev_err(dev, "attaching hub failed: %d\n", err);
0305             return err;
0306         }
0307         return 0;
0308     }
0309 
0310     i2c_wb[USB251XB_ADDR_VENDOR_ID_MSB]     = (hub->vendor_id >> 8) & 0xFF;
0311     i2c_wb[USB251XB_ADDR_VENDOR_ID_LSB]     = hub->vendor_id & 0xFF;
0312     i2c_wb[USB251XB_ADDR_PRODUCT_ID_MSB]    = (hub->product_id >> 8) & 0xFF;
0313     i2c_wb[USB251XB_ADDR_PRODUCT_ID_LSB]    = hub->product_id & 0xFF;
0314     i2c_wb[USB251XB_ADDR_DEVICE_ID_MSB]     = (hub->device_id >> 8) & 0xFF;
0315     i2c_wb[USB251XB_ADDR_DEVICE_ID_LSB]     = hub->device_id & 0xFF;
0316     i2c_wb[USB251XB_ADDR_CONFIG_DATA_1]     = hub->conf_data1;
0317     i2c_wb[USB251XB_ADDR_CONFIG_DATA_2]     = hub->conf_data2;
0318     i2c_wb[USB251XB_ADDR_CONFIG_DATA_3]     = hub->conf_data3;
0319     i2c_wb[USB251XB_ADDR_NON_REMOVABLE_DEVICES] = hub->non_rem_dev;
0320     i2c_wb[USB251XB_ADDR_PORT_DISABLE_SELF] = hub->port_disable_sp;
0321     i2c_wb[USB251XB_ADDR_PORT_DISABLE_BUS]  = hub->port_disable_bp;
0322     i2c_wb[USB251XB_ADDR_MAX_POWER_SELF]    = hub->max_power_sp;
0323     i2c_wb[USB251XB_ADDR_MAX_POWER_BUS]     = hub->max_power_bp;
0324     i2c_wb[USB251XB_ADDR_MAX_CURRENT_SELF]  = hub->max_current_sp;
0325     i2c_wb[USB251XB_ADDR_MAX_CURRENT_BUS]   = hub->max_current_bp;
0326     i2c_wb[USB251XB_ADDR_POWER_ON_TIME]     = hub->power_on_time;
0327     i2c_wb[USB251XB_ADDR_LANGUAGE_ID_HIGH]  = (hub->lang_id >> 8) & 0xFF;
0328     i2c_wb[USB251XB_ADDR_LANGUAGE_ID_LOW]   = hub->lang_id & 0xFF;
0329     i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING_LEN] = hub->manufacturer_len;
0330     i2c_wb[USB251XB_ADDR_PRODUCT_STRING_LEN]      = hub->product_len;
0331     i2c_wb[USB251XB_ADDR_SERIAL_STRING_LEN]       = hub->serial_len;
0332     memcpy(&i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING], hub->manufacturer,
0333            USB251XB_STRING_BUFSIZE);
0334     memcpy(&i2c_wb[USB251XB_ADDR_SERIAL_STRING], hub->serial,
0335            USB251XB_STRING_BUFSIZE);
0336     memcpy(&i2c_wb[USB251XB_ADDR_PRODUCT_STRING], hub->product,
0337            USB251XB_STRING_BUFSIZE);
0338     i2c_wb[USB251XB_ADDR_BATTERY_CHARGING_ENABLE] = hub->bat_charge_en;
0339     i2c_wb[USB251XB_ADDR_BOOST_UP]          = hub->boost_up;
0340     i2c_wb[USB251XB_ADDR_BOOST_57]          = hub->boost_57;
0341     i2c_wb[USB251XB_ADDR_BOOST_14]          = hub->boost_14;
0342     i2c_wb[USB251XB_ADDR_PORT_SWAP]         = hub->port_swap;
0343     i2c_wb[USB251XB_ADDR_PORT_MAP_12]       = hub->port_map12;
0344     i2c_wb[USB251XB_ADDR_PORT_MAP_34]       = hub->port_map34;
0345     i2c_wb[USB251XB_ADDR_PORT_MAP_56]       = hub->port_map56;
0346     i2c_wb[USB251XB_ADDR_PORT_MAP_7]        = hub->port_map7;
0347     i2c_wb[USB251XB_ADDR_STATUS_COMMAND] = USB251XB_STATUS_COMMAND_ATTACH;
0348 
0349     usb251xb_reset(hub);
0350 
0351     /* write registers */
0352     for (i = 0; i < (USB251XB_I2C_REG_SZ / USB251XB_I2C_WRITE_SZ); i++) {
0353         int offset = i * USB251XB_I2C_WRITE_SZ;
0354         char wbuf[USB251XB_I2C_WRITE_SZ + 1];
0355 
0356         /* The first data byte transferred tells the hub how many data
0357          * bytes will follow (byte count).
0358          */
0359         wbuf[0] = USB251XB_I2C_WRITE_SZ;
0360         memcpy(&wbuf[1], &i2c_wb[offset], USB251XB_I2C_WRITE_SZ);
0361 
0362         dev_dbg(dev, "writing %d byte block %d to 0x%02X\n",
0363             USB251XB_I2C_WRITE_SZ, i, offset);
0364 
0365         err = i2c_smbus_write_i2c_block_data(hub->i2c, offset,
0366                              USB251XB_I2C_WRITE_SZ + 1,
0367                              wbuf);
0368         if (err)
0369             goto out_err;
0370     }
0371 
0372     dev_info(dev, "Hub configuration was successful.\n");
0373     return 0;
0374 
0375 out_err:
0376     dev_err(dev, "configuring block %d failed: %d\n", i, err);
0377     return err;
0378 }
0379 
0380 #ifdef CONFIG_OF
0381 static void usb251xb_get_ports_field(struct usb251xb *hub,
0382                     const char *prop_name, u8 port_cnt,
0383                     bool ds_only, u8 *fld)
0384 {
0385     struct device *dev = hub->dev;
0386     struct property *prop;
0387     const __be32 *p;
0388     u32 port;
0389 
0390     of_property_for_each_u32(dev->of_node, prop_name, prop, p, port) {
0391         if ((port >= ds_only ? 1 : 0) && (port <= port_cnt))
0392             *fld |= BIT(port);
0393         else
0394             dev_warn(dev, "port %u doesn't exist\n", port);
0395     }
0396 }
0397 
0398 static int usb251xb_get_ofdata(struct usb251xb *hub,
0399                    const struct usb251xb_data *data)
0400 {
0401     struct device *dev = hub->dev;
0402     struct device_node *np = dev->of_node;
0403     int len, err;
0404     u32 property_u32 = 0;
0405     const char *cproperty_char;
0406     char str[USB251XB_STRING_BUFSIZE / 2];
0407 
0408     if (!np) {
0409         dev_err(dev, "failed to get ofdata\n");
0410         return -ENODEV;
0411     }
0412 
0413     if (of_get_property(np, "skip-config", NULL))
0414         hub->skip_config = 1;
0415     else
0416         hub->skip_config = 0;
0417 
0418     hub->gpio_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
0419     if (PTR_ERR(hub->gpio_reset) == -EPROBE_DEFER) {
0420         return -EPROBE_DEFER;
0421     } else if (IS_ERR(hub->gpio_reset)) {
0422         err = PTR_ERR(hub->gpio_reset);
0423         dev_err(dev, "unable to request GPIO reset pin (%d)\n", err);
0424         return err;
0425     }
0426 
0427     if (of_property_read_u16_array(np, "vendor-id", &hub->vendor_id, 1))
0428         hub->vendor_id = USB251XB_DEF_VENDOR_ID;
0429 
0430     if (of_property_read_u16_array(np, "product-id",
0431                        &hub->product_id, 1))
0432         hub->product_id = data->product_id;
0433 
0434     if (of_property_read_u16_array(np, "device-id", &hub->device_id, 1))
0435         hub->device_id = USB251XB_DEF_DEVICE_ID;
0436 
0437     hub->conf_data1 = USB251XB_DEF_CONFIG_DATA_1;
0438     if (of_get_property(np, "self-powered", NULL)) {
0439         hub->conf_data1 |= BIT(7);
0440 
0441         /* Configure Over-Current sens when self-powered */
0442         hub->conf_data1 &= ~BIT(2);
0443         if (of_get_property(np, "ganged-sensing", NULL))
0444             hub->conf_data1 &= ~BIT(1);
0445         else if (of_get_property(np, "individual-sensing", NULL))
0446             hub->conf_data1 |= BIT(1);
0447     } else if (of_get_property(np, "bus-powered", NULL)) {
0448         hub->conf_data1 &= ~BIT(7);
0449 
0450         /* Disable Over-Current sense when bus-powered */
0451         hub->conf_data1 |= BIT(2);
0452     }
0453 
0454     if (of_get_property(np, "disable-hi-speed", NULL))
0455         hub->conf_data1 |= BIT(5);
0456 
0457     if (of_get_property(np, "multi-tt", NULL))
0458         hub->conf_data1 |= BIT(4);
0459     else if (of_get_property(np, "single-tt", NULL))
0460         hub->conf_data1 &= ~BIT(4);
0461 
0462     if (of_get_property(np, "disable-eop", NULL))
0463         hub->conf_data1 |= BIT(3);
0464 
0465     if (of_get_property(np, "individual-port-switching", NULL))
0466         hub->conf_data1 |= BIT(0);
0467     else if (of_get_property(np, "ganged-port-switching", NULL))
0468         hub->conf_data1 &= ~BIT(0);
0469 
0470     hub->conf_data2 = USB251XB_DEF_CONFIG_DATA_2;
0471     if (of_get_property(np, "dynamic-power-switching", NULL))
0472         hub->conf_data2 |= BIT(7);
0473 
0474     if (!of_property_read_u32(np, "oc-delay-us", &property_u32)) {
0475         if (property_u32 == 100) {
0476             /* 100 us*/
0477             hub->conf_data2 &= ~BIT(5);
0478             hub->conf_data2 &= ~BIT(4);
0479         } else if (property_u32 == 4000) {
0480             /* 4 ms */
0481             hub->conf_data2 &= ~BIT(5);
0482             hub->conf_data2 |= BIT(4);
0483         } else if (property_u32 == 16000) {
0484             /* 16 ms */
0485             hub->conf_data2 |= BIT(5);
0486             hub->conf_data2 |= BIT(4);
0487         } else {
0488             /* 8 ms (DEFAULT) */
0489             hub->conf_data2 |= BIT(5);
0490             hub->conf_data2 &= ~BIT(4);
0491         }
0492     }
0493 
0494     if (of_get_property(np, "compound-device", NULL))
0495         hub->conf_data2 |= BIT(3);
0496 
0497     hub->conf_data3 = USB251XB_DEF_CONFIG_DATA_3;
0498     if (of_get_property(np, "port-mapping-mode", NULL))
0499         hub->conf_data3 |= BIT(3);
0500 
0501     if (data->led_support && of_get_property(np, "led-usb-mode", NULL))
0502         hub->conf_data3 &= ~BIT(1);
0503 
0504     if (of_get_property(np, "string-support", NULL))
0505         hub->conf_data3 |= BIT(0);
0506 
0507     hub->non_rem_dev = USB251XB_DEF_NON_REMOVABLE_DEVICES;
0508     usb251xb_get_ports_field(hub, "non-removable-ports", data->port_cnt,
0509                  true, &hub->non_rem_dev);
0510 
0511     hub->port_disable_sp = USB251XB_DEF_PORT_DISABLE_SELF;
0512     usb251xb_get_ports_field(hub, "sp-disabled-ports", data->port_cnt,
0513                  true, &hub->port_disable_sp);
0514 
0515     hub->port_disable_bp = USB251XB_DEF_PORT_DISABLE_BUS;
0516     usb251xb_get_ports_field(hub, "bp-disabled-ports", data->port_cnt,
0517                  true, &hub->port_disable_bp);
0518 
0519     hub->max_power_sp = USB251XB_DEF_MAX_POWER_SELF;
0520     if (!of_property_read_u32(np, "sp-max-total-current-microamp",
0521         &property_u32))
0522         hub->max_power_sp = min_t(u8, property_u32 / 2000, 50);
0523 
0524     hub->max_power_bp = USB251XB_DEF_MAX_POWER_BUS;
0525     if (!of_property_read_u32(np, "bp-max-total-current-microamp",
0526         &property_u32))
0527         hub->max_power_bp = min_t(u8, property_u32 / 2000, 255);
0528 
0529     hub->max_current_sp = USB251XB_DEF_MAX_CURRENT_SELF;
0530     if (!of_property_read_u32(np, "sp-max-removable-current-microamp",
0531         &property_u32))
0532         hub->max_current_sp = min_t(u8, property_u32 / 2000, 50);
0533 
0534     hub->max_current_bp = USB251XB_DEF_MAX_CURRENT_BUS;
0535     if (!of_property_read_u32(np, "bp-max-removable-current-microamp",
0536         &property_u32))
0537         hub->max_current_bp = min_t(u8, property_u32 / 2000, 255);
0538 
0539     hub->power_on_time = USB251XB_DEF_POWER_ON_TIME;
0540     if (!of_property_read_u32(np, "power-on-time-ms", &property_u32))
0541         hub->power_on_time = min_t(u8, property_u32 / 2, 255);
0542 
0543     if (of_property_read_u16_array(np, "language-id", &hub->lang_id, 1))
0544         hub->lang_id = USB251XB_DEF_LANGUAGE_ID;
0545 
0546     if (of_property_read_u8(np, "boost-up", &hub->boost_up))
0547         hub->boost_up = USB251XB_DEF_BOOST_UP;
0548 
0549     cproperty_char = of_get_property(np, "manufacturer", NULL);
0550     strlcpy(str, cproperty_char ? : USB251XB_DEF_MANUFACTURER_STRING,
0551         sizeof(str));
0552     hub->manufacturer_len = strlen(str) & 0xFF;
0553     memset(hub->manufacturer, 0, USB251XB_STRING_BUFSIZE);
0554     len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str));
0555     len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN,
0556                   (wchar_t *)hub->manufacturer,
0557                   USB251XB_STRING_BUFSIZE);
0558 
0559     cproperty_char = of_get_property(np, "product", NULL);
0560     strlcpy(str, cproperty_char ? : data->product_str, sizeof(str));
0561     hub->product_len = strlen(str) & 0xFF;
0562     memset(hub->product, 0, USB251XB_STRING_BUFSIZE);
0563     len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str));
0564     len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN,
0565                   (wchar_t *)hub->product,
0566                   USB251XB_STRING_BUFSIZE);
0567 
0568     cproperty_char = of_get_property(np, "serial", NULL);
0569     strlcpy(str, cproperty_char ? : USB251XB_DEF_SERIAL_STRING,
0570         sizeof(str));
0571     hub->serial_len = strlen(str) & 0xFF;
0572     memset(hub->serial, 0, USB251XB_STRING_BUFSIZE);
0573     len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str));
0574     len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN,
0575                   (wchar_t *)hub->serial,
0576                   USB251XB_STRING_BUFSIZE);
0577 
0578     /*
0579      * The datasheet documents the register as 'Port Swap' but in real the
0580      * register controls the USB DP/DM signal swapping for each port.
0581      */
0582     hub->port_swap = USB251XB_DEF_PORT_SWAP;
0583     usb251xb_get_ports_field(hub, "swap-dx-lanes", data->port_cnt,
0584                  false, &hub->port_swap);
0585 
0586     /* The following parameters are currently not exposed to devicetree, but
0587      * may be as soon as needed.
0588      */
0589     hub->bat_charge_en = USB251XB_DEF_BATTERY_CHARGING_ENABLE;
0590     hub->boost_57 = USB251XB_DEF_BOOST_57;
0591     hub->boost_14 = USB251XB_DEF_BOOST_14;
0592     hub->port_map12 = USB251XB_DEF_PORT_MAP_12;
0593     hub->port_map34 = USB251XB_DEF_PORT_MAP_34;
0594     hub->port_map56 = USB251XB_DEF_PORT_MAP_56;
0595     hub->port_map7  = USB251XB_DEF_PORT_MAP_7;
0596 
0597     return 0;
0598 }
0599 
0600 static const struct of_device_id usb251xb_of_match[] = {
0601     {
0602         .compatible = "microchip,usb2422",
0603         .data = &usb2422_data,
0604     }, {
0605         .compatible = "microchip,usb2512b",
0606         .data = &usb2512b_data,
0607     }, {
0608         .compatible = "microchip,usb2512bi",
0609         .data = &usb2512bi_data,
0610     }, {
0611         .compatible = "microchip,usb2513b",
0612         .data = &usb2513b_data,
0613     }, {
0614         .compatible = "microchip,usb2513bi",
0615         .data = &usb2513bi_data,
0616     }, {
0617         .compatible = "microchip,usb2514b",
0618         .data = &usb2514b_data,
0619     }, {
0620         .compatible = "microchip,usb2514bi",
0621         .data = &usb2514bi_data,
0622     }, {
0623         .compatible = "microchip,usb2517",
0624         .data = &usb2517_data,
0625     }, {
0626         .compatible = "microchip,usb2517i",
0627         .data = &usb2517i_data,
0628     }, {
0629         /* sentinel */
0630     }
0631 };
0632 MODULE_DEVICE_TABLE(of, usb251xb_of_match);
0633 #else /* CONFIG_OF */
0634 static int usb251xb_get_ofdata(struct usb251xb *hub,
0635                    const struct usb251xb_data *data)
0636 {
0637     return 0;
0638 }
0639 #endif /* CONFIG_OF */
0640 
0641 static void usb251xb_regulator_disable_action(void *data)
0642 {
0643     struct usb251xb *hub = data;
0644 
0645     regulator_disable(hub->vdd);
0646 }
0647 
0648 static int usb251xb_probe(struct usb251xb *hub)
0649 {
0650     struct device *dev = hub->dev;
0651     struct device_node *np = dev->of_node;
0652     const struct usb251xb_data *usb_data = of_device_get_match_data(dev);
0653     int err;
0654 
0655     if (np && usb_data) {
0656         err = usb251xb_get_ofdata(hub, usb_data);
0657         if (err) {
0658             dev_err(dev, "failed to get ofdata: %d\n", err);
0659             return err;
0660         }
0661     }
0662 
0663     /*
0664      * usb251x SMBus-slave SCL lane is muxed with CFG_SEL0 pin. So if anyone
0665      * tries to work with the bus at the moment the hub reset is released,
0666      * it may cause an invalid config being latched by usb251x. Particularly
0667      * one of the config modes makes the hub loading a default registers
0668      * value without SMBus-slave interface activation. If the hub
0669      * accidentally gets this mode, this will cause the driver SMBus-
0670      * functions failure. Normally we could just lock the SMBus-segment the
0671      * hub i2c-interface resides for the device-specific reset timing. But
0672      * the GPIO controller, which is used to handle the hub reset, might be
0673      * placed at the same i2c-bus segment. In this case an error should be
0674      * returned since we can't safely use the GPIO controller to clear the
0675      * reset state (it may affect the hub configuration) and we can't lock
0676      * the i2c-bus segment (it will cause a deadlock).
0677      */
0678     err = usb251x_check_gpio_chip(hub);
0679     if (err)
0680         return err;
0681 
0682     hub->vdd = devm_regulator_get(dev, "vdd");
0683     if (IS_ERR(hub->vdd))
0684         return PTR_ERR(hub->vdd);
0685 
0686     err = regulator_enable(hub->vdd);
0687     if (err)
0688         return err;
0689 
0690     err = devm_add_action_or_reset(dev,
0691                        usb251xb_regulator_disable_action, hub);
0692     if (err)
0693         return err;
0694 
0695     err = usb251xb_connect(hub);
0696     if (err) {
0697         dev_err(dev, "Failed to connect hub (%d)\n", err);
0698         return err;
0699     }
0700 
0701     dev_info(dev, "Hub probed successfully\n");
0702 
0703     return 0;
0704 }
0705 
0706 static int usb251xb_i2c_probe(struct i2c_client *i2c,
0707                   const struct i2c_device_id *id)
0708 {
0709     struct usb251xb *hub;
0710 
0711     hub = devm_kzalloc(&i2c->dev, sizeof(struct usb251xb), GFP_KERNEL);
0712     if (!hub)
0713         return -ENOMEM;
0714 
0715     i2c_set_clientdata(i2c, hub);
0716     hub->dev = &i2c->dev;
0717     hub->i2c = i2c;
0718 
0719     return usb251xb_probe(hub);
0720 }
0721 
0722 static int __maybe_unused usb251xb_suspend(struct device *dev)
0723 {
0724     struct i2c_client *client = to_i2c_client(dev);
0725     struct usb251xb *hub = i2c_get_clientdata(client);
0726 
0727     return regulator_disable(hub->vdd);
0728 }
0729 
0730 static int __maybe_unused usb251xb_resume(struct device *dev)
0731 {
0732     struct i2c_client *client = to_i2c_client(dev);
0733     struct usb251xb *hub = i2c_get_clientdata(client);
0734     int err;
0735 
0736     err = regulator_enable(hub->vdd);
0737     if (err)
0738         return err;
0739 
0740     return usb251xb_connect(hub);
0741 }
0742 
0743 static SIMPLE_DEV_PM_OPS(usb251xb_pm_ops, usb251xb_suspend, usb251xb_resume);
0744 
0745 static const struct i2c_device_id usb251xb_id[] = {
0746     { "usb2422", 0 },
0747     { "usb2512b", 0 },
0748     { "usb2512bi", 0 },
0749     { "usb2513b", 0 },
0750     { "usb2513bi", 0 },
0751     { "usb2514b", 0 },
0752     { "usb2514bi", 0 },
0753     { "usb2517", 0 },
0754     { "usb2517i", 0 },
0755     { /* sentinel */ }
0756 };
0757 MODULE_DEVICE_TABLE(i2c, usb251xb_id);
0758 
0759 static struct i2c_driver usb251xb_i2c_driver = {
0760     .driver = {
0761         .name = DRIVER_NAME,
0762         .of_match_table = of_match_ptr(usb251xb_of_match),
0763         .pm = &usb251xb_pm_ops,
0764     },
0765     .probe    = usb251xb_i2c_probe,
0766     .id_table = usb251xb_id,
0767 };
0768 
0769 module_i2c_driver(usb251xb_i2c_driver);
0770 
0771 MODULE_AUTHOR("Richard Leitner <richard.leitner@skidata.com>");
0772 MODULE_DESCRIPTION("USB251x/xBi USB 2.0 Hub Controller Driver");
0773 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!