[linux-2.6-block.git] / drivers / usb / phy / phy.c

/*
 * phy.c -- USB phy handling
 *
 * Copyright (C) 2004-2013 Texas Instruments
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/err.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/of.h>

#include <linux/usb/phy.h>

static LIST_HEAD(phy_list);
static LIST_HEAD(phy_bind_list);
static DEFINE_SPINLOCK(phy_lock);

struct phy_devm {
	struct usb_phy *phy;
	struct notifier_block *nb;
};

static struct usb_phy *__usb_find_phy(struct list_head *list,
	enum usb_phy_type type)
{
	struct usb_phy  *phy = NULL;

	list_for_each_entry(phy, list, head) {
		if (phy->type != type)
			continue;

		return phy;
	}

	return ERR_PTR(-ENODEV);
}

static struct usb_phy *__usb_find_phy_dev(struct device *dev,
	struct list_head *list, u8 index)
{
	struct usb_phy_bind *phy_bind = NULL;

	list_for_each_entry(phy_bind, list, list) {
		if (!(strcmp(phy_bind->dev_name, dev_name(dev))) &&
				phy_bind->index == index) {
			if (phy_bind->phy)
				return phy_bind->phy;
			else
				return ERR_PTR(-EPROBE_DEFER);
		}
	}

	return ERR_PTR(-ENODEV);
}

static struct usb_phy *__of_usb_find_phy(struct device_node *node)
{
	struct usb_phy  *phy;

	if (!of_device_is_available(node))
		return ERR_PTR(-ENODEV);

	list_for_each_entry(phy, &phy_list, head) {
		if (node != phy->dev->of_node)
			continue;

		return phy;
	}

	return ERR_PTR(-EPROBE_DEFER);
}

static void devm_usb_phy_release(struct device *dev, void *res)
{
	struct usb_phy *phy = *(struct usb_phy **)res;

	usb_put_phy(phy);
}

static void devm_usb_phy_release2(struct device *dev, void *_res)
{
	struct phy_devm *res = _res;

	if (res->nb)
		usb_unregister_notifier(res->phy, res->nb);
	usb_put_phy(res->phy);
}

static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
{
	struct usb_phy **phy = res;

	return *phy == match_data;
}

/**
 * devm_usb_get_phy - find the USB PHY
 * @dev - device that requests this phy
 * @type - the type of the phy the controller requires
 *
 * Gets the phy using usb_get_phy(), and associates a device with it using
 * devres. On driver detach, release function is invoked on the devres data,
 * then, devres data is freed.
 *
 * For use by USB host and peripheral drivers.
 */
struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
{
	struct usb_phy **ptr, *phy;

	ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return ERR_PTR(-ENOMEM);

	phy = usb_get_phy(type);
	if (!IS_ERR(phy)) {
		*ptr = phy;
		devres_add(dev, ptr);
	} else
		devres_free(ptr);

	return phy;
}
EXPORT_SYMBOL_GPL(devm_usb_get_phy);

/**
 * usb_get_phy - find the USB PHY
 * @type - the type of the phy the controller requires
 *
 * Returns the phy driver, after getting a refcount to it; or
 * -ENODEV if there is no such phy.  The caller is responsible for
 * calling usb_put_phy() to release that count.
 *
 * For use by USB host and peripheral drivers.
 */
struct usb_phy *usb_get_phy(enum usb_phy_type type)
{
	struct usb_phy	*phy = NULL;
	unsigned long	flags;

	spin_lock_irqsave(&phy_lock, flags);

	phy = __usb_find_phy(&phy_list, type);
	if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
		pr_debug("PHY: unable to find transceiver of type %s\n",
			usb_phy_type_string(type));
		if (!IS_ERR(phy))
			phy = ERR_PTR(-ENODEV);

		goto err0;
	}

	get_device(phy->dev);

err0:
	spin_unlock_irqrestore(&phy_lock, flags);

	return phy;
}
EXPORT_SYMBOL_GPL(usb_get_phy);

