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