1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * phy-core.c -- Generic Phy framework.
4 *
5 * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
6 *
7 * Author: Kishon Vijay Abraham I <kishon@ti.com>
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/export.h>
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/device.h>
15 #include <linux/slab.h>
16 #include <linux/of.h>
17 #include <linux/phy/phy.h>
18 #include <linux/idr.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/regulator/consumer.h>
21
22 static struct class *phy_class;
23 static DEFINE_MUTEX(phy_provider_mutex);
24 static LIST_HEAD(phy_provider_list);
25 static LIST_HEAD(phys);
26 static DEFINE_IDA(phy_ida);
27
devm_phy_release(struct device * dev,void * res)28 static void devm_phy_release(struct device *dev, void *res)
29 {
30 struct phy *phy = *(struct phy **)res;
31
32 phy_put(dev, phy);
33 }
34
devm_phy_provider_release(struct device * dev,void * res)35 static void devm_phy_provider_release(struct device *dev, void *res)
36 {
37 struct phy_provider *phy_provider = *(struct phy_provider **)res;
38
39 of_phy_provider_unregister(phy_provider);
40 }
41
devm_phy_consume(struct device * dev,void * res)42 static void devm_phy_consume(struct device *dev, void *res)
43 {
44 struct phy *phy = *(struct phy **)res;
45
46 phy_destroy(phy);
47 }
48
devm_phy_match(struct device * dev,void * res,void * match_data)49 static int devm_phy_match(struct device *dev, void *res, void *match_data)
50 {
51 struct phy **phy = res;
52
53 return *phy == match_data;
54 }
55
56 /**
57 * phy_create_lookup() - allocate and register PHY/device association
58 * @phy: the phy of the association
59 * @con_id: connection ID string on device
60 * @dev_id: the device of the association
61 *
62 * Creates and registers phy_lookup entry.
63 */
phy_create_lookup(struct phy * phy,const char * con_id,const char * dev_id)64 int phy_create_lookup(struct phy *phy, const char *con_id, const char *dev_id)
65 {
66 struct phy_lookup *pl;
67
68 if (!phy || !dev_id || !con_id)
69 return -EINVAL;
70
71 pl = kzalloc(sizeof(*pl), GFP_KERNEL);
72 if (!pl)
73 return -ENOMEM;
74
75 pl->dev_id = dev_id;
76 pl->con_id = con_id;
77 pl->phy = phy;
78
79 mutex_lock(&phy_provider_mutex);
80 list_add_tail(&pl->node, &phys);
81 mutex_unlock(&phy_provider_mutex);
82
83 return 0;
84 }
85 EXPORT_SYMBOL_GPL(phy_create_lookup);
86
87 /**
88 * phy_remove_lookup() - find and remove PHY/device association
89 * @phy: the phy of the association
90 * @con_id: connection ID string on device
91 * @dev_id: the device of the association
92 *
93 * Finds and unregisters phy_lookup entry that was created with
94 * phy_create_lookup().
95 */
phy_remove_lookup(struct phy * phy,const char * con_id,const char * dev_id)96 void phy_remove_lookup(struct phy *phy, const char *con_id, const char *dev_id)
97 {
98 struct phy_lookup *pl;
99
100 if (!phy || !dev_id || !con_id)
101 return;
102
103 mutex_lock(&phy_provider_mutex);
104 list_for_each_entry(pl, &phys, node)
105 if (pl->phy == phy && !strcmp(pl->dev_id, dev_id) &&
106 !strcmp(pl->con_id, con_id)) {
107 list_del(&pl->node);
108 kfree(pl);
109 break;
110 }
111 mutex_unlock(&phy_provider_mutex);
112 }
113 EXPORT_SYMBOL_GPL(phy_remove_lookup);
114
phy_find(struct device * dev,const char * con_id)115 static struct phy *phy_find(struct device *dev, const char *con_id)
116 {
117 const char *dev_id = dev_name(dev);
118 struct phy_lookup *p, *pl = NULL;
119
120 mutex_lock(&phy_provider_mutex);
121 list_for_each_entry(p, &phys, node)
122 if (!strcmp(p->dev_id, dev_id) && !strcmp(p->con_id, con_id)) {
123 pl = p;
124 break;
125 }
126 mutex_unlock(&phy_provider_mutex);
127
128 return pl ? pl->phy : ERR_PTR(-ENODEV);
129 }
130
of_phy_provider_lookup(struct device_node * node)131 static struct phy_provider *of_phy_provider_lookup(struct device_node *node)
132 {
133 struct phy_provider *phy_provider;
134 struct device_node *child;
135
136 list_for_each_entry(phy_provider, &phy_provider_list, list) {
137 if (phy_provider->dev->of_node == node)
138 return phy_provider;
139
140 for_each_child_of_node(phy_provider->children, child)
141 if (child == node)
142 return phy_provider;
143 }
144
145 return ERR_PTR(-EPROBE_DEFER);
146 }
147
phy_pm_runtime_get(struct phy * phy)148 int phy_pm_runtime_get(struct phy *phy)
149 {
150 int ret;
151
152 if (!phy)
153 return 0;
154
155 if (!pm_runtime_enabled(&phy->dev))
156 return -ENOTSUPP;
157
158 ret = pm_runtime_get(&phy->dev);
159 if (ret < 0 && ret != -EINPROGRESS)
160 pm_runtime_put_noidle(&phy->dev);
161
162 return ret;
163 }
164 EXPORT_SYMBOL_GPL(phy_pm_runtime_get);
165
phy_pm_runtime_get_sync(struct phy * phy)166 int phy_pm_runtime_get_sync(struct phy *phy)
167 {
168 int ret;
169
170 if (!phy)
171 return 0;
172
173 if (!pm_runtime_enabled(&phy->dev))
174 return -ENOTSUPP;
175
176 ret = pm_runtime_get_sync(&phy->dev);
177 if (ret < 0)
178 pm_runtime_put_sync(&phy->dev);
179
180 return ret;
181 }
182 EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync);
183
phy_pm_runtime_put(struct phy * phy)184 int phy_pm_runtime_put(struct phy *phy)
185 {
186 if (!phy)
187 return 0;
188
189 if (!pm_runtime_enabled(&phy->dev))
190 return -ENOTSUPP;
191
192 return pm_runtime_put(&phy->dev);
193 }
194 EXPORT_SYMBOL_GPL(phy_pm_runtime_put);
195
phy_pm_runtime_put_sync(struct phy * phy)196 int phy_pm_runtime_put_sync(struct phy *phy)
197 {
198 if (!phy)
199 return 0;
200
201 if (!pm_runtime_enabled(&phy->dev))
202 return -ENOTSUPP;
203
204 return pm_runtime_put_sync(&phy->dev);
205 }
206 EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync);
207
phy_pm_runtime_allow(struct phy * phy)208 void phy_pm_runtime_allow(struct phy *phy)
209 {
210 if (!phy)
211 return;
212
213 if (!pm_runtime_enabled(&phy->dev))
214 return;
215
216 pm_runtime_allow(&phy->dev);
217 }
218 EXPORT_SYMBOL_GPL(phy_pm_runtime_allow);
219
phy_pm_runtime_forbid(struct phy * phy)220 void phy_pm_runtime_forbid(struct phy *phy)
221 {
222 if (!phy)
223 return;
224
225 if (!pm_runtime_enabled(&phy->dev))
226 return;
227
228 pm_runtime_forbid(&phy->dev);
229 }
230 EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid);
231
232 /**
233 * phy_init - phy internal initialization before phy operation
234 * @phy: the phy returned by phy_get()
235 *
236 * Used to allow phy's driver to perform phy internal initialization,
237 * such as PLL block powering, clock initialization or anything that's
238 * is required by the phy to perform the start of operation.
239 * Must be called before phy_power_on().
240 *
241 * Return: %0 if successful, a negative error code otherwise
242 */
phy_init(struct phy * phy)243 int phy_init(struct phy *phy)
244 {
245 int ret;
246
247 if (!phy)
248 return 0;
249
250 ret = phy_pm_runtime_get_sync(phy);
251 if (ret < 0 && ret != -ENOTSUPP)
252 return ret;
253 ret = 0; /* Override possible ret == -ENOTSUPP */
254
255 mutex_lock(&phy->mutex);
256 if (phy->power_count > phy->init_count)
257 dev_warn(&phy->dev, "phy_power_on was called before phy_init\n");
258
259 if (phy->init_count == 0 && phy->ops->init) {
260 ret = phy->ops->init(phy);
261 if (ret < 0) {
262 dev_err(&phy->dev, "phy init failed --> %d\n", ret);
263 goto out;
264 }
265 }
266 ++phy->init_count;
267
268 out:
269 mutex_unlock(&phy->mutex);
270 phy_pm_runtime_put(phy);
271 return ret;
272 }
273 EXPORT_SYMBOL_GPL(phy_init);
274
275 /**
276 * phy_exit - Phy internal un-initialization
277 * @phy: the phy returned by phy_get()
278 *
279 * Must be called after phy_power_off().
280 *
281 * Return: %0 if successful, a negative error code otherwise
282 */
phy_exit(struct phy * phy)283 int phy_exit(struct phy *phy)
284 {
285 int ret;
286
287 if (!phy)
288 return 0;
289
290 ret = phy_pm_runtime_get_sync(phy);
291 if (ret < 0 && ret != -ENOTSUPP)
292 return ret;
293 ret = 0; /* Override possible ret == -ENOTSUPP */
294
295 mutex_lock(&phy->mutex);
296 if (phy->init_count == 1 && phy->ops->exit) {
297 ret = phy->ops->exit(phy);
298 if (ret < 0) {
299 dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
300 goto out;
301 }
302 }
303 --phy->init_count;
304
305 out:
306 mutex_unlock(&phy->mutex);
307 phy_pm_runtime_put(phy);
308 return ret;
309 }
310 EXPORT_SYMBOL_GPL(phy_exit);
311
312 /**
313 * phy_power_on - Enable the phy and enter proper operation
314 * @phy: the phy returned by phy_get()
315 *
316 * Must be called after phy_init().
317 *
318 * Return: %0 if successful, a negative error code otherwise
319 */
phy_power_on(struct phy * phy)320 int phy_power_on(struct phy *phy)
321 {
322 int ret = 0;
323
324 if (!phy)
325 goto out;
326
327 if (phy->pwr) {
328 ret = regulator_enable(phy->pwr);
329 if (ret)
330 goto out;
331 }
332
333 ret = phy_pm_runtime_get_sync(phy);
334 if (ret < 0 && ret != -ENOTSUPP)
335 goto err_pm_sync;
336
337 ret = 0; /* Override possible ret == -ENOTSUPP */
338
339 mutex_lock(&phy->mutex);
340 if (phy->power_count == 0 && phy->ops->power_on) {
341 ret = phy->ops->power_on(phy);
342 if (ret < 0) {
343 dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
344 goto err_pwr_on;
345 }
346 }
347 ++phy->power_count;
348 mutex_unlock(&phy->mutex);
349 return 0;
350
351 err_pwr_on:
352 mutex_unlock(&phy->mutex);
353 phy_pm_runtime_put_sync(phy);
354 err_pm_sync:
355 if (phy->pwr)
356 regulator_disable(phy->pwr);
357 out:
358 return ret;
359 }
360 EXPORT_SYMBOL_GPL(phy_power_on);
361
362 /**
363 * phy_power_off - Disable the phy.
364 * @phy: the phy returned by phy_get()
365 *
366 * Must be called before phy_exit().
367 *
368 * Return: %0 if successful, a negative error code otherwise
369 */
phy_power_off(struct phy * phy)370 int phy_power_off(struct phy *phy)
371 {
372 int ret;
373
374 if (!phy)
375 return 0;
376
377 mutex_lock(&phy->mutex);
378 if (phy->power_count == 1 && phy->ops->power_off) {
379 ret = phy->ops->power_off(phy);
380 if (ret < 0) {
381 dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
382 mutex_unlock(&phy->mutex);
383 return ret;
384 }
385 }
386 --phy->power_count;
387 mutex_unlock(&phy->mutex);
388 phy_pm_runtime_put(phy);
389
390 if (phy->pwr)
391 regulator_disable(phy->pwr);
392
393 return 0;
394 }
395 EXPORT_SYMBOL_GPL(phy_power_off);
396
phy_set_mode_ext(struct phy * phy,enum phy_mode mode,int submode)397 int phy_set_mode_ext(struct phy *phy, enum phy_mode mode, int submode)
398 {
399 int ret;
400
401 if (!phy || !phy->ops->set_mode)
402 return 0;
403
404 mutex_lock(&phy->mutex);
405 ret = phy->ops->set_mode(phy, mode, submode);
406 if (!ret)
407 phy->attrs.mode = mode;
408 mutex_unlock(&phy->mutex);
409
410 return ret;
411 }
412 EXPORT_SYMBOL_GPL(phy_set_mode_ext);
413
phy_set_media(struct phy * phy,enum phy_media media)414 int phy_set_media(struct phy *phy, enum phy_media media)
415 {
416 int ret;
417
418 if (!phy || !phy->ops->set_media)
419 return 0;
420
421 mutex_lock(&phy->mutex);
422 ret = phy->ops->set_media(phy, media);
423 mutex_unlock(&phy->mutex);
424
425 return ret;
426 }
427 EXPORT_SYMBOL_GPL(phy_set_media);
428
phy_set_speed(struct phy * phy,int speed)429 int phy_set_speed(struct phy *phy, int speed)
430 {
431 int ret;
432
433 if (!phy || !phy->ops->set_speed)
434 return 0;
435
436 mutex_lock(&phy->mutex);
437 ret = phy->ops->set_speed(phy, speed);
438 mutex_unlock(&phy->mutex);
439
440 return ret;
441 }
442 EXPORT_SYMBOL_GPL(phy_set_speed);
443
phy_reset(struct phy * phy)444 int phy_reset(struct phy *phy)
445 {
446 int ret;
447
448 if (!phy || !phy->ops->reset)
449 return 0;
450
451 ret = phy_pm_runtime_get_sync(phy);
452 if (ret < 0 && ret != -ENOTSUPP)
453 return ret;
454
455 mutex_lock(&phy->mutex);
456 ret = phy->ops->reset(phy);
457 mutex_unlock(&phy->mutex);
458
459 phy_pm_runtime_put(phy);
460
461 return ret;
462 }
463 EXPORT_SYMBOL_GPL(phy_reset);
464
465 /**
466 * phy_calibrate() - Tunes the phy hw parameters for current configuration
467 * @phy: the phy returned by phy_get()
468 *
469 * Used to calibrate phy hardware, typically by adjusting some parameters in
470 * runtime, which are otherwise lost after host controller reset and cannot
471 * be applied in phy_init() or phy_power_on().
472 *
473 * Return: %0 if successful, a negative error code otherwise
474 */
phy_calibrate(struct phy * phy)475 int phy_calibrate(struct phy *phy)
476 {
477 int ret;
478
479 if (!phy || !phy->ops->calibrate)
480 return 0;
481
482 mutex_lock(&phy->mutex);
483 ret = phy->ops->calibrate(phy);
484 mutex_unlock(&phy->mutex);
485
486 return ret;
487 }
488 EXPORT_SYMBOL_GPL(phy_calibrate);
489
490 /**
491 * phy_configure() - Changes the phy parameters
492 * @phy: the phy returned by phy_get()
493 * @opts: New configuration to apply
494 *
495 * Used to change the PHY parameters. phy_init() must have been called
496 * on the phy. The configuration will be applied on the current phy
497 * mode, that can be changed using phy_set_mode().
498 *
499 * Return: %0 if successful, a negative error code otherwise
500 */
phy_configure(struct phy * phy,union phy_configure_opts * opts)501 int phy_configure(struct phy *phy, union phy_configure_opts *opts)
502 {
503 int ret;
504
505 if (!phy)
506 return -EINVAL;
507
508 if (!phy->ops->configure)
509 return -EOPNOTSUPP;
510
511 mutex_lock(&phy->mutex);
512 ret = phy->ops->configure(phy, opts);
513 mutex_unlock(&phy->mutex);
514
515 return ret;
516 }
517 EXPORT_SYMBOL_GPL(phy_configure);
518
519 /**
520 * phy_validate() - Checks the phy parameters
521 * @phy: the phy returned by phy_get()
522 * @mode: phy_mode the configuration is applicable to.
523 * @submode: PHY submode the configuration is applicable to.
524 * @opts: Configuration to check
525 *
526 * Used to check that the current set of parameters can be handled by
527 * the phy. Implementations are free to tune the parameters passed as
528 * arguments if needed by some implementation detail or
529 * constraints. It will not change any actual configuration of the
530 * PHY, so calling it as many times as deemed fit will have no side
531 * effect.
532 *
533 * Return: %0 if successful, a negative error code otherwise
534 */
phy_validate(struct phy * phy,enum phy_mode mode,int submode,union phy_configure_opts * opts)535 int phy_validate(struct phy *phy, enum phy_mode mode, int submode,
536 union phy_configure_opts *opts)
537 {
538 int ret;
539
540 if (!phy)
541 return -EINVAL;
542
543 if (!phy->ops->validate)
544 return -EOPNOTSUPP;
545
546 mutex_lock(&phy->mutex);
547 ret = phy->ops->validate(phy, mode, submode, opts);
548 mutex_unlock(&phy->mutex);
549
550 return ret;
551 }
552 EXPORT_SYMBOL_GPL(phy_validate);
553
554 /**
555 * _of_phy_get() - lookup and obtain a reference to a phy by phandle
556 * @np: device_node for which to get the phy
557 * @index: the index of the phy
558 *
559 * Returns the phy associated with the given phandle value,
560 * after getting a refcount to it or -ENODEV if there is no such phy or
561 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
562 * not yet loaded. This function uses of_xlate call back function provided
563 * while registering the phy_provider to find the phy instance.
564 */
_of_phy_get(struct device_node * np,int index)565 static struct phy *_of_phy_get(struct device_node *np, int index)
566 {
567 int ret;
568 struct phy_provider *phy_provider;
569 struct phy *phy = NULL;
570 struct of_phandle_args args;
571
572 ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
573 index, &args);
574 if (ret)
575 return ERR_PTR(-ENODEV);
576
577 /* This phy type handled by the usb-phy subsystem for now */
578 if (of_device_is_compatible(args.np, "usb-nop-xceiv"))
579 return ERR_PTR(-ENODEV);
580
581 mutex_lock(&phy_provider_mutex);
582 phy_provider = of_phy_provider_lookup(args.np);
583 if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
584 phy = ERR_PTR(-EPROBE_DEFER);
585 goto out_unlock;
586 }
587
588 if (!of_device_is_available(args.np)) {
589 dev_warn(phy_provider->dev, "Requested PHY is disabled\n");
590 phy = ERR_PTR(-ENODEV);
591 goto out_put_module;
592 }
593
594 phy = phy_provider->of_xlate(phy_provider->dev, &args);
595
596 out_put_module:
597 module_put(phy_provider->owner);
598
599 out_unlock:
600 mutex_unlock(&phy_provider_mutex);
601 of_node_put(args.np);
602
603 return phy;
604 }
605
606 /**
607 * of_phy_get() - lookup and obtain a reference to a phy using a device_node.
608 * @np: device_node for which to get the phy
609 * @con_id: name of the phy from device's point of view
610 *
611 * Returns the phy driver, after getting a refcount to it; or
612 * -ENODEV if there is no such phy. The caller is responsible for
613 * calling phy_put() to release that count.
614 */
of_phy_get(struct device_node * np,const char * con_id)615 struct phy *of_phy_get(struct device_node *np, const char *con_id)
616 {
617 struct phy *phy = NULL;
618 int index = 0;
619
620 if (con_id)
621 index = of_property_match_string(np, "phy-names", con_id);
622
623 phy = _of_phy_get(np, index);
624 if (IS_ERR(phy))
625 return phy;
626
627 if (!try_module_get(phy->ops->owner))
628 return ERR_PTR(-EPROBE_DEFER);
629
630 get_device(&phy->dev);
631
632 return phy;
633 }
634 EXPORT_SYMBOL_GPL(of_phy_get);
635
636 /**
637 * of_phy_put() - release the PHY
638 * @phy: the phy returned by of_phy_get()
639 *
640 * Releases a refcount the caller received from of_phy_get().
641 */
of_phy_put(struct phy * phy)642 void of_phy_put(struct phy *phy)
643 {
644 if (!phy || IS_ERR(phy))
645 return;
646
647 mutex_lock(&phy->mutex);
648 if (phy->ops->release)
649 phy->ops->release(phy);
650 mutex_unlock(&phy->mutex);
651
652 module_put(phy->ops->owner);
653 put_device(&phy->dev);
654 }
655 EXPORT_SYMBOL_GPL(of_phy_put);
656
657 /**
658 * phy_put() - release the PHY
659 * @dev: device that wants to release this phy
660 * @phy: the phy returned by phy_get()
661 *
662 * Releases a refcount the caller received from phy_get().
663 */
phy_put(struct device * dev,struct phy * phy)664 void phy_put(struct device *dev, struct phy *phy)
665 {
666 device_link_remove(dev, &phy->dev);
667 of_phy_put(phy);
668 }
669 EXPORT_SYMBOL_GPL(phy_put);
670
671 /**
672 * devm_phy_put() - release the PHY
673 * @dev: device that wants to release this phy
674 * @phy: the phy returned by devm_phy_get()
675 *
676 * destroys the devres associated with this phy and invokes phy_put
677 * to release the phy.
678 */
devm_phy_put(struct device * dev,struct phy * phy)679 void devm_phy_put(struct device *dev, struct phy *phy)
680 {
681 int r;
682
683 if (!phy)
684 return;
685
686 r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
687 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
688 }
689 EXPORT_SYMBOL_GPL(devm_phy_put);
690
691 /**
692 * of_phy_simple_xlate() - returns the phy instance from phy provider
693 * @dev: the PHY provider device
694 * @args: of_phandle_args (not used here)
695 *
696 * Intended to be used by phy provider for the common case where #phy-cells is
697 * 0. For other cases where #phy-cells is greater than '0', the phy provider
698 * should provide a custom of_xlate function that reads the *args* and returns
699 * the appropriate phy.
700 */
of_phy_simple_xlate(struct device * dev,struct of_phandle_args * args)701 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
702 *args)
703 {
704 struct phy *phy;
705 struct class_dev_iter iter;
706
707 class_dev_iter_init(&iter, phy_class, NULL, NULL);
708 while ((dev = class_dev_iter_next(&iter))) {
709 phy = to_phy(dev);
710 if (args->np != phy->dev.of_node)
711 continue;
712
713 class_dev_iter_exit(&iter);
714 return phy;
715 }
716
717 class_dev_iter_exit(&iter);
718 return ERR_PTR(-ENODEV);
719 }
720 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
721
722 /**
723 * phy_get() - lookup and obtain a reference to a phy.
724 * @dev: device that requests this phy
725 * @string: the phy name as given in the dt data or the name of the controller
726 * port for non-dt case
727 *
728 * Returns the phy driver, after getting a refcount to it; or
729 * -ENODEV if there is no such phy. The caller is responsible for
730 * calling phy_put() to release that count.
731 */
phy_get(struct device * dev,const char * string)732 struct phy *phy_get(struct device *dev, const char *string)
733 {
734 int index = 0;
735 struct phy *phy;
736 struct device_link *link;
737
738 if (dev->of_node) {
739 if (string)
740 index = of_property_match_string(dev->of_node, "phy-names",
741 string);
742 else
743 index = 0;
744 phy = _of_phy_get(dev->of_node, index);
745 } else {
746 if (string == NULL) {
747 dev_WARN(dev, "missing string\n");
748 return ERR_PTR(-EINVAL);
749 }
750 phy = phy_find(dev, string);
751 }
752 if (IS_ERR(phy))
753 return phy;
754
755 if (!try_module_get(phy->ops->owner))
756 return ERR_PTR(-EPROBE_DEFER);
757
758 get_device(&phy->dev);
759
760 link = device_link_add(dev, &phy->dev, DL_FLAG_STATELESS);
761 if (!link)
762 dev_dbg(dev, "failed to create device link to %s\n",
763 dev_name(phy->dev.parent));
764
765 return phy;
766 }
767 EXPORT_SYMBOL_GPL(phy_get);
768
769 /**
770 * devm_phy_get() - lookup and obtain a reference to a phy.
771 * @dev: device that requests this phy
772 * @string: the phy name as given in the dt data or phy device name
773 * for non-dt case
774 *
775 * Gets the phy using phy_get(), and associates a device with it using
776 * devres. On driver detach, release function is invoked on the devres data,
777 * then, devres data is freed.
778 */
devm_phy_get(struct device * dev,const char * string)779 struct phy *devm_phy_get(struct device *dev, const char *string)
780 {
781 struct phy **ptr, *phy;
782
783 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
784 if (!ptr)
785 return ERR_PTR(-ENOMEM);
786
787 phy = phy_get(dev, string);
788 if (!IS_ERR(phy)) {
789 *ptr = phy;
790 devres_add(dev, ptr);
791 } else {
792 devres_free(ptr);
793 }
794
795 return phy;
796 }
797 EXPORT_SYMBOL_GPL(devm_phy_get);
798
799 /**
800 * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
801 * @dev: device that requests this phy
802 * @string: the phy name as given in the dt data or phy device name
803 * for non-dt case
804 *
805 * Gets the phy using phy_get(), and associates a device with it using
806 * devres. On driver detach, release function is invoked on the devres
807 * data, then, devres data is freed. This differs to devm_phy_get() in
808 * that if the phy does not exist, it is not considered an error and
809 * -ENODEV will not be returned. Instead the NULL phy is returned,
810 * which can be passed to all other phy consumer calls.
811 */
devm_phy_optional_get(struct device * dev,const char * string)812 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
813 {
814 struct phy *phy = devm_phy_get(dev, string);
815
816 if (PTR_ERR(phy) == -ENODEV)
817 phy = NULL;
818
819 return phy;
820 }
821 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
822
823 /**
824 * devm_of_phy_get() - lookup and obtain a reference to a phy.
825 * @dev: device that requests this phy
826 * @np: node containing the phy
827 * @con_id: name of the phy from device's point of view
828 *
829 * Gets the phy using of_phy_get(), and associates a device with it using
830 * devres. On driver detach, release function is invoked on the devres data,
831 * then, devres data is freed.
832 */
devm_of_phy_get(struct device * dev,struct device_node * np,const char * con_id)833 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
834 const char *con_id)
835 {
836 struct phy **ptr, *phy;
837 struct device_link *link;
838
839 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
840 if (!ptr)
841 return ERR_PTR(-ENOMEM);
842
843 phy = of_phy_get(np, con_id);
844 if (!IS_ERR(phy)) {
845 *ptr = phy;
846 devres_add(dev, ptr);
847 } else {
848 devres_free(ptr);
849 return phy;
850 }
851
852 link = device_link_add(dev, &phy->dev, DL_FLAG_STATELESS);
853 if (!link)
854 dev_dbg(dev, "failed to create device link to %s\n",
855 dev_name(phy->dev.parent));
856
857 return phy;
858 }
859 EXPORT_SYMBOL_GPL(devm_of_phy_get);
860
861 /**
862 * devm_of_phy_optional_get() - lookup and obtain a reference to an optional
863 * phy.
864 * @dev: device that requests this phy
865 * @np: node containing the phy
866 * @con_id: name of the phy from device's point of view
867 *
868 * Gets the phy using of_phy_get(), and associates a device with it using
869 * devres. On driver detach, release function is invoked on the devres data,
870 * then, devres data is freed. This differs to devm_of_phy_get() in
871 * that if the phy does not exist, it is not considered an error and
872 * -ENODEV will not be returned. Instead the NULL phy is returned,
873 * which can be passed to all other phy consumer calls.
874 */
devm_of_phy_optional_get(struct device * dev,struct device_node * np,const char * con_id)875 struct phy *devm_of_phy_optional_get(struct device *dev, struct device_node *np,
876 const char *con_id)
877 {
878 struct phy *phy = devm_of_phy_get(dev, np, con_id);
879
880 if (PTR_ERR(phy) == -ENODEV)
881 phy = NULL;
882
883 if (IS_ERR(phy))
884 dev_err_probe(dev, PTR_ERR(phy), "failed to get PHY %pOF:%s",
885 np, con_id);
886
887 return phy;
888 }
889 EXPORT_SYMBOL_GPL(devm_of_phy_optional_get);
890
891 /**
892 * devm_of_phy_get_by_index() - lookup and obtain a reference to a phy by index.
893 * @dev: device that requests this phy
894 * @np: node containing the phy
895 * @index: index of the phy
896 *
897 * Gets the phy using _of_phy_get(), then gets a refcount to it,
898 * and associates a device with it using devres. On driver detach,
899 * release function is invoked on the devres data,
900 * then, devres data is freed.
901 *
902 */
devm_of_phy_get_by_index(struct device * dev,struct device_node * np,int index)903 struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
904 int index)
905 {
906 struct phy **ptr, *phy;
907 struct device_link *link;
908
909 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
910 if (!ptr)
911 return ERR_PTR(-ENOMEM);
912
913 phy = _of_phy_get(np, index);
914 if (IS_ERR(phy)) {
915 devres_free(ptr);
916 return phy;
917 }
918
919 if (!try_module_get(phy->ops->owner)) {
920 devres_free(ptr);
921 return ERR_PTR(-EPROBE_DEFER);
922 }
923
924 get_device(&phy->dev);
925
926 *ptr = phy;
927 devres_add(dev, ptr);
928
929 link = device_link_add(dev, &phy->dev, DL_FLAG_STATELESS);
930 if (!link)
931 dev_dbg(dev, "failed to create device link to %s\n",
932 dev_name(phy->dev.parent));
933
934 return phy;
935 }
936 EXPORT_SYMBOL_GPL(devm_of_phy_get_by_index);
937
938 /**
939 * phy_create() - create a new phy
940 * @dev: device that is creating the new phy
941 * @node: device node of the phy
942 * @ops: function pointers for performing phy operations
943 *
944 * Called to create a phy using phy framework.
945 */
phy_create(struct device * dev,struct device_node * node,const struct phy_ops * ops)946 struct phy *phy_create(struct device *dev, struct device_node *node,
947 const struct phy_ops *ops)
948 {
949 int ret;
950 int id;
951 struct phy *phy;
952
953 if (WARN_ON(!dev))
954 return ERR_PTR(-EINVAL);
955
956 phy = kzalloc(sizeof(*phy), GFP_KERNEL);
957 if (!phy)
958 return ERR_PTR(-ENOMEM);
959
960 id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
961 if (id < 0) {
962 dev_err(dev, "unable to get id\n");
963 ret = id;
964 goto free_phy;
965 }
966
967 device_initialize(&phy->dev);
968 mutex_init(&phy->mutex);
969
970 phy->dev.class = phy_class;
971 phy->dev.parent = dev;
972 phy->dev.of_node = node ?: dev->of_node;
973 phy->id = id;
974 phy->ops = ops;
975
976 ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
977 if (ret)
978 goto put_dev;
979
980 /* phy-supply */
981 phy->pwr = regulator_get_optional(&phy->dev, "phy");
982 if (IS_ERR(phy->pwr)) {
983 ret = PTR_ERR(phy->pwr);
984 if (ret == -EPROBE_DEFER)
985 goto put_dev;
986
987 phy->pwr = NULL;
988 }
989
990 ret = device_add(&phy->dev);
991 if (ret)
992 goto put_dev;
993
994 if (pm_runtime_enabled(dev)) {
995 pm_runtime_enable(&phy->dev);
996 pm_runtime_no_callbacks(&phy->dev);
997 }
998
999 return phy;
1000
1001 put_dev:
1002 put_device(&phy->dev); /* calls phy_release() which frees resources */
1003 return ERR_PTR(ret);
1004
1005 free_phy:
1006 kfree(phy);
1007 return ERR_PTR(ret);
1008 }
1009 EXPORT_SYMBOL_GPL(phy_create);
1010
1011 /**
1012 * devm_phy_create() - create a new phy
1013 * @dev: device that is creating the new phy
1014 * @node: device node of the phy
1015 * @ops: function pointers for performing phy operations
1016 *
1017 * Creates a new PHY device adding it to the PHY class.
1018 * While at that, it also associates the device with the phy using devres.
1019 * On driver detach, release function is invoked on the devres data,
1020 * then, devres data is freed.
1021 */
devm_phy_create(struct device * dev,struct device_node * node,const struct phy_ops * ops)1022 struct phy *devm_phy_create(struct device *dev, struct device_node *node,
1023 const struct phy_ops *ops)
1024 {
1025 struct phy **ptr, *phy;
1026
1027 ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
1028 if (!ptr)
1029 return ERR_PTR(-ENOMEM);
1030
1031 phy = phy_create(dev, node, ops);
1032 if (!IS_ERR(phy)) {
1033 *ptr = phy;
1034 devres_add(dev, ptr);
1035 } else {
1036 devres_free(ptr);
1037 }
1038
1039 return phy;
1040 }
1041 EXPORT_SYMBOL_GPL(devm_phy_create);
1042
1043 /**
1044 * phy_destroy() - destroy the phy
1045 * @phy: the phy to be destroyed
1046 *
1047 * Called to destroy the phy.
1048 */
phy_destroy(struct phy * phy)1049 void phy_destroy(struct phy *phy)
1050 {
1051 pm_runtime_disable(&phy->dev);
1052 device_unregister(&phy->dev);
1053 }
1054 EXPORT_SYMBOL_GPL(phy_destroy);
1055
1056 /**
1057 * devm_phy_destroy() - destroy the PHY
1058 * @dev: device that wants to release this phy
1059 * @phy: the phy returned by devm_phy_get()
1060 *
1061 * destroys the devres associated with this phy and invokes phy_destroy
1062 * to destroy the phy.
1063 */
devm_phy_destroy(struct device * dev,struct phy * phy)1064 void devm_phy_destroy(struct device *dev, struct phy *phy)
1065 {
1066 int r;
1067
1068 r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
1069 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
1070 }
1071 EXPORT_SYMBOL_GPL(devm_phy_destroy);
1072
1073 /**
1074 * __of_phy_provider_register() - create/register phy provider with the framework
1075 * @dev: struct device of the phy provider
1076 * @children: device node containing children (if different from dev->of_node)
1077 * @owner: the module owner containing of_xlate
1078 * @of_xlate: function pointer to obtain phy instance from phy provider
1079 *
1080 * Creates struct phy_provider from dev and of_xlate function pointer.
1081 * This is used in the case of dt boot for finding the phy instance from
1082 * phy provider.
1083 *
1084 * If the PHY provider doesn't nest children directly but uses a separate
1085 * child node to contain the individual children, the @children parameter
1086 * can be used to override the default. If NULL, the default (dev->of_node)
1087 * will be used. If non-NULL, the device node must be a child (or further
1088 * descendant) of dev->of_node. Otherwise an ERR_PTR()-encoded -EINVAL
1089 * error code is returned.
1090 */
__of_phy_provider_register(struct device * dev,struct device_node * children,struct module * owner,struct phy * (* of_xlate)(struct device * dev,struct of_phandle_args * args))1091 struct phy_provider *__of_phy_provider_register(struct device *dev,
1092 struct device_node *children, struct module *owner,
1093 struct phy * (*of_xlate)(struct device *dev,
1094 struct of_phandle_args *args))
1095 {
1096 struct phy_provider *phy_provider;
1097
1098 /*
1099 * If specified, the device node containing the children must itself
1100 * be the provider's device node or a child (or further descendant)
1101 * thereof.
1102 */
1103 if (children) {
1104 struct device_node *parent = of_node_get(children), *next;
1105
1106 while (parent) {
1107 if (parent == dev->of_node)
1108 break;
1109
1110 next = of_get_parent(parent);
1111 of_node_put(parent);
1112 parent = next;
1113 }
1114
1115 if (!parent)
1116 return ERR_PTR(-EINVAL);
1117
1118 of_node_put(parent);
1119 } else {
1120 children = dev->of_node;
1121 }
1122
1123 phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
1124 if (!phy_provider)
1125 return ERR_PTR(-ENOMEM);
1126
1127 phy_provider->dev = dev;
1128 phy_provider->children = of_node_get(children);
1129 phy_provider->owner = owner;
1130 phy_provider->of_xlate = of_xlate;
1131
1132 mutex_lock(&phy_provider_mutex);
1133 list_add_tail(&phy_provider->list, &phy_provider_list);
1134 mutex_unlock(&phy_provider_mutex);
1135
1136 return phy_provider;
1137 }
1138 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
1139
1140 /**
1141 * __devm_of_phy_provider_register() - create/register phy provider with the
1142 * framework
1143 * @dev: struct device of the phy provider
1144 * @children: device node containing children (if different from dev->of_node)
1145 * @owner: the module owner containing of_xlate
1146 * @of_xlate: function pointer to obtain phy instance from phy provider
1147 *
1148 * Creates struct phy_provider from dev and of_xlate function pointer.
1149 * This is used in the case of dt boot for finding the phy instance from
1150 * phy provider. While at that, it also associates the device with the
1151 * phy provider using devres. On driver detach, release function is invoked
1152 * on the devres data, then, devres data is freed.
1153 */
__devm_of_phy_provider_register(struct device * dev,struct device_node * children,struct module * owner,struct phy * (* of_xlate)(struct device * dev,struct of_phandle_args * args))1154 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
1155 struct device_node *children, struct module *owner,
1156 struct phy * (*of_xlate)(struct device *dev,
1157 struct of_phandle_args *args))
1158 {
1159 struct phy_provider **ptr, *phy_provider;
1160
1161 ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
1162 if (!ptr)
1163 return ERR_PTR(-ENOMEM);
1164
1165 phy_provider = __of_phy_provider_register(dev, children, owner,
1166 of_xlate);
1167 if (!IS_ERR(phy_provider)) {
1168 *ptr = phy_provider;
1169 devres_add(dev, ptr);
1170 } else {
1171 devres_free(ptr);
1172 }
1173
1174 return phy_provider;
1175 }
1176 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
1177
1178 /**
1179 * of_phy_provider_unregister() - unregister phy provider from the framework
1180 * @phy_provider: phy provider returned by of_phy_provider_register()
1181 *
1182 * Removes the phy_provider created using of_phy_provider_register().
1183 */
of_phy_provider_unregister(struct phy_provider * phy_provider)1184 void of_phy_provider_unregister(struct phy_provider *phy_provider)
1185 {
1186 if (IS_ERR(phy_provider))
1187 return;
1188
1189 mutex_lock(&phy_provider_mutex);
1190 list_del(&phy_provider->list);
1191 of_node_put(phy_provider->children);
1192 kfree(phy_provider);
1193 mutex_unlock(&phy_provider_mutex);
1194 }
1195 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
1196
1197 /**
1198 * devm_of_phy_provider_unregister() - remove phy provider from the framework
1199 * @dev: struct device of the phy provider
1200 * @phy_provider: phy provider returned by of_phy_provider_register()
1201 *
1202 * destroys the devres associated with this phy provider and invokes
1203 * of_phy_provider_unregister to unregister the phy provider.
1204 */
devm_of_phy_provider_unregister(struct device * dev,struct phy_provider * phy_provider)1205 void devm_of_phy_provider_unregister(struct device *dev,
1206 struct phy_provider *phy_provider)
1207 {
1208 int r;
1209
1210 r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
1211 phy_provider);
1212 dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
1213 }
1214 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
1215
1216 /**
1217 * phy_release() - release the phy
1218 * @dev: the dev member within phy
1219 *
1220 * When the last reference to the device is removed, it is called
1221 * from the embedded kobject as release method.
1222 */
phy_release(struct device * dev)1223 static void phy_release(struct device *dev)
1224 {
1225 struct phy *phy;
1226
1227 phy = to_phy(dev);
1228 dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
1229 regulator_put(phy->pwr);
1230 ida_simple_remove(&phy_ida, phy->id);
1231 kfree(phy);
1232 }
1233
phy_core_init(void)1234 static int __init phy_core_init(void)
1235 {
1236 phy_class = class_create(THIS_MODULE, "phy");
1237 if (IS_ERR(phy_class)) {
1238 pr_err("failed to create phy class --> %ld\n",
1239 PTR_ERR(phy_class));
1240 return PTR_ERR(phy_class);
1241 }
1242
1243 phy_class->dev_release = phy_release;
1244
1245 return 0;
1246 }
1247 device_initcall(phy_core_init);
1248