/**
 * devm_usb_get_phy_by_node - find the USB PHY by device_node
 * @dev - device that requests this phy
 * @node - the device_node for the phy device.
 * @nb - a notifier_block to register with the phy.
 *
 * Returns the phy driver associated with the given device_node,
 * after getting a refcount to it, -ENODEV if there is no such phy or
 * -EPROBE_DEFER if the device is not yet loaded. While at that, it
 * also associates the device with
 * the phy using devres. On driver detach, release function is invoked
 * on the devres data, then, devres data is freed.
 *
 * For use by peripheral drivers for devices related to a phy,
 * such as a charger.
 */
struct  usb_phy *devm_usb_get_phy_by_node(struct device *dev,
					  struct device_node *node,
					  struct notifier_block *nb)
{
	struct usb_phy	*phy = ERR_PTR(-ENOMEM);
	struct phy_devm	*ptr;
	unsigned long	flags;

	ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
	if (!ptr) {
		dev_dbg(dev, "failed to allocate memory for devres\n");
		goto err0;
	}

	spin_lock_irqsave(&phy_lock, flags);

	phy = __of_usb_find_phy(node);
	if (IS_ERR(phy)) {
		devres_free(ptr);
		goto err1;
	}

	if (!try_module_get(phy->dev->driver->owner)) {
		phy = ERR_PTR(-ENODEV);
		devres_free(ptr);
		goto err1;
	}
	if (nb)
		usb_register_notifier(phy, nb);
	ptr->phy = phy;
	ptr->nb = nb;
	devres_add(dev, ptr);

	get_device(phy->dev);

err1:
	spin_unlock_irqrestore(&phy_lock, flags);

err0:

	return phy;
}
EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);

/**
 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
 * @dev - device that requests this phy
 * @phandle - name of the property holding the phy phandle value
 * @index - the index of the phy
 *
 * Returns the phy driver associated with the given phandle value,
 * after getting a refcount to it, -ENODEV if there is no such phy or
 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
 * not yet loaded. While at that, it also associates the device with
 * the phy using devres. On driver detach, release function is invoked
 * on the devres data, then, devres data is freed.
 *
 * For use by USB host and peripheral drivers.
 */
struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
	const char *phandle, u8 index)
{
	struct device_node *node;
	struct usb_phy	*phy;

	if (!dev->of_node) {
		dev_dbg(dev, "device does not have a device node entry\n");
		return ERR_PTR(-EINVAL);
	}

	node = of_parse_phandle(dev->of_node, phandle, index);
	if (!node) {
		dev_dbg(dev, "failed to get %s phandle in %s node\n", phandle,
			dev->of_node->full_name);
		return ERR_PTR(-ENODEV);
	}
	phy = devm_usb_get_phy_by_node(dev, node, NULL);
	of_node_put(node);
	return phy;
}
EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);

/**
 * usb_get_phy_dev - find the USB PHY
 * @dev - device that requests this phy
 * @index - the index of the phy
 *
 * Returns the phy driver, after getting a refcount to it; or
 * -ENODEV if there is no such phy.  The caller is responsible for
 * calling usb_put_phy() to release that count.
 *
 * For use by USB host and peripheral drivers.
 */
struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
{
	struct usb_phy	*phy = NULL;
	unsigned long	flags;

	spin_lock_irqsave(&phy_lock, flags);

	phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
	if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
		dev_dbg(dev, "unable to find transceiver\n");
		if (!IS_ERR(phy))
			phy = ERR_PTR(-ENODEV);

		goto err0;
	}

	get_device(phy->dev);

err0:
	spin_unlock_irqrestore(&phy_lock, flags);

	return phy;
}
EXPORT_SYMBOL_GPL(usb_get_phy_dev);

/**
 * devm_usb_get_phy_dev - find the USB PHY using device ptr and index
 * @dev - device that requests this phy
 * @index - the index of the phy
 *
 * Gets the phy using usb_get_phy_dev(), and associates a device with it using
 * devres. On driver detach, release function is invoked on the devres data,
 * then, devres data is freed.
 *
 * For use by USB host and peripheral drivers.
 */
struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
{
	struct usb_phy **ptr, *phy;

	ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return NULL;

	phy = usb_get_phy_dev(dev, index);
	if (!IS_ERR(phy)) {
		*ptr = phy;
		devres_add(dev, ptr);
	} else
		devres_free(ptr);

	return phy;
}
EXPORT_SYMBOL_GPL(devm_usb_get_phy_dev);

/**
 * devm_usb_put_phy - release the USB PHY
 * @dev - device that wants to release this phy
 * @phy - the phy returned by devm_usb_get_phy()
 *
 * destroys the devres associated with this phy and invokes usb_put_phy
 * to release the phy.
 *
 * For use by USB host and peripheral drivers.
 */
void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
{
	int r;

	r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
	dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
}
EXPORT_SYMBOL_GPL(devm_usb_put_phy);

/**
 * usb_put_phy - release the USB PHY
 * @x: the phy returned by usb_get_phy()
 *
 * Releases a refcount the caller received from usb_get_phy().
 *
 * For use by USB host and peripheral drivers.
 */
void usb_put_phy(struct usb_phy *x)
{
	if (x) {
		struct module *owner = x->dev->driver->owner;

		put_device(x->dev);
		module_put(owner);
	}
}
EXPORT_SYMBOL_GPL(usb_put_phy);

/**
 * usb_add_phy - declare the USB PHY
 * @x: the USB phy to be used; or NULL
 * @type - the type of this PHY
 *
 * This call is exclusively for use by phy drivers, which
 * coordinate the activities of drivers for host and peripheral
 * controllers, and in some cases for VBUS current regulation.
 */
int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
{
	int		ret = 0;
	unsigned long	flags;
	struct usb_phy	*phy;

	if (x->type != USB_PHY_TYPE_UNDEFINED) {
		dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
		return -EINVAL;
	}

	ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);

	spin_lock_irqsave(&phy_lock, flags);

	list_for_each_entry(phy, &phy_list, head) {
		if (phy->type == type) {
			ret = -EBUSY;
			dev_err(x->dev, "transceiver type %s already exists\n",
						usb_phy_type_string(type));
			goto out;
		}
	}

	x->type = type;
	list_add_tail(&x->head, &phy_list);

out:
	spin_unlock_irqrestore(&phy_lock, flags);
	return ret;
}
EXPORT_SYMBOL_GPL(usb_add_phy);

/**
 * usb_add_phy_dev - declare the USB PHY
 * @x: the USB phy to be used; or NULL
 *
 * This call is exclusively for use by phy drivers, which
 * coordinate the activities of drivers for host and peripheral
 * controllers, and in some cases for VBUS current regulation.
 */
int usb_add_phy_dev(struct usb_phy *x)
{
	struct usb_phy_bind *phy_bind;
	unsigned long flags;

	if (!x->dev) {
		dev_err(x->dev, "no device provided for PHY\n");
		return -EINVAL;
	}

	ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);

	spin_lock_irqsave(&phy_lock, flags);
	list_for_each_entry(phy_bind, &phy_bind_list, list)
		if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
			phy_bind->phy = x;

	list_add_tail(&x->head, &phy_list);

	spin_unlock_irqrestore(&phy_lock, flags);
	return 0;
}
EXPORT_SYMBOL_GPL(usb_add_phy_dev);

/**
 * usb_remove_phy - remove the OTG PHY
 * @x: the USB OTG PHY to be removed;
 *
 * This reverts the effects of usb_add_phy
 */
void usb_remove_phy(struct usb_phy *x)
{
	unsigned long	flags;
	struct usb_phy_bind *phy_bind;

	spin_lock_irqsave(&phy_lock, flags);
	if (x) {
		list_for_each_entry(phy_bind, &phy_bind_list, list)
			if (phy_bind->phy == x)
				phy_bind->phy = NULL;
		list_del(&x->head);
	}
	spin_unlock_irqrestore(&phy_lock, flags);
}
EXPORT_SYMBOL_GPL(usb_remove_phy);

