1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for Microchip USB251xB USB 2.0 Hi-Speed Hub Controller 4 * Configuration via SMBus. 5 * 6 * Copyright (c) 2017 SKIDATA AG 7 * 8 * This work is based on the USB3503 driver by Dongjin Kim and 9 * a not-accepted patch by Fabien Lahoudere, see: 10 * https://patchwork.kernel.org/patch/9257715/ 11 */ 12 13 #include <linux/delay.h> 14 #include <linux/gpio/consumer.h> 15 #include <linux/i2c.h> 16 #include <linux/module.h> 17 #include <linux/nls.h> 18 #include <linux/of_device.h> 19 #include <linux/slab.h> 20 21 /* Internal Register Set Addresses & Default Values acc. to DS00001692C */ 22 #define USB251XB_ADDR_VENDOR_ID_LSB 0x00 23 #define USB251XB_ADDR_VENDOR_ID_MSB 0x01 24 #define USB251XB_DEF_VENDOR_ID 0x0424 25 26 #define USB251XB_ADDR_PRODUCT_ID_LSB 0x02 27 #define USB251XB_ADDR_PRODUCT_ID_MSB 0x03 28 #define USB251XB_DEF_PRODUCT_ID_12 0x2512 /* USB2512B/12Bi */ 29 #define USB251XB_DEF_PRODUCT_ID_13 0x2513 /* USB2513B/13Bi */ 30 #define USB251XB_DEF_PRODUCT_ID_14 0x2514 /* USB2514B/14Bi */ 31 #define USB251XB_DEF_PRODUCT_ID_17 0x2517 /* USB2517/17i */ 32 33 #define USB251XB_ADDR_DEVICE_ID_LSB 0x04 34 #define USB251XB_ADDR_DEVICE_ID_MSB 0x05 35 #define USB251XB_DEF_DEVICE_ID 0x0BB3 36 37 #define USB251XB_ADDR_CONFIG_DATA_1 0x06 38 #define USB251XB_DEF_CONFIG_DATA_1 0x9B 39 #define USB251XB_ADDR_CONFIG_DATA_2 0x07 40 #define USB251XB_DEF_CONFIG_DATA_2 0x20 41 #define USB251XB_ADDR_CONFIG_DATA_3 0x08 42 #define USB251XB_DEF_CONFIG_DATA_3 0x02 43 44 #define USB251XB_ADDR_NON_REMOVABLE_DEVICES 0x09 45 #define USB251XB_DEF_NON_REMOVABLE_DEVICES 0x00 46 47 #define USB251XB_ADDR_PORT_DISABLE_SELF 0x0A 48 #define USB251XB_DEF_PORT_DISABLE_SELF 0x00 49 #define USB251XB_ADDR_PORT_DISABLE_BUS 0x0B 50 #define USB251XB_DEF_PORT_DISABLE_BUS 0x00 51 52 #define USB251XB_ADDR_MAX_POWER_SELF 0x0C 53 #define USB251XB_DEF_MAX_POWER_SELF 0x01 54 #define USB251XB_ADDR_MAX_POWER_BUS 0x0D 55 #define USB251XB_DEF_MAX_POWER_BUS 0x32 56 57 #define USB251XB_ADDR_MAX_CURRENT_SELF 0x0E 58 #define USB251XB_DEF_MAX_CURRENT_SELF 0x01 59 #define USB251XB_ADDR_MAX_CURRENT_BUS 0x0F 60 #define USB251XB_DEF_MAX_CURRENT_BUS 0x32 61 62 #define USB251XB_ADDR_POWER_ON_TIME 0x10 63 #define USB251XB_DEF_POWER_ON_TIME 0x32 64 65 #define USB251XB_ADDR_LANGUAGE_ID_HIGH 0x11 66 #define USB251XB_ADDR_LANGUAGE_ID_LOW 0x12 67 #define USB251XB_DEF_LANGUAGE_ID 0x0000 68 69 #define USB251XB_STRING_BUFSIZE 62 70 #define USB251XB_ADDR_MANUFACTURER_STRING_LEN 0x13 71 #define USB251XB_ADDR_MANUFACTURER_STRING 0x16 72 #define USB251XB_DEF_MANUFACTURER_STRING "Microchip" 73 74 #define USB251XB_ADDR_PRODUCT_STRING_LEN 0x14 75 #define USB251XB_ADDR_PRODUCT_STRING 0x54 76 #define USB251XB_DEF_PRODUCT_STRING "USB251xB/xBi/7i" 77 78 #define USB251XB_ADDR_SERIAL_STRING_LEN 0x15 79 #define USB251XB_ADDR_SERIAL_STRING 0x92 80 #define USB251XB_DEF_SERIAL_STRING "" 81 82 #define USB251XB_ADDR_BATTERY_CHARGING_ENABLE 0xD0 83 #define USB251XB_DEF_BATTERY_CHARGING_ENABLE 0x00 84 85 #define USB251XB_ADDR_BOOST_UP 0xF6 86 #define USB251XB_DEF_BOOST_UP 0x00 87 #define USB251XB_ADDR_BOOST_57 0xF7 88 #define USB251XB_DEF_BOOST_57 0x00 89 #define USB251XB_ADDR_BOOST_14 0xF8 90 #define USB251XB_DEF_BOOST_14 0x00 91 92 #define USB251XB_ADDR_PORT_SWAP 0xFA 93 #define USB251XB_DEF_PORT_SWAP 0x00 94 95 #define USB251XB_ADDR_PORT_MAP_12 0xFB 96 #define USB251XB_DEF_PORT_MAP_12 0x00 97 #define USB251XB_ADDR_PORT_MAP_34 0xFC 98 #define USB251XB_DEF_PORT_MAP_34 0x00 /* USB251{3B/i,4B/i,7/i} only */ 99 #define USB251XB_ADDR_PORT_MAP_56 0xFD 100 #define USB251XB_DEF_PORT_MAP_56 0x00 /* USB2517/i only */ 101 #define USB251XB_ADDR_PORT_MAP_7 0xFE 102 #define USB251XB_DEF_PORT_MAP_7 0x00 /* USB2517/i only */ 103 104 #define USB251XB_ADDR_STATUS_COMMAND 0xFF 105 #define USB251XB_STATUS_COMMAND_SMBUS_DOWN 0x04 106 #define USB251XB_STATUS_COMMAND_RESET 0x02 107 #define USB251XB_STATUS_COMMAND_ATTACH 0x01 108 109 #define USB251XB_I2C_REG_SZ 0x100 110 #define USB251XB_I2C_WRITE_SZ 0x10 111 112 #define DRIVER_NAME "usb251xb" 113 #define DRIVER_DESC "Microchip USB 2.0 Hi-Speed Hub Controller" 114 115 struct usb251xb { 116 struct device *dev; 117 struct i2c_client *i2c; 118 u8 skip_config; 119 struct gpio_desc *gpio_reset; 120 u16 vendor_id; 121 u16 product_id; 122 u16 device_id; 123 u8 conf_data1; 124 u8 conf_data2; 125 u8 conf_data3; 126 u8 non_rem_dev; 127 u8 port_disable_sp; 128 u8 port_disable_bp; 129 u8 max_power_sp; 130 u8 max_power_bp; 131 u8 max_current_sp; 132 u8 max_current_bp; 133 u8 power_on_time; 134 u16 lang_id; 135 u8 manufacturer_len; 136 u8 product_len; 137 u8 serial_len; 138 char manufacturer[USB251XB_STRING_BUFSIZE]; 139 char product[USB251XB_STRING_BUFSIZE]; 140 char serial[USB251XB_STRING_BUFSIZE]; 141 u8 bat_charge_en; 142 u8 boost_up; 143 u8 boost_57; 144 u8 boost_14; 145 u8 port_swap; 146 u8 port_map12; 147 u8 port_map34; 148 u8 port_map56; 149 u8 port_map7; 150 u8 status; 151 }; 152 153 struct usb251xb_data { 154 u16 product_id; 155 u8 port_cnt; 156 bool led_support; 157 bool bat_support; 158 char product_str[USB251XB_STRING_BUFSIZE / 2]; /* ASCII string */ 159 }; 160 161 static const struct usb251xb_data usb2512b_data = { 162 .product_id = 0x2512, 163 .port_cnt = 2, 164 .led_support = false, 165 .bat_support = true, 166 .product_str = "USB2512B", 167 }; 168 169 static const struct usb251xb_data usb2512bi_data = { 170 .product_id = 0x2512, 171 .port_cnt = 2, 172 .led_support = false, 173 .bat_support = true, 174 .product_str = "USB2512Bi", 175 }; 176 177 static const struct usb251xb_data usb2513b_data = { 178 .product_id = 0x2513, 179 .port_cnt = 3, 180 .led_support = false, 181 .bat_support = true, 182 .product_str = "USB2513B", 183 }; 184 185 static const struct usb251xb_data usb2513bi_data = { 186 .product_id = 0x2513, 187 .port_cnt = 3, 188 .led_support = false, 189 .bat_support = true, 190 .product_str = "USB2513Bi", 191 }; 192 193 static const struct usb251xb_data usb2514b_data = { 194 .product_id = 0x2514, 195 .port_cnt = 4, 196 .led_support = false, 197 .bat_support = true, 198 .product_str = "USB2514B", 199 }; 200 201 static const struct usb251xb_data usb2514bi_data = { 202 .product_id = 0x2514, 203 .port_cnt = 4, 204 .led_support = false, 205 .bat_support = true, 206 .product_str = "USB2514Bi", 207 }; 208 209 static const struct usb251xb_data usb2517_data = { 210 .product_id = 0x2517, 211 .port_cnt = 7, 212 .led_support = true, 213 .bat_support = false, 214 .product_str = "USB2517", 215 }; 216 217 static const struct usb251xb_data usb2517i_data = { 218 .product_id = 0x2517, 219 .port_cnt = 7, 220 .led_support = true, 221 .bat_support = false, 222 .product_str = "USB2517i", 223 }; 224 225 static void usb251xb_reset(struct usb251xb *hub, int state) 226 { 227 if (!hub->gpio_reset) 228 return; 229 230 gpiod_set_value_cansleep(hub->gpio_reset, state); 231 232 /* wait for hub recovery/stabilization */ 233 if (!state) 234 usleep_range(500, 750); /* >=500us at power on */ 235 else 236 usleep_range(1, 10); /* >=1us at power down */ 237 } 238 239 static int usb251xb_connect(struct usb251xb *hub) 240 { 241 struct device *dev = hub->dev; 242 int err, i; 243 char i2c_wb[USB251XB_I2C_REG_SZ]; 244 245 memset(i2c_wb, 0, USB251XB_I2C_REG_SZ); 246 247 if (hub->skip_config) { 248 dev_info(dev, "Skip hub configuration, only attach.\n"); 249 i2c_wb[0] = 0x01; 250 i2c_wb[1] = USB251XB_STATUS_COMMAND_ATTACH; 251 252 usb251xb_reset(hub, 0); 253 254 err = i2c_smbus_write_i2c_block_data(hub->i2c, 255 USB251XB_ADDR_STATUS_COMMAND, 2, i2c_wb); 256 if (err) { 257 dev_err(dev, "attaching hub failed: %d\n", err); 258 return err; 259 } 260 return 0; 261 } 262 263 i2c_wb[USB251XB_ADDR_VENDOR_ID_MSB] = (hub->vendor_id >> 8) & 0xFF; 264 i2c_wb[USB251XB_ADDR_VENDOR_ID_LSB] = hub->vendor_id & 0xFF; 265 i2c_wb[USB251XB_ADDR_PRODUCT_ID_MSB] = (hub->product_id >> 8) & 0xFF; 266 i2c_wb[USB251XB_ADDR_PRODUCT_ID_LSB] = hub->product_id & 0xFF; 267 i2c_wb[USB251XB_ADDR_DEVICE_ID_MSB] = (hub->device_id >> 8) & 0xFF; 268 i2c_wb[USB251XB_ADDR_DEVICE_ID_LSB] = hub->device_id & 0xFF; 269 i2c_wb[USB251XB_ADDR_CONFIG_DATA_1] = hub->conf_data1; 270 i2c_wb[USB251XB_ADDR_CONFIG_DATA_2] = hub->conf_data2; 271 i2c_wb[USB251XB_ADDR_CONFIG_DATA_3] = hub->conf_data3; 272 i2c_wb[USB251XB_ADDR_NON_REMOVABLE_DEVICES] = hub->non_rem_dev; 273 i2c_wb[USB251XB_ADDR_PORT_DISABLE_SELF] = hub->port_disable_sp; 274 i2c_wb[USB251XB_ADDR_PORT_DISABLE_BUS] = hub->port_disable_bp; 275 i2c_wb[USB251XB_ADDR_MAX_POWER_SELF] = hub->max_power_sp; 276 i2c_wb[USB251XB_ADDR_MAX_POWER_BUS] = hub->max_power_bp; 277 i2c_wb[USB251XB_ADDR_MAX_CURRENT_SELF] = hub->max_current_sp; 278 i2c_wb[USB251XB_ADDR_MAX_CURRENT_BUS] = hub->max_current_bp; 279 i2c_wb[USB251XB_ADDR_POWER_ON_TIME] = hub->power_on_time; 280 i2c_wb[USB251XB_ADDR_LANGUAGE_ID_HIGH] = (hub->lang_id >> 8) & 0xFF; 281 i2c_wb[USB251XB_ADDR_LANGUAGE_ID_LOW] = hub->lang_id & 0xFF; 282 i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING_LEN] = hub->manufacturer_len; 283 i2c_wb[USB251XB_ADDR_PRODUCT_STRING_LEN] = hub->product_len; 284 i2c_wb[USB251XB_ADDR_SERIAL_STRING_LEN] = hub->serial_len; 285 memcpy(&i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING], hub->manufacturer, 286 USB251XB_STRING_BUFSIZE); 287 memcpy(&i2c_wb[USB251XB_ADDR_SERIAL_STRING], hub->serial, 288 USB251XB_STRING_BUFSIZE); 289 memcpy(&i2c_wb[USB251XB_ADDR_PRODUCT_STRING], hub->product, 290 USB251XB_STRING_BUFSIZE); 291 i2c_wb[USB251XB_ADDR_BATTERY_CHARGING_ENABLE] = hub->bat_charge_en; 292 i2c_wb[USB251XB_ADDR_BOOST_UP] = hub->boost_up; 293 i2c_wb[USB251XB_ADDR_BOOST_57] = hub->boost_57; 294 i2c_wb[USB251XB_ADDR_BOOST_14] = hub->boost_14; 295 i2c_wb[USB251XB_ADDR_PORT_SWAP] = hub->port_swap; 296 i2c_wb[USB251XB_ADDR_PORT_MAP_12] = hub->port_map12; 297 i2c_wb[USB251XB_ADDR_PORT_MAP_34] = hub->port_map34; 298 i2c_wb[USB251XB_ADDR_PORT_MAP_56] = hub->port_map56; 299 i2c_wb[USB251XB_ADDR_PORT_MAP_7] = hub->port_map7; 300 i2c_wb[USB251XB_ADDR_STATUS_COMMAND] = USB251XB_STATUS_COMMAND_ATTACH; 301 302 usb251xb_reset(hub, 0); 303 304 /* write registers */ 305 for (i = 0; i < (USB251XB_I2C_REG_SZ / USB251XB_I2C_WRITE_SZ); i++) { 306 int offset = i * USB251XB_I2C_WRITE_SZ; 307 char wbuf[USB251XB_I2C_WRITE_SZ + 1]; 308 309 /* The first data byte transferred tells the hub how many data 310 * bytes will follow (byte count). 311 */ 312 wbuf[0] = USB251XB_I2C_WRITE_SZ; 313 memcpy(&wbuf[1], &i2c_wb[offset], USB251XB_I2C_WRITE_SZ); 314 315 dev_dbg(dev, "writing %d byte block %d to 0x%02X\n", 316 USB251XB_I2C_WRITE_SZ, i, offset); 317 318 err = i2c_smbus_write_i2c_block_data(hub->i2c, offset, 319 USB251XB_I2C_WRITE_SZ + 1, 320 wbuf); 321 if (err) 322 goto out_err; 323 } 324 325 dev_info(dev, "Hub configuration was successful.\n"); 326 return 0; 327 328 out_err: 329 dev_err(dev, "configuring block %d failed: %d\n", i, err); 330 return err; 331 } 332 333 #ifdef CONFIG_OF 334 static int usb251xb_get_ofdata(struct usb251xb *hub, 335 struct usb251xb_data *data) 336 { 337 struct device *dev = hub->dev; 338 struct device_node *np = dev->of_node; 339 int len, err, i; 340 u32 property_u32 = 0; 341 const u32 *cproperty_u32; 342 const char *cproperty_char; 343 char str[USB251XB_STRING_BUFSIZE / 2]; 344 345 if (!np) { 346 dev_err(dev, "failed to get ofdata\n"); 347 return -ENODEV; 348 } 349 350 if (of_get_property(np, "skip-config", NULL)) 351 hub->skip_config = 1; 352 else 353 hub->skip_config = 0; 354 355 hub->gpio_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); 356 if (PTR_ERR(hub->gpio_reset) == -EPROBE_DEFER) { 357 return -EPROBE_DEFER; 358 } else if (IS_ERR(hub->gpio_reset)) { 359 err = PTR_ERR(hub->gpio_reset); 360 dev_err(dev, "unable to request GPIO reset pin (%d)\n", err); 361 return err; 362 } 363 364 if (of_property_read_u16_array(np, "vendor-id", &hub->vendor_id, 1)) 365 hub->vendor_id = USB251XB_DEF_VENDOR_ID; 366 367 if (of_property_read_u16_array(np, "product-id", 368 &hub->product_id, 1)) 369 hub->product_id = data->product_id; 370 371 if (of_property_read_u16_array(np, "device-id", &hub->device_id, 1)) 372 hub->device_id = USB251XB_DEF_DEVICE_ID; 373 374 hub->conf_data1 = USB251XB_DEF_CONFIG_DATA_1; 375 if (of_get_property(np, "self-powered", NULL)) { 376 hub->conf_data1 |= BIT(7); 377 378 /* Configure Over-Current sens when self-powered */ 379 hub->conf_data1 &= ~BIT(2); 380 if (of_get_property(np, "ganged-sensing", NULL)) 381 hub->conf_data1 &= ~BIT(1); 382 else if (of_get_property(np, "individual-sensing", NULL)) 383 hub->conf_data1 |= BIT(1); 384 } else if (of_get_property(np, "bus-powered", NULL)) { 385 hub->conf_data1 &= ~BIT(7); 386 387 /* Disable Over-Current sense when bus-powered */ 388 hub->conf_data1 |= BIT(2); 389 } 390 391 if (of_get_property(np, "disable-hi-speed", NULL)) 392 hub->conf_data1 |= BIT(5); 393 394 if (of_get_property(np, "multi-tt", NULL)) 395 hub->conf_data1 |= BIT(4); 396 else if (of_get_property(np, "single-tt", NULL)) 397 hub->conf_data1 &= ~BIT(4); 398 399 if (of_get_property(np, "disable-eop", NULL)) 400 hub->conf_data1 |= BIT(3); 401 402 if (of_get_property(np, "individual-port-switching", NULL)) 403 hub->conf_data1 |= BIT(0); 404 else if (of_get_property(np, "ganged-port-switching", NULL)) 405 hub->conf_data1 &= ~BIT(0); 406 407 hub->conf_data2 = USB251XB_DEF_CONFIG_DATA_2; 408 if (of_get_property(np, "dynamic-power-switching", NULL)) 409 hub->conf_data2 |= BIT(7); 410 411 if (!of_property_read_u32(np, "oc-delay-us", &property_u32)) { 412 if (property_u32 == 100) { 413 /* 100 us*/ 414 hub->conf_data2 &= ~BIT(5); 415 hub->conf_data2 &= ~BIT(4); 416 } else if (property_u32 == 4000) { 417 /* 4 ms */ 418 hub->conf_data2 &= ~BIT(5); 419 hub->conf_data2 |= BIT(4); 420 } else if (property_u32 == 16000) { 421 /* 16 ms */ 422 hub->conf_data2 |= BIT(5); 423 hub->conf_data2 |= BIT(4); 424 } else { 425 /* 8 ms (DEFAULT) */ 426 hub->conf_data2 |= BIT(5); 427 hub->conf_data2 &= ~BIT(4); 428 } 429 } 430 431 if (of_get_property(np, "compound-device", NULL)) 432 hub->conf_data2 |= BIT(3); 433 434 hub->conf_data3 = USB251XB_DEF_CONFIG_DATA_3; 435 if (of_get_property(np, "port-mapping-mode", NULL)) 436 hub->conf_data3 |= BIT(3); 437 438 if (data->led_support && of_get_property(np, "led-usb-mode", NULL)) 439 hub->conf_data3 &= ~BIT(1); 440 441 if (of_get_property(np, "string-support", NULL)) 442 hub->conf_data3 |= BIT(0); 443 444 hub->non_rem_dev = USB251XB_DEF_NON_REMOVABLE_DEVICES; 445 cproperty_u32 = of_get_property(np, "non-removable-ports", &len); 446 if (cproperty_u32 && (len / sizeof(u32)) > 0) { 447 for (i = 0; i < len / sizeof(u32); i++) { 448 u32 port = be32_to_cpu(cproperty_u32[i]); 449 450 if ((port >= 1) && (port <= data->port_cnt)) 451 hub->non_rem_dev |= BIT(port); 452 else 453 dev_warn(dev, "NRD port %u doesn't exist\n", 454 port); 455 } 456 } 457 458 hub->port_disable_sp = USB251XB_DEF_PORT_DISABLE_SELF; 459 cproperty_u32 = of_get_property(np, "sp-disabled-ports", &len); 460 if (cproperty_u32 && (len / sizeof(u32)) > 0) { 461 for (i = 0; i < len / sizeof(u32); i++) { 462 u32 port = be32_to_cpu(cproperty_u32[i]); 463 464 if ((port >= 1) && (port <= data->port_cnt)) 465 hub->port_disable_sp |= BIT(port); 466 else 467 dev_warn(dev, "PDS port %u doesn't exist\n", 468 port); 469 } 470 } 471 472 hub->port_disable_bp = USB251XB_DEF_PORT_DISABLE_BUS; 473 cproperty_u32 = of_get_property(np, "bp-disabled-ports", &len); 474 if (cproperty_u32 && (len / sizeof(u32)) > 0) { 475 for (i = 0; i < len / sizeof(u32); i++) { 476 u32 port = be32_to_cpu(cproperty_u32[i]); 477 478 if ((port >= 1) && (port <= data->port_cnt)) 479 hub->port_disable_bp |= BIT(port); 480 else 481 dev_warn(dev, "PDB port %u doesn't exist\n", 482 port); 483 } 484 } 485 486 hub->max_power_sp = USB251XB_DEF_MAX_POWER_SELF; 487 if (!of_property_read_u32(np, "sp-max-total-current-microamp", 488 &property_u32)) 489 hub->max_power_sp = min_t(u8, property_u32 / 2000, 50); 490 491 hub->max_power_bp = USB251XB_DEF_MAX_POWER_BUS; 492 if (!of_property_read_u32(np, "bp-max-total-current-microamp", 493 &property_u32)) 494 hub->max_power_bp = min_t(u8, property_u32 / 2000, 255); 495 496 hub->max_current_sp = USB251XB_DEF_MAX_CURRENT_SELF; 497 if (!of_property_read_u32(np, "sp-max-removable-current-microamp", 498 &property_u32)) 499 hub->max_current_sp = min_t(u8, property_u32 / 2000, 50); 500 501 hub->max_current_bp = USB251XB_DEF_MAX_CURRENT_BUS; 502 if (!of_property_read_u32(np, "bp-max-removable-current-microamp", 503 &property_u32)) 504 hub->max_current_bp = min_t(u8, property_u32 / 2000, 255); 505 506 hub->power_on_time = USB251XB_DEF_POWER_ON_TIME; 507 if (!of_property_read_u32(np, "power-on-time-ms", &property_u32)) 508 hub->power_on_time = min_t(u8, property_u32 / 2, 255); 509 510 if (of_property_read_u16_array(np, "language-id", &hub->lang_id, 1)) 511 hub->lang_id = USB251XB_DEF_LANGUAGE_ID; 512 513 cproperty_char = of_get_property(np, "manufacturer", NULL); 514 strlcpy(str, cproperty_char ? : USB251XB_DEF_MANUFACTURER_STRING, 515 sizeof(str)); 516 hub->manufacturer_len = strlen(str) & 0xFF; 517 memset(hub->manufacturer, 0, USB251XB_STRING_BUFSIZE); 518 len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); 519 len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN, 520 (wchar_t *)hub->manufacturer, 521 USB251XB_STRING_BUFSIZE); 522 523 cproperty_char = of_get_property(np, "product", NULL); 524 strlcpy(str, cproperty_char ? : data->product_str, sizeof(str)); 525 hub->product_len = strlen(str) & 0xFF; 526 memset(hub->product, 0, USB251XB_STRING_BUFSIZE); 527 len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); 528 len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN, 529 (wchar_t *)hub->product, 530 USB251XB_STRING_BUFSIZE); 531 532 cproperty_char = of_get_property(np, "serial", NULL); 533 strlcpy(str, cproperty_char ? : USB251XB_DEF_SERIAL_STRING, 534 sizeof(str)); 535 hub->serial_len = strlen(str) & 0xFF; 536 memset(hub->serial, 0, USB251XB_STRING_BUFSIZE); 537 len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); 538 len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN, 539 (wchar_t *)hub->serial, 540 USB251XB_STRING_BUFSIZE); 541 542 /* The following parameters are currently not exposed to devicetree, but 543 * may be as soon as needed. 544 */ 545 hub->bat_charge_en = USB251XB_DEF_BATTERY_CHARGING_ENABLE; 546 hub->boost_up = USB251XB_DEF_BOOST_UP; 547 hub->boost_57 = USB251XB_DEF_BOOST_57; 548 hub->boost_14 = USB251XB_DEF_BOOST_14; 549 hub->port_swap = USB251XB_DEF_PORT_SWAP; 550 hub->port_map12 = USB251XB_DEF_PORT_MAP_12; 551 hub->port_map34 = USB251XB_DEF_PORT_MAP_34; 552 hub->port_map56 = USB251XB_DEF_PORT_MAP_56; 553 hub->port_map7 = USB251XB_DEF_PORT_MAP_7; 554 555 return 0; 556 } 557 558 static const struct of_device_id usb251xb_of_match[] = { 559 { 560 .compatible = "microchip,usb2512b", 561 .data = &usb2512b_data, 562 }, { 563 .compatible = "microchip,usb2512bi", 564 .data = &usb2512bi_data, 565 }, { 566 .compatible = "microchip,usb2513b", 567 .data = &usb2513b_data, 568 }, { 569 .compatible = "microchip,usb2513bi", 570 .data = &usb2513bi_data, 571 }, { 572 .compatible = "microchip,usb2514b", 573 .data = &usb2514b_data, 574 }, { 575 .compatible = "microchip,usb2514bi", 576 .data = &usb2514bi_data, 577 }, { 578 .compatible = "microchip,usb2517", 579 .data = &usb2517_data, 580 }, { 581 .compatible = "microchip,usb2517i", 582 .data = &usb2517i_data, 583 }, { 584 /* sentinel */ 585 } 586 }; 587 MODULE_DEVICE_TABLE(of, usb251xb_of_match); 588 #else /* CONFIG_OF */ 589 static int usb251xb_get_ofdata(struct usb251xb *hub, 590 struct usb251xb_data *data) 591 { 592 return 0; 593 } 594 #endif /* CONFIG_OF */ 595 596 static int usb251xb_probe(struct usb251xb *hub) 597 { 598 struct device *dev = hub->dev; 599 struct device_node *np = dev->of_node; 600 const struct of_device_id *of_id = of_match_device(usb251xb_of_match, 601 dev); 602 int err; 603 604 if (np) { 605 err = usb251xb_get_ofdata(hub, 606 (struct usb251xb_data *)of_id->data); 607 if (err) { 608 dev_err(dev, "failed to get ofdata: %d\n", err); 609 return err; 610 } 611 } 612 613 err = usb251xb_connect(hub); 614 if (err) { 615 dev_err(dev, "Failed to connect hub (%d)\n", err); 616 return err; 617 } 618 619 dev_info(dev, "Hub probed successfully\n"); 620 621 return 0; 622 } 623 624 static int usb251xb_i2c_probe(struct i2c_client *i2c, 625 const struct i2c_device_id *id) 626 { 627 struct usb251xb *hub; 628 629 hub = devm_kzalloc(&i2c->dev, sizeof(struct usb251xb), GFP_KERNEL); 630 if (!hub) 631 return -ENOMEM; 632 633 i2c_set_clientdata(i2c, hub); 634 hub->dev = &i2c->dev; 635 hub->i2c = i2c; 636 637 return usb251xb_probe(hub); 638 } 639 640 static const struct i2c_device_id usb251xb_id[] = { 641 { "usb2512b", 0 }, 642 { "usb2512bi", 0 }, 643 { "usb2513b", 0 }, 644 { "usb2513bi", 0 }, 645 { "usb2514b", 0 }, 646 { "usb2514bi", 0 }, 647 { "usb2517", 0 }, 648 { "usb2517i", 0 }, 649 { /* sentinel */ } 650 }; 651 MODULE_DEVICE_TABLE(i2c, usb251xb_id); 652 653 static struct i2c_driver usb251xb_i2c_driver = { 654 .driver = { 655 .name = DRIVER_NAME, 656 .of_match_table = of_match_ptr(usb251xb_of_match), 657 }, 658 .probe = usb251xb_i2c_probe, 659 .id_table = usb251xb_id, 660 }; 661 662 module_i2c_driver(usb251xb_i2c_driver); 663 664 MODULE_AUTHOR("Richard Leitner <richard.leitner@skidata.com>"); 665 MODULE_DESCRIPTION("USB251x/xBi USB 2.0 Hub Controller Driver"); 666 MODULE_LICENSE("GPL"); 667