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