/**
 * usb_bind_phy - bind the phy and the controller that uses the phy
 * @dev_name: the device name of the device that will bind to the phy
 * @index: index to specify the port number
 * @phy_dev_name: the device name of the phy
 *
 * Fills the phy_bind structure with the dev_name and phy_dev_name. This will
 * be used when the phy driver registers the phy and when the controller
 * requests this phy.
 *
 * To be used by platform specific initialization code.
 */
int usb_bind_phy(const char *dev_name, u8 index,
				const char *phy_dev_name)
{
	struct usb_phy_bind *phy_bind;
	unsigned long flags;

	phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
	if (!phy_bind)
		return -ENOMEM;

	phy_bind->dev_name = dev_name;
	phy_bind->phy_dev_name = phy_dev_name;
	phy_bind->index = index;

	spin_lock_irqsave(&phy_lock, flags);
	list_add_tail(&phy_bind->list, &phy_bind_list);
	spin_unlock_irqrestore(&phy_lock, flags);

	return 0;
}
EXPORT_SYMBOL_GPL(usb_bind_phy);

/**
 * usb_phy_set_event - set event to phy event
 * @x: the phy returned by usb_get_phy();
 *
 * This sets event to phy event
 */
void usb_phy_set_event(struct usb_phy *x, unsigned long event)
{
	x->last_event = event;
}
EXPORT_SYMBOL_GPL(usb_phy_set_event);
Commit	Line	Data
cedf8602 SH	1	/*
	2	* phy.c -- USB phy handling
	3	*
	4	* Copyright (C) 2004-2013 Texas Instruments
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*/
	11	#include <linux/kernel.h>
	12	#include <linux/export.h>
	13	#include <linux/err.h>
	14	#include <linux/device.h>
	15	#include <linux/module.h>
	16	#include <linux/slab.h>
	17	#include <linux/of.h>
	18
	19	#include <linux/usb/phy.h>
	20
	21	static LIST_HEAD(phy_list);
	22	static LIST_HEAD(phy_bind_list);
	23	static DEFINE_SPINLOCK(phy_lock);
	24
e842b84c N	25	struct phy_devm {
	26	struct usb_phy *phy;
	27	struct notifier_block *nb;
	28	};
	29
cedf8602 SH	30	static struct usb_phy __usb_find_phy(struct list_head list,
	31	enum usb_phy_type type)
	32	{
	33	struct usb_phy *phy = NULL;
	34
	35	list_for_each_entry(phy, list, head) {
	36	if (phy->type != type)
	37	continue;
	38
	39	return phy;
	40	}
	41
0df8fc37	42	return ERR_PTR(-ENODEV);
cedf8602 SH	43	}
	44
	45	static struct usb_phy __usb_find_phy_dev(struct device dev,
	46	struct list_head *list, u8 index)
	47	{
	48	struct usb_phy_bind *phy_bind = NULL;
	49
	50	list_for_each_entry(phy_bind, list, list) {
	51	if (!(strcmp(phy_bind->dev_name, dev_name(dev))) &&
	52	phy_bind->index == index) {
	53	if (phy_bind->phy)
	54	return phy_bind->phy;
	55	else
	56	return ERR_PTR(-EPROBE_DEFER);
	57	}
	58	}
	59
	60	return ERR_PTR(-ENODEV);
	61	}
	62
	63	static struct usb_phy __of_usb_find_phy(struct device_node node)
	64	{
	65	struct usb_phy *phy;
	66
c818a94c TR	67	if (!of_device_is_available(node))
	68	return ERR_PTR(-ENODEV);
	69
cedf8602 SH	70	list_for_each_entry(phy, &phy_list, head) {
	71	if (node != phy->dev->of_node)
	72	continue;
	73
	74	return phy;
	75	}
	76
9c9d8249	77	return ERR_PTR(-EPROBE_DEFER);
cedf8602 SH	78	}
	79
	80	static void devm_usb_phy_release(struct device dev, void res)
	81	{
	82	struct usb_phy phy = (struct usb_phy **)res;
	83
	84	usb_put_phy(phy);
	85	}
	86
