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