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