e842b84c N	87	static void devm_usb_phy_release2(struct device dev, void _res)
	88	{
	89	struct phy_devm *res = _res;
	90
	91	if (res->nb)
	92	usb_unregister_notifier(res->phy, res->nb);
	93	usb_put_phy(res->phy);
	94	}
	95
cedf8602 SH	96	static int devm_usb_phy_match(struct device dev, void res, void *match_data)
cedf8602 SH	97	{
869aee0f AL	98	struct usb_phy **phy = res;
	99
	100	return *phy == match_data;
cedf8602 SH	101	}
	102
	103	/**
	104	* devm_usb_get_phy - find the USB PHY
	105	* @dev - device that requests this phy
	106	* @type - the type of the phy the controller requires
	107	*
	108	* Gets the phy using usb_get_phy(), and associates a device with it using
	109	* devres. On driver detach, release function is invoked on the devres data,
	110	* then, devres data is freed.
	111	*
	112	* For use by USB host and peripheral drivers.
	113	*/
	114	struct usb_phy devm_usb_get_phy(struct device dev, enum usb_phy_type type)
	115	{
	116	struct usb_phy *ptr, phy;
	117
	118	ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
	119	if (!ptr)
7f4d1e7b	120	return ERR_PTR(-ENOMEM);
cedf8602 SH	121
	122	phy = usb_get_phy(type);
	123	if (!IS_ERR(phy)) {
	124	*ptr = phy;
	125	devres_add(dev, ptr);
	126	} else
	127	devres_free(ptr);
	128
	129	return phy;
	130	}
110ff6d0	131	EXPORT_SYMBOL_GPL(devm_usb_get_phy);
cedf8602 SH	132
	133	/**
	134	* usb_get_phy - find the USB PHY
	135	* @type - the type of the phy the controller requires
	136	*
	137	* Returns the phy driver, after getting a refcount to it; or
	138	* -ENODEV if there is no such phy. The caller is responsible for
	139	* calling usb_put_phy() to release that count.
	140	*
	141	* For use by USB host and peripheral drivers.
	142	*/
	143	struct usb_phy *usb_get_phy(enum usb_phy_type type)
	144	{
	145	struct usb_phy *phy = NULL;
	146	unsigned long flags;
	147
	148	spin_lock_irqsave(&phy_lock, flags);
	149
	150	phy = __usb_find_phy(&phy_list, type);
	151	if (IS_ERR(phy) \|\| !try_module_get(phy->dev->driver->owner)) {
e9d123a5	152	pr_debug("PHY: unable to find transceiver of type %s\n",
cedf8602	153	usb_phy_type_string(type));
9dc9cb0c MK	154	if (!IS_ERR(phy))
	155	phy = ERR_PTR(-ENODEV);
	156
cedf8602 SH	157	goto err0;
	158	}
	159
	160	get_device(phy->dev);
	161
	162	err0:
	163	spin_unlock_irqrestore(&phy_lock, flags);
	164
	165	return phy;
	166	}
110ff6d0	167	EXPORT_SYMBOL_GPL(usb_get_phy);
cedf8602	168
fb1928de	169	/**
e842b84c	170	* devm_usb_get_phy_by_node - find the USB PHY by device_node
cedf8602	171	* @dev - device that requests this phy
e842b84c N	172	* @node - the device_node for the phy device.
e842b84c N	173	* @nb - a notifier_block to register with the phy.
cedf8602	174	*
e842b84c	175	* Returns the phy driver associated with the given device_node,
cedf8602	176	* after getting a refcount to it, -ENODEV if there is no such phy or
e842b84c N	177	* -EPROBE_DEFER if the device is not yet loaded. While at that, it
e842b84c N	178	* also associates the device with
cedf8602 SH	179	* the phy using devres. On driver detach, release function is invoked
	180	* on the devres data, then, devres data is freed.
	181	*
e842b84c N	182	* For use by peripheral drivers for devices related to a phy,
e842b84c N	183	* such as a charger.
cedf8602	184	*/
e842b84c N	185	struct usb_phy devm_usb_get_phy_by_node(struct device dev,
	186	struct device_node *node,
	187	struct notifier_block *nb)
