1 // SPDX-License-Identifier: GPL-2.0+
3 * phy.c -- USB phy handling
5 * Copyright (C) 2004-2013 Texas Instruments
7 #include <linux/kernel.h>
8 #include <linux/export.h>
10 #include <linux/device.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
15 #include <linux/usb/phy.h>
17 /* Default current range by charger type. */
18 #define DEFAULT_SDP_CUR_MIN 2
19 #define DEFAULT_SDP_CUR_MAX 500
20 #define DEFAULT_SDP_CUR_MIN_SS 150
21 #define DEFAULT_SDP_CUR_MAX_SS 900
22 #define DEFAULT_DCP_CUR_MIN 500
23 #define DEFAULT_DCP_CUR_MAX 5000
24 #define DEFAULT_CDP_CUR_MIN 1500
25 #define DEFAULT_CDP_CUR_MAX 5000
26 #define DEFAULT_ACA_CUR_MIN 1500
27 #define DEFAULT_ACA_CUR_MAX 5000
29 static LIST_HEAD(phy_list);
30 static DEFINE_SPINLOCK(phy_lock);
34 struct notifier_block *nb;
37 static const char *const usb_chger_type[] = {
38 [UNKNOWN_TYPE] = "USB_CHARGER_UNKNOWN_TYPE",
39 [SDP_TYPE] = "USB_CHARGER_SDP_TYPE",
40 [CDP_TYPE] = "USB_CHARGER_CDP_TYPE",
41 [DCP_TYPE] = "USB_CHARGER_DCP_TYPE",
42 [ACA_TYPE] = "USB_CHARGER_ACA_TYPE",
45 static const char *const usb_chger_state[] = {
46 [USB_CHARGER_DEFAULT] = "USB_CHARGER_DEFAULT",
47 [USB_CHARGER_PRESENT] = "USB_CHARGER_PRESENT",
48 [USB_CHARGER_ABSENT] = "USB_CHARGER_ABSENT",
51 static struct usb_phy *__usb_find_phy(struct list_head *list,
52 enum usb_phy_type type)
54 struct usb_phy *phy = NULL;
56 list_for_each_entry(phy, list, head) {
57 if (phy->type != type)
63 return ERR_PTR(-ENODEV);
66 static struct usb_phy *__of_usb_find_phy(struct device_node *node)
70 if (!of_device_is_available(node))
71 return ERR_PTR(-ENODEV);
73 list_for_each_entry(phy, &phy_list, head) {
74 if (node != phy->dev->of_node)
80 return ERR_PTR(-EPROBE_DEFER);
83 static struct usb_phy *__device_to_usb_phy(const struct device *dev)
85 struct usb_phy *usb_phy;
87 list_for_each_entry(usb_phy, &phy_list, head) {
88 if (usb_phy->dev == dev)
95 static void usb_phy_set_default_current(struct usb_phy *usb_phy)
97 usb_phy->chg_cur.sdp_min = DEFAULT_SDP_CUR_MIN;
98 usb_phy->chg_cur.sdp_max = DEFAULT_SDP_CUR_MAX;
99 usb_phy->chg_cur.dcp_min = DEFAULT_DCP_CUR_MIN;
100 usb_phy->chg_cur.dcp_max = DEFAULT_DCP_CUR_MAX;
101 usb_phy->chg_cur.cdp_min = DEFAULT_CDP_CUR_MIN;
102 usb_phy->chg_cur.cdp_max = DEFAULT_CDP_CUR_MAX;
103 usb_phy->chg_cur.aca_min = DEFAULT_ACA_CUR_MIN;
104 usb_phy->chg_cur.aca_max = DEFAULT_ACA_CUR_MAX;
108 * usb_phy_notify_charger_work - notify the USB charger state
109 * @work: the charger work to notify the USB charger state
111 * This work can be issued when USB charger state has been changed or
112 * USB charger current has been changed, then we can notify the current
113 * what can be drawn to power user and the charger state to userspace.
115 * If we get the charger type from extcon subsystem, we can notify the
116 * charger state to power user automatically by usb_phy_get_charger_type()
117 * issuing from extcon subsystem.
119 * If we get the charger type from ->charger_detect() instead of extcon
120 * subsystem, the usb phy driver should issue usb_phy_set_charger_state()
121 * to set charger state when the charger state has been changed.
123 static void usb_phy_notify_charger_work(struct work_struct *work)
125 struct usb_phy *usb_phy = container_of(work, struct usb_phy, chg_work);
126 unsigned int min, max;
128 switch (usb_phy->chg_state) {
129 case USB_CHARGER_PRESENT:
130 usb_phy_get_charger_current(usb_phy, &min, &max);
132 atomic_notifier_call_chain(&usb_phy->notifier, max, usb_phy);
134 case USB_CHARGER_ABSENT:
135 usb_phy_set_default_current(usb_phy);
137 atomic_notifier_call_chain(&usb_phy->notifier, 0, usb_phy);
140 dev_warn(usb_phy->dev, "Unknown USB charger state: %d\n",
145 kobject_uevent(&usb_phy->dev->kobj, KOBJ_CHANGE);
148 static int usb_phy_uevent(const struct device *dev, struct kobj_uevent_env *env)
150 const struct usb_phy *usb_phy;
151 char uchger_state[50] = { 0 };
152 char uchger_type[50] = { 0 };
155 spin_lock_irqsave(&phy_lock, flags);
156 usb_phy = __device_to_usb_phy(dev);
157 spin_unlock_irqrestore(&phy_lock, flags);
162 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
163 "USB_CHARGER_STATE=%s", usb_chger_state[usb_phy->chg_state]);
165 snprintf(uchger_type, ARRAY_SIZE(uchger_type),
166 "USB_CHARGER_TYPE=%s", usb_chger_type[usb_phy->chg_type]);
168 if (add_uevent_var(env, uchger_state))
171 if (add_uevent_var(env, uchger_type))
177 static void __usb_phy_get_charger_type(struct usb_phy *usb_phy)
179 if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_SDP) > 0) {
180 usb_phy->chg_type = SDP_TYPE;
181 usb_phy->chg_state = USB_CHARGER_PRESENT;
182 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_CDP) > 0) {
183 usb_phy->chg_type = CDP_TYPE;
184 usb_phy->chg_state = USB_CHARGER_PRESENT;
185 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_DCP) > 0) {
186 usb_phy->chg_type = DCP_TYPE;
187 usb_phy->chg_state = USB_CHARGER_PRESENT;
188 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_ACA) > 0) {
189 usb_phy->chg_type = ACA_TYPE;
190 usb_phy->chg_state = USB_CHARGER_PRESENT;
192 usb_phy->chg_type = UNKNOWN_TYPE;
193 usb_phy->chg_state = USB_CHARGER_ABSENT;
196 schedule_work(&usb_phy->chg_work);
200 * usb_phy_get_charger_type - get charger type from extcon subsystem
201 * @nb: the notifier block to determine charger type
202 * @state: the cable state
203 * @data: private data
205 * Determin the charger type from extcon subsystem which also means the
206 * charger state has been chaned, then we should notify this event.
208 static int usb_phy_get_charger_type(struct notifier_block *nb,
209 unsigned long state, void *data)
211 struct usb_phy *usb_phy = container_of(nb, struct usb_phy, type_nb);
213 __usb_phy_get_charger_type(usb_phy);
218 * usb_phy_set_charger_current - set the USB charger current
219 * @usb_phy: the USB phy to be used
220 * @mA: the current need to be set
222 * Usually we only change the charger default current when USB finished the
223 * enumeration as one SDP charger. As one SDP charger, usb_phy_set_power()
224 * will issue this function to change charger current when after setting USB
225 * configuration, or suspend/resume USB. For other type charger, we should
226 * use the default charger current and we do not suggest to issue this function
227 * to change the charger current.
229 * When USB charger current has been changed, we need to notify the power users.
231 void usb_phy_set_charger_current(struct usb_phy *usb_phy, unsigned int mA)
233 switch (usb_phy->chg_type) {
235 if (usb_phy->chg_cur.sdp_max == mA)
238 usb_phy->chg_cur.sdp_max = (mA > DEFAULT_SDP_CUR_MAX_SS) ?
239 DEFAULT_SDP_CUR_MAX_SS : mA;
242 if (usb_phy->chg_cur.dcp_max == mA)
245 usb_phy->chg_cur.dcp_max = (mA > DEFAULT_DCP_CUR_MAX) ?
246 DEFAULT_DCP_CUR_MAX : mA;
249 if (usb_phy->chg_cur.cdp_max == mA)
252 usb_phy->chg_cur.cdp_max = (mA > DEFAULT_CDP_CUR_MAX) ?
253 DEFAULT_CDP_CUR_MAX : mA;
256 if (usb_phy->chg_cur.aca_max == mA)
259 usb_phy->chg_cur.aca_max = (mA > DEFAULT_ACA_CUR_MAX) ?
260 DEFAULT_ACA_CUR_MAX : mA;
266 schedule_work(&usb_phy->chg_work);
268 EXPORT_SYMBOL_GPL(usb_phy_set_charger_current);
271 * usb_phy_get_charger_current - get the USB charger current
272 * @usb_phy: the USB phy to be used
273 * @min: the minimum current
274 * @max: the maximum current
276 * Usually we will notify the maximum current to power user, but for some
277 * special case, power user also need the minimum current value. Then the
278 * power user can issue this function to get the suitable current.
280 void usb_phy_get_charger_current(struct usb_phy *usb_phy,
281 unsigned int *min, unsigned int *max)
283 switch (usb_phy->chg_type) {
285 *min = usb_phy->chg_cur.sdp_min;
286 *max = usb_phy->chg_cur.sdp_max;
289 *min = usb_phy->chg_cur.dcp_min;
290 *max = usb_phy->chg_cur.dcp_max;
293 *min = usb_phy->chg_cur.cdp_min;
294 *max = usb_phy->chg_cur.cdp_max;
297 *min = usb_phy->chg_cur.aca_min;
298 *max = usb_phy->chg_cur.aca_max;
306 EXPORT_SYMBOL_GPL(usb_phy_get_charger_current);
309 * usb_phy_set_charger_state - set the USB charger state
310 * @usb_phy: the USB phy to be used
311 * @state: the new state need to be set for charger
313 * The usb phy driver can issue this function when the usb phy driver
314 * detected the charger state has been changed, in this case the charger
315 * type should be get from ->charger_detect().
317 void usb_phy_set_charger_state(struct usb_phy *usb_phy,
318 enum usb_charger_state state)
320 if (usb_phy->chg_state == state || !usb_phy->charger_detect)
323 usb_phy->chg_state = state;
324 if (usb_phy->chg_state == USB_CHARGER_PRESENT)
325 usb_phy->chg_type = usb_phy->charger_detect(usb_phy);
327 usb_phy->chg_type = UNKNOWN_TYPE;
329 schedule_work(&usb_phy->chg_work);
331 EXPORT_SYMBOL_GPL(usb_phy_set_charger_state);
333 static void devm_usb_phy_release(struct device *dev, void *res)
335 struct usb_phy *phy = *(struct usb_phy **)res;
340 static void devm_usb_phy_release2(struct device *dev, void *_res)
342 struct phy_devm *res = _res;
345 usb_unregister_notifier(res->phy, res->nb);
346 usb_put_phy(res->phy);
349 static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
351 struct usb_phy **phy = res;
353 return *phy == match_data;
356 static void usb_charger_init(struct usb_phy *usb_phy)
358 usb_phy->chg_type = UNKNOWN_TYPE;
359 usb_phy->chg_state = USB_CHARGER_DEFAULT;
360 usb_phy_set_default_current(usb_phy);
361 INIT_WORK(&usb_phy->chg_work, usb_phy_notify_charger_work);
364 static int usb_add_extcon(struct usb_phy *x)
368 if (of_property_read_bool(x->dev->of_node, "extcon")) {
369 x->edev = extcon_get_edev_by_phandle(x->dev, 0);
371 return PTR_ERR(x->edev);
373 x->id_edev = extcon_get_edev_by_phandle(x->dev, 1);
374 if (IS_ERR(x->id_edev)) {
376 dev_info(x->dev, "No separate ID extcon device\n");
379 if (x->vbus_nb.notifier_call) {
380 ret = devm_extcon_register_notifier(x->dev, x->edev,
385 "register VBUS notifier failed\n");
389 x->type_nb.notifier_call = usb_phy_get_charger_type;
391 ret = devm_extcon_register_notifier(x->dev, x->edev,
396 "register extcon USB SDP failed.\n");
400 ret = devm_extcon_register_notifier(x->dev, x->edev,
405 "register extcon USB CDP failed.\n");
409 ret = devm_extcon_register_notifier(x->dev, x->edev,
414 "register extcon USB DCP failed.\n");
418 ret = devm_extcon_register_notifier(x->dev, x->edev,
423 "register extcon USB ACA failed.\n");
428 if (x->id_nb.notifier_call) {
429 struct extcon_dev *id_ext;
436 ret = devm_extcon_register_notifier(x->dev, id_ext,
441 "register ID notifier failed\n");
447 if (x->type_nb.notifier_call)
448 __usb_phy_get_charger_type(x);
454 * devm_usb_get_phy - find the USB PHY
455 * @dev: device that requests this phy
456 * @type: the type of the phy the controller requires
458 * Gets the phy using usb_get_phy(), and associates a device with it using
459 * devres. On driver detach, release function is invoked on the devres data,
460 * then, devres data is freed.
462 * For use by USB host and peripheral drivers.
464 struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
466 struct usb_phy **ptr, *phy;
468 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
470 return ERR_PTR(-ENOMEM);
472 phy = usb_get_phy(type);
475 devres_add(dev, ptr);
481 EXPORT_SYMBOL_GPL(devm_usb_get_phy);
484 * usb_get_phy - find the USB PHY
485 * @type: the type of the phy the controller requires
487 * Returns the phy driver, after getting a refcount to it; or
488 * -ENODEV if there is no such phy. The caller is responsible for
489 * calling usb_put_phy() to release that count.
491 * For use by USB host and peripheral drivers.
493 struct usb_phy *usb_get_phy(enum usb_phy_type type)
495 struct usb_phy *phy = NULL;
498 spin_lock_irqsave(&phy_lock, flags);
500 phy = __usb_find_phy(&phy_list, type);
501 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
502 pr_debug("PHY: unable to find transceiver of type %s\n",
503 usb_phy_type_string(type));
505 phy = ERR_PTR(-ENODEV);
510 get_device(phy->dev);
513 spin_unlock_irqrestore(&phy_lock, flags);
517 EXPORT_SYMBOL_GPL(usb_get_phy);
520 * devm_usb_get_phy_by_node - find the USB PHY by device_node
521 * @dev: device that requests this phy
522 * @node: the device_node for the phy device.
523 * @nb: a notifier_block to register with the phy.
525 * Returns the phy driver associated with the given device_node,
526 * after getting a refcount to it, -ENODEV if there is no such phy or
527 * -EPROBE_DEFER if the device is not yet loaded. While at that, it
528 * also associates the device with
529 * the phy using devres. On driver detach, release function is invoked
530 * on the devres data, then, devres data is freed.
532 * For use by peripheral drivers for devices related to a phy,
535 struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
536 struct device_node *node,
537 struct notifier_block *nb)
539 struct usb_phy *phy = ERR_PTR(-ENOMEM);
540 struct phy_devm *ptr;
543 ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
545 dev_dbg(dev, "failed to allocate memory for devres\n");
549 spin_lock_irqsave(&phy_lock, flags);
551 phy = __of_usb_find_phy(node);
557 if (!try_module_get(phy->dev->driver->owner)) {
558 phy = ERR_PTR(-ENODEV);
563 usb_register_notifier(phy, nb);
566 devres_add(dev, ptr);
568 get_device(phy->dev);
571 spin_unlock_irqrestore(&phy_lock, flags);
577 EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
580 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
581 * @dev: device that requests this phy
582 * @phandle: name of the property holding the phy phandle value
583 * @index: the index of the phy
585 * Returns the phy driver associated with the given phandle value,
586 * after getting a refcount to it, -ENODEV if there is no such phy or
587 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
588 * not yet loaded. While at that, it also associates the device with
589 * the phy using devres. On driver detach, release function is invoked
590 * on the devres data, then, devres data is freed.
592 * For use by USB host and peripheral drivers.
594 struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
595 const char *phandle, u8 index)
597 struct device_node *node;
601 dev_dbg(dev, "device does not have a device node entry\n");
602 return ERR_PTR(-EINVAL);
605 node = of_parse_phandle(dev->of_node, phandle, index);
607 dev_dbg(dev, "failed to get %s phandle in %pOF node\n", phandle,
609 return ERR_PTR(-ENODEV);
611 phy = devm_usb_get_phy_by_node(dev, node, NULL);
615 EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
618 * devm_usb_put_phy - release the USB PHY
619 * @dev: device that wants to release this phy
620 * @phy: the phy returned by devm_usb_get_phy()
622 * destroys the devres associated with this phy and invokes usb_put_phy
623 * to release the phy.
625 * For use by USB host and peripheral drivers.
627 void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
631 r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
632 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
634 EXPORT_SYMBOL_GPL(devm_usb_put_phy);
637 * usb_put_phy - release the USB PHY
638 * @x: the phy returned by usb_get_phy()
640 * Releases a refcount the caller received from usb_get_phy().
642 * For use by USB host and peripheral drivers.
644 void usb_put_phy(struct usb_phy *x)
647 struct module *owner = x->dev->driver->owner;
653 EXPORT_SYMBOL_GPL(usb_put_phy);
656 * usb_add_phy: declare the USB PHY
657 * @x: the USB phy to be used; or NULL
658 * @type: the type of this PHY
660 * This call is exclusively for use by phy drivers, which
661 * coordinate the activities of drivers for host and peripheral
662 * controllers, and in some cases for VBUS current regulation.
664 int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
670 if (x->type != USB_PHY_TYPE_UNDEFINED) {
671 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
676 ret = usb_add_extcon(x);
680 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
682 spin_lock_irqsave(&phy_lock, flags);
684 list_for_each_entry(phy, &phy_list, head) {
685 if (phy->type == type) {
687 dev_err(x->dev, "transceiver type %s already exists\n",
688 usb_phy_type_string(type));
694 list_add_tail(&x->head, &phy_list);
697 spin_unlock_irqrestore(&phy_lock, flags);
700 EXPORT_SYMBOL_GPL(usb_add_phy);
702 static struct device_type usb_phy_dev_type = {
704 .uevent = usb_phy_uevent,
708 * usb_add_phy_dev - declare the USB PHY
709 * @x: the USB phy to be used; or NULL
711 * This call is exclusively for use by phy drivers, which
712 * coordinate the activities of drivers for host and peripheral
713 * controllers, and in some cases for VBUS current regulation.
715 int usb_add_phy_dev(struct usb_phy *x)
721 dev_err(x->dev, "no device provided for PHY\n");
726 ret = usb_add_extcon(x);
730 x->dev->type = &usb_phy_dev_type;
732 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
734 spin_lock_irqsave(&phy_lock, flags);
735 list_add_tail(&x->head, &phy_list);
736 spin_unlock_irqrestore(&phy_lock, flags);
740 EXPORT_SYMBOL_GPL(usb_add_phy_dev);
743 * usb_remove_phy - remove the OTG PHY
744 * @x: the USB OTG PHY to be removed;
746 * This reverts the effects of usb_add_phy
748 void usb_remove_phy(struct usb_phy *x)
752 spin_lock_irqsave(&phy_lock, flags);
755 spin_unlock_irqrestore(&phy_lock, flags);
757 EXPORT_SYMBOL_GPL(usb_remove_phy);
760 * usb_phy_set_event - set event to phy event
761 * @x: the phy returned by usb_get_phy();
762 * @event: event to set
764 * This sets event to phy event
766 void usb_phy_set_event(struct usb_phy *x, unsigned long event)
768 x->last_event = event;
770 EXPORT_SYMBOL_GPL(usb_phy_set_event);