phy.c

  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 void usb_charger_init(struct usb_phy *usb_phy)
350{
351	usb_phy->chg_type = UNKNOWN_TYPE;
352	usb_phy->chg_state = USB_CHARGER_DEFAULT;
353	usb_phy_set_default_current(usb_phy);
354	INIT_WORK(&usb_phy->chg_work, usb_phy_notify_charger_work);
355}
356
357static int usb_add_extcon(struct usb_phy *x)
358{
359	int ret;
360
361	if (of_property_present(x->dev->of_node, "extcon")) {
362		x->edev = extcon_get_edev_by_phandle(x->dev, 0);
363		if (IS_ERR(x->edev))
364			return PTR_ERR(x->edev);
365
366		x->id_edev = extcon_get_edev_by_phandle(x->dev, 1);
367		if (IS_ERR(x->id_edev)) {
368			x->id_edev = NULL;
369			dev_info(x->dev, "No separate ID extcon device\n");
370		}
371
372		if (x->vbus_nb.notifier_call) {
373			ret = devm_extcon_register_notifier(x->dev, x->edev,
374							    EXTCON_USB,
375							    &x->vbus_nb);
376			if (ret < 0) {
377				dev_err(x->dev,
378					"register VBUS notifier failed\n");
379				return ret;
380			}
381		} else {
382			x->type_nb.notifier_call = usb_phy_get_charger_type;
383
384			ret = devm_extcon_register_notifier(x->dev, x->edev,
385							    EXTCON_CHG_USB_SDP,
386							    &x->type_nb);
387			if (ret) {
388				dev_err(x->dev,
389					"register extcon USB SDP failed.\n");
390				return ret;
391			}
392
393			ret = devm_extcon_register_notifier(x->dev, x->edev,
394							    EXTCON_CHG_USB_CDP,
395							    &x->type_nb);
396			if (ret) {
397				dev_err(x->dev,
398					"register extcon USB CDP failed.\n");
399				return ret;
400			}
401
402			ret = devm_extcon_register_notifier(x->dev, x->edev,
403							    EXTCON_CHG_USB_DCP,
404							    &x->type_nb);
405			if (ret) {
406				dev_err(x->dev,
407					"register extcon USB DCP failed.\n");
408				return ret;
409			}
410
411			ret = devm_extcon_register_notifier(x->dev, x->edev,
412							    EXTCON_CHG_USB_ACA,
413							    &x->type_nb);
414			if (ret) {
415				dev_err(x->dev,
416					"register extcon USB ACA failed.\n");
417				return ret;
418			}
419		}
420
421		if (x->id_nb.notifier_call) {
422			struct extcon_dev *id_ext;
423
424			if (x->id_edev)
425				id_ext = x->id_edev;
426			else
427				id_ext = x->edev;
428
429			ret = devm_extcon_register_notifier(x->dev, id_ext,
430							    EXTCON_USB_HOST,
431							    &x->id_nb);
432			if (ret < 0) {
433				dev_err(x->dev,
434					"register ID notifier failed\n");
435				return ret;
436			}
437		}
438	}
439
440	if (x->type_nb.notifier_call)
441		__usb_phy_get_charger_type(x);
442
443	return 0;
444}
445
446/**
447 * devm_usb_get_phy - find the USB PHY
448 * @dev: device that requests this phy
449 * @type: the type of the phy the controller requires
450 *
451 * Gets the phy using usb_get_phy(), and associates a device with it using
452 * devres. On driver detach, release function is invoked on the devres data,
453 * then, devres data is freed.
454 *
455 * For use by USB host and peripheral drivers.
456 */
457struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
458{
459	struct usb_phy **ptr, *phy;
460
461	ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
462	if (!ptr)
463		return ERR_PTR(-ENOMEM);
464
465	phy = usb_get_phy(type);
466	if (!IS_ERR(phy)) {
467		*ptr = phy;
468		devres_add(dev, ptr);
469	} else
470		devres_free(ptr);
471
472	return phy;
473}
474EXPORT_SYMBOL_GPL(devm_usb_get_phy);
475
476/**
477 * usb_get_phy - find the USB PHY
478 * @type: the type of the phy the controller requires
479 *
480 * Returns the phy driver, after getting a refcount to it; or
481 * -ENODEV if there is no such phy.  The caller is responsible for
482 * calling usb_put_phy() to release that count.
483 *
484 * For use by USB host and peripheral drivers.
485 */
486struct usb_phy *usb_get_phy(enum usb_phy_type type)
487{
488	struct usb_phy	*phy = NULL;
489	unsigned long	flags;
490
491	spin_lock_irqsave(&phy_lock, flags);
492
493	phy = __usb_find_phy(&phy_list, type);
494	if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
495		pr_debug("PHY: unable to find transceiver of type %s\n",
496			usb_phy_type_string(type));
497		if (!IS_ERR(phy))
498			phy = ERR_PTR(-ENODEV);
499
500		goto err0;
501	}
502
503	get_device(phy->dev);
504
505err0:
506	spin_unlock_irqrestore(&phy_lock, flags);
507
508	return phy;
509}
510EXPORT_SYMBOL_GPL(usb_get_phy);
511
512/**
513 * devm_usb_get_phy_by_node - find the USB PHY by device_node
514 * @dev: device that requests this phy
515 * @node: the device_node for the phy device.
516 * @nb: a notifier_block to register with the phy.
517 *
518 * Returns the phy driver associated with the given device_node,
519 * after getting a refcount to it, -ENODEV if there is no such phy or
520 * -EPROBE_DEFER if the device is not yet loaded. While at that, it
521 * also associates the device with
522 * the phy using devres. On driver detach, release function is invoked
523 * on the devres data, then, devres data is freed.
524 *
525 * For use by peripheral drivers for devices related to a phy,
526 * such as a charger.
527 */
528struct  usb_phy *devm_usb_get_phy_by_node(struct device *dev,
529					  struct device_node *node,
530					  struct notifier_block *nb)
531{
532	struct usb_phy	*phy = ERR_PTR(-ENOMEM);
533	struct phy_devm	*ptr;
534	unsigned long	flags;
535
536	ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
537	if (!ptr) {
538		dev_dbg(dev, "failed to allocate memory for devres\n");
539		goto err0;
540	}
541
542	spin_lock_irqsave(&phy_lock, flags);
543
544	phy = __of_usb_find_phy(node);
545	if (IS_ERR(phy)) {
546		devres_free(ptr);
547		goto err1;
548	}
549
550	if (!try_module_get(phy->dev->driver->owner)) {
551		phy = ERR_PTR(-ENODEV);
552		devres_free(ptr);
553		goto err1;
554	}
555	if (nb)
556		usb_register_notifier(phy, nb);
557	ptr->phy = phy;
558	ptr->nb = nb;
559	devres_add(dev, ptr);
560
561	get_device(phy->dev);
562
563err1:
564	spin_unlock_irqrestore(&phy_lock, flags);
565
566err0:
567
568	return phy;
569}
570EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
571
572/**
573 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
574 * @dev: device that requests this phy
575 * @phandle: name of the property holding the phy phandle value
576 * @index: the index of the phy
577 *
578 * Returns the phy driver associated with the given phandle value,
579 * after getting a refcount to it, -ENODEV if there is no such phy or
580 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
581 * not yet loaded. While at that, it also associates the device with
582 * the phy using devres. On driver detach, release function is invoked
583 * on the devres data, then, devres data is freed.
584 *
585 * For use by USB host and peripheral drivers.
586 */
587struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
588	const char *phandle, u8 index)
589{
590	struct device_node *node;
591	struct usb_phy	*phy;
592
593	if (!dev->of_node) {
594		dev_dbg(dev, "device does not have a device node entry\n");
595		return ERR_PTR(-EINVAL);
596	}
597
598	node = of_parse_phandle(dev->of_node, phandle, index);
599	if (!node) {
600		dev_dbg(dev, "failed to get %s phandle in %pOF node\n", phandle,
601			dev->of_node);
602		return ERR_PTR(-ENODEV);
603	}
604	phy = devm_usb_get_phy_by_node(dev, node, NULL);
605	of_node_put(node);
606	return phy;
607}
608EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
609
610/**
611 * usb_put_phy - release the USB PHY
612 * @x: the phy returned by usb_get_phy()
613 *
614 * Releases a refcount the caller received from usb_get_phy().
615 *
616 * For use by USB host and peripheral drivers.
617 */
618void usb_put_phy(struct usb_phy *x)
619{
620	if (x) {
621		struct module *owner = x->dev->driver->owner;
622
623		put_device(x->dev);
624		module_put(owner);
625	}
626}
627EXPORT_SYMBOL_GPL(usb_put_phy);
628
629/**
630 * usb_add_phy: declare the USB PHY
631 * @x: the USB phy to be used; or NULL
632 * @type: the type of this PHY
633 *
634 * This call is exclusively for use by phy drivers, which
635 * coordinate the activities of drivers for host and peripheral
636 * controllers, and in some cases for VBUS current regulation.
637 */
638int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
639{
640	int		ret = 0;
641	unsigned long	flags;
642	struct usb_phy	*phy;
643
644	if (x->type != USB_PHY_TYPE_UNDEFINED) {
645		dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
646		return -EINVAL;
647	}
648
649	INIT_LIST_HEAD(&x->head);
650
651	usb_charger_init(x);
652	ret = usb_add_extcon(x);
653	if (ret)
654		return ret;
655
656	ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
657
658	spin_lock_irqsave(&phy_lock, flags);
659
660	list_for_each_entry(phy, &phy_list, head) {
661		if (phy->type == type) {
662			ret = -EBUSY;
663			dev_err(x->dev, "transceiver type %s already exists\n",
664						usb_phy_type_string(type));
665			goto out;
666		}
667	}
668
669	x->type = type;
670	list_add_tail(&x->head, &phy_list);
671
672out:
673	spin_unlock_irqrestore(&phy_lock, flags);
674	return ret;
675}
676EXPORT_SYMBOL_GPL(usb_add_phy);
677
678static const struct device_type usb_phy_dev_type = {
679	.name = "usb_phy",
680	.uevent = usb_phy_uevent,
681};
682
683/**
684 * usb_add_phy_dev - declare the USB PHY
685 * @x: the USB phy to be used; or NULL
686 *
687 * This call is exclusively for use by phy drivers, which
688 * coordinate the activities of drivers for host and peripheral
689 * controllers, and in some cases for VBUS current regulation.
690 */
691int usb_add_phy_dev(struct usb_phy *x)
692{
693	unsigned long flags;
694	int ret;
695
696	if (!x->dev) {
697		dev_err(x->dev, "no device provided for PHY\n");
698		return -EINVAL;
699	}
700
701	INIT_LIST_HEAD(&x->head);
702
703	usb_charger_init(x);
704	ret = usb_add_extcon(x);
705	if (ret)
706		return ret;
707
708	x->dev->type = &usb_phy_dev_type;
709
710	ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
711
712	spin_lock_irqsave(&phy_lock, flags);
713	list_add_tail(&x->head, &phy_list);
714	spin_unlock_irqrestore(&phy_lock, flags);
715
716	return 0;
717}
718EXPORT_SYMBOL_GPL(usb_add_phy_dev);
719
720/**
721 * usb_remove_phy - remove the OTG PHY
722 * @x: the USB OTG PHY to be removed;
723 *
724 * This reverts the effects of usb_add_phy
725 */
726void usb_remove_phy(struct usb_phy *x)
727{
728	unsigned long	flags;
729
730	spin_lock_irqsave(&phy_lock, flags);
731	if (x)
732		list_del(&x->head);
733	spin_unlock_irqrestore(&phy_lock, flags);
734}
735EXPORT_SYMBOL_GPL(usb_remove_phy);
736
737/**
738 * usb_phy_set_event - set event to phy event
739 * @x: the phy returned by usb_get_phy();
740 * @event: event to set
741 *
742 * This sets event to phy event
743 */
744void usb_phy_set_event(struct usb_phy *x, unsigned long event)
745{
746	x->last_event = event;
747}
748EXPORT_SYMBOL_GPL(usb_phy_set_event);