cedf8602	188	{
e842b84c N	189	struct usb_phy *phy = ERR_PTR(-ENOMEM);
e842b84c N	190	struct phy_devm *ptr;
cedf8602	191	unsigned long flags;
cedf8602	192
e842b84c	193	ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
cedf8602 SH	194	if (!ptr) {
	195	dev_dbg(dev, "failed to allocate memory for devres\n");
	196	goto err0;
	197	}
	198
	199	spin_lock_irqsave(&phy_lock, flags);
	200
	201	phy = __of_usb_find_phy(node);
c818a94c TR	202	if (IS_ERR(phy)) {
	203	devres_free(ptr);
	204	goto err1;
	205	}
1290a958	206
c818a94c TR	207	if (!try_module_get(phy->dev->driver->owner)) {
c818a94c TR	208	phy = ERR_PTR(-ENODEV);
cedf8602 SH	209	devres_free(ptr);
	210	goto err1;
	211	}
e842b84c N	212	if (nb)
	213	usb_register_notifier(phy, nb);
	214	ptr->phy = phy;
	215	ptr->nb = nb;
cedf8602 SH	216	devres_add(dev, ptr);
	217
	218	get_device(phy->dev);
	219
	220	err1:
	221	spin_unlock_irqrestore(&phy_lock, flags);
	222
	223	err0:
cedf8602 SH	224
	225	return phy;
	226	}
e842b84c N	227	EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
	228
	229	/**
	230	* devm_usb_get_phy_by_phandle - find the USB PHY by phandle
	231	* @dev - device that requests this phy
	232	* @phandle - name of the property holding the phy phandle value
	233	* @index - the index of the phy
	234	*
	235	* Returns the phy driver associated with the given phandle value,
	236	* after getting a refcount to it, -ENODEV if there is no such phy or
	237	* -EPROBE_DEFER if there is a phandle to the phy, but the device is
	238	* not yet loaded. While at that, it also associates the device with
	239	* the phy using devres. On driver detach, release function is invoked
	240	* on the devres data, then, devres data is freed.
	241	*
	242	* For use by USB host and peripheral drivers.
	243	*/
	244	struct usb_phy devm_usb_get_phy_by_phandle(struct device dev,
	245	const char *phandle, u8 index)
	246	{
	247	struct device_node *node;
	248	struct usb_phy *phy;
	249
	250	if (!dev->of_node) {
	251	dev_dbg(dev, "device does not have a device node entry\n");
	252	return ERR_PTR(-EINVAL);
	253	}
	254
	255	node = of_parse_phandle(dev->of_node, phandle, index);
	256	if (!node) {
	257	dev_dbg(dev, "failed to get %s phandle in %s node\n", phandle,
	258	dev->of_node->full_name);
	259	return ERR_PTR(-ENODEV);
	260	}
	261	phy = devm_usb_get_phy_by_node(dev, node, NULL);
	262	of_node_put(node);
	263	return phy;
	264	}
110ff6d0	265	EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
cedf8602 SH	266
	267	/**
	268	* usb_get_phy_dev - find the USB PHY
	269	* @dev - device that requests this phy
	270	* @index - the index of the phy
	271	*
	272	* Returns the phy driver, after getting a refcount to it; or
	273	* -ENODEV if there is no such phy. The caller is responsible for
	274	* calling usb_put_phy() to release that count.
	275	*
	276	* For use by USB host and peripheral drivers.
	277	*/
	278	struct usb_phy usb_get_phy_dev(struct device dev, u8 index)
	279	{
	280	struct usb_phy *phy = NULL;
	281	unsigned long flags;
	282
	283	spin_lock_irqsave(&phy_lock, flags);
	284
	285	phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
	286	if (IS_ERR(phy) \|\| !try_module_get(phy->dev->driver->owner)) {
e9d123a5	287	dev_dbg(dev, "unable to find transceiver\n");
2c4e3dbf AS	288	if (!IS_ERR(phy))
	289	phy = ERR_PTR(-ENODEV);
	290
cedf8602 SH	291	goto err0;
	292	}
	293
	294	get_device(phy->dev);
	295
	296	err0:
	297	spin_unlock_irqrestore(&phy_lock, flags);
	298
	299	return phy;
	300	}
