Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * phy.c -- USB phy handling
4 *
5 * Copyright (C) 2004-2013 Texas Instruments
6 */
7#include <linux/kernel.h>
8#include <linux/export.h>
9#include <linux/err.h>
10#include <linux/device.h>
11#include <linux/module.h>
12#include <linux/slab.h>
13#include <linux/of.h>
14
15#include <linux/usb/phy.h>
16
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
28
29static LIST_HEAD(phy_list);
30static DEFINE_SPINLOCK(phy_lock);
31
32struct phy_devm {
33 struct usb_phy *phy;
34 struct notifier_block *nb;
35};
36
37static 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",
43};
44
45static 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",
49};
50
51static struct usb_phy *__usb_find_phy(struct list_head *list,
52 enum usb_phy_type type)
53{
54 struct usb_phy *phy = NULL;
55
56 list_for_each_entry(phy, list, head) {
57 if (phy->type != type)
58 continue;
59
60 return phy;
61 }
62
63 return ERR_PTR(-ENODEV);
64}
65
66static struct usb_phy *__of_usb_find_phy(struct device_node *node)
67{
68 struct usb_phy *phy;
69
70 if (!of_device_is_available(node))
71 return ERR_PTR(-ENODEV);
72
73 list_for_each_entry(phy, &phy_list, head) {
74 if (node != phy->dev->of_node)
75 continue;
76
77 return phy;
78 }
79
80 return ERR_PTR(-EPROBE_DEFER);
81}
82
83static struct usb_phy *__device_to_usb_phy(const struct device *dev)
84{
85 struct usb_phy *usb_phy;
86
87 list_for_each_entry(usb_phy, &phy_list, head) {
88 if (usb_phy->dev == dev)
89 return usb_phy;
90 }
91
92 return NULL;
93}
94
95static void usb_phy_set_default_current(struct usb_phy *usb_phy)
96{
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;
105}
106
107/**
108 * usb_phy_notify_charger_work - notify the USB charger state
109 * @work: the charger work to notify the USB charger state
110 *
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.
114 *
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.
118 *
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.
122 */
123static void usb_phy_notify_charger_work(struct work_struct *work)
124{
125 struct usb_phy *usb_phy = container_of(work, struct usb_phy, chg_work);
126 unsigned int min, max;
127
128 switch (usb_phy->chg_state) {
129 case USB_CHARGER_PRESENT:
130 usb_phy_get_charger_current(usb_phy, &min, &max);
131
132 atomic_notifier_call_chain(&usb_phy->notifier, max, usb_phy);
133 break;
134 case USB_CHARGER_ABSENT:
135 usb_phy_set_default_current(usb_phy);
136
137 atomic_notifier_call_chain(&usb_phy->notifier, 0, usb_phy);
138 break;
139 default:
140 dev_warn(usb_phy->dev, "Unknown USB charger state: %d\n",
141 usb_phy->chg_state);
142 return;
143 }
144
145 kobject_uevent(&usb_phy->dev->kobj, KOBJ_CHANGE);
146}
147
148static int usb_phy_uevent(const struct device *dev, struct kobj_uevent_env *env)
149{
150 const struct usb_phy *usb_phy;
151 char uchger_state[50] = { 0 };
152 char uchger_type[50] = { 0 };
153 unsigned long flags;
154
155 spin_lock_irqsave(&phy_lock, flags);
156 usb_phy = __device_to_usb_phy(dev);
157 spin_unlock_irqrestore(&phy_lock, flags);
158
159 if (!usb_phy)
160 return -ENODEV;
161
162 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
163 "USB_CHARGER_STATE=%s", usb_chger_state[usb_phy->chg_state]);
164
165 snprintf(uchger_type, ARRAY_SIZE(uchger_type),
166 "USB_CHARGER_TYPE=%s", usb_chger_type[usb_phy->chg_type]);
167
168 if (add_uevent_var(env, uchger_state))
169 return -ENOMEM;
170
171 if (add_uevent_var(env, uchger_type))
172 return -ENOMEM;
173
174 return 0;
175}
176
177static void __usb_phy_get_charger_type(struct usb_phy *usb_phy)
178{
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;
191 } else {
192 usb_phy->chg_type = UNKNOWN_TYPE;
193 usb_phy->chg_state = USB_CHARGER_ABSENT;
194 }
195
196 schedule_work(&usb_phy->chg_work);
197}
198
199/**
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
204 *
205 * Determin the charger type from extcon subsystem which also means the
206 * charger state has been chaned, then we should notify this event.
207 */
208static int usb_phy_get_charger_type(struct notifier_block *nb,
209 unsigned long state, void *data)
210{
211 struct usb_phy *usb_phy = container_of(nb, struct usb_phy, type_nb);
212
213 __usb_phy_get_charger_type(usb_phy);
214 return NOTIFY_OK;
215}
216
217/**
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
221 *
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.
228 *
229 * When USB charger current has been changed, we need to notify the power users.
230 */
231void usb_phy_set_charger_current(struct usb_phy *usb_phy, unsigned int mA)
232{
233 switch (usb_phy->chg_type) {
234 case SDP_TYPE:
235 if (usb_phy->chg_cur.sdp_max == mA)
236 return;
237
238 usb_phy->chg_cur.sdp_max = (mA > DEFAULT_SDP_CUR_MAX_SS) ?
239 DEFAULT_SDP_CUR_MAX_SS : mA;
240 break;
241 case DCP_TYPE:
242 if (usb_phy->chg_cur.dcp_max == mA)
243 return;
244
245 usb_phy->chg_cur.dcp_max = (mA > DEFAULT_DCP_CUR_MAX) ?
246 DEFAULT_DCP_CUR_MAX : mA;
247 break;
248 case CDP_TYPE:
249 if (usb_phy->chg_cur.cdp_max == mA)
250 return;
251
252 usb_phy->chg_cur.cdp_max = (mA > DEFAULT_CDP_CUR_MAX) ?
253 DEFAULT_CDP_CUR_MAX : mA;
254 break;
255 case ACA_TYPE:
256 if (usb_phy->chg_cur.aca_max == mA)
257 return;
258
259 usb_phy->chg_cur.aca_max = (mA > DEFAULT_ACA_CUR_MAX) ?
260 DEFAULT_ACA_CUR_MAX : mA;
261 break;
262 default:
263 return;
264 }
265
266 schedule_work(&usb_phy->chg_work);
267}
268EXPORT_SYMBOL_GPL(usb_phy_set_charger_current);
269
270/**
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
275 *
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.
279 */
280void usb_phy_get_charger_current(struct usb_phy *usb_phy,
281 unsigned int *min, unsigned int *max)
282{
283 switch (usb_phy->chg_type) {
284 case SDP_TYPE:
285 *min = usb_phy->chg_cur.sdp_min;
286 *max = usb_phy->chg_cur.sdp_max;
287 break;
288 case DCP_TYPE:
289 *min = usb_phy->chg_cur.dcp_min;
290 *max = usb_phy->chg_cur.dcp_max;
291 break;
292 case CDP_TYPE:
293 *min = usb_phy->chg_cur.cdp_min;
294 *max = usb_phy->chg_cur.cdp_max;
295 break;
296 case ACA_TYPE:
297 *min = usb_phy->chg_cur.aca_min;
298 *max = usb_phy->chg_cur.aca_max;
299 break;
300 default:
301 *min = 0;
302 *max = 0;
303 break;
304 }
305}
306EXPORT_SYMBOL_GPL(usb_phy_get_charger_current);
307
308/**
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
312 *
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().
316 */
317void usb_phy_set_charger_state(struct usb_phy *usb_phy,
318 enum usb_charger_state state)
319{
320 if (usb_phy->chg_state == state || !usb_phy->charger_detect)
321 return;
322
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);
326 else
327 usb_phy->chg_type = UNKNOWN_TYPE;
328
329 schedule_work(&usb_phy->chg_work);
330}
331EXPORT_SYMBOL_GPL(usb_phy_set_charger_state);
332
333static void devm_usb_phy_release(struct device *dev, void *res)
334{
335 struct usb_phy *phy = *(struct usb_phy **)res;
336
337 usb_put_phy(phy);
338}
339
340static void devm_usb_phy_release2(struct device *dev, void *_res)
341{
342 struct phy_devm *res = _res;
343
344 if (res->nb)
345 usb_unregister_notifier(res->phy, res->nb);
346 usb_put_phy(res->phy);
347}
348
349static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
350{
351 struct usb_phy **phy = res;
352
353 return *phy == match_data;
354}
355
356static void usb_charger_init(struct usb_phy *usb_phy)
357{
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);
362}
363
364static int usb_add_extcon(struct usb_phy *x)
365{
366 int ret;
367
368 if (of_property_read_bool(x->dev->of_node, "extcon")) {
369 x->edev = extcon_get_edev_by_phandle(x->dev, 0);
370 if (IS_ERR(x->edev))
371 return PTR_ERR(x->edev);
372
373 x->id_edev = extcon_get_edev_by_phandle(x->dev, 1);
374 if (IS_ERR(x->id_edev)) {
375 x->id_edev = NULL;
376 dev_info(x->dev, "No separate ID extcon device\n");
377 }
378
379 if (x->vbus_nb.notifier_call) {
380 ret = devm_extcon_register_notifier(x->dev, x->edev,
381 EXTCON_USB,
382 &x->vbus_nb);
383 if (ret < 0) {
384 dev_err(x->dev,
385 "register VBUS notifier failed\n");
386 return ret;
387 }
388 } else {
389 x->type_nb.notifier_call = usb_phy_get_charger_type;
390
391 ret = devm_extcon_register_notifier(x->dev, x->edev,
392 EXTCON_CHG_USB_SDP,
393 &x->type_nb);
394 if (ret) {
395 dev_err(x->dev,
396 "register extcon USB SDP failed.\n");
397 return ret;
398 }
399
400 ret = devm_extcon_register_notifier(x->dev, x->edev,
401 EXTCON_CHG_USB_CDP,
402 &x->type_nb);
403 if (ret) {
404 dev_err(x->dev,
405 "register extcon USB CDP failed.\n");
406 return ret;
407 }
408
409 ret = devm_extcon_register_notifier(x->dev, x->edev,
410 EXTCON_CHG_USB_DCP,
411 &x->type_nb);
412 if (ret) {
413 dev_err(x->dev,
414 "register extcon USB DCP failed.\n");
415 return ret;
416 }
417
418 ret = devm_extcon_register_notifier(x->dev, x->edev,
419 EXTCON_CHG_USB_ACA,
420 &x->type_nb);
421 if (ret) {
422 dev_err(x->dev,
423 "register extcon USB ACA failed.\n");
424 return ret;
425 }
426 }
427
428 if (x->id_nb.notifier_call) {
429 struct extcon_dev *id_ext;
430
431 if (x->id_edev)
432 id_ext = x->id_edev;
433 else
434 id_ext = x->edev;
435
436 ret = devm_extcon_register_notifier(x->dev, id_ext,
437 EXTCON_USB_HOST,
438 &x->id_nb);
439 if (ret < 0) {
440 dev_err(x->dev,
441 "register ID notifier failed\n");
442 return ret;
443 }
444 }
445 }
446
447 if (x->type_nb.notifier_call)
448 __usb_phy_get_charger_type(x);
449
450 return 0;
451}
452
453/**
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
457 *
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.
461 *
462 * For use by USB host and peripheral drivers.
463 */
464struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
465{
466 struct usb_phy **ptr, *phy;
467
468 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
469 if (!ptr)
470 return ERR_PTR(-ENOMEM);
471
472 phy = usb_get_phy(type);
473 if (!IS_ERR(phy)) {
474 *ptr = phy;
475 devres_add(dev, ptr);
476 } else
477 devres_free(ptr);
478
479 return phy;
480}
481EXPORT_SYMBOL_GPL(devm_usb_get_phy);
482
483/**
484 * usb_get_phy - find the USB PHY
485 * @type: the type of the phy the controller requires
486 *
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.
490 *
491 * For use by USB host and peripheral drivers.
492 */
493struct usb_phy *usb_get_phy(enum usb_phy_type type)
494{
495 struct usb_phy *phy = NULL;
496 unsigned long flags;
497
498 spin_lock_irqsave(&phy_lock, flags);
499
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));
504 if (!IS_ERR(phy))
505 phy = ERR_PTR(-ENODEV);
506
507 goto err0;
508 }
509
510 get_device(phy->dev);
511
512err0:
513 spin_unlock_irqrestore(&phy_lock, flags);
514
515 return phy;
516}
517EXPORT_SYMBOL_GPL(usb_get_phy);
518
519/**
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.
524 *
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.
531 *
532 * For use by peripheral drivers for devices related to a phy,
533 * such as a charger.
534 */
535struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
536 struct device_node *node,
537 struct notifier_block *nb)
538{
539 struct usb_phy *phy = ERR_PTR(-ENOMEM);
540 struct phy_devm *ptr;
541 unsigned long flags;
542
543 ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
544 if (!ptr) {
545 dev_dbg(dev, "failed to allocate memory for devres\n");
546 goto err0;
547 }
548
549 spin_lock_irqsave(&phy_lock, flags);
550
551 phy = __of_usb_find_phy(node);
552 if (IS_ERR(phy)) {
553 devres_free(ptr);
554 goto err1;
555 }
556
557 if (!try_module_get(phy->dev->driver->owner)) {
558 phy = ERR_PTR(-ENODEV);
559 devres_free(ptr);
560 goto err1;
561 }
562 if (nb)
563 usb_register_notifier(phy, nb);
564 ptr->phy = phy;
565 ptr->nb = nb;
566 devres_add(dev, ptr);
567
568 get_device(phy->dev);
569
570err1:
571 spin_unlock_irqrestore(&phy_lock, flags);
572
573err0:
574
575 return phy;
576}
577EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
578
579/**
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
584 *
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.
591 *
592 * For use by USB host and peripheral drivers.
593 */
594struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
595 const char *phandle, u8 index)
596{
597 struct device_node *node;
598 struct usb_phy *phy;
599
600 if (!dev->of_node) {
601 dev_dbg(dev, "device does not have a device node entry\n");
602 return ERR_PTR(-EINVAL);
603 }
604
605 node = of_parse_phandle(dev->of_node, phandle, index);
606 if (!node) {
607 dev_dbg(dev, "failed to get %s phandle in %pOF node\n", phandle,
608 dev->of_node);
609 return ERR_PTR(-ENODEV);
610 }
611 phy = devm_usb_get_phy_by_node(dev, node, NULL);
612 of_node_put(node);
613 return phy;
614}
615EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
616
617/**
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()
621 *
622 * destroys the devres associated with this phy and invokes usb_put_phy
623 * to release the phy.
624 *
625 * For use by USB host and peripheral drivers.
626 */
627void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
628{
629 int r;
630
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");
633}
634EXPORT_SYMBOL_GPL(devm_usb_put_phy);
635
636/**
637 * usb_put_phy - release the USB PHY
638 * @x: the phy returned by usb_get_phy()
639 *
640 * Releases a refcount the caller received from usb_get_phy().
641 *
642 * For use by USB host and peripheral drivers.
643 */
644void usb_put_phy(struct usb_phy *x)
645{
646 if (x) {
647 struct module *owner = x->dev->driver->owner;
648
649 put_device(x->dev);
650 module_put(owner);
651 }
652}
653EXPORT_SYMBOL_GPL(usb_put_phy);
654
655/**
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
659 *
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.
663 */
664int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
665{
666 int ret = 0;
667 unsigned long flags;
668 struct usb_phy *phy;
669
670 if (x->type != USB_PHY_TYPE_UNDEFINED) {
671 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
672 return -EINVAL;
673 }
674
675 usb_charger_init(x);
676 ret = usb_add_extcon(x);
677 if (ret)
678 return ret;
679
680 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
681
682 spin_lock_irqsave(&phy_lock, flags);
683
684 list_for_each_entry(phy, &phy_list, head) {
685 if (phy->type == type) {
686 ret = -EBUSY;
687 dev_err(x->dev, "transceiver type %s already exists\n",
688 usb_phy_type_string(type));
689 goto out;
690 }
691 }
692
693 x->type = type;
694 list_add_tail(&x->head, &phy_list);
695
696out:
697 spin_unlock_irqrestore(&phy_lock, flags);
698 return ret;
699}
700EXPORT_SYMBOL_GPL(usb_add_phy);
701
702static struct device_type usb_phy_dev_type = {
703 .name = "usb_phy",
704 .uevent = usb_phy_uevent,
705};
706
707/**
708 * usb_add_phy_dev - declare the USB PHY
709 * @x: the USB phy to be used; or NULL
710 *
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.
714 */
715int usb_add_phy_dev(struct usb_phy *x)
716{
717 unsigned long flags;
718 int ret;
719
720 if (!x->dev) {
721 dev_err(x->dev, "no device provided for PHY\n");
722 return -EINVAL;
723 }
724
725 usb_charger_init(x);
726 ret = usb_add_extcon(x);
727 if (ret)
728 return ret;
729
730 x->dev->type = &usb_phy_dev_type;
731
732 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
733
734 spin_lock_irqsave(&phy_lock, flags);
735 list_add_tail(&x->head, &phy_list);
736 spin_unlock_irqrestore(&phy_lock, flags);
737
738 return 0;
739}
740EXPORT_SYMBOL_GPL(usb_add_phy_dev);
741
742/**
743 * usb_remove_phy - remove the OTG PHY
744 * @x: the USB OTG PHY to be removed;
745 *
746 * This reverts the effects of usb_add_phy
747 */
748void usb_remove_phy(struct usb_phy *x)
749{
750 unsigned long flags;
751
752 spin_lock_irqsave(&phy_lock, flags);
753 if (x)
754 list_del(&x->head);
755 spin_unlock_irqrestore(&phy_lock, flags);
756}
757EXPORT_SYMBOL_GPL(usb_remove_phy);
758
759/**
760 * usb_phy_set_event - set event to phy event
761 * @x: the phy returned by usb_get_phy();
762 * @event: event to set
763 *
764 * This sets event to phy event
765 */
766void usb_phy_set_event(struct usb_phy *x, unsigned long event)
767{
768 x->last_event = event;
769}
770EXPORT_SYMBOL_GPL(usb_phy_set_event);
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * phy.c -- USB phy handling
4 *
5 * Copyright (C) 2004-2013 Texas Instruments
6 */
7#include <linux/kernel.h>
8#include <linux/export.h>
9#include <linux/err.h>
10#include <linux/device.h>
11#include <linux/module.h>
12#include <linux/slab.h>
13#include <linux/of.h>
14
15#include <linux/usb/phy.h>
16
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
28
29static LIST_HEAD(phy_list);
30static LIST_HEAD(phy_bind_list);
31static DEFINE_SPINLOCK(phy_lock);
32
33struct phy_devm {
34 struct usb_phy *phy;
35 struct notifier_block *nb;
36};
37
38static struct usb_phy *__usb_find_phy(struct list_head *list,
39 enum usb_phy_type type)
40{
41 struct usb_phy *phy = NULL;
42
43 list_for_each_entry(phy, list, head) {
44 if (phy->type != type)
45 continue;
46
47 return phy;
48 }
49
50 return ERR_PTR(-ENODEV);
51}
52
53static struct usb_phy *__usb_find_phy_dev(struct device *dev,
54 struct list_head *list, u8 index)
55{
56 struct usb_phy_bind *phy_bind = NULL;
57
58 list_for_each_entry(phy_bind, list, list) {
59 if (!(strcmp(phy_bind->dev_name, dev_name(dev))) &&
60 phy_bind->index == index) {
61 if (phy_bind->phy)
62 return phy_bind->phy;
63 else
64 return ERR_PTR(-EPROBE_DEFER);
65 }
66 }
67
68 return ERR_PTR(-ENODEV);
69}
70
71static struct usb_phy *__of_usb_find_phy(struct device_node *node)
72{
73 struct usb_phy *phy;
74
75 if (!of_device_is_available(node))
76 return ERR_PTR(-ENODEV);
77
78 list_for_each_entry(phy, &phy_list, head) {
79 if (node != phy->dev->of_node)
80 continue;
81
82 return phy;
83 }
84
85 return ERR_PTR(-EPROBE_DEFER);
86}
87
88static void usb_phy_set_default_current(struct usb_phy *usb_phy)
89{
90 usb_phy->chg_cur.sdp_min = DEFAULT_SDP_CUR_MIN;
91 usb_phy->chg_cur.sdp_max = DEFAULT_SDP_CUR_MAX;
92 usb_phy->chg_cur.dcp_min = DEFAULT_DCP_CUR_MIN;
93 usb_phy->chg_cur.dcp_max = DEFAULT_DCP_CUR_MAX;
94 usb_phy->chg_cur.cdp_min = DEFAULT_CDP_CUR_MIN;
95 usb_phy->chg_cur.cdp_max = DEFAULT_CDP_CUR_MAX;
96 usb_phy->chg_cur.aca_min = DEFAULT_ACA_CUR_MIN;
97 usb_phy->chg_cur.aca_max = DEFAULT_ACA_CUR_MAX;
98}
99
100/**
101 * usb_phy_notify_charger_work - notify the USB charger state
102 * @work - the charger work to notify the USB charger state
103 *
104 * This work can be issued when USB charger state has been changed or
105 * USB charger current has been changed, then we can notify the current
106 * what can be drawn to power user and the charger state to userspace.
107 *
108 * If we get the charger type from extcon subsystem, we can notify the
109 * charger state to power user automatically by usb_phy_get_charger_type()
110 * issuing from extcon subsystem.
111 *
112 * If we get the charger type from ->charger_detect() instead of extcon
113 * subsystem, the usb phy driver should issue usb_phy_set_charger_state()
114 * to set charger state when the charger state has been changed.
115 */
116static void usb_phy_notify_charger_work(struct work_struct *work)
117{
118 struct usb_phy *usb_phy = container_of(work, struct usb_phy, chg_work);
119 char uchger_state[50] = { 0 };
120 char *envp[] = { uchger_state, NULL };
121 unsigned int min, max;
122
123 switch (usb_phy->chg_state) {
124 case USB_CHARGER_PRESENT:
125 usb_phy_get_charger_current(usb_phy, &min, &max);
126
127 atomic_notifier_call_chain(&usb_phy->notifier, max, usb_phy);
128 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
129 "USB_CHARGER_STATE=%s", "USB_CHARGER_PRESENT");
130 break;
131 case USB_CHARGER_ABSENT:
132 usb_phy_set_default_current(usb_phy);
133
134 atomic_notifier_call_chain(&usb_phy->notifier, 0, usb_phy);
135 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
136 "USB_CHARGER_STATE=%s", "USB_CHARGER_ABSENT");
137 break;
138 default:
139 dev_warn(usb_phy->dev, "Unknown USB charger state: %d\n",
140 usb_phy->chg_state);
141 return;
142 }
143
144 kobject_uevent_env(&usb_phy->dev->kobj, KOBJ_CHANGE, envp);
145}
146
147static void __usb_phy_get_charger_type(struct usb_phy *usb_phy)
148{
149 if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_SDP) > 0) {
150 usb_phy->chg_type = SDP_TYPE;
151 usb_phy->chg_state = USB_CHARGER_PRESENT;
152 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_CDP) > 0) {
153 usb_phy->chg_type = CDP_TYPE;
154 usb_phy->chg_state = USB_CHARGER_PRESENT;
155 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_DCP) > 0) {
156 usb_phy->chg_type = DCP_TYPE;
157 usb_phy->chg_state = USB_CHARGER_PRESENT;
158 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_ACA) > 0) {
159 usb_phy->chg_type = ACA_TYPE;
160 usb_phy->chg_state = USB_CHARGER_PRESENT;
161 } else {
162 usb_phy->chg_type = UNKNOWN_TYPE;
163 usb_phy->chg_state = USB_CHARGER_ABSENT;
164 }
165
166 schedule_work(&usb_phy->chg_work);
167}
168
169/**
170 * usb_phy_get_charger_type - get charger type from extcon subsystem
171 * @nb -the notifier block to determine charger type
172 * @state - the cable state
173 * @data - private data
174 *
175 * Determin the charger type from extcon subsystem which also means the
176 * charger state has been chaned, then we should notify this event.
177 */
178static int usb_phy_get_charger_type(struct notifier_block *nb,
179 unsigned long state, void *data)
180{
181 struct usb_phy *usb_phy = container_of(nb, struct usb_phy, type_nb);
182
183 __usb_phy_get_charger_type(usb_phy);
184 return NOTIFY_OK;
185}
186
187/**
188 * usb_phy_set_charger_current - set the USB charger current
189 * @usb_phy - the USB phy to be used
190 * @mA - the current need to be set
191 *
192 * Usually we only change the charger default current when USB finished the
193 * enumeration as one SDP charger. As one SDP charger, usb_phy_set_power()
194 * will issue this function to change charger current when after setting USB
195 * configuration, or suspend/resume USB. For other type charger, we should
196 * use the default charger current and we do not suggest to issue this function
197 * to change the charger current.
198 *
199 * When USB charger current has been changed, we need to notify the power users.
200 */
201void usb_phy_set_charger_current(struct usb_phy *usb_phy, unsigned int mA)
202{
203 switch (usb_phy->chg_type) {
204 case SDP_TYPE:
205 if (usb_phy->chg_cur.sdp_max == mA)
206 return;
207
208 usb_phy->chg_cur.sdp_max = (mA > DEFAULT_SDP_CUR_MAX_SS) ?
209 DEFAULT_SDP_CUR_MAX_SS : mA;
210 break;
211 case DCP_TYPE:
212 if (usb_phy->chg_cur.dcp_max == mA)
213 return;
214
215 usb_phy->chg_cur.dcp_max = (mA > DEFAULT_DCP_CUR_MAX) ?
216 DEFAULT_DCP_CUR_MAX : mA;
217 break;
218 case CDP_TYPE:
219 if (usb_phy->chg_cur.cdp_max == mA)
220 return;
221
222 usb_phy->chg_cur.cdp_max = (mA > DEFAULT_CDP_CUR_MAX) ?
223 DEFAULT_CDP_CUR_MAX : mA;
224 break;
225 case ACA_TYPE:
226 if (usb_phy->chg_cur.aca_max == mA)
227 return;
228
229 usb_phy->chg_cur.aca_max = (mA > DEFAULT_ACA_CUR_MAX) ?
230 DEFAULT_ACA_CUR_MAX : mA;
231 break;
232 default:
233 return;
234 }
235
236 schedule_work(&usb_phy->chg_work);
237}
238EXPORT_SYMBOL_GPL(usb_phy_set_charger_current);
239
240/**
241 * usb_phy_get_charger_current - get the USB charger current
242 * @usb_phy - the USB phy to be used
243 * @min - the minimum current
244 * @max - the maximum current
245 *
246 * Usually we will notify the maximum current to power user, but for some
247 * special case, power user also need the minimum current value. Then the
248 * power user can issue this function to get the suitable current.
249 */
250void usb_phy_get_charger_current(struct usb_phy *usb_phy,
251 unsigned int *min, unsigned int *max)
252{
253 switch (usb_phy->chg_type) {
254 case SDP_TYPE:
255 *min = usb_phy->chg_cur.sdp_min;
256 *max = usb_phy->chg_cur.sdp_max;
257 break;
258 case DCP_TYPE:
259 *min = usb_phy->chg_cur.dcp_min;
260 *max = usb_phy->chg_cur.dcp_max;
261 break;
262 case CDP_TYPE:
263 *min = usb_phy->chg_cur.cdp_min;
264 *max = usb_phy->chg_cur.cdp_max;
265 break;
266 case ACA_TYPE:
267 *min = usb_phy->chg_cur.aca_min;
268 *max = usb_phy->chg_cur.aca_max;
269 break;
270 default:
271 *min = 0;
272 *max = 0;
273 break;
274 }
275}
276EXPORT_SYMBOL_GPL(usb_phy_get_charger_current);
277
278/**
279 * usb_phy_set_charger_state - set the USB charger state
280 * @usb_phy - the USB phy to be used
281 * @state - the new state need to be set for charger
282 *
283 * The usb phy driver can issue this function when the usb phy driver
284 * detected the charger state has been changed, in this case the charger
285 * type should be get from ->charger_detect().
286 */
287void usb_phy_set_charger_state(struct usb_phy *usb_phy,
288 enum usb_charger_state state)
289{
290 if (usb_phy->chg_state == state || !usb_phy->charger_detect)
291 return;
292
293 usb_phy->chg_state = state;
294 if (usb_phy->chg_state == USB_CHARGER_PRESENT)
295 usb_phy->chg_type = usb_phy->charger_detect(usb_phy);
296 else
297 usb_phy->chg_type = UNKNOWN_TYPE;
298
299 schedule_work(&usb_phy->chg_work);
300}
301EXPORT_SYMBOL_GPL(usb_phy_set_charger_state);
302
303static void devm_usb_phy_release(struct device *dev, void *res)
304{
305 struct usb_phy *phy = *(struct usb_phy **)res;
306
307 usb_put_phy(phy);
308}
309
310static void devm_usb_phy_release2(struct device *dev, void *_res)
311{
312 struct phy_devm *res = _res;
313
314 if (res->nb)
315 usb_unregister_notifier(res->phy, res->nb);
316 usb_put_phy(res->phy);
317}
318
319static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
320{
321 struct usb_phy **phy = res;
322
323 return *phy == match_data;
324}
325
326static void usb_charger_init(struct usb_phy *usb_phy)
327{
328 usb_phy->chg_type = UNKNOWN_TYPE;
329 usb_phy->chg_state = USB_CHARGER_DEFAULT;
330 usb_phy_set_default_current(usb_phy);
331 INIT_WORK(&usb_phy->chg_work, usb_phy_notify_charger_work);
332}
333
334static int usb_add_extcon(struct usb_phy *x)
335{
336 int ret;
337
338 if (of_property_read_bool(x->dev->of_node, "extcon")) {
339 x->edev = extcon_get_edev_by_phandle(x->dev, 0);
340 if (IS_ERR(x->edev))
341 return PTR_ERR(x->edev);
342
343 x->id_edev = extcon_get_edev_by_phandle(x->dev, 1);
344 if (IS_ERR(x->id_edev)) {
345 x->id_edev = NULL;
346 dev_info(x->dev, "No separate ID extcon device\n");
347 }
348
349 if (x->vbus_nb.notifier_call) {
350 ret = devm_extcon_register_notifier(x->dev, x->edev,
351 EXTCON_USB,
352 &x->vbus_nb);
353 if (ret < 0) {
354 dev_err(x->dev,
355 "register VBUS notifier failed\n");
356 return ret;
357 }
358 } else {
359 x->type_nb.notifier_call = usb_phy_get_charger_type;
360
361 ret = devm_extcon_register_notifier(x->dev, x->edev,
362 EXTCON_CHG_USB_SDP,
363 &x->type_nb);
364 if (ret) {
365 dev_err(x->dev,
366 "register extcon USB SDP failed.\n");
367 return ret;
368 }
369
370 ret = devm_extcon_register_notifier(x->dev, x->edev,
371 EXTCON_CHG_USB_CDP,
372 &x->type_nb);
373 if (ret) {
374 dev_err(x->dev,
375 "register extcon USB CDP failed.\n");
376 return ret;
377 }
378
379 ret = devm_extcon_register_notifier(x->dev, x->edev,
380 EXTCON_CHG_USB_DCP,
381 &x->type_nb);
382 if (ret) {
383 dev_err(x->dev,
384 "register extcon USB DCP failed.\n");
385 return ret;
386 }
387
388 ret = devm_extcon_register_notifier(x->dev, x->edev,
389 EXTCON_CHG_USB_ACA,
390 &x->type_nb);
391 if (ret) {
392 dev_err(x->dev,
393 "register extcon USB ACA failed.\n");
394 return ret;
395 }
396 }
397
398 if (x->id_nb.notifier_call) {
399 struct extcon_dev *id_ext;
400
401 if (x->id_edev)
402 id_ext = x->id_edev;
403 else
404 id_ext = x->edev;
405
406 ret = devm_extcon_register_notifier(x->dev, id_ext,
407 EXTCON_USB_HOST,
408 &x->id_nb);
409 if (ret < 0) {
410 dev_err(x->dev,
411 "register ID notifier failed\n");
412 return ret;
413 }
414 }
415 }
416
417 if (x->type_nb.notifier_call)
418 __usb_phy_get_charger_type(x);
419
420 return 0;
421}
422
423/**
424 * devm_usb_get_phy - find the USB PHY
425 * @dev - device that requests this phy
426 * @type - the type of the phy the controller requires
427 *
428 * Gets the phy using usb_get_phy(), and associates a device with it using
429 * devres. On driver detach, release function is invoked on the devres data,
430 * then, devres data is freed.
431 *
432 * For use by USB host and peripheral drivers.
433 */
434struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
435{
436 struct usb_phy **ptr, *phy;
437
438 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
439 if (!ptr)
440 return ERR_PTR(-ENOMEM);
441
442 phy = usb_get_phy(type);
443 if (!IS_ERR(phy)) {
444 *ptr = phy;
445 devres_add(dev, ptr);
446 } else
447 devres_free(ptr);
448
449 return phy;
450}
451EXPORT_SYMBOL_GPL(devm_usb_get_phy);
452
453/**
454 * usb_get_phy - find the USB PHY
455 * @type - the type of the phy the controller requires
456 *
457 * Returns the phy driver, after getting a refcount to it; or
458 * -ENODEV if there is no such phy. The caller is responsible for
459 * calling usb_put_phy() to release that count.
460 *
461 * For use by USB host and peripheral drivers.
462 */
463struct usb_phy *usb_get_phy(enum usb_phy_type type)
464{
465 struct usb_phy *phy = NULL;
466 unsigned long flags;
467
468 spin_lock_irqsave(&phy_lock, flags);
469
470 phy = __usb_find_phy(&phy_list, type);
471 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
472 pr_debug("PHY: unable to find transceiver of type %s\n",
473 usb_phy_type_string(type));
474 if (!IS_ERR(phy))
475 phy = ERR_PTR(-ENODEV);
476
477 goto err0;
478 }
479
480 get_device(phy->dev);
481
482err0:
483 spin_unlock_irqrestore(&phy_lock, flags);
484
485 return phy;
486}
487EXPORT_SYMBOL_GPL(usb_get_phy);
488
489/**
490 * devm_usb_get_phy_by_node - find the USB PHY by device_node
491 * @dev - device that requests this phy
492 * @node - the device_node for the phy device.
493 * @nb - a notifier_block to register with the phy.
494 *
495 * Returns the phy driver associated with the given device_node,
496 * after getting a refcount to it, -ENODEV if there is no such phy or
497 * -EPROBE_DEFER if the device is not yet loaded. While at that, it
498 * also associates the device with
499 * the phy using devres. On driver detach, release function is invoked
500 * on the devres data, then, devres data is freed.
501 *
502 * For use by peripheral drivers for devices related to a phy,
503 * such as a charger.
504 */
505struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
506 struct device_node *node,
507 struct notifier_block *nb)
508{
509 struct usb_phy *phy = ERR_PTR(-ENOMEM);
510 struct phy_devm *ptr;
511 unsigned long flags;
512
513 ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
514 if (!ptr) {
515 dev_dbg(dev, "failed to allocate memory for devres\n");
516 goto err0;
517 }
518
519 spin_lock_irqsave(&phy_lock, flags);
520
521 phy = __of_usb_find_phy(node);
522 if (IS_ERR(phy)) {
523 devres_free(ptr);
524 goto err1;
525 }
526
527 if (!try_module_get(phy->dev->driver->owner)) {
528 phy = ERR_PTR(-ENODEV);
529 devres_free(ptr);
530 goto err1;
531 }
532 if (nb)
533 usb_register_notifier(phy, nb);
534 ptr->phy = phy;
535 ptr->nb = nb;
536 devres_add(dev, ptr);
537
538 get_device(phy->dev);
539
540err1:
541 spin_unlock_irqrestore(&phy_lock, flags);
542
543err0:
544
545 return phy;
546}
547EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
548
549/**
550 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
551 * @dev - device that requests this phy
552 * @phandle - name of the property holding the phy phandle value
553 * @index - the index of the phy
554 *
555 * Returns the phy driver associated with the given phandle value,
556 * after getting a refcount to it, -ENODEV if there is no such phy or
557 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
558 * not yet loaded. While at that, it also associates the device with
559 * the phy using devres. On driver detach, release function is invoked
560 * on the devres data, then, devres data is freed.
561 *
562 * For use by USB host and peripheral drivers.
563 */
564struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
565 const char *phandle, u8 index)
566{
567 struct device_node *node;
568 struct usb_phy *phy;
569
570 if (!dev->of_node) {
571 dev_dbg(dev, "device does not have a device node entry\n");
572 return ERR_PTR(-EINVAL);
573 }
574
575 node = of_parse_phandle(dev->of_node, phandle, index);
576 if (!node) {
577 dev_dbg(dev, "failed to get %s phandle in %pOF node\n", phandle,
578 dev->of_node);
579 return ERR_PTR(-ENODEV);
580 }
581 phy = devm_usb_get_phy_by_node(dev, node, NULL);
582 of_node_put(node);
583 return phy;
584}
585EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
586
587/**
588 * usb_get_phy_dev - find the USB PHY
589 * @dev - device that requests this phy
590 * @index - the index of the phy
591 *
592 * Returns the phy driver, after getting a refcount to it; or
593 * -ENODEV if there is no such phy. The caller is responsible for
594 * calling usb_put_phy() to release that count.
595 *
596 * For use by USB host and peripheral drivers.
597 */
598struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
599{
600 struct usb_phy *phy = NULL;
601 unsigned long flags;
602
603 spin_lock_irqsave(&phy_lock, flags);
604
605 phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
606 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
607 dev_dbg(dev, "unable to find transceiver\n");
608 if (!IS_ERR(phy))
609 phy = ERR_PTR(-ENODEV);
610
611 goto err0;
612 }
613
614 get_device(phy->dev);
615
616err0:
617 spin_unlock_irqrestore(&phy_lock, flags);
618
619 return phy;
620}
621EXPORT_SYMBOL_GPL(usb_get_phy_dev);
622
623/**
624 * devm_usb_get_phy_dev - find the USB PHY using device ptr and index
625 * @dev - device that requests this phy
626 * @index - the index of the phy
627 *
628 * Gets the phy using usb_get_phy_dev(), and associates a device with it using
629 * devres. On driver detach, release function is invoked on the devres data,
630 * then, devres data is freed.
631 *
632 * For use by USB host and peripheral drivers.
633 */
634struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
635{
636 struct usb_phy **ptr, *phy;
637
638 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
639 if (!ptr)
640 return NULL;
641
642 phy = usb_get_phy_dev(dev, index);
643 if (!IS_ERR(phy)) {
644 *ptr = phy;
645 devres_add(dev, ptr);
646 } else
647 devres_free(ptr);
648
649 return phy;
650}
651EXPORT_SYMBOL_GPL(devm_usb_get_phy_dev);
652
653/**
654 * devm_usb_put_phy - release the USB PHY
655 * @dev - device that wants to release this phy
656 * @phy - the phy returned by devm_usb_get_phy()
657 *
658 * destroys the devres associated with this phy and invokes usb_put_phy
659 * to release the phy.
660 *
661 * For use by USB host and peripheral drivers.
662 */
663void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
664{
665 int r;
666
667 r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
668 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
669}
670EXPORT_SYMBOL_GPL(devm_usb_put_phy);
671
672/**
673 * usb_put_phy - release the USB PHY
674 * @x: the phy returned by usb_get_phy()
675 *
676 * Releases a refcount the caller received from usb_get_phy().
677 *
678 * For use by USB host and peripheral drivers.
679 */
680void usb_put_phy(struct usb_phy *x)
681{
682 if (x) {
683 struct module *owner = x->dev->driver->owner;
684
685 put_device(x->dev);
686 module_put(owner);
687 }
688}
689EXPORT_SYMBOL_GPL(usb_put_phy);
690
691/**
692 * usb_add_phy - declare the USB PHY
693 * @x: the USB phy to be used; or NULL
694 * @type - the type of this PHY
695 *
696 * This call is exclusively for use by phy drivers, which
697 * coordinate the activities of drivers for host and peripheral
698 * controllers, and in some cases for VBUS current regulation.
699 */
700int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
701{
702 int ret = 0;
703 unsigned long flags;
704 struct usb_phy *phy;
705
706 if (x->type != USB_PHY_TYPE_UNDEFINED) {
707 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
708 return -EINVAL;
709 }
710
711 usb_charger_init(x);
712 ret = usb_add_extcon(x);
713 if (ret)
714 return ret;
715
716 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
717
718 spin_lock_irqsave(&phy_lock, flags);
719
720 list_for_each_entry(phy, &phy_list, head) {
721 if (phy->type == type) {
722 ret = -EBUSY;
723 dev_err(x->dev, "transceiver type %s already exists\n",
724 usb_phy_type_string(type));
725 goto out;
726 }
727 }
728
729 x->type = type;
730 list_add_tail(&x->head, &phy_list);
731
732out:
733 spin_unlock_irqrestore(&phy_lock, flags);
734 return ret;
735}
736EXPORT_SYMBOL_GPL(usb_add_phy);
737
738/**
739 * usb_add_phy_dev - declare the USB PHY
740 * @x: the USB phy to be used; or NULL
741 *
742 * This call is exclusively for use by phy drivers, which
743 * coordinate the activities of drivers for host and peripheral
744 * controllers, and in some cases for VBUS current regulation.
745 */
746int usb_add_phy_dev(struct usb_phy *x)
747{
748 struct usb_phy_bind *phy_bind;
749 unsigned long flags;
750 int ret;
751
752 if (!x->dev) {
753 dev_err(x->dev, "no device provided for PHY\n");
754 return -EINVAL;
755 }
756
757 usb_charger_init(x);
758 ret = usb_add_extcon(x);
759 if (ret)
760 return ret;
761
762 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
763
764 spin_lock_irqsave(&phy_lock, flags);
765 list_for_each_entry(phy_bind, &phy_bind_list, list)
766 if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
767 phy_bind->phy = x;
768
769 list_add_tail(&x->head, &phy_list);
770
771 spin_unlock_irqrestore(&phy_lock, flags);
772 return 0;
773}
774EXPORT_SYMBOL_GPL(usb_add_phy_dev);
775
776/**
777 * usb_remove_phy - remove the OTG PHY
778 * @x: the USB OTG PHY to be removed;
779 *
780 * This reverts the effects of usb_add_phy
781 */
782void usb_remove_phy(struct usb_phy *x)
783{
784 unsigned long flags;
785 struct usb_phy_bind *phy_bind;
786
787 spin_lock_irqsave(&phy_lock, flags);
788 if (x) {
789 list_for_each_entry(phy_bind, &phy_bind_list, list)
790 if (phy_bind->phy == x)
791 phy_bind->phy = NULL;
792 list_del(&x->head);
793 }
794 spin_unlock_irqrestore(&phy_lock, flags);
795}
796EXPORT_SYMBOL_GPL(usb_remove_phy);
797
798/**
799 * usb_bind_phy - bind the phy and the controller that uses the phy
800 * @dev_name: the device name of the device that will bind to the phy
801 * @index: index to specify the port number
802 * @phy_dev_name: the device name of the phy
803 *
804 * Fills the phy_bind structure with the dev_name and phy_dev_name. This will
805 * be used when the phy driver registers the phy and when the controller
806 * requests this phy.
807 *
808 * To be used by platform specific initialization code.
809 */
810int usb_bind_phy(const char *dev_name, u8 index,
811 const char *phy_dev_name)
812{
813 struct usb_phy_bind *phy_bind;
814 unsigned long flags;
815
816 phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
817 if (!phy_bind)
818 return -ENOMEM;
819
820 phy_bind->dev_name = dev_name;
821 phy_bind->phy_dev_name = phy_dev_name;
822 phy_bind->index = index;
823
824 spin_lock_irqsave(&phy_lock, flags);
825 list_add_tail(&phy_bind->list, &phy_bind_list);
826 spin_unlock_irqrestore(&phy_lock, flags);
827
828 return 0;
829}
830EXPORT_SYMBOL_GPL(usb_bind_phy);
831
832/**
833 * usb_phy_set_event - set event to phy event
834 * @x: the phy returned by usb_get_phy();
835 *
836 * This sets event to phy event
837 */
838void usb_phy_set_event(struct usb_phy *x, unsigned long event)
839{
840 x->last_event = event;
841}
842EXPORT_SYMBOL_GPL(usb_phy_set_event);