1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * tusb1210.c - TUSB1210 USB ULPI PHY driver 4 * 5 * Copyright (C) 2015 Intel Corporation 6 * 7 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> 8 */ 9 #include <linux/module.h> 10 #include <linux/bitfield.h> 11 #include <linux/delay.h> 12 #include <linux/ulpi/driver.h> 13 #include <linux/ulpi/regs.h> 14 #include <linux/gpio/consumer.h> 15 #include <linux/phy/ulpi_phy.h> 16 #include <linux/power_supply.h> 17 #include <linux/workqueue.h> 18 19 #define TUSB1211_POWER_CONTROL 0x3d 20 #define TUSB1211_POWER_CONTROL_SET 0x3e 21 #define TUSB1211_POWER_CONTROL_CLEAR 0x3f 22 #define TUSB1211_POWER_CONTROL_SW_CONTROL BIT(0) 23 #define TUSB1211_POWER_CONTROL_DET_COMP BIT(1) 24 #define TUSB1211_POWER_CONTROL_DP_VSRC_EN BIT(6) 25 26 #define TUSB1210_VENDOR_SPECIFIC2 0x80 27 #define TUSB1210_VENDOR_SPECIFIC2_IHSTX_MASK GENMASK(3, 0) 28 #define TUSB1210_VENDOR_SPECIFIC2_ZHSDRV_MASK GENMASK(5, 4) 29 #define TUSB1210_VENDOR_SPECIFIC2_DP_MASK BIT(6) 30 31 #define TUSB1211_VENDOR_SPECIFIC3 0x85 32 #define TUSB1211_VENDOR_SPECIFIC3_SET 0x86 33 #define TUSB1211_VENDOR_SPECIFIC3_CLEAR 0x87 34 #define TUSB1211_VENDOR_SPECIFIC3_SW_USB_DET BIT(4) 35 #define TUSB1211_VENDOR_SPECIFIC3_CHGD_IDP_SRC_EN BIT(6) 36 37 #define TUSB1210_RESET_TIME_MS 50 38 39 #define TUSB1210_CHG_DET_MAX_RETRIES 5 40 41 /* TUSB1210 charger detection work states */ 42 enum tusb1210_chg_det_state { 43 TUSB1210_CHG_DET_CONNECTING, 44 TUSB1210_CHG_DET_START_DET, 45 TUSB1210_CHG_DET_READ_DET, 46 TUSB1210_CHG_DET_FINISH_DET, 47 TUSB1210_CHG_DET_CONNECTED, 48 TUSB1210_CHG_DET_DISCONNECTING, 49 TUSB1210_CHG_DET_DISCONNECTING_DONE, 50 TUSB1210_CHG_DET_DISCONNECTED, 51 }; 52 53 struct tusb1210 { 54 struct ulpi *ulpi; 55 struct phy *phy; 56 struct gpio_desc *gpio_reset; 57 struct gpio_desc *gpio_cs; 58 u8 otg_ctrl; 59 u8 vendor_specific2; 60 #ifdef CONFIG_POWER_SUPPLY 61 enum power_supply_usb_type chg_type; 62 enum tusb1210_chg_det_state chg_det_state; 63 int chg_det_retries; 64 struct delayed_work chg_det_work; 65 struct notifier_block psy_nb; 66 struct power_supply *psy; 67 struct power_supply *charger; 68 #endif 69 }; 70 71 static int tusb1210_ulpi_write(struct tusb1210 *tusb, u8 reg, u8 val) 72 { 73 int ret; 74 75 ret = ulpi_write(tusb->ulpi, reg, val); 76 if (ret) 77 dev_err(&tusb->ulpi->dev, "error %d writing val 0x%02x to reg 0x%02x\n", 78 ret, val, reg); 79 80 return ret; 81 } 82 83 static int tusb1210_ulpi_read(struct tusb1210 *tusb, u8 reg, u8 *val) 84 { 85 int ret; 86 87 ret = ulpi_read(tusb->ulpi, reg); 88 if (ret >= 0) { 89 *val = ret; 90 ret = 0; 91 } else { 92 dev_err(&tusb->ulpi->dev, "error %d reading reg 0x%02x\n", ret, reg); 93 } 94 95 return ret; 96 } 97 98 static int tusb1210_power_on(struct phy *phy) 99 { 100 struct tusb1210 *tusb = phy_get_drvdata(phy); 101 102 gpiod_set_value_cansleep(tusb->gpio_reset, 1); 103 gpiod_set_value_cansleep(tusb->gpio_cs, 1); 104 105 msleep(TUSB1210_RESET_TIME_MS); 106 107 /* Restore the optional eye diagram optimization value */ 108 return tusb1210_ulpi_write(tusb, TUSB1210_VENDOR_SPECIFIC2, 109 tusb->vendor_specific2); 110 } 111 112 static int tusb1210_power_off(struct phy *phy) 113 { 114 struct tusb1210 *tusb = phy_get_drvdata(phy); 115 116 gpiod_set_value_cansleep(tusb->gpio_reset, 0); 117 gpiod_set_value_cansleep(tusb->gpio_cs, 0); 118 119 return 0; 120 } 121 122 static int tusb1210_set_mode(struct phy *phy, enum phy_mode mode, int submode) 123 { 124 struct tusb1210 *tusb = phy_get_drvdata(phy); 125 int ret; 126 u8 reg; 127 128 ret = tusb1210_ulpi_read(tusb, ULPI_OTG_CTRL, ®); 129 if (ret < 0) 130 return ret; 131 132 switch (mode) { 133 case PHY_MODE_USB_HOST: 134 reg |= (ULPI_OTG_CTRL_DRVVBUS_EXT 135 | ULPI_OTG_CTRL_ID_PULLUP 136 | ULPI_OTG_CTRL_DP_PULLDOWN 137 | ULPI_OTG_CTRL_DM_PULLDOWN); 138 tusb1210_ulpi_write(tusb, ULPI_OTG_CTRL, reg); 139 reg |= ULPI_OTG_CTRL_DRVVBUS; 140 break; 141 case PHY_MODE_USB_DEVICE: 142 reg &= ~(ULPI_OTG_CTRL_DRVVBUS 143 | ULPI_OTG_CTRL_DP_PULLDOWN 144 | ULPI_OTG_CTRL_DM_PULLDOWN); 145 tusb1210_ulpi_write(tusb, ULPI_OTG_CTRL, reg); 146 reg &= ~ULPI_OTG_CTRL_DRVVBUS_EXT; 147 break; 148 default: 149 /* nothing */ 150 return 0; 151 } 152 153 tusb->otg_ctrl = reg; 154 return tusb1210_ulpi_write(tusb, ULPI_OTG_CTRL, reg); 155 } 156 157 #ifdef CONFIG_POWER_SUPPLY 158 const char * const tusb1210_chg_det_states[] = { 159 "CHG_DET_CONNECTING", 160 "CHG_DET_START_DET", 161 "CHG_DET_READ_DET", 162 "CHG_DET_FINISH_DET", 163 "CHG_DET_CONNECTED", 164 "CHG_DET_DISCONNECTING", 165 "CHG_DET_DISCONNECTING_DONE", 166 "CHG_DET_DISCONNECTED", 167 }; 168 169 static void tusb1210_reset(struct tusb1210 *tusb) 170 { 171 gpiod_set_value_cansleep(tusb->gpio_reset, 0); 172 usleep_range(200, 500); 173 gpiod_set_value_cansleep(tusb->gpio_reset, 1); 174 } 175 176 static void tusb1210_chg_det_set_type(struct tusb1210 *tusb, 177 enum power_supply_usb_type type) 178 { 179 dev_dbg(&tusb->ulpi->dev, "charger type: %d\n", type); 180 tusb->chg_type = type; 181 tusb->chg_det_retries = 0; 182 power_supply_changed(tusb->psy); 183 } 184 185 static void tusb1210_chg_det_set_state(struct tusb1210 *tusb, 186 enum tusb1210_chg_det_state new_state, 187 int delay_ms) 188 { 189 if (delay_ms) 190 dev_dbg(&tusb->ulpi->dev, "chg_det new state %s in %d ms\n", 191 tusb1210_chg_det_states[new_state], delay_ms); 192 193 tusb->chg_det_state = new_state; 194 mod_delayed_work(system_long_wq, &tusb->chg_det_work, 195 msecs_to_jiffies(delay_ms)); 196 } 197 198 static void tusb1210_chg_det_handle_ulpi_error(struct tusb1210 *tusb) 199 { 200 tusb1210_reset(tusb); 201 if (tusb->chg_det_retries < TUSB1210_CHG_DET_MAX_RETRIES) { 202 tusb->chg_det_retries++; 203 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_START_DET, 204 TUSB1210_RESET_TIME_MS); 205 } else { 206 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_FINISH_DET, 207 TUSB1210_RESET_TIME_MS); 208 } 209 } 210 211 /* 212 * Boards using a TUSB121x for charger-detection have 3 power_supply class devs: 213 * 214 * tusb1211-charger-detect(1) -> charger -> fuel-gauge 215 * 216 * To determine if an USB charger is connected to the board, the online prop of 217 * the charger psy needs to be read. Since the tusb1211-charger-detect psy is 218 * the start of the supplier -> supplied-to chain, power_supply_am_i_supplied() 219 * cannot be used here. 220 * 221 * Instead, below is a list of the power_supply names of known chargers for 222 * these boards and the charger psy is looked up by name from this list. 223 * 224 * (1) modelling the external USB charger 225 */ 226 static const char * const tusb1210_chargers[] = { 227 "bq24190-charger", 228 }; 229 230 static bool tusb1210_get_online(struct tusb1210 *tusb) 231 { 232 union power_supply_propval val; 233 int i; 234 235 for (i = 0; i < ARRAY_SIZE(tusb1210_chargers) && !tusb->charger; i++) 236 tusb->charger = power_supply_get_by_name(tusb1210_chargers[i]); 237 238 if (!tusb->charger) 239 return false; 240 241 if (power_supply_get_property(tusb->charger, POWER_SUPPLY_PROP_ONLINE, &val)) 242 return false; 243 244 return val.intval; 245 } 246 247 static void tusb1210_chg_det_work(struct work_struct *work) 248 { 249 struct tusb1210 *tusb = container_of(work, struct tusb1210, chg_det_work.work); 250 bool vbus_present = tusb1210_get_online(tusb); 251 int ret; 252 u8 val; 253 254 dev_dbg(&tusb->ulpi->dev, "chg_det state %s vbus_present %d\n", 255 tusb1210_chg_det_states[tusb->chg_det_state], vbus_present); 256 257 switch (tusb->chg_det_state) { 258 case TUSB1210_CHG_DET_CONNECTING: 259 tusb->chg_type = POWER_SUPPLY_USB_TYPE_UNKNOWN; 260 tusb->chg_det_retries = 0; 261 /* Power on USB controller for ulpi_read()/_write() */ 262 ret = pm_runtime_resume_and_get(tusb->ulpi->dev.parent); 263 if (ret < 0) { 264 dev_err(&tusb->ulpi->dev, "error %d runtime-resuming\n", ret); 265 /* Should never happen, skip charger detection */ 266 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_CONNECTED, 0); 267 return; 268 } 269 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_START_DET, 0); 270 break; 271 case TUSB1210_CHG_DET_START_DET: 272 /* 273 * Use the builtin charger detection FSM to keep things simple. 274 * This only detects DCP / SDP. This is good enough for the few 275 * boards which actually rely on the phy for charger detection. 276 */ 277 mutex_lock(&tusb->phy->mutex); 278 ret = tusb1210_ulpi_write(tusb, TUSB1211_VENDOR_SPECIFIC3_SET, 279 TUSB1211_VENDOR_SPECIFIC3_SW_USB_DET); 280 mutex_unlock(&tusb->phy->mutex); 281 if (ret) { 282 tusb1210_chg_det_handle_ulpi_error(tusb); 283 break; 284 } 285 286 /* Wait 400 ms for the charger detection FSM to finish */ 287 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_READ_DET, 400); 288 break; 289 case TUSB1210_CHG_DET_READ_DET: 290 mutex_lock(&tusb->phy->mutex); 291 ret = tusb1210_ulpi_read(tusb, TUSB1211_POWER_CONTROL, &val); 292 mutex_unlock(&tusb->phy->mutex); 293 if (ret) { 294 tusb1210_chg_det_handle_ulpi_error(tusb); 295 break; 296 } 297 298 if (val & TUSB1211_POWER_CONTROL_DET_COMP) 299 tusb1210_chg_det_set_type(tusb, POWER_SUPPLY_USB_TYPE_DCP); 300 else 301 tusb1210_chg_det_set_type(tusb, POWER_SUPPLY_USB_TYPE_SDP); 302 303 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_FINISH_DET, 0); 304 break; 305 case TUSB1210_CHG_DET_FINISH_DET: 306 mutex_lock(&tusb->phy->mutex); 307 308 /* Set SW_CONTROL to stop the charger-det FSM */ 309 ret = tusb1210_ulpi_write(tusb, TUSB1211_POWER_CONTROL_SET, 310 TUSB1211_POWER_CONTROL_SW_CONTROL); 311 312 /* Clear DP_VSRC_EN which may have been enabled by the charger-det FSM */ 313 ret |= tusb1210_ulpi_write(tusb, TUSB1211_POWER_CONTROL_CLEAR, 314 TUSB1211_POWER_CONTROL_DP_VSRC_EN); 315 316 /* Clear CHGD_IDP_SRC_EN (may have been enabled by the charger-det FSM) */ 317 ret |= tusb1210_ulpi_write(tusb, TUSB1211_VENDOR_SPECIFIC3_CLEAR, 318 TUSB1211_VENDOR_SPECIFIC3_CHGD_IDP_SRC_EN); 319 320 /* If any of the above fails reset the phy */ 321 if (ret) { 322 tusb1210_reset(tusb); 323 msleep(TUSB1210_RESET_TIME_MS); 324 } 325 326 /* Restore phy-parameters and OTG_CTRL register */ 327 tusb1210_ulpi_write(tusb, ULPI_OTG_CTRL, tusb->otg_ctrl); 328 tusb1210_ulpi_write(tusb, TUSB1210_VENDOR_SPECIFIC2, 329 tusb->vendor_specific2); 330 331 mutex_unlock(&tusb->phy->mutex); 332 333 pm_runtime_put(tusb->ulpi->dev.parent); 334 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_CONNECTED, 0); 335 break; 336 case TUSB1210_CHG_DET_CONNECTED: 337 if (!vbus_present) 338 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_DISCONNECTING, 0); 339 break; 340 case TUSB1210_CHG_DET_DISCONNECTING: 341 /* 342 * The phy seems to take approx. 600ms longer then the charger 343 * chip (which is used to get vbus_present) to determine Vbus 344 * session end. Wait 800ms to ensure the phy has detected and 345 * signalled Vbus session end. 346 */ 347 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_DISCONNECTING_DONE, 800); 348 break; 349 case TUSB1210_CHG_DET_DISCONNECTING_DONE: 350 /* 351 * The phy often stops reacting to ulpi_read()/_write requests 352 * after a Vbus-session end. Reset it to work around this. 353 */ 354 tusb1210_reset(tusb); 355 tusb1210_chg_det_set_type(tusb, POWER_SUPPLY_USB_TYPE_UNKNOWN); 356 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_DISCONNECTED, 0); 357 break; 358 case TUSB1210_CHG_DET_DISCONNECTED: 359 if (vbus_present) 360 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_CONNECTING, 0); 361 break; 362 } 363 } 364 365 static int tusb1210_psy_notifier(struct notifier_block *nb, 366 unsigned long event, void *ptr) 367 { 368 struct tusb1210 *tusb = container_of(nb, struct tusb1210, psy_nb); 369 struct power_supply *psy = ptr; 370 371 if (psy != tusb->psy && psy->desc->type == POWER_SUPPLY_TYPE_USB) 372 queue_delayed_work(system_long_wq, &tusb->chg_det_work, 0); 373 374 return NOTIFY_OK; 375 } 376 377 static int tusb1210_psy_get_prop(struct power_supply *psy, 378 enum power_supply_property psp, 379 union power_supply_propval *val) 380 { 381 struct tusb1210 *tusb = power_supply_get_drvdata(psy); 382 383 switch (psp) { 384 case POWER_SUPPLY_PROP_ONLINE: 385 val->intval = tusb1210_get_online(tusb); 386 break; 387 case POWER_SUPPLY_PROP_USB_TYPE: 388 val->intval = tusb->chg_type; 389 break; 390 case POWER_SUPPLY_PROP_CURRENT_MAX: 391 if (tusb->chg_type == POWER_SUPPLY_USB_TYPE_DCP) 392 val->intval = 2000000; 393 else 394 val->intval = 500000; 395 break; 396 default: 397 return -EINVAL; 398 } 399 400 return 0; 401 } 402 403 static const enum power_supply_usb_type tusb1210_psy_usb_types[] = { 404 POWER_SUPPLY_USB_TYPE_SDP, 405 POWER_SUPPLY_USB_TYPE_DCP, 406 POWER_SUPPLY_USB_TYPE_UNKNOWN, 407 }; 408 409 static const enum power_supply_property tusb1210_psy_props[] = { 410 POWER_SUPPLY_PROP_ONLINE, 411 POWER_SUPPLY_PROP_USB_TYPE, 412 POWER_SUPPLY_PROP_CURRENT_MAX, 413 }; 414 415 static const struct power_supply_desc tusb1210_psy_desc = { 416 .name = "tusb1211-charger-detect", 417 .type = POWER_SUPPLY_TYPE_USB, 418 .usb_types = tusb1210_psy_usb_types, 419 .num_usb_types = ARRAY_SIZE(tusb1210_psy_usb_types), 420 .properties = tusb1210_psy_props, 421 .num_properties = ARRAY_SIZE(tusb1210_psy_props), 422 .get_property = tusb1210_psy_get_prop, 423 }; 424 425 /* Setup charger detection if requested, on errors continue without chg-det */ 426 static void tusb1210_probe_charger_detect(struct tusb1210 *tusb) 427 { 428 struct power_supply_config psy_cfg = { .drv_data = tusb }; 429 struct device *dev = &tusb->ulpi->dev; 430 int ret; 431 432 if (!device_property_read_bool(dev->parent, "linux,phy_charger_detect")) 433 return; 434 435 if (tusb->ulpi->id.product != 0x1508) { 436 dev_err(dev, "error charger detection is only supported on the TUSB1211\n"); 437 return; 438 } 439 440 ret = tusb1210_ulpi_read(tusb, ULPI_OTG_CTRL, &tusb->otg_ctrl); 441 if (ret) 442 return; 443 444 tusb->psy = power_supply_register(dev, &tusb1210_psy_desc, &psy_cfg); 445 if (IS_ERR(tusb->psy)) 446 return; 447 448 /* 449 * Delay initial run by 2 seconds to allow the charger driver, 450 * which is used to determine vbus_present, to load. 451 */ 452 tusb->chg_det_state = TUSB1210_CHG_DET_DISCONNECTED; 453 INIT_DELAYED_WORK(&tusb->chg_det_work, tusb1210_chg_det_work); 454 queue_delayed_work(system_long_wq, &tusb->chg_det_work, 2 * HZ); 455 456 tusb->psy_nb.notifier_call = tusb1210_psy_notifier; 457 power_supply_reg_notifier(&tusb->psy_nb); 458 } 459 460 static void tusb1210_remove_charger_detect(struct tusb1210 *tusb) 461 { 462 463 if (!IS_ERR_OR_NULL(tusb->psy)) { 464 power_supply_unreg_notifier(&tusb->psy_nb); 465 cancel_delayed_work_sync(&tusb->chg_det_work); 466 power_supply_unregister(tusb->psy); 467 } 468 469 if (tusb->charger) 470 power_supply_put(tusb->charger); 471 } 472 #else 473 static void tusb1210_probe_charger_detect(struct tusb1210 *tusb) { } 474 static void tusb1210_remove_charger_detect(struct tusb1210 *tusb) { } 475 #endif 476 477 static const struct phy_ops phy_ops = { 478 .power_on = tusb1210_power_on, 479 .power_off = tusb1210_power_off, 480 .set_mode = tusb1210_set_mode, 481 .owner = THIS_MODULE, 482 }; 483 484 static int tusb1210_probe(struct ulpi *ulpi) 485 { 486 struct tusb1210 *tusb; 487 u8 val, reg; 488 int ret; 489 490 tusb = devm_kzalloc(&ulpi->dev, sizeof(*tusb), GFP_KERNEL); 491 if (!tusb) 492 return -ENOMEM; 493 494 tusb->ulpi = ulpi; 495 496 tusb->gpio_reset = devm_gpiod_get_optional(&ulpi->dev, "reset", 497 GPIOD_OUT_LOW); 498 if (IS_ERR(tusb->gpio_reset)) 499 return PTR_ERR(tusb->gpio_reset); 500 501 gpiod_set_value_cansleep(tusb->gpio_reset, 1); 502 503 tusb->gpio_cs = devm_gpiod_get_optional(&ulpi->dev, "cs", 504 GPIOD_OUT_LOW); 505 if (IS_ERR(tusb->gpio_cs)) 506 return PTR_ERR(tusb->gpio_cs); 507 508 gpiod_set_value_cansleep(tusb->gpio_cs, 1); 509 510 /* 511 * VENDOR_SPECIFIC2 register in TUSB1210 can be used for configuring eye 512 * diagram optimization and DP/DM swap. 513 */ 514 515 ret = tusb1210_ulpi_read(tusb, TUSB1210_VENDOR_SPECIFIC2, ®); 516 if (ret) 517 return ret; 518 519 /* High speed output drive strength configuration */ 520 if (!device_property_read_u8(&ulpi->dev, "ihstx", &val)) 521 u8p_replace_bits(®, val, (u8)TUSB1210_VENDOR_SPECIFIC2_IHSTX_MASK); 522 523 /* High speed output impedance configuration */ 524 if (!device_property_read_u8(&ulpi->dev, "zhsdrv", &val)) 525 u8p_replace_bits(®, val, (u8)TUSB1210_VENDOR_SPECIFIC2_ZHSDRV_MASK); 526 527 /* DP/DM swap control */ 528 if (!device_property_read_u8(&ulpi->dev, "datapolarity", &val)) 529 u8p_replace_bits(®, val, (u8)TUSB1210_VENDOR_SPECIFIC2_DP_MASK); 530 531 ret = tusb1210_ulpi_write(tusb, TUSB1210_VENDOR_SPECIFIC2, reg); 532 if (ret) 533 return ret; 534 535 tusb->vendor_specific2 = reg; 536 537 tusb1210_probe_charger_detect(tusb); 538 539 tusb->phy = ulpi_phy_create(ulpi, &phy_ops); 540 if (IS_ERR(tusb->phy)) 541 return PTR_ERR(tusb->phy); 542 543 phy_set_drvdata(tusb->phy, tusb); 544 ulpi_set_drvdata(ulpi, tusb); 545 return 0; 546 } 547 548 static void tusb1210_remove(struct ulpi *ulpi) 549 { 550 struct tusb1210 *tusb = ulpi_get_drvdata(ulpi); 551 552 ulpi_phy_destroy(ulpi, tusb->phy); 553 tusb1210_remove_charger_detect(tusb); 554 } 555 556 #define TI_VENDOR_ID 0x0451 557 558 static const struct ulpi_device_id tusb1210_ulpi_id[] = { 559 { TI_VENDOR_ID, 0x1507, }, /* TUSB1210 */ 560 { TI_VENDOR_ID, 0x1508, }, /* TUSB1211 */ 561 { }, 562 }; 563 MODULE_DEVICE_TABLE(ulpi, tusb1210_ulpi_id); 564 565 static struct ulpi_driver tusb1210_driver = { 566 .id_table = tusb1210_ulpi_id, 567 .probe = tusb1210_probe, 568 .remove = tusb1210_remove, 569 .driver = { 570 .name = "tusb1210", 571 .owner = THIS_MODULE, 572 }, 573 }; 574 575 module_ulpi_driver(tusb1210_driver); 576 577 MODULE_AUTHOR("Intel Corporation"); 578 MODULE_LICENSE("GPL v2"); 579 MODULE_DESCRIPTION("TUSB1210 ULPI PHY driver"); 580