FILE
usb251xb.c
File preview with syntax highlighting.
linux-6.19.14/drivers/usb/misc/usb251xb.c
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/gpio/driver.h> 16#include <linux/i2c.h> 17#include <linux/module.h> 18#include <linux/nls.h> 19#include <linux/of.h> 20#include <linux/platform_device.h> 21#include <linux/regulator/consumer.h> 22#include <linux/slab.h> 23 24/* Internal Register Set Addresses & Default Values acc. to DS00001692C */ 25#define USB251XB_ADDR_VENDOR_ID_LSB 0x00 26#define USB251XB_ADDR_VENDOR_ID_MSB 0x01 27#define USB251XB_DEF_VENDOR_ID 0x0424 28 29#define USB251XB_ADDR_PRODUCT_ID_LSB 0x02 30#define USB251XB_ADDR_PRODUCT_ID_MSB 0x03 31 32#define USB251XB_ADDR_DEVICE_ID_LSB 0x04 33#define USB251XB_ADDR_DEVICE_ID_MSB 0x05 34#define USB251XB_DEF_DEVICE_ID 0x0BB3 35 36#define USB251XB_ADDR_CONFIG_DATA_1 0x06 37#define USB251XB_DEF_CONFIG_DATA_1 0x9B 38#define USB251XB_ADDR_CONFIG_DATA_2 0x07 39#define USB251XB_DEF_CONFIG_DATA_2 0x20 40#define USB251XB_ADDR_CONFIG_DATA_3 0x08 41#define USB251XB_DEF_CONFIG_DATA_3 0x02 42 43#define USB251XB_ADDR_NON_REMOVABLE_DEVICES 0x09 44#define USB251XB_DEF_NON_REMOVABLE_DEVICES 0x00 45 46#define USB251XB_ADDR_PORT_DISABLE_SELF 0x0A 47#define USB251XB_DEF_PORT_DISABLE_SELF 0x00 48#define USB251XB_ADDR_PORT_DISABLE_BUS 0x0B 49#define USB251XB_DEF_PORT_DISABLE_BUS 0x00 50 51#define USB251XB_ADDR_MAX_POWER_SELF 0x0C 52#define USB251XB_DEF_MAX_POWER_SELF 0x01 53#define USB251XB_ADDR_MAX_POWER_BUS 0x0D 54#define USB251XB_DEF_MAX_POWER_BUS 0x32 55 56#define USB251XB_ADDR_MAX_CURRENT_SELF 0x0E 57#define USB251XB_DEF_MAX_CURRENT_SELF 0x01 58#define USB251XB_ADDR_MAX_CURRENT_BUS 0x0F 59#define USB251XB_DEF_MAX_CURRENT_BUS 0x32 60 61#define USB251XB_ADDR_POWER_ON_TIME 0x10 62#define USB251XB_DEF_POWER_ON_TIME 0x32 63 64#define USB251XB_ADDR_LANGUAGE_ID_HIGH 0x11 65#define USB251XB_ADDR_LANGUAGE_ID_LOW 0x12 66#define USB251XB_DEF_LANGUAGE_ID 0x0000 67 68#define USB251XB_STRING_BUFSIZE 62 69#define USB251XB_ADDR_MANUFACTURER_STRING_LEN 0x13 70#define USB251XB_ADDR_MANUFACTURER_STRING 0x16 71#define USB251XB_DEF_MANUFACTURER_STRING "Microchip" 72 73#define USB251XB_ADDR_PRODUCT_STRING_LEN 0x14 74#define USB251XB_ADDR_PRODUCT_STRING 0x54 75 76#define USB251XB_ADDR_SERIAL_STRING_LEN 0x15 77#define USB251XB_ADDR_SERIAL_STRING 0x92 78#define USB251XB_DEF_SERIAL_STRING "" 79 80#define USB251XB_ADDR_BATTERY_CHARGING_ENABLE 0xD0 81#define USB251XB_DEF_BATTERY_CHARGING_ENABLE 0x00 82 83#define USB251XB_ADDR_BOOST_UP 0xF6 84#define USB251XB_DEF_BOOST_UP 0x00 85#define USB251XB_ADDR_BOOST_57 0xF7 86#define USB251XB_DEF_BOOST_57 0x00 87#define USB251XB_ADDR_BOOST_14 0xF8 88#define USB251XB_DEF_BOOST_14 0x00 89 90#define USB251XB_ADDR_PORT_SWAP 0xFA 91#define USB251XB_DEF_PORT_SWAP 0x00 92 93#define USB251XB_ADDR_PORT_MAP_12 0xFB 94#define USB251XB_DEF_PORT_MAP_12 0x00 95#define USB251XB_ADDR_PORT_MAP_34 0xFC 96#define USB251XB_DEF_PORT_MAP_34 0x00 /* USB251{3B/i,4B/i,7/i} only */ 97#define USB251XB_ADDR_PORT_MAP_56 0xFD 98#define USB251XB_DEF_PORT_MAP_56 0x00 /* USB2517/i only */ 99#define USB251XB_ADDR_PORT_MAP_7 0xFE 100#define USB251XB_DEF_PORT_MAP_7 0x00 /* USB2517/i only */ 101 102#define USB251XB_ADDR_STATUS_COMMAND 0xFF 103#define USB251XB_STATUS_COMMAND_SMBUS_DOWN 0x04 104#define USB251XB_STATUS_COMMAND_RESET 0x02 105#define USB251XB_STATUS_COMMAND_ATTACH 0x01 106 107#define USB251XB_I2C_REG_SZ 0x100 108#define USB251XB_I2C_WRITE_SZ 0x10 109 110#define DRIVER_NAME "usb251xb" 111#define DRIVER_DESC "Microchip USB 2.0 Hi-Speed Hub Controller" 112 113struct usb251xb { 114 struct device *dev; 115 struct i2c_client *i2c; 116 struct regulator *vdd; 117 u8 skip_config; 118 struct gpio_desc *gpio_reset; 119 u16 vendor_id; 120 u16 product_id; 121 u16 device_id; 122 u8 conf_data1; 123 u8 conf_data2; 124 u8 conf_data3; 125 u8 non_rem_dev; 126 u8 port_disable_sp; 127 u8 port_disable_bp; 128 u8 max_power_sp; 129 u8 max_power_bp; 130 u8 max_current_sp; 131 u8 max_current_bp; 132 u8 power_on_time; 133 u16 lang_id; 134 u8 manufacturer_len; 135 u8 product_len; 136 u8 serial_len; 137 char manufacturer[USB251XB_STRING_BUFSIZE]; 138 char product[USB251XB_STRING_BUFSIZE]; 139 char serial[USB251XB_STRING_BUFSIZE]; 140 u8 bat_charge_en; 141 u8 boost_up; 142 u8 boost_57; 143 u8 boost_14; 144 u8 port_swap; 145 u8 port_map12; 146 u8 port_map34; 147 u8 port_map56; 148 u8 port_map7; 149 u8 status; 150}; 151 152struct usb251xb_data { 153 u16 product_id; 154 u8 port_cnt; 155 bool led_support; 156 bool bat_support; 157 char product_str[USB251XB_STRING_BUFSIZE / 2]; /* ASCII string */ 158}; 159 160static const struct usb251xb_data usb2422_data = { 161 .product_id = 0x2422, 162 .port_cnt = 2, 163 .led_support = false, 164 .bat_support = true, 165 .product_str = "USB2422", 166}; 167 168static const struct usb251xb_data usb2512b_data = { 169 .product_id = 0x2512, 170 .port_cnt = 2, 171 .led_support = false, 172 .bat_support = true, 173 .product_str = "USB2512B", 174}; 175 176static const struct usb251xb_data usb2512bi_data = { 177 .product_id = 0x2512, 178 .port_cnt = 2, 179 .led_support = false, 180 .bat_support = true, 181 .product_str = "USB2512Bi", 182}; 183 184static const struct usb251xb_data usb2513b_data = { 185 .product_id = 0x2513, 186 .port_cnt = 3, 187 .led_support = false, 188 .bat_support = true, 189 .product_str = "USB2513B", 190}; 191 192static const struct usb251xb_data usb2513bi_data = { 193 .product_id = 0x2513, 194 .port_cnt = 3, 195 .led_support = false, 196 .bat_support = true, 197 .product_str = "USB2513Bi", 198}; 199 200static const struct usb251xb_data usb2514b_data = { 201 .product_id = 0x2514, 202 .port_cnt = 4, 203 .led_support = false, 204 .bat_support = true, 205 .product_str = "USB2514B", 206}; 207 208static const struct usb251xb_data usb2514bi_data = { 209 .product_id = 0x2514, 210 .port_cnt = 4, 211 .led_support = false, 212 .bat_support = true, 213 .product_str = "USB2514Bi", 214}; 215 216static const struct usb251xb_data usb2517_data = { 217 .product_id = 0x2517, 218 .port_cnt = 7, 219 .led_support = true, 220 .bat_support = false, 221 .product_str = "USB2517", 222}; 223 224static const struct usb251xb_data usb2517i_data = { 225 .product_id = 0x2517, 226 .port_cnt = 7, 227 .led_support = true, 228 .bat_support = false, 229 .product_str = "USB2517i", 230}; 231 232#ifdef CONFIG_GPIOLIB 233static int usb251xb_check_dev_children(struct device *dev, void *child) 234{ 235 if (dev->type == &i2c_adapter_type) { 236 return device_for_each_child(dev, child, 237 usb251xb_check_dev_children); 238 } 239 240 return (dev == child); 241} 242 243static int usb251x_check_gpio_chip(struct usb251xb *hub) 244{ 245 struct gpio_chip *gc = gpiod_to_chip(hub->gpio_reset); 246 struct i2c_adapter *adap; 247 int ret; 248 249 if (!hub->i2c) 250 return 0; 251 252 if (!hub->gpio_reset) 253 return 0; 254 255 if (!gc) 256 return -EINVAL; 257 258 adap = hub->i2c->adapter; 259 ret = usb251xb_check_dev_children(&adap->dev, gc->parent); 260 if (ret) { 261 dev_err(hub->dev, "Reset GPIO chip is at the same i2c-bus\n"); 262 return -EINVAL; 263 } 264 265 return 0; 266} 267#else 268static int usb251x_check_gpio_chip(struct usb251xb *hub) 269{ 270 return 0; 271} 272#endif 273 274static void usb251xb_reset(struct usb251xb *hub) 275{ 276 if (!hub->gpio_reset) 277 return; 278 279 if (hub->i2c) 280 i2c_lock_bus(hub->i2c->adapter, I2C_LOCK_SEGMENT); 281 282 gpiod_set_value_cansleep(hub->gpio_reset, 1); 283 usleep_range(1, 10); /* >=1us RESET_N asserted */ 284 gpiod_set_value_cansleep(hub->gpio_reset, 0); 285 286 /* wait for hub recovery/stabilization */ 287 usleep_range(500, 750); /* >=500us after RESET_N deasserted */ 288 289 if (hub->i2c) 290 i2c_unlock_bus(hub->i2c->adapter, I2C_LOCK_SEGMENT); 291} 292 293static int usb251xb_connect(struct usb251xb *hub) 294{ 295 struct device *dev = hub->dev; 296 int err, i; 297 char i2c_wb[USB251XB_I2C_REG_SZ]; 298 299 if (!hub->i2c) { 300 usb251xb_reset(hub); 301 dev_info(dev, "hub is put in default configuration.\n"); 302 return 0; 303 } 304 305 memset(i2c_wb, 0, USB251XB_I2C_REG_SZ); 306 307 if (hub->skip_config) { 308 dev_info(dev, "Skip hub configuration, only attach.\n"); 309 i2c_wb[0] = 0x01; 310 i2c_wb[1] = USB251XB_STATUS_COMMAND_ATTACH; 311 312 usb251xb_reset(hub); 313 314 err = i2c_smbus_write_i2c_block_data(hub->i2c, 315 USB251XB_ADDR_STATUS_COMMAND, 2, i2c_wb); 316 if (err) { 317 dev_err(dev, "attaching hub failed: %d\n", err); 318 return err; 319 } 320 return 0; 321 } 322 323 i2c_wb[USB251XB_ADDR_VENDOR_ID_MSB] = (hub->vendor_id >> 8) & 0xFF; 324 i2c_wb[USB251XB_ADDR_VENDOR_ID_LSB] = hub->vendor_id & 0xFF; 325 i2c_wb[USB251XB_ADDR_PRODUCT_ID_MSB] = (hub->product_id >> 8) & 0xFF; 326 i2c_wb[USB251XB_ADDR_PRODUCT_ID_LSB] = hub->product_id & 0xFF; 327 i2c_wb[USB251XB_ADDR_DEVICE_ID_MSB] = (hub->device_id >> 8) & 0xFF; 328 i2c_wb[USB251XB_ADDR_DEVICE_ID_LSB] = hub->device_id & 0xFF; 329 i2c_wb[USB251XB_ADDR_CONFIG_DATA_1] = hub->conf_data1; 330 i2c_wb[USB251XB_ADDR_CONFIG_DATA_2] = hub->conf_data2; 331 i2c_wb[USB251XB_ADDR_CONFIG_DATA_3] = hub->conf_data3; 332 i2c_wb[USB251XB_ADDR_NON_REMOVABLE_DEVICES] = hub->non_rem_dev; 333 i2c_wb[USB251XB_ADDR_PORT_DISABLE_SELF] = hub->port_disable_sp; 334 i2c_wb[USB251XB_ADDR_PORT_DISABLE_BUS] = hub->port_disable_bp; 335 i2c_wb[USB251XB_ADDR_MAX_POWER_SELF] = hub->max_power_sp; 336 i2c_wb[USB251XB_ADDR_MAX_POWER_BUS] = hub->max_power_bp; 337 i2c_wb[USB251XB_ADDR_MAX_CURRENT_SELF] = hub->max_current_sp; 338 i2c_wb[USB251XB_ADDR_MAX_CURRENT_BUS] = hub->max_current_bp; 339 i2c_wb[USB251XB_ADDR_POWER_ON_TIME] = hub->power_on_time; 340 i2c_wb[USB251XB_ADDR_LANGUAGE_ID_HIGH] = (hub->lang_id >> 8) & 0xFF; 341 i2c_wb[USB251XB_ADDR_LANGUAGE_ID_LOW] = hub->lang_id & 0xFF; 342 i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING_LEN] = hub->manufacturer_len; 343 i2c_wb[USB251XB_ADDR_PRODUCT_STRING_LEN] = hub->product_len; 344 i2c_wb[USB251XB_ADDR_SERIAL_STRING_LEN] = hub->serial_len; 345 memcpy(&i2c_wb[USB251XB_ADDR_MANUFACTURER_STRING], hub->manufacturer, 346 USB251XB_STRING_BUFSIZE); 347 memcpy(&i2c_wb[USB251XB_ADDR_SERIAL_STRING], hub->serial, 348 USB251XB_STRING_BUFSIZE); 349 memcpy(&i2c_wb[USB251XB_ADDR_PRODUCT_STRING], hub->product, 350 USB251XB_STRING_BUFSIZE); 351 i2c_wb[USB251XB_ADDR_BATTERY_CHARGING_ENABLE] = hub->bat_charge_en; 352 i2c_wb[USB251XB_ADDR_BOOST_UP] = hub->boost_up; 353 i2c_wb[USB251XB_ADDR_BOOST_57] = hub->boost_57; 354 i2c_wb[USB251XB_ADDR_BOOST_14] = hub->boost_14; 355 i2c_wb[USB251XB_ADDR_PORT_SWAP] = hub->port_swap; 356 i2c_wb[USB251XB_ADDR_PORT_MAP_12] = hub->port_map12; 357 i2c_wb[USB251XB_ADDR_PORT_MAP_34] = hub->port_map34; 358 i2c_wb[USB251XB_ADDR_PORT_MAP_56] = hub->port_map56; 359 i2c_wb[USB251XB_ADDR_PORT_MAP_7] = hub->port_map7; 360 i2c_wb[USB251XB_ADDR_STATUS_COMMAND] = USB251XB_STATUS_COMMAND_ATTACH; 361 362 usb251xb_reset(hub); 363 364 /* write registers */ 365 for (i = 0; i < (USB251XB_I2C_REG_SZ / USB251XB_I2C_WRITE_SZ); i++) { 366 int offset = i * USB251XB_I2C_WRITE_SZ; 367 char wbuf[USB251XB_I2C_WRITE_SZ + 1]; 368 369 /* The first data byte transferred tells the hub how many data 370 * bytes will follow (byte count). 371 */ 372 wbuf[0] = USB251XB_I2C_WRITE_SZ; 373 memcpy(&wbuf[1], &i2c_wb[offset], USB251XB_I2C_WRITE_SZ); 374 375 dev_dbg(dev, "writing %d byte block %d to 0x%02X\n", 376 USB251XB_I2C_WRITE_SZ, i, offset); 377 378 err = i2c_smbus_write_i2c_block_data(hub->i2c, offset, 379 USB251XB_I2C_WRITE_SZ + 1, 380 wbuf); 381 if (err) 382 goto out_err; 383 } 384 385 dev_info(dev, "Hub configuration was successful.\n"); 386 return 0; 387 388out_err: 389 dev_err(dev, "configuring block %d failed: %d\n", i, err); 390 return err; 391} 392 393static void usb251xb_get_ports_field(struct usb251xb *hub, 394 const char *prop_name, u8 port_cnt, 395 bool ds_only, u8 *fld) 396{ 397 struct device *dev = hub->dev; 398 u32 port; 399 400 of_property_for_each_u32(dev->of_node, prop_name, port) { 401 if ((port >= ds_only ? 1 : 0) && (port <= port_cnt)) 402 *fld |= BIT(port); 403 else 404 dev_warn(dev, "port %u doesn't exist\n", port); 405 } 406} 407 408static int usb251xb_get_ofdata(struct usb251xb *hub, 409 const struct usb251xb_data *data) 410{ 411 struct device *dev = hub->dev; 412 struct device_node *np = dev->of_node; 413 int len; 414 u32 property_u32 = 0; 415 const char *cproperty_char; 416 char str[USB251XB_STRING_BUFSIZE / 2]; 417 418 if (!np) { 419 dev_err(dev, "failed to get ofdata\n"); 420 return -ENODEV; 421 } 422 423 hub->skip_config = of_property_read_bool(np, "skip-config"); 424 425 hub->gpio_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); 426 if (IS_ERR(hub->gpio_reset)) 427 return dev_err_probe(dev, PTR_ERR(hub->gpio_reset), 428 "unable to request GPIO reset pin\n"); 429 430 if (of_property_read_u16(np, "vendor-id", &hub->vendor_id)) 431 hub->vendor_id = USB251XB_DEF_VENDOR_ID; 432 433 if (of_property_read_u16(np, "product-id", &hub->product_id)) 434 hub->product_id = data->product_id; 435 436 if (of_property_read_u16(np, "device-id", &hub->device_id)) 437 hub->device_id = USB251XB_DEF_DEVICE_ID; 438 439 hub->conf_data1 = USB251XB_DEF_CONFIG_DATA_1; 440 if (of_property_read_bool(np, "self-powered")) { 441 hub->conf_data1 |= BIT(7); 442 443 /* Configure Over-Current sens when self-powered */ 444 hub->conf_data1 &= ~BIT(2); 445 if (of_property_read_bool(np, "ganged-sensing")) 446 hub->conf_data1 &= ~BIT(1); 447 else if (of_property_read_bool(np, "individual-sensing")) 448 hub->conf_data1 |= BIT(1); 449 } else if (of_property_read_bool(np, "bus-powered")) { 450 hub->conf_data1 &= ~BIT(7); 451 452 /* Disable Over-Current sense when bus-powered */ 453 hub->conf_data1 |= BIT(2); 454 } 455 456 if (of_property_read_bool(np, "disable-hi-speed")) 457 hub->conf_data1 |= BIT(5); 458 459 if (of_property_read_bool(np, "multi-tt")) 460 hub->conf_data1 |= BIT(4); 461 else if (of_property_read_bool(np, "single-tt")) 462 hub->conf_data1 &= ~BIT(4); 463 464 if (of_property_read_bool(np, "disable-eop")) 465 hub->conf_data1 |= BIT(3); 466 467 if (of_property_read_bool(np, "individual-port-switching")) 468 hub->conf_data1 |= BIT(0); 469 else if (of_property_read_bool(np, "ganged-port-switching")) 470 hub->conf_data1 &= ~BIT(0); 471 472 hub->conf_data2 = USB251XB_DEF_CONFIG_DATA_2; 473 if (of_property_read_bool(np, "dynamic-power-switching")) 474 hub->conf_data2 |= BIT(7); 475 476 if (!of_property_read_u32(np, "oc-delay-us", &property_u32)) { 477 if (property_u32 == 100) { 478 /* 100 us*/ 479 hub->conf_data2 &= ~BIT(5); 480 hub->conf_data2 &= ~BIT(4); 481 } else if (property_u32 == 4000) { 482 /* 4 ms */ 483 hub->conf_data2 &= ~BIT(5); 484 hub->conf_data2 |= BIT(4); 485 } else if (property_u32 == 16000) { 486 /* 16 ms */ 487 hub->conf_data2 |= BIT(5); 488 hub->conf_data2 |= BIT(4); 489 } else { 490 /* 8 ms (DEFAULT) */ 491 hub->conf_data2 |= BIT(5); 492 hub->conf_data2 &= ~BIT(4); 493 } 494 } 495 496 if (of_property_read_bool(np, "compound-device")) 497 hub->conf_data2 |= BIT(3); 498 499 hub->conf_data3 = USB251XB_DEF_CONFIG_DATA_3; 500 if (of_property_read_bool(np, "port-mapping-mode")) 501 hub->conf_data3 |= BIT(3); 502 503 if (data->led_support && of_get_property(np, "led-usb-mode", NULL)) 504 hub->conf_data3 &= ~BIT(1); 505 506 if (of_property_read_bool(np, "string-support")) 507 hub->conf_data3 |= BIT(0); 508 509 hub->non_rem_dev = USB251XB_DEF_NON_REMOVABLE_DEVICES; 510 usb251xb_get_ports_field(hub, "non-removable-ports", data->port_cnt, 511 true, &hub->non_rem_dev); 512 513 hub->port_disable_sp = USB251XB_DEF_PORT_DISABLE_SELF; 514 usb251xb_get_ports_field(hub, "sp-disabled-ports", data->port_cnt, 515 true, &hub->port_disable_sp); 516 517 hub->port_disable_bp = USB251XB_DEF_PORT_DISABLE_BUS; 518 usb251xb_get_ports_field(hub, "bp-disabled-ports", data->port_cnt, 519 true, &hub->port_disable_bp); 520 521 hub->max_power_sp = USB251XB_DEF_MAX_POWER_SELF; 522 if (!of_property_read_u32(np, "sp-max-total-current-microamp", 523 &property_u32)) 524 hub->max_power_sp = min_t(u8, property_u32 / 2000, 50); 525 526 hub->max_power_bp = USB251XB_DEF_MAX_POWER_BUS; 527 if (!of_property_read_u32(np, "bp-max-total-current-microamp", 528 &property_u32)) 529 hub->max_power_bp = min_t(u8, property_u32 / 2000, 255); 530 531 hub->max_current_sp = USB251XB_DEF_MAX_CURRENT_SELF; 532 if (!of_property_read_u32(np, "sp-max-removable-current-microamp", 533 &property_u32)) 534 hub->max_current_sp = min_t(u8, property_u32 / 2000, 50); 535 536 hub->max_current_bp = USB251XB_DEF_MAX_CURRENT_BUS; 537 if (!of_property_read_u32(np, "bp-max-removable-current-microamp", 538 &property_u32)) 539 hub->max_current_bp = min_t(u8, property_u32 / 2000, 255); 540 541 hub->power_on_time = USB251XB_DEF_POWER_ON_TIME; 542 if (!of_property_read_u32(np, "power-on-time-ms", &property_u32)) 543 hub->power_on_time = min_t(u8, property_u32 / 2, 255); 544 545 if (of_property_read_u16(np, "language-id", &hub->lang_id)) 546 hub->lang_id = USB251XB_DEF_LANGUAGE_ID; 547 548 if (of_property_read_u8(np, "boost-up", &hub->boost_up)) 549 hub->boost_up = USB251XB_DEF_BOOST_UP; 550 551 cproperty_char = of_get_property(np, "manufacturer", NULL); 552 strscpy(str, cproperty_char ? : USB251XB_DEF_MANUFACTURER_STRING, 553 sizeof(str)); 554 hub->manufacturer_len = strlen(str) & 0xFF; 555 memset(hub->manufacturer, 0, USB251XB_STRING_BUFSIZE); 556 len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); 557 len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN, 558 (wchar_t *)hub->manufacturer, 559 USB251XB_STRING_BUFSIZE); 560 561 cproperty_char = of_get_property(np, "product", NULL); 562 strscpy(str, cproperty_char ? : data->product_str, sizeof(str)); 563 hub->product_len = strlen(str) & 0xFF; 564 memset(hub->product, 0, USB251XB_STRING_BUFSIZE); 565 len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); 566 len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN, 567 (wchar_t *)hub->product, 568 USB251XB_STRING_BUFSIZE); 569 570 cproperty_char = of_get_property(np, "serial", NULL); 571 strscpy(str, cproperty_char ? : USB251XB_DEF_SERIAL_STRING, 572 sizeof(str)); 573 hub->serial_len = strlen(str) & 0xFF; 574 memset(hub->serial, 0, USB251XB_STRING_BUFSIZE); 575 len = min_t(size_t, USB251XB_STRING_BUFSIZE / 2, strlen(str)); 576 len = utf8s_to_utf16s(str, len, UTF16_LITTLE_ENDIAN, 577 (wchar_t *)hub->serial, 578 USB251XB_STRING_BUFSIZE); 579 580 /* 581 * The datasheet documents the register as 'Port Swap' but in real the 582 * register controls the USB DP/DM signal swapping for each port. 583 */ 584 hub->port_swap = USB251XB_DEF_PORT_SWAP; 585 usb251xb_get_ports_field(hub, "swap-dx-lanes", data->port_cnt, 586 false, &hub->port_swap); 587 588 /* The following parameters are currently not exposed to devicetree, but 589 * may be as soon as needed. 590 */ 591 hub->bat_charge_en = USB251XB_DEF_BATTERY_CHARGING_ENABLE; 592 hub->boost_57 = USB251XB_DEF_BOOST_57; 593 hub->boost_14 = USB251XB_DEF_BOOST_14; 594 hub->port_map12 = USB251XB_DEF_PORT_MAP_12; 595 hub->port_map34 = USB251XB_DEF_PORT_MAP_34; 596 hub->port_map56 = USB251XB_DEF_PORT_MAP_56; 597 hub->port_map7 = USB251XB_DEF_PORT_MAP_7; 598 599 return 0; 600} 601 602static const struct of_device_id usb251xb_of_match[] = { 603 { 604 .compatible = "microchip,usb2422", 605 .data = &usb2422_data, 606 }, { 607 .compatible = "microchip,usb2512b", 608 .data = &usb2512b_data, 609 }, { 610 .compatible = "microchip,usb2512bi", 611 .data = &usb2512bi_data, 612 }, { 613 .compatible = "microchip,usb2513b", 614 .data = &usb2513b_data, 615 }, { 616 .compatible = "microchip,usb2513bi", 617 .data = &usb2513bi_data, 618 }, { 619 .compatible = "microchip,usb2514b", 620 .data = &usb2514b_data, 621 }, { 622 .compatible = "microchip,usb2514bi", 623 .data = &usb2514bi_data, 624 }, { 625 .compatible = "microchip,usb2517", 626 .data = &usb2517_data, 627 }, { 628 .compatible = "microchip,usb2517i", 629 .data = &usb2517i_data, 630 }, { 631 /* sentinel */ 632 } 633}; 634MODULE_DEVICE_TABLE(of, usb251xb_of_match); 635 636static void usb251xb_regulator_disable_action(void *data) 637{ 638 struct usb251xb *hub = data; 639 640 regulator_disable(hub->vdd); 641} 642 643static int usb251xb_probe(struct usb251xb *hub) 644{ 645 struct device *dev = hub->dev; 646 struct device_node *np = dev->of_node; 647 const struct usb251xb_data *usb_data = of_device_get_match_data(dev); 648 int err; 649 650 if (np && usb_data) { 651 err = usb251xb_get_ofdata(hub, usb_data); 652 if (err) 653 return dev_err_probe(dev, err, "failed to get ofdata\n"); 654 } 655 656 /* 657 * usb251x SMBus-slave SCL lane is muxed with CFG_SEL0 pin. So if anyone 658 * tries to work with the bus at the moment the hub reset is released, 659 * it may cause an invalid config being latched by usb251x. Particularly 660 * one of the config modes makes the hub loading a default registers 661 * value without SMBus-slave interface activation. If the hub 662 * accidentally gets this mode, this will cause the driver SMBus- 663 * functions failure. Normally we could just lock the SMBus-segment the 664 * hub i2c-interface resides for the device-specific reset timing. But 665 * the GPIO controller, which is used to handle the hub reset, might be 666 * placed at the same i2c-bus segment. In this case an error should be 667 * returned since we can't safely use the GPIO controller to clear the 668 * reset state (it may affect the hub configuration) and we can't lock 669 * the i2c-bus segment (it will cause a deadlock). 670 */ 671 err = usb251x_check_gpio_chip(hub); 672 if (err) 673 return err; 674 675 hub->vdd = devm_regulator_get(dev, "vdd"); 676 if (IS_ERR(hub->vdd)) 677 return PTR_ERR(hub->vdd); 678 679 err = regulator_enable(hub->vdd); 680 if (err) 681 return err; 682 683 err = devm_add_action_or_reset(dev, 684 usb251xb_regulator_disable_action, hub); 685 if (err) 686 return err; 687 688 err = usb251xb_connect(hub); 689 if (err) { 690 dev_err(dev, "Failed to connect hub (%d)\n", err); 691 return err; 692 } 693 694 dev_info(dev, "Hub probed successfully\n"); 695 696 return 0; 697} 698 699static int usb251xb_i2c_probe(struct i2c_client *i2c) 700{ 701 struct usb251xb *hub; 702 703 hub = devm_kzalloc(&i2c->dev, sizeof(struct usb251xb), GFP_KERNEL); 704 if (!hub) 705 return -ENOMEM; 706 707 i2c_set_clientdata(i2c, hub); 708 hub->dev = &i2c->dev; 709 hub->i2c = i2c; 710 711 return usb251xb_probe(hub); 712} 713 714static int usb251xb_suspend(struct usb251xb *hub) 715{ 716 return regulator_disable(hub->vdd); 717} 718 719static int usb251xb_resume(struct usb251xb *hub) 720{ 721 int err; 722 723 err = regulator_enable(hub->vdd); 724 if (err) 725 return err; 726 727 return usb251xb_connect(hub); 728} 729 730static int usb251xb_i2c_suspend(struct device *dev) 731{ 732 struct i2c_client *client = to_i2c_client(dev); 733 struct usb251xb *hub = i2c_get_clientdata(client); 734 735 return usb251xb_suspend(hub); 736} 737 738static int usb251xb_i2c_resume(struct device *dev) 739{ 740 struct i2c_client *client = to_i2c_client(dev); 741 struct usb251xb *hub = i2c_get_clientdata(client); 742 743 return usb251xb_resume(hub); 744} 745 746static DEFINE_SIMPLE_DEV_PM_OPS(usb251xb_i2c_pm_ops, usb251xb_i2c_suspend, usb251xb_i2c_resume); 747 748static const struct i2c_device_id usb251xb_id[] = { 749 { "usb2422" }, 750 { "usb2512b" }, 751 { "usb2512bi" }, 752 { "usb2513b" }, 753 { "usb2513bi" }, 754 { "usb2514b" }, 755 { "usb2514bi" }, 756 { "usb2517" }, 757 { "usb2517i" }, 758 { /* sentinel */ } 759}; 760MODULE_DEVICE_TABLE(i2c, usb251xb_id); 761 762static struct i2c_driver usb251xb_i2c_driver = { 763 .driver = { 764 .name = DRIVER_NAME, 765 .of_match_table = usb251xb_of_match, 766 .pm = pm_sleep_ptr(&usb251xb_i2c_pm_ops), 767 }, 768 .probe = usb251xb_i2c_probe, 769 .id_table = usb251xb_id, 770}; 771 772static int usb251xb_plat_probe(struct platform_device *pdev) 773{ 774 struct usb251xb *hub; 775 776 hub = devm_kzalloc(&pdev->dev, sizeof(*hub), GFP_KERNEL); 777 if (!hub) 778 return -ENOMEM; 779 780 platform_set_drvdata(pdev, hub); 781 hub->dev = &pdev->dev; 782 783 return usb251xb_probe(hub); 784} 785 786static int usb251xb_plat_suspend(struct device *dev) 787{ 788 return usb251xb_suspend(dev_get_drvdata(dev)); 789} 790 791static int usb251xb_plat_resume(struct device *dev) 792{ 793 return usb251xb_resume(dev_get_drvdata(dev)); 794} 795 796static DEFINE_SIMPLE_DEV_PM_OPS(usb251xb_plat_pm_ops, usb251xb_plat_suspend, usb251xb_plat_resume); 797 798static struct platform_driver usb251xb_plat_driver = { 799 .driver = { 800 .name = DRIVER_NAME, 801 .of_match_table = usb251xb_of_match, 802 .pm = pm_sleep_ptr(&usb251xb_plat_pm_ops), 803 }, 804 .probe = usb251xb_plat_probe, 805}; 806 807static int __init usb251xb_init(void) 808{ 809 int err; 810 811 err = i2c_add_driver(&usb251xb_i2c_driver); 812 if (err) 813 return err; 814 815 err = platform_driver_register(&usb251xb_plat_driver); 816 if (err) { 817 i2c_del_driver(&usb251xb_i2c_driver); 818 return err; 819 } 820 821 return 0; 822} 823module_init(usb251xb_init); 824 825static void __exit usb251xb_exit(void) 826{ 827 platform_driver_unregister(&usb251xb_plat_driver); 828 i2c_del_driver(&usb251xb_i2c_driver); 829} 830module_exit(usb251xb_exit); 831 832MODULE_AUTHOR("Richard Leitner <richard.leitner@skidata.com>"); 833MODULE_DESCRIPTION("USB251x/xBi USB 2.0 Hub Controller Driver"); 834MODULE_LICENSE("GPL");
~/
Read-only file preview.