1 // SPDX-License-Identifier: GPL-2.0-only
3 * tusb1210.c - TUSB1210 USB ULPI PHY driver
5 * Copyright (C) 2015 Intel Corporation
7 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
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>
20 #define TI_VENDOR_ID 0x0451
21 #define TI_DEVICE_TUSB1210 0x1507
22 #define TI_DEVICE_TUSB1211 0x1508
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)
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)
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)
42 #define TUSB1210_RESET_TIME_MS 50
44 #define TUSB1210_CHG_DET_MAX_RETRIES 5
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,
61 struct gpio_desc *gpio_reset;
62 struct gpio_desc *gpio_cs;
65 #ifdef CONFIG_POWER_SUPPLY
66 enum power_supply_usb_type chg_type;
67 enum tusb1210_chg_det_state chg_det_state;
69 struct delayed_work chg_det_work;
70 struct notifier_block psy_nb;
71 struct power_supply *psy;
72 struct power_supply *charger;
76 static int tusb1210_ulpi_write(struct tusb1210 *tusb, u8 reg, u8 val)
78 struct device *dev = tusb->dev;
81 ret = ulpi_write(to_ulpi_dev(dev), reg, val);
83 dev_err(dev, "error %d writing val 0x%02x to reg 0x%02x\n", ret, val, reg);
88 static int tusb1210_ulpi_read(struct tusb1210 *tusb, u8 reg, u8 *val)
90 struct device *dev = tusb->dev;
93 ret = ulpi_read(to_ulpi_dev(dev), reg);
98 dev_err(dev, "error %d reading reg 0x%02x\n", ret, reg);
104 static int tusb1210_power_on(struct phy *phy)
106 struct tusb1210 *tusb = phy_get_drvdata(phy);
108 gpiod_set_value_cansleep(tusb->gpio_reset, 1);
109 gpiod_set_value_cansleep(tusb->gpio_cs, 1);
111 msleep(TUSB1210_RESET_TIME_MS);
113 /* Restore the optional eye diagram optimization value */
114 tusb1210_ulpi_write(tusb, TUSB1210_VENDOR_SPECIFIC2, tusb->vendor_specific2);
119 static int tusb1210_power_off(struct phy *phy)
121 struct tusb1210 *tusb = phy_get_drvdata(phy);
123 gpiod_set_value_cansleep(tusb->gpio_reset, 0);
124 gpiod_set_value_cansleep(tusb->gpio_cs, 0);
129 static int tusb1210_set_mode(struct phy *phy, enum phy_mode mode, int submode)
131 struct tusb1210 *tusb = phy_get_drvdata(phy);
135 ret = tusb1210_ulpi_read(tusb, ULPI_OTG_CTRL, ®);
140 case PHY_MODE_USB_HOST:
141 reg |= (ULPI_OTG_CTRL_DRVVBUS_EXT
142 | ULPI_OTG_CTRL_ID_PULLUP
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;
148 case PHY_MODE_USB_DEVICE:
149 reg &= ~(ULPI_OTG_CTRL_DRVVBUS
150 | ULPI_OTG_CTRL_DP_PULLDOWN
151 | ULPI_OTG_CTRL_DM_PULLDOWN);
152 tusb1210_ulpi_write(tusb, ULPI_OTG_CTRL, reg);
153 reg &= ~ULPI_OTG_CTRL_DRVVBUS_EXT;
160 tusb->otg_ctrl = reg;
161 return tusb1210_ulpi_write(tusb, ULPI_OTG_CTRL, reg);
164 #ifdef CONFIG_POWER_SUPPLY
165 static const char * const tusb1210_chg_det_states[] = {
166 "CHG_DET_CONNECTING",
169 "CHG_DET_FINISH_DET",
171 "CHG_DET_DISCONNECTING",
172 "CHG_DET_DISCONNECTING_DONE",
173 "CHG_DET_DISCONNECTED",
176 static void tusb1210_reset(struct tusb1210 *tusb)
178 gpiod_set_value_cansleep(tusb->gpio_reset, 0);
179 usleep_range(200, 500);
180 gpiod_set_value_cansleep(tusb->gpio_reset, 1);
183 static void tusb1210_chg_det_set_type(struct tusb1210 *tusb,
184 enum power_supply_usb_type type)
186 dev_dbg(tusb->dev, "charger type: %d\n", type);
187 tusb->chg_type = type;
188 tusb->chg_det_retries = 0;
189 power_supply_changed(tusb->psy);
192 static void tusb1210_chg_det_set_state(struct tusb1210 *tusb,
193 enum tusb1210_chg_det_state new_state,
197 dev_dbg(tusb->dev, "chg_det new state %s in %d ms\n",
198 tusb1210_chg_det_states[new_state], delay_ms);
200 tusb->chg_det_state = new_state;
201 mod_delayed_work(system_long_wq, &tusb->chg_det_work,
202 msecs_to_jiffies(delay_ms));
205 static void tusb1210_chg_det_handle_ulpi_error(struct tusb1210 *tusb)
207 tusb1210_reset(tusb);
208 if (tusb->chg_det_retries < TUSB1210_CHG_DET_MAX_RETRIES) {
209 tusb->chg_det_retries++;
210 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_START_DET,
211 TUSB1210_RESET_TIME_MS);
213 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_FINISH_DET,
214 TUSB1210_RESET_TIME_MS);
219 * Boards using a TUSB121x for charger-detection have 3 power_supply class devs:
221 * tusb1211-charger-detect(1) -> charger -> fuel-gauge
223 * To determine if an USB charger is connected to the board, the online prop of
224 * the charger psy needs to be read. Since the tusb1211-charger-detect psy is
225 * the start of the supplier -> supplied-to chain, power_supply_am_i_supplied()
226 * cannot be used here.
228 * Instead, below is a list of the power_supply names of known chargers for
229 * these boards and the charger psy is looked up by name from this list.
231 * (1) modelling the external USB charger
233 static const char * const tusb1210_chargers[] = {
237 static bool tusb1210_get_online(struct tusb1210 *tusb)
239 union power_supply_propval val;
242 for (i = 0; i < ARRAY_SIZE(tusb1210_chargers) && !tusb->charger; i++)
243 tusb->charger = power_supply_get_by_name(tusb1210_chargers[i]);
248 if (power_supply_get_property(tusb->charger, POWER_SUPPLY_PROP_ONLINE, &val))
254 static void tusb1210_chg_det_work(struct work_struct *work)
256 struct tusb1210 *tusb = container_of(work, struct tusb1210, chg_det_work.work);
257 bool vbus_present = tusb1210_get_online(tusb);
261 dev_dbg(tusb->dev, "chg_det state %s vbus_present %d\n",
262 tusb1210_chg_det_states[tusb->chg_det_state], vbus_present);
264 switch (tusb->chg_det_state) {
265 case TUSB1210_CHG_DET_CONNECTING:
266 tusb->chg_type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
267 tusb->chg_det_retries = 0;
268 /* Power on USB controller for ulpi_read()/_write() */
269 ret = pm_runtime_resume_and_get(tusb->dev->parent);
271 dev_err(tusb->dev, "error %d runtime-resuming\n", ret);
272 /* Should never happen, skip charger detection */
273 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_CONNECTED, 0);
276 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_START_DET, 0);
278 case TUSB1210_CHG_DET_START_DET:
280 * Use the builtin charger detection FSM to keep things simple.
281 * This only detects DCP / SDP. This is good enough for the few
282 * boards which actually rely on the phy for charger detection.
284 mutex_lock(&tusb->phy->mutex);
285 ret = tusb1210_ulpi_write(tusb, TUSB1211_VENDOR_SPECIFIC3_SET,
286 TUSB1211_VENDOR_SPECIFIC3_SW_USB_DET);
287 mutex_unlock(&tusb->phy->mutex);
289 tusb1210_chg_det_handle_ulpi_error(tusb);
293 /* Wait 400 ms for the charger detection FSM to finish */
294 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_READ_DET, 400);
296 case TUSB1210_CHG_DET_READ_DET:
297 mutex_lock(&tusb->phy->mutex);
298 ret = tusb1210_ulpi_read(tusb, TUSB1211_POWER_CONTROL, &val);
299 mutex_unlock(&tusb->phy->mutex);
301 tusb1210_chg_det_handle_ulpi_error(tusb);
305 if (val & TUSB1211_POWER_CONTROL_DET_COMP)
306 tusb1210_chg_det_set_type(tusb, POWER_SUPPLY_USB_TYPE_DCP);
308 tusb1210_chg_det_set_type(tusb, POWER_SUPPLY_USB_TYPE_SDP);
310 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_FINISH_DET, 0);
312 case TUSB1210_CHG_DET_FINISH_DET:
313 mutex_lock(&tusb->phy->mutex);
315 /* Set SW_CONTROL to stop the charger-det FSM */
316 ret = tusb1210_ulpi_write(tusb, TUSB1211_POWER_CONTROL_SET,
317 TUSB1211_POWER_CONTROL_SW_CONTROL);
319 /* Clear DP_VSRC_EN which may have been enabled by the charger-det FSM */
320 ret |= tusb1210_ulpi_write(tusb, TUSB1211_POWER_CONTROL_CLEAR,
321 TUSB1211_POWER_CONTROL_DP_VSRC_EN);
323 /* Clear CHGD_IDP_SRC_EN (may have been enabled by the charger-det FSM) */
324 ret |= tusb1210_ulpi_write(tusb, TUSB1211_VENDOR_SPECIFIC3_CLEAR,
325 TUSB1211_VENDOR_SPECIFIC3_CHGD_IDP_SRC_EN);
327 /* If any of the above fails reset the phy */
329 tusb1210_reset(tusb);
330 msleep(TUSB1210_RESET_TIME_MS);
333 /* Restore phy-parameters and OTG_CTRL register */
334 tusb1210_ulpi_write(tusb, ULPI_OTG_CTRL, tusb->otg_ctrl);
335 tusb1210_ulpi_write(tusb, TUSB1210_VENDOR_SPECIFIC2,
336 tusb->vendor_specific2);
338 mutex_unlock(&tusb->phy->mutex);
340 pm_runtime_put(tusb->dev->parent);
341 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_CONNECTED, 0);
343 case TUSB1210_CHG_DET_CONNECTED:
345 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_DISCONNECTING, 0);
347 case TUSB1210_CHG_DET_DISCONNECTING:
349 * The phy seems to take approx. 600ms longer then the charger
350 * chip (which is used to get vbus_present) to determine Vbus
351 * session end. Wait 800ms to ensure the phy has detected and
352 * signalled Vbus session end.
354 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_DISCONNECTING_DONE, 800);
356 case TUSB1210_CHG_DET_DISCONNECTING_DONE:
358 * The phy often stops reacting to ulpi_read()/_write requests
359 * after a Vbus-session end. Reset it to work around this.
361 tusb1210_reset(tusb);
362 tusb1210_chg_det_set_type(tusb, POWER_SUPPLY_USB_TYPE_UNKNOWN);
363 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_DISCONNECTED, 0);
365 case TUSB1210_CHG_DET_DISCONNECTED:
367 tusb1210_chg_det_set_state(tusb, TUSB1210_CHG_DET_CONNECTING, 0);
372 static int tusb1210_psy_notifier(struct notifier_block *nb,
373 unsigned long event, void *ptr)
375 struct tusb1210 *tusb = container_of(nb, struct tusb1210, psy_nb);
376 struct power_supply *psy = ptr;
378 if (psy != tusb->psy && psy->desc->type == POWER_SUPPLY_TYPE_USB)
379 queue_delayed_work(system_long_wq, &tusb->chg_det_work, 0);
384 static int tusb1210_psy_get_prop(struct power_supply *psy,
385 enum power_supply_property psp,
386 union power_supply_propval *val)
388 struct tusb1210 *tusb = power_supply_get_drvdata(psy);
391 case POWER_SUPPLY_PROP_ONLINE:
392 val->intval = tusb1210_get_online(tusb);
394 case POWER_SUPPLY_PROP_USB_TYPE:
395 val->intval = tusb->chg_type;
397 case POWER_SUPPLY_PROP_CURRENT_MAX:
398 if (tusb->chg_type == POWER_SUPPLY_USB_TYPE_DCP)
399 val->intval = 2000000;
401 val->intval = 500000;
410 static const enum power_supply_usb_type tusb1210_psy_usb_types[] = {
411 POWER_SUPPLY_USB_TYPE_SDP,
412 POWER_SUPPLY_USB_TYPE_DCP,
413 POWER_SUPPLY_USB_TYPE_UNKNOWN,
416 static const enum power_supply_property tusb1210_psy_props[] = {
417 POWER_SUPPLY_PROP_ONLINE,
418 POWER_SUPPLY_PROP_USB_TYPE,
419 POWER_SUPPLY_PROP_CURRENT_MAX,
422 static const struct power_supply_desc tusb1210_psy_desc = {
423 .name = "tusb1211-charger-detect",
424 .type = POWER_SUPPLY_TYPE_USB,
425 .usb_types = tusb1210_psy_usb_types,
426 .num_usb_types = ARRAY_SIZE(tusb1210_psy_usb_types),
427 .properties = tusb1210_psy_props,
428 .num_properties = ARRAY_SIZE(tusb1210_psy_props),
429 .get_property = tusb1210_psy_get_prop,
432 /* Setup charger detection if requested, on errors continue without chg-det */
433 static void tusb1210_probe_charger_detect(struct tusb1210 *tusb)
435 struct power_supply_config psy_cfg = { .drv_data = tusb };
436 struct device *dev = tusb->dev;
437 struct ulpi *ulpi = to_ulpi_dev(dev);
440 if (!device_property_read_bool(dev->parent, "linux,phy_charger_detect"))
443 if (ulpi->id.product != TI_DEVICE_TUSB1211) {
444 dev_err(dev, "error charger detection is only supported on the TUSB1211\n");
448 ret = tusb1210_ulpi_read(tusb, ULPI_OTG_CTRL, &tusb->otg_ctrl);
452 tusb->psy = power_supply_register(dev, &tusb1210_psy_desc, &psy_cfg);
453 if (IS_ERR(tusb->psy))
457 * Delay initial run by 2 seconds to allow the charger driver,
458 * which is used to determine vbus_present, to load.
460 tusb->chg_det_state = TUSB1210_CHG_DET_DISCONNECTED;
461 INIT_DELAYED_WORK(&tusb->chg_det_work, tusb1210_chg_det_work);
462 queue_delayed_work(system_long_wq, &tusb->chg_det_work, 2 * HZ);
464 tusb->psy_nb.notifier_call = tusb1210_psy_notifier;
465 power_supply_reg_notifier(&tusb->psy_nb);
468 static void tusb1210_remove_charger_detect(struct tusb1210 *tusb)
471 if (!IS_ERR_OR_NULL(tusb->psy)) {
472 power_supply_unreg_notifier(&tusb->psy_nb);
473 cancel_delayed_work_sync(&tusb->chg_det_work);
474 power_supply_unregister(tusb->psy);
478 power_supply_put(tusb->charger);
481 static void tusb1210_probe_charger_detect(struct tusb1210 *tusb) { }
482 static void tusb1210_remove_charger_detect(struct tusb1210 *tusb) { }
485 static const struct phy_ops phy_ops = {
486 .power_on = tusb1210_power_on,
487 .power_off = tusb1210_power_off,
488 .set_mode = tusb1210_set_mode,
489 .owner = THIS_MODULE,
492 static int tusb1210_probe(struct ulpi *ulpi)
494 struct device *dev = &ulpi->dev;
495 struct tusb1210 *tusb;
499 tusb = devm_kzalloc(dev, sizeof(*tusb), GFP_KERNEL);
505 tusb->gpio_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
506 if (IS_ERR(tusb->gpio_reset))
507 return PTR_ERR(tusb->gpio_reset);
509 gpiod_set_value_cansleep(tusb->gpio_reset, 1);
511 tusb->gpio_cs = devm_gpiod_get_optional(dev, "cs", GPIOD_OUT_LOW);
512 if (IS_ERR(tusb->gpio_cs))
513 return PTR_ERR(tusb->gpio_cs);
515 gpiod_set_value_cansleep(tusb->gpio_cs, 1);
518 * VENDOR_SPECIFIC2 register in TUSB1210 can be used for configuring eye
519 * diagram optimization and DP/DM swap.
522 ret = tusb1210_ulpi_read(tusb, TUSB1210_VENDOR_SPECIFIC2, ®);
526 /* High speed output drive strength configuration */
527 if (!device_property_read_u8(dev, "ihstx", &val))
528 u8p_replace_bits(®, val, (u8)TUSB1210_VENDOR_SPECIFIC2_IHSTX_MASK);
530 /* High speed output impedance configuration */
531 if (!device_property_read_u8(dev, "zhsdrv", &val))
532 u8p_replace_bits(®, val, (u8)TUSB1210_VENDOR_SPECIFIC2_ZHSDRV_MASK);
534 /* DP/DM swap control */
535 if (!device_property_read_u8(dev, "datapolarity", &val))
536 u8p_replace_bits(®, val, (u8)TUSB1210_VENDOR_SPECIFIC2_DP_MASK);
538 ret = tusb1210_ulpi_write(tusb, TUSB1210_VENDOR_SPECIFIC2, reg);
542 tusb->vendor_specific2 = reg;
544 tusb1210_probe_charger_detect(tusb);
546 tusb->phy = ulpi_phy_create(ulpi, &phy_ops);
547 if (IS_ERR(tusb->phy)) {
548 ret = PTR_ERR(tusb->phy);
549 goto err_remove_charger;
552 phy_set_drvdata(tusb->phy, tusb);
553 ulpi_set_drvdata(ulpi, tusb);
557 tusb1210_remove_charger_detect(tusb);
561 static void tusb1210_remove(struct ulpi *ulpi)
563 struct tusb1210 *tusb = ulpi_get_drvdata(ulpi);
565 ulpi_phy_destroy(ulpi, tusb->phy);
566 tusb1210_remove_charger_detect(tusb);
569 static const struct ulpi_device_id tusb1210_ulpi_id[] = {
570 { TI_VENDOR_ID, TI_DEVICE_TUSB1210 },
571 { TI_VENDOR_ID, TI_DEVICE_TUSB1211 },
574 MODULE_DEVICE_TABLE(ulpi, tusb1210_ulpi_id);
576 static struct ulpi_driver tusb1210_driver = {
577 .id_table = tusb1210_ulpi_id,
578 .probe = tusb1210_probe,
579 .remove = tusb1210_remove,
582 .owner = THIS_MODULE,
586 module_ulpi_driver(tusb1210_driver);
588 MODULE_AUTHOR("Intel Corporation");
589 MODULE_LICENSE("GPL v2");
590 MODULE_DESCRIPTION("TUSB1210 ULPI PHY driver");