110ff6d0	301	EXPORT_SYMBOL_GPL(usb_get_phy_dev);
cedf8602 SH	302
	303	/**
	304	* devm_usb_get_phy_dev - find the USB PHY using device ptr and index
	305	* @dev - device that requests this phy
	306	* @index - the index of the phy
	307	*
	308	* Gets the phy using usb_get_phy_dev(), and associates a device with it using
	309	* devres. On driver detach, release function is invoked on the devres data,
	310	* then, devres data is freed.
	311	*
	312	* For use by USB host and peripheral drivers.
	313	*/
	314	struct usb_phy devm_usb_get_phy_dev(struct device dev, u8 index)
	315	{
	316	struct usb_phy *ptr, phy;
	317
	318	ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
	319	if (!ptr)
	320	return NULL;
	321
	322	phy = usb_get_phy_dev(dev, index);
	323	if (!IS_ERR(phy)) {
	324	*ptr = phy;
	325	devres_add(dev, ptr);
	326	} else
	327	devres_free(ptr);
	328
	329	return phy;
	330	}
110ff6d0	331	EXPORT_SYMBOL_GPL(devm_usb_get_phy_dev);
cedf8602 SH	332
	333	/**
	334	* devm_usb_put_phy - release the USB PHY
	335	* @dev - device that wants to release this phy
	336	* @phy - the phy returned by devm_usb_get_phy()
	337	*
	338	* destroys the devres associated with this phy and invokes usb_put_phy
	339	* to release the phy.
	340	*
	341	* For use by USB host and peripheral drivers.
	342	*/
	343	void devm_usb_put_phy(struct device dev, struct usb_phy phy)
	344	{
	345	int r;
	346
	347	r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
	348	dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
	349	}
110ff6d0	350	EXPORT_SYMBOL_GPL(devm_usb_put_phy);
cedf8602 SH	351
	352	/**
	353	* usb_put_phy - release the USB PHY
	354	* @x: the phy returned by usb_get_phy()
	355	*
	356	* Releases a refcount the caller received from usb_get_phy().
	357	*
	358	* For use by USB host and peripheral drivers.
	359	*/
	360	void usb_put_phy(struct usb_phy *x)
	361	{
	362	if (x) {
	363	struct module *owner = x->dev->driver->owner;
	364
	365	put_device(x->dev);
	366	module_put(owner);
	367	}
	368	}
110ff6d0	369	EXPORT_SYMBOL_GPL(usb_put_phy);
cedf8602 SH	370
	371	/**
	372	* usb_add_phy - declare the USB PHY
	373	* @x: the USB phy to be used; or NULL
	374	* @type - the type of this PHY
	375	*
	376	* This call is exclusively for use by phy drivers, which
	377	* coordinate the activities of drivers for host and peripheral
	378	* controllers, and in some cases for VBUS current regulation.
	379	*/
	380	int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
	381	{
	382	int ret = 0;
	383	unsigned long flags;
	384	struct usb_phy *phy;
	385
	386	if (x->type != USB_PHY_TYPE_UNDEFINED) {
	387	dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
	388	return -EINVAL;
	389	}
	390
31e32227 NZ	391	ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
31e32227 NZ	392
cedf8602 SH	393	spin_lock_irqsave(&phy_lock, flags);
	394
	395	list_for_each_entry(phy, &phy_list, head) {
	396	if (phy->type == type) {
	397	ret = -EBUSY;
	398	dev_err(x->dev, "transceiver type %s already exists\n",
	399	usb_phy_type_string(type));
	400	goto out;
	401	}
	402	}
	403
	404	x->type = type;
	405	list_add_tail(&x->head, &phy_list);
	406
	407	out:
	408	spin_unlock_irqrestore(&phy_lock, flags);
	409	return ret;
	410	}
