1
2
3
4
5
6
7
8
9
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
86
87
88
89
90
91
92
93
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_GPL(devm_usb_get_phy);
113
114
115
116
117
118
119
120
121
122
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_GPL(usb_get_phy);
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
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_GPL(devm_usb_get_phy_by_phandle);
210
211
212
213
214
215
216
217
218
219
220
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_GPL(usb_get_phy_dev);
243
244
245
246
247
248
249
250
251
252
253
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_GPL(devm_usb_get_phy_dev);
273
274
275
276
277
278
279
280
281
282
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_GPL(devm_usb_put_phy);
292
293
294
295
296
297
298
299
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_GPL(usb_put_phy);
311
312
313
314
315
316
317
318
319
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_GPL(usb_add_phy);
351
352
353
354
355
356
357
358
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_GPL(usb_add_phy_dev);
381
382
383
384
385
386
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_GPL(usb_remove_phy);
403
404
405
406
407
408
409
410
411
412
413
414
415
416int 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);
439