aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorSascha Hauer <s.hauer@pengutronix.de>2013-02-27 09:16:28 -0500
committerFelipe Balbi <balbi@ti.com>2013-03-18 05:17:58 -0400
commitcedf8602373a3a5d02e49af7bebc401ffe3b38f3 (patch)
treea62b72556ce07e78807cf2f3f88a1a5e04d57556 /drivers
parent0b0cc1cd31bed3e3147398e54530f1f819b27692 (diff)
usb: phy: move bulk of otg/otg.c to phy/phy.c
Most of otg/otg.c is not otg specific, but phy specific, so move it to the phy directory. Tested-by: Steffen Trumtrar <s.trumtrar@pengutronix.de> Reported-by: Kishon Vijay Abraham I <kishon@ti.com> Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de> Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de> Signed-off-by: Felipe Balbi <balbi@ti.com>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/usb/otg/otg.c427
-rw-r--r--drivers/usb/phy/Makefile1
-rw-r--r--drivers/usb/phy/phy.c438
3 files changed, 439 insertions, 427 deletions
diff --git a/drivers/usb/otg/otg.c b/drivers/usb/otg/otg.c
index 2bd03d261a50..358cfd9bce89 100644
--- a/drivers/usb/otg/otg.c
+++ b/drivers/usb/otg/otg.c
@@ -8,436 +8,9 @@
8 * the Free Software Foundation; either version 2 of the License, or 8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version. 9 * (at your option) any later version.
10 */ 10 */
11
12#include <linux/kernel.h>
13#include <linux/export.h> 11#include <linux/export.h>
14#include <linux/err.h>
15#include <linux/device.h>
16#include <linux/module.h>
17#include <linux/slab.h>
18#include <linux/of.h>
19
20#include <linux/usb/otg.h> 12#include <linux/usb/otg.h>
21 13
22static LIST_HEAD(phy_list);
23static LIST_HEAD(phy_bind_list);
24static DEFINE_SPINLOCK(phy_lock);
25
26static struct usb_phy *__usb_find_phy(struct list_head *list,
27 enum usb_phy_type type)
28{
29 struct usb_phy *phy = NULL;
30
31 list_for_each_entry(phy, list, head) {
32 if (phy->type != type)
33 continue;
34
35 return phy;
36 }
37
38 return ERR_PTR(-ENODEV);
39}
40
41static struct usb_phy *__usb_find_phy_dev(struct device *dev,
42 struct list_head *list, u8 index)
43{
44 struct usb_phy_bind *phy_bind = NULL;
45
46 list_for_each_entry(phy_bind, list, list) {
47 if (!(strcmp(phy_bind->dev_name, dev_name(dev))) &&
48 phy_bind->index == index) {
49 if (phy_bind->phy)
50 return phy_bind->phy;
51 else
52 return ERR_PTR(-EPROBE_DEFER);
53 }
54 }
55
56 return ERR_PTR(-ENODEV);
57}
58
59static struct usb_phy *__of_usb_find_phy(struct device_node *node)
60{
61 struct usb_phy *phy;
62
63 list_for_each_entry(phy, &phy_list, head) {
64 if (node != phy->dev->of_node)
65 continue;
66
67 return phy;
68 }
69
70 return ERR_PTR(-ENODEV);
71}
72
73static void devm_usb_phy_release(struct device *dev, void *res)
74{
75 struct usb_phy *phy = *(struct usb_phy **)res;
76
77 usb_put_phy(phy);
78}
79
80static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
81{
82 return res == match_data;
83}
84
85/**
86 * devm_usb_get_phy - find the USB PHY
87 * @dev - device that requests this phy
88 * @type - the type of the phy the controller requires
89 *
90 * Gets the phy using usb_get_phy(), and associates a device with it using
91 * devres. On driver detach, release function is invoked on the devres data,
92 * then, devres data is freed.
93 *
94 * For use by USB host and peripheral drivers.
95 */
96struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
97{
98 struct usb_phy **ptr, *phy;
99
100 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
101 if (!ptr)
102 return NULL;
103
104 phy = usb_get_phy(type);
105 if (!IS_ERR(phy)) {
106 *ptr = phy;
107 devres_add(dev, ptr);
108 } else
109 devres_free(ptr);
110
111 return phy;
112}
113EXPORT_SYMBOL(devm_usb_get_phy);
114
115/**
116 * usb_get_phy - find the USB PHY
117 * @type - the type of the phy the controller requires
118 *
119 * Returns the phy driver, after getting a refcount to it; or
120 * -ENODEV if there is no such phy. The caller is responsible for
121 * calling usb_put_phy() to release that count.
122 *
123 * For use by USB host and peripheral drivers.
124 */
125struct usb_phy *usb_get_phy(enum usb_phy_type type)
126{
127 struct usb_phy *phy = NULL;
128 unsigned long flags;
129
130 spin_lock_irqsave(&phy_lock, flags);
131
132 phy = __usb_find_phy(&phy_list, type);
133 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
134 pr_err("unable to find transceiver of type %s\n",
135 usb_phy_type_string(type));
136 goto err0;
137 }
138
139 get_device(phy->dev);
140
141err0:
142 spin_unlock_irqrestore(&phy_lock, flags);
143
144 return phy;
145}
146EXPORT_SYMBOL(usb_get_phy);
147
148 /**
149 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
150 * @dev - device that requests this phy
151 * @phandle - name of the property holding the phy phandle value
152 * @index - the index of the phy
153 *
154 * Returns the phy driver associated with the given phandle value,
155 * after getting a refcount to it, -ENODEV if there is no such phy or
156 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
157 * not yet loaded. While at that, it also associates the device with
158 * the phy using devres. On driver detach, release function is invoked
159 * on the devres data, then, devres data is freed.
160 *
161 * For use by USB host and peripheral drivers.
162 */
163struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
164 const char *phandle, u8 index)
165{
166 struct usb_phy *phy = ERR_PTR(-ENOMEM), **ptr;
167 unsigned long flags;
168 struct device_node *node;
169
170 if (!dev->of_node) {
171 dev_dbg(dev, "device does not have a device node entry\n");
172 return ERR_PTR(-EINVAL);
173 }
174
175 node = of_parse_phandle(dev->of_node, phandle, index);
176 if (!node) {
177 dev_dbg(dev, "failed to get %s phandle in %s node\n", phandle,
178 dev->of_node->full_name);
179 return ERR_PTR(-ENODEV);
180 }
181
182 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
183 if (!ptr) {
184 dev_dbg(dev, "failed to allocate memory for devres\n");
185 goto err0;
186 }
187
188 spin_lock_irqsave(&phy_lock, flags);
189
190 phy = __of_usb_find_phy(node);
191 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
192 phy = ERR_PTR(-EPROBE_DEFER);
193 devres_free(ptr);
194 goto err1;
195 }
196
197 *ptr = phy;
198 devres_add(dev, ptr);
199
200 get_device(phy->dev);
201
202err1:
203 spin_unlock_irqrestore(&phy_lock, flags);
204
205err0:
206 of_node_put(node);
207
208 return phy;
209}
210EXPORT_SYMBOL(devm_usb_get_phy_by_phandle);
211
212/**
213 * usb_get_phy_dev - find the USB PHY
214 * @dev - device that requests this phy
215 * @index - the index of the phy
216 *
217 * Returns the phy driver, after getting a refcount to it; or
218 * -ENODEV if there is no such phy. The caller is responsible for
219 * calling usb_put_phy() to release that count.
220 *
221 * For use by USB host and peripheral drivers.
222 */
223struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
224{
225 struct usb_phy *phy = NULL;
226 unsigned long flags;
227
228 spin_lock_irqsave(&phy_lock, flags);
229
230 phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
231 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
232 pr_err("unable to find transceiver\n");
233 goto err0;
234 }
235
236 get_device(phy->dev);
237
238err0:
239 spin_unlock_irqrestore(&phy_lock, flags);
240
241 return phy;
242}
243EXPORT_SYMBOL(usb_get_phy_dev);
244
245/**
246 * devm_usb_get_phy_dev - find the USB PHY using device ptr and index
247 * @dev - device that requests this phy
248 * @index - the index of the phy
249 *
250 * Gets the phy using usb_get_phy_dev(), and associates a device with it using
251 * devres. On driver detach, release function is invoked on the devres data,
252 * then, devres data is freed.
253 *
254 * For use by USB host and peripheral drivers.
255 */
256struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
257{
258 struct usb_phy **ptr, *phy;
259
260 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
261 if (!ptr)
262 return NULL;
263
264 phy = usb_get_phy_dev(dev, index);
265 if (!IS_ERR(phy)) {
266 *ptr = phy;
267 devres_add(dev, ptr);
268 } else
269 devres_free(ptr);
270
271 return phy;
272}
273EXPORT_SYMBOL(devm_usb_get_phy_dev);
274
275/**
276 * devm_usb_put_phy - release the USB PHY
277 * @dev - device that wants to release this phy
278 * @phy - the phy returned by devm_usb_get_phy()
279 *
280 * destroys the devres associated with this phy and invokes usb_put_phy
281 * to release the phy.
282 *
283 * For use by USB host and peripheral drivers.
284 */
285void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
286{
287 int r;
288
289 r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
290 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
291}
292EXPORT_SYMBOL(devm_usb_put_phy);
293
294/**
295 * usb_put_phy - release the USB PHY
296 * @x: the phy returned by usb_get_phy()
297 *
298 * Releases a refcount the caller received from usb_get_phy().
299 *
300 * For use by USB host and peripheral drivers.
301 */
302void usb_put_phy(struct usb_phy *x)
303{
304 if (x) {
305 struct module *owner = x->dev->driver->owner;
306
307 put_device(x->dev);
308 module_put(owner);
309 }
310}
311EXPORT_SYMBOL(usb_put_phy);
312
313/**
314 * usb_add_phy - declare the USB PHY
315 * @x: the USB phy to be used; or NULL
316 * @type - the type of this PHY
317 *
318 * This call is exclusively for use by phy drivers, which
319 * coordinate the activities of drivers for host and peripheral
320 * controllers, and in some cases for VBUS current regulation.
321 */
322int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
323{
324 int ret = 0;
325 unsigned long flags;
326 struct usb_phy *phy;
327
328 if (x->type != USB_PHY_TYPE_UNDEFINED) {
329 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
330 return -EINVAL;
331 }
332
333 spin_lock_irqsave(&phy_lock, flags);
334
335 list_for_each_entry(phy, &phy_list, head) {
336 if (phy->type == type) {
337 ret = -EBUSY;
338 dev_err(x->dev, "transceiver type %s already exists\n",
339 usb_phy_type_string(type));
340 goto out;
341 }
342 }
343
344 x->type = type;
345 list_add_tail(&x->head, &phy_list);
346
347out:
348 spin_unlock_irqrestore(&phy_lock, flags);
349 return ret;
350}
351EXPORT_SYMBOL(usb_add_phy);
352
353/**
354 * usb_add_phy_dev - declare the USB PHY
355 * @x: the USB phy to be used; or NULL
356 *
357 * This call is exclusively for use by phy drivers, which
358 * coordinate the activities of drivers for host and peripheral
359 * controllers, and in some cases for VBUS current regulation.
360 */
361int usb_add_phy_dev(struct usb_phy *x)
362{
363 struct usb_phy_bind *phy_bind;
364 unsigned long flags;
365
366 if (!x->dev) {
367 dev_err(x->dev, "no device provided for PHY\n");
368 return -EINVAL;
369 }
370
371 spin_lock_irqsave(&phy_lock, flags);
372 list_for_each_entry(phy_bind, &phy_bind_list, list)
373 if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
374 phy_bind->phy = x;
375
376 list_add_tail(&x->head, &phy_list);
377
378 spin_unlock_irqrestore(&phy_lock, flags);
379 return 0;
380}
381EXPORT_SYMBOL(usb_add_phy_dev);
382
383/**
384 * usb_remove_phy - remove the OTG PHY
385 * @x: the USB OTG PHY to be removed;
386 *
387 * This reverts the effects of usb_add_phy
388 */
389void usb_remove_phy(struct usb_phy *x)
390{
391 unsigned long flags;
392 struct usb_phy_bind *phy_bind;
393
394 spin_lock_irqsave(&phy_lock, flags);
395 if (x) {
396 list_for_each_entry(phy_bind, &phy_bind_list, list)
397 if (phy_bind->phy == x)
398 phy_bind->phy = NULL;
399 list_del(&x->head);
400 }
401 spin_unlock_irqrestore(&phy_lock, flags);
402}
403EXPORT_SYMBOL(usb_remove_phy);
404
405/**
406 * usb_bind_phy - bind the phy and the controller that uses the phy
407 * @dev_name: the device name of the device that will bind to the phy
408 * @index: index to specify the port number
409 * @phy_dev_name: the device name of the phy
410 *
411 * Fills the phy_bind structure with the dev_name and phy_dev_name. This will
412 * be used when the phy driver registers the phy and when the controller
413 * requests this phy.
414 *
415 * To be used by platform specific initialization code.
416 */
417int __init usb_bind_phy(const char *dev_name, u8 index,
418 const char *phy_dev_name)
419{
420 struct usb_phy_bind *phy_bind;
421 unsigned long flags;
422
423 phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
424 if (!phy_bind) {
425 pr_err("phy_bind(): No memory for phy_bind");
426 return -ENOMEM;
427 }
428
429 phy_bind->dev_name = dev_name;
430 phy_bind->phy_dev_name = phy_dev_name;
431 phy_bind->index = index;
432
433 spin_lock_irqsave(&phy_lock, flags);
434 list_add_tail(&phy_bind->list, &phy_bind_list);
435 spin_unlock_irqrestore(&phy_lock, flags);
436
437 return 0;
438}
439EXPORT_SYMBOL_GPL(usb_bind_phy);
440
441const char *otg_state_string(enum usb_otg_state state) 14const char *otg_state_string(enum usb_otg_state state)
442{ 15{
443 switch (state) { 16 switch (state) {
diff --git a/drivers/usb/phy/Makefile b/drivers/usb/phy/Makefile
index b13faa193e0c..9fa6327d4c52 100644
--- a/drivers/usb/phy/Makefile
+++ b/drivers/usb/phy/Makefile
@@ -4,6 +4,7 @@
4 4
5ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG 5ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
6 6
7obj-$(CONFIG_USB_OTG_UTILS) += phy.o
7obj-$(CONFIG_OMAP_USB2) += omap-usb2.o 8obj-$(CONFIG_OMAP_USB2) += omap-usb2.o
8obj-$(CONFIG_OMAP_USB3) += omap-usb3.o 9obj-$(CONFIG_OMAP_USB3) += omap-usb3.o
9obj-$(CONFIG_OMAP_CONTROL_USB) += omap-control-usb.o 10obj-$(CONFIG_OMAP_CONTROL_USB) += omap-control-usb.o
diff --git a/drivers/usb/phy/phy.c b/drivers/usb/phy/phy.c
new file mode 100644
index 000000000000..bc1970c55df0
--- /dev/null
+++ b/drivers/usb/phy/phy.c
@@ -0,0 +1,438 @@
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
21static LIST_HEAD(phy_list);
22static LIST_HEAD(phy_bind_list);
23static DEFINE_SPINLOCK(phy_lock);
24
25static struct usb_phy *__usb_find_phy(struct list_head *list,
26 enum usb_phy_type type)
27{
28 struct usb_phy *phy = NULL;
29
30 list_for_each_entry(phy, list, head) {
31 if (phy->type != type)
32 continue;
33
34 return phy;
35 }
36
37 return ERR_PTR(-ENODEV);
38}
39
40static struct usb_phy *__usb_find_phy_dev(struct device *dev,
41 struct list_head *list, u8 index)
42{
43 struct usb_phy_bind *phy_bind = NULL;
44
45 list_for_each_entry(phy_bind, list, list) {
46 if (!(strcmp(phy_bind->dev_name, dev_name(dev))) &&
47 phy_bind->index == index) {
48 if (phy_bind->phy)
49 return phy_bind->phy;
50 else
51 return ERR_PTR(-EPROBE_DEFER);
52 }
53 }
54
55 return ERR_PTR(-ENODEV);
56}
57
58static struct usb_phy *__of_usb_find_phy(struct device_node *node)
59{
60 struct usb_phy *phy;
61
62 list_for_each_entry(phy, &phy_list, head) {
63 if (node != phy->dev->of_node)
64 continue;
65
66 return phy;
67 }
68
69 return ERR_PTR(-ENODEV);
70}
71
72static void devm_usb_phy_release(struct device *dev, void *res)
73{
74 struct usb_phy *phy = *(struct usb_phy **)res;
75
76 usb_put_phy(phy);
77}
78
79static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
80{
81 return res == match_data;
82}
83
84/**
85 * devm_usb_get_phy - find the USB PHY
86 * @dev - device that requests this phy
87 * @type - the type of the phy the controller requires
88 *
89 * Gets the phy using usb_get_phy(), and associates a device with it using
90 * devres. On driver detach, release function is invoked on the devres data,
91 * then, devres data is freed.
92 *
93 * For use by USB host and peripheral drivers.
94 */
95struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
96{
97 struct usb_phy **ptr, *phy;
98
99 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
100 if (!ptr)
101 return NULL;
102
103 phy = usb_get_phy(type);
104 if (!IS_ERR(phy)) {
105 *ptr = phy;
106 devres_add(dev, ptr);
107 } else
108 devres_free(ptr);
109
110 return phy;
111}
112EXPORT_SYMBOL(devm_usb_get_phy);
113
114/**
115 * usb_get_phy - find the USB PHY
116 * @type - the type of the phy the controller requires
117 *
118 * Returns the phy driver, after getting a refcount to it; or
119 * -ENODEV if there is no such phy. The caller is responsible for
120 * calling usb_put_phy() to release that count.
121 *
122 * For use by USB host and peripheral drivers.
123 */
124struct usb_phy *usb_get_phy(enum usb_phy_type type)
125{
126 struct usb_phy *phy = NULL;
127 unsigned long flags;
128
129 spin_lock_irqsave(&phy_lock, flags);
130
131 phy = __usb_find_phy(&phy_list, type);
132 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
133 pr_err("unable to find transceiver of type %s\n",
134 usb_phy_type_string(type));
135 goto err0;
136 }
137
138 get_device(phy->dev);
139
140err0:
141 spin_unlock_irqrestore(&phy_lock, flags);
142
143 return phy;
144}
145EXPORT_SYMBOL(usb_get_phy);
146
147 /**
148 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
149 * @dev - device that requests this phy
150 * @phandle - name of the property holding the phy phandle value
151 * @index - the index of the phy
152 *
153 * Returns the phy driver associated with the given phandle value,
154 * after getting a refcount to it, -ENODEV if there is no such phy or
155 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
156 * not yet loaded. While at that, it also associates the device with
157 * the phy using devres. On driver detach, release function is invoked
158 * on the devres data, then, devres data is freed.
159 *
160 * For use by USB host and peripheral drivers.
161 */
162struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
163 const char *phandle, u8 index)
164{
165 struct usb_phy *phy = ERR_PTR(-ENOMEM), **ptr;
166 unsigned long flags;
167 struct device_node *node;
168
169 if (!dev->of_node) {
170 dev_dbg(dev, "device does not have a device node entry\n");
171 return ERR_PTR(-EINVAL);
172 }
173
174 node = of_parse_phandle(dev->of_node, phandle, index);
175 if (!node) {
176 dev_dbg(dev, "failed to get %s phandle in %s node\n", phandle,
177 dev->of_node->full_name);
178 return ERR_PTR(-ENODEV);
179 }
180
181 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
182 if (!ptr) {
183 dev_dbg(dev, "failed to allocate memory for devres\n");
184 goto err0;
185 }
186
187 spin_lock_irqsave(&phy_lock, flags);
188
189 phy = __of_usb_find_phy(node);
190 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
191 phy = ERR_PTR(-EPROBE_DEFER);
192 devres_free(ptr);
193 goto err1;
194 }
195
196 *ptr = phy;
197 devres_add(dev, ptr);
198
199 get_device(phy->dev);
200
201err1:
202 spin_unlock_irqrestore(&phy_lock, flags);
203
204err0:
205 of_node_put(node);
206
207 return phy;
208}
209EXPORT_SYMBOL(devm_usb_get_phy_by_phandle);
210
211/**
212 * usb_get_phy_dev - find the USB PHY
213 * @dev - device that requests this phy
214 * @index - the index of the phy
215 *
216 * Returns the phy driver, after getting a refcount to it; or
217 * -ENODEV if there is no such phy. The caller is responsible for
218 * calling usb_put_phy() to release that count.
219 *
220 * For use by USB host and peripheral drivers.
221 */
222struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
223{
224 struct usb_phy *phy = NULL;
225 unsigned long flags;
226
227 spin_lock_irqsave(&phy_lock, flags);
228
229 phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
230 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
231 pr_err("unable to find transceiver\n");
232 goto err0;
233 }
234
235 get_device(phy->dev);
236
237err0:
238 spin_unlock_irqrestore(&phy_lock, flags);
239
240 return phy;
241}
242EXPORT_SYMBOL(usb_get_phy_dev);
243
244/**
245 * devm_usb_get_phy_dev - find the USB PHY using device ptr and index
246 * @dev - device that requests this phy
247 * @index - the index of the phy
248 *
249 * Gets the phy using usb_get_phy_dev(), and associates a device with it using
250 * devres. On driver detach, release function is invoked on the devres data,
251 * then, devres data is freed.
252 *
253 * For use by USB host and peripheral drivers.
254 */
255struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
256{
257 struct usb_phy **ptr, *phy;
258
259 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
260 if (!ptr)
261 return NULL;
262
263 phy = usb_get_phy_dev(dev, index);
264 if (!IS_ERR(phy)) {
265 *ptr = phy;
266 devres_add(dev, ptr);
267 } else
268 devres_free(ptr);
269
270 return phy;
271}
272EXPORT_SYMBOL(devm_usb_get_phy_dev);
273
274/**
275 * devm_usb_put_phy - release the USB PHY
276 * @dev - device that wants to release this phy
277 * @phy - the phy returned by devm_usb_get_phy()
278 *
279 * destroys the devres associated with this phy and invokes usb_put_phy
280 * to release the phy.
281 *
282 * For use by USB host and peripheral drivers.
283 */
284void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
285{
286 int r;
287
288 r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
289 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
290}
291EXPORT_SYMBOL(devm_usb_put_phy);
292
293/**
294 * usb_put_phy - release the USB PHY
295 * @x: the phy returned by usb_get_phy()
296 *
297 * Releases a refcount the caller received from usb_get_phy().
298 *
299 * For use by USB host and peripheral drivers.
300 */
301void usb_put_phy(struct usb_phy *x)
302{
303 if (x) {
304 struct module *owner = x->dev->driver->owner;
305
306 put_device(x->dev);
307 module_put(owner);
308 }
309}
310EXPORT_SYMBOL(usb_put_phy);
311
312/**
313 * usb_add_phy - declare the USB PHY
314 * @x: the USB phy to be used; or NULL
315 * @type - the type of this PHY
316 *
317 * This call is exclusively for use by phy drivers, which
318 * coordinate the activities of drivers for host and peripheral
319 * controllers, and in some cases for VBUS current regulation.
320 */
321int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
322{
323 int ret = 0;
324 unsigned long flags;
325 struct usb_phy *phy;
326
327 if (x->type != USB_PHY_TYPE_UNDEFINED) {
328 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
329 return -EINVAL;
330 }
331
332 spin_lock_irqsave(&phy_lock, flags);
333
334 list_for_each_entry(phy, &phy_list, head) {
335 if (phy->type == type) {
336 ret = -EBUSY;
337 dev_err(x->dev, "transceiver type %s already exists\n",
338 usb_phy_type_string(type));
339 goto out;
340 }
341 }
342
343 x->type = type;
344 list_add_tail(&x->head, &phy_list);
345
346out:
347 spin_unlock_irqrestore(&phy_lock, flags);
348 return ret;
349}
350EXPORT_SYMBOL(usb_add_phy);
351
352/**
353 * usb_add_phy_dev - declare the USB PHY
354 * @x: the USB phy to be used; or NULL
355 *
356 * This call is exclusively for use by phy drivers, which
357 * coordinate the activities of drivers for host and peripheral
358 * controllers, and in some cases for VBUS current regulation.
359 */
360int usb_add_phy_dev(struct usb_phy *x)
361{
362 struct usb_phy_bind *phy_bind;
363 unsigned long flags;
364
365 if (!x->dev) {
366 dev_err(x->dev, "no device provided for PHY\n");
367 return -EINVAL;
368 }
369
370 spin_lock_irqsave(&phy_lock, flags);
371 list_for_each_entry(phy_bind, &phy_bind_list, list)
372 if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
373 phy_bind->phy = x;
374
375 list_add_tail(&x->head, &phy_list);
376
377 spin_unlock_irqrestore(&phy_lock, flags);
378 return 0;
379}
380EXPORT_SYMBOL(usb_add_phy_dev);
381
382/**
383 * usb_remove_phy - remove the OTG PHY
384 * @x: the USB OTG PHY to be removed;
385 *
386 * This reverts the effects of usb_add_phy
387 */
388void usb_remove_phy(struct usb_phy *x)
389{
390 unsigned long flags;
391 struct usb_phy_bind *phy_bind;
392
393 spin_lock_irqsave(&phy_lock, flags);
394 if (x) {
395 list_for_each_entry(phy_bind, &phy_bind_list, list)
396 if (phy_bind->phy == x)
397 phy_bind->phy = NULL;
398 list_del(&x->head);
399 }
400 spin_unlock_irqrestore(&phy_lock, flags);
401}
402EXPORT_SYMBOL(usb_remove_phy);
403
404/**
405 * usb_bind_phy - bind the phy and the controller that uses the phy
406 * @dev_name: the device name of the device that will bind to the phy
407 * @index: index to specify the port number
408 * @phy_dev_name: the device name of the phy
409 *
410 * Fills the phy_bind structure with the dev_name and phy_dev_name. This will
411 * be used when the phy driver registers the phy and when the controller
412 * requests this phy.
413 *
414 * To be used by platform specific initialization code.
415 */
416int __init usb_bind_phy(const char *dev_name, u8 index,
417 const char *phy_dev_name)
418{
419 struct usb_phy_bind *phy_bind;
420 unsigned long flags;
421
422 phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
423 if (!phy_bind) {
424 pr_err("phy_bind(): No memory for phy_bind");
425 return -ENOMEM;
426 }
427
428 phy_bind->dev_name = dev_name;
429 phy_bind->phy_dev_name = phy_dev_name;
430 phy_bind->index = index;
431
432 spin_lock_irqsave(&phy_lock, flags);
433 list_add_tail(&phy_bind->list, &phy_bind_list);
434 spin_unlock_irqrestore(&phy_lock, flags);
435
436 return 0;
437}
438EXPORT_SYMBOL_GPL(usb_bind_phy);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-09 12:16:46 -0500