110ff6d0	411	EXPORT_SYMBOL_GPL(usb_add_phy);
cedf8602 SH	412
	413	/**
	414	* usb_add_phy_dev - declare the USB PHY
	415	* @x: the USB phy to be used; or NULL
	416	*
	417	* This call is exclusively for use by phy drivers, which
	418	* coordinate the activities of drivers for host and peripheral
	419	* controllers, and in some cases for VBUS current regulation.
	420	*/
	421	int usb_add_phy_dev(struct usb_phy *x)
	422	{
	423	struct usb_phy_bind *phy_bind;
	424	unsigned long flags;
	425
	426	if (!x->dev) {
	427	dev_err(x->dev, "no device provided for PHY\n");
	428	return -EINVAL;
	429	}
	430
31e32227 NZ	431	ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
31e32227 NZ	432
cedf8602 SH	433	spin_lock_irqsave(&phy_lock, flags);
	434	list_for_each_entry(phy_bind, &phy_bind_list, list)
	435	if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
	436	phy_bind->phy = x;
	437
	438	list_add_tail(&x->head, &phy_list);
	439
	440	spin_unlock_irqrestore(&phy_lock, flags);
	441	return 0;
	442	}
110ff6d0	443	EXPORT_SYMBOL_GPL(usb_add_phy_dev);
cedf8602 SH	444
	445	/**
	446	* usb_remove_phy - remove the OTG PHY
	447	* @x: the USB OTG PHY to be removed;
	448	*
	449	* This reverts the effects of usb_add_phy
	450	*/
	451	void usb_remove_phy(struct usb_phy *x)
	452	{
	453	unsigned long flags;
	454	struct usb_phy_bind *phy_bind;
	455
	456	spin_lock_irqsave(&phy_lock, flags);
	457	if (x) {
	458	list_for_each_entry(phy_bind, &phy_bind_list, list)
	459	if (phy_bind->phy == x)
	460	phy_bind->phy = NULL;
	461	list_del(&x->head);
	462	}
	463	spin_unlock_irqrestore(&phy_lock, flags);
	464	}
110ff6d0	465	EXPORT_SYMBOL_GPL(usb_remove_phy);
cedf8602 SH	466
	467	/**
	468	* usb_bind_phy - bind the phy and the controller that uses the phy
	469	* @dev_name: the device name of the device that will bind to the phy
	470	* @index: index to specify the port number
	471	* @phy_dev_name: the device name of the phy
	472	*
	473	* Fills the phy_bind structure with the dev_name and phy_dev_name. This will
	474	* be used when the phy driver registers the phy and when the controller
	475	* requests this phy.
	476	*
	477	* To be used by platform specific initialization code.
	478	*/
19d8cedd	479	int usb_bind_phy(const char *dev_name, u8 index,
cedf8602 SH	480	const char *phy_dev_name)
	481	{
	482	struct usb_phy_bind *phy_bind;
	483	unsigned long flags;
	484
	485	phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
e9d123a5	486	if (!phy_bind)
cedf8602	487	return -ENOMEM;
cedf8602 SH	488
	489	phy_bind->dev_name = dev_name;
	490	phy_bind->phy_dev_name = phy_dev_name;
	491	phy_bind->index = index;
	492
	493	spin_lock_irqsave(&phy_lock, flags);
	494	list_add_tail(&phy_bind->list, &phy_bind_list);
	495	spin_unlock_irqrestore(&phy_lock, flags);
	496
	497	return 0;
	498	}
	499	EXPORT_SYMBOL_GPL(usb_bind_phy);
df9f7b31 KR	500
	501	/**
	502	* usb_phy_set_event - set event to phy event
	503	* @x: the phy returned by usb_get_phy();
	504	*
	505	* This sets event to phy event
	506	*/
	507	void usb_phy_set_event(struct usb_phy *x, unsigned long event)
	508	{
	509	x->last_event = event;
	510	}
	511	EXPORT_SYMBOL_GPL(usb_phy_set_event);