1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/export.h>
16#include <linux/module.h>
17#include <linux/err.h>
18#include <linux/device.h>
19#include <linux/slab.h>
20#include <linux/of.h>
21#include <linux/phy/phy.h>
22#include <linux/idr.h>
23#include <linux/pm_runtime.h>
24#include <linux/regulator/consumer.h>
25
26static struct class *phy_class;
27static DEFINE_MUTEX(phy_provider_mutex);
28static LIST_HEAD(phy_provider_list);
29static LIST_HEAD(phys);
30static DEFINE_IDA(phy_ida);
31
32static void devm_phy_release(struct device *dev, void *res)
33{
34 struct phy *phy = *(struct phy **)res;
35
36 phy_put(phy);
37}
38
39static void devm_phy_provider_release(struct device *dev, void *res)
40{
41 struct phy_provider *phy_provider = *(struct phy_provider **)res;
42
43 of_phy_provider_unregister(phy_provider);
44}
45
46static void devm_phy_consume(struct device *dev, void *res)
47{
48 struct phy *phy = *(struct phy **)res;
49
50 phy_destroy(phy);
51}
52
53static int devm_phy_match(struct device *dev, void *res, void *match_data)
54{
55 struct phy **phy = res;
56
57 return *phy == match_data;
58}
59
60
61
62
63
64
65
66
67
68int phy_create_lookup(struct phy *phy, const char *con_id, const char *dev_id)
69{
70 struct phy_lookup *pl;
71
72 if (!phy || !dev_id || !con_id)
73 return -EINVAL;
74
75 pl = kzalloc(sizeof(*pl), GFP_KERNEL);
76 if (!pl)
77 return -ENOMEM;
78
79 pl->dev_id = dev_id;
80 pl->con_id = con_id;
81 pl->phy = phy;
82
83 mutex_lock(&phy_provider_mutex);
84 list_add_tail(&pl->node, &phys);
85 mutex_unlock(&phy_provider_mutex);
86
87 return 0;
88}
89EXPORT_SYMBOL_GPL(phy_create_lookup);
90
91
92
93
94
95
96
97
98
99
100void phy_remove_lookup(struct phy *phy, const char *con_id, const char *dev_id)
101{
102 struct phy_lookup *pl;
103
104 if (!phy || !dev_id || !con_id)
105 return;
106
107 mutex_lock(&phy_provider_mutex);
108 list_for_each_entry(pl, &phys, node)
109 if (pl->phy == phy && !strcmp(pl->dev_id, dev_id) &&
110 !strcmp(pl->con_id, con_id)) {
111 list_del(&pl->node);
112 kfree(pl);
113 break;
114 }
115 mutex_unlock(&phy_provider_mutex);
116}
117EXPORT_SYMBOL_GPL(phy_remove_lookup);
118
119static struct phy *phy_find(struct device *dev, const char *con_id)
120{
121 const char *dev_id = dev_name(dev);
122 struct phy_lookup *p, *pl = NULL;
123
124 mutex_lock(&phy_provider_mutex);
125 list_for_each_entry(p, &phys, node)
126 if (!strcmp(p->dev_id, dev_id) && !strcmp(p->con_id, con_id)) {
127 pl = p;
128 break;
129 }
130 mutex_unlock(&phy_provider_mutex);
131
132 return pl ? pl->phy : ERR_PTR(-ENODEV);
133}
134
135static struct phy_provider *of_phy_provider_lookup(struct device_node *node)
136{
137 struct phy_provider *phy_provider;
138 struct device_node *child;
139
140 list_for_each_entry(phy_provider, &phy_provider_list, list) {
141 if (phy_provider->dev->of_node == node)
142 return phy_provider;
143
144 for_each_child_of_node(phy_provider->dev->of_node, child)
145 if (child == node)
146 return phy_provider;
147 }
148
149 return ERR_PTR(-EPROBE_DEFER);
150}
151
152int phy_pm_runtime_get(struct phy *phy)
153{
154 int ret;
155
156 if (!pm_runtime_enabled(&phy->dev))
157 return -ENOTSUPP;
158
159 ret = pm_runtime_get(&phy->dev);
160 if (ret < 0 && ret != -EINPROGRESS)
161 pm_runtime_put_noidle(&phy->dev);
162
163 return ret;
164}
165EXPORT_SYMBOL_GPL(phy_pm_runtime_get);
166
167int phy_pm_runtime_get_sync(struct phy *phy)
168{
169 int ret;
170
171 if (!pm_runtime_enabled(&phy->dev))
172 return -ENOTSUPP;
173
174 ret = pm_runtime_get_sync(&phy->dev);
175 if (ret < 0)
176 pm_runtime_put_sync(&phy->dev);
177
178 return ret;
179}
180EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync);
181
182int phy_pm_runtime_put(struct phy *phy)
183{
184 if (!pm_runtime_enabled(&phy->dev))
185 return -ENOTSUPP;
186
187 return pm_runtime_put(&phy->dev);
188}
189EXPORT_SYMBOL_GPL(phy_pm_runtime_put);
190
191int phy_pm_runtime_put_sync(struct phy *phy)
192{
193 if (!pm_runtime_enabled(&phy->dev))
194 return -ENOTSUPP;
195
196 return pm_runtime_put_sync(&phy->dev);
197}
198EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync);
199
200void phy_pm_runtime_allow(struct phy *phy)
201{
202 if (!pm_runtime_enabled(&phy->dev))
203 return;
204
205 pm_runtime_allow(&phy->dev);
206}
207EXPORT_SYMBOL_GPL(phy_pm_runtime_allow);
208
209void phy_pm_runtime_forbid(struct phy *phy)
210{
211 if (!pm_runtime_enabled(&phy->dev))
212 return;
213
214 pm_runtime_forbid(&phy->dev);
215}
216EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid);
217
218int phy_init(struct phy *phy)
219{
220 int ret;
221
222 if (!phy)
223 return 0;
224
225 ret = phy_pm_runtime_get_sync(phy);
226 if (ret < 0 && ret != -ENOTSUPP)
227 return ret;
228 ret = 0;
229
230 mutex_lock(&phy->mutex);
231 if (phy->init_count == 0 && phy->ops->init) {
232 ret = phy->ops->init(phy);
233 if (ret < 0) {
234 dev_err(&phy->dev, "phy init failed --> %d\n", ret);
235 goto out;
236 }
237 }
238 ++phy->init_count;
239
240out:
241 mutex_unlock(&phy->mutex);
242 phy_pm_runtime_put(phy);
243 return ret;
244}
245EXPORT_SYMBOL_GPL(phy_init);
246
247int phy_exit(struct phy *phy)
248{
249 int ret;
250
251 if (!phy)
252 return 0;
253
254 ret = phy_pm_runtime_get_sync(phy);
255 if (ret < 0 && ret != -ENOTSUPP)
256 return ret;
257 ret = 0;
258
259 mutex_lock(&phy->mutex);
260 if (phy->init_count == 1 && phy->ops->exit) {
261 ret = phy->ops->exit(phy);
262 if (ret < 0) {
263 dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
264 goto out;
265 }
266 }
267 --phy->init_count;
268
269out:
270 mutex_unlock(&phy->mutex);
271 phy_pm_runtime_put(phy);
272 return ret;
273}
274EXPORT_SYMBOL_GPL(phy_exit);
275
276int phy_power_on(struct phy *phy)
277{
278 int ret;
279
280 if (!phy)
281 return 0;
282
283 if (phy->pwr) {
284 ret = regulator_enable(phy->pwr);
285 if (ret)
286 return ret;
287 }
288
289 ret = phy_pm_runtime_get_sync(phy);
290 if (ret < 0 && ret != -ENOTSUPP)
291 return ret;
292 ret = 0;
293
294 mutex_lock(&phy->mutex);
295 if (phy->power_count == 0 && phy->ops->power_on) {
296 ret = phy->ops->power_on(phy);
297 if (ret < 0) {
298 dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
299 goto out;
300 }
301 }
302 ++phy->power_count;
303 mutex_unlock(&phy->mutex);
304 return 0;
305
306out:
307 mutex_unlock(&phy->mutex);
308 phy_pm_runtime_put_sync(phy);
309 if (phy->pwr)
310 regulator_disable(phy->pwr);
311
312 return ret;
313}
314EXPORT_SYMBOL_GPL(phy_power_on);
315
316int phy_power_off(struct phy *phy)
317{
318 int ret;
319
320 if (!phy)
321 return 0;
322
323 mutex_lock(&phy->mutex);
324 if (phy->power_count == 1 && phy->ops->power_off) {
325 ret = phy->ops->power_off(phy);
326 if (ret < 0) {
327 dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
328 mutex_unlock(&phy->mutex);
329 return ret;
330 }
331 }
332 --phy->power_count;
333 mutex_unlock(&phy->mutex);
334 phy_pm_runtime_put(phy);
335
336 if (phy->pwr)
337 regulator_disable(phy->pwr);
338
339 return 0;
340}
341EXPORT_SYMBOL_GPL(phy_power_off);
342
343
344
345
346
347
348
349
350
351
352
353
354static struct phy *_of_phy_get(struct device_node *np, int index)
355{
356 int ret;
357 struct phy_provider *phy_provider;
358 struct phy *phy = NULL;
359 struct of_phandle_args args;
360
361 ret = of_parse_phandle_with_args(np, "phys", "#phy-cells",
362 index, &args);
363 if (ret)
364 return ERR_PTR(-ENODEV);
365
366 mutex_lock(&phy_provider_mutex);
367 phy_provider = of_phy_provider_lookup(args.np);
368 if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
369 phy = ERR_PTR(-EPROBE_DEFER);
370 goto out_unlock;
371 }
372
373 if (!of_device_is_available(args.np)) {
374 dev_warn(phy_provider->dev, "Requested PHY is disabled\n");
375 phy = ERR_PTR(-ENODEV);
376 goto out_put_module;
377 }
378
379 phy = phy_provider->of_xlate(phy_provider->dev, &args);
380
381out_put_module:
382 module_put(phy_provider->owner);
383
384out_unlock:
385 mutex_unlock(&phy_provider_mutex);
386 of_node_put(args.np);
387
388 return phy;
389}
390
391
392
393
394
395
396
397
398
399
400struct phy *of_phy_get(struct device_node *np, const char *con_id)
401{
402 struct phy *phy = NULL;
403 int index = 0;
404
405 if (con_id)
406 index = of_property_match_string(np, "phy-names", con_id);
407
408 phy = _of_phy_get(np, index);
409 if (IS_ERR(phy))
410 return phy;
411
412 if (!try_module_get(phy->ops->owner))
413 return ERR_PTR(-EPROBE_DEFER);
414
415 get_device(&phy->dev);
416
417 return phy;
418}
419EXPORT_SYMBOL_GPL(of_phy_get);
420
421
422
423
424
425
426
427void phy_put(struct phy *phy)
428{
429 if (!phy || IS_ERR(phy))
430 return;
431
432 module_put(phy->ops->owner);
433 put_device(&phy->dev);
434}
435EXPORT_SYMBOL_GPL(phy_put);
436
437
438
439
440
441
442
443
444
445void devm_phy_put(struct device *dev, struct phy *phy)
446{
447 int r;
448
449 if (!phy)
450 return;
451
452 r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
453 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
454}
455EXPORT_SYMBOL_GPL(devm_phy_put);
456
457
458
459
460
461
462
463
464
465
466
467struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
468 *args)
469{
470 struct phy *phy;
471 struct class_dev_iter iter;
472
473 class_dev_iter_init(&iter, phy_class, NULL, NULL);
474 while ((dev = class_dev_iter_next(&iter))) {
475 phy = to_phy(dev);
476 if (args->np != phy->dev.of_node)
477 continue;
478
479 class_dev_iter_exit(&iter);
480 return phy;
481 }
482
483 class_dev_iter_exit(&iter);
484 return ERR_PTR(-ENODEV);
485}
486EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
487
488
489
490
491
492
493
494
495
496
497
498struct phy *phy_get(struct device *dev, const char *string)
499{
500 int index = 0;
501 struct phy *phy;
502
503 if (string == NULL) {
504 dev_WARN(dev, "missing string\n");
505 return ERR_PTR(-EINVAL);
506 }
507
508 if (dev->of_node) {
509 index = of_property_match_string(dev->of_node, "phy-names",
510 string);
511 phy = _of_phy_get(dev->of_node, index);
512 } else {
513 phy = phy_find(dev, string);
514 }
515 if (IS_ERR(phy))
516 return phy;
517
518 if (!try_module_get(phy->ops->owner))
519 return ERR_PTR(-EPROBE_DEFER);
520
521 get_device(&phy->dev);
522
523 return phy;
524}
525EXPORT_SYMBOL_GPL(phy_get);
526
527
528
529
530
531
532
533
534
535
536
537struct phy *phy_optional_get(struct device *dev, const char *string)
538{
539 struct phy *phy = phy_get(dev, string);
540
541 if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
542 phy = NULL;
543
544 return phy;
545}
546EXPORT_SYMBOL_GPL(phy_optional_get);
547
548
549
550
551
552
553
554
555
556
557
558struct phy *devm_phy_get(struct device *dev, const char *string)
559{
560 struct phy **ptr, *phy;
561
562 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
563 if (!ptr)
564 return ERR_PTR(-ENOMEM);
565
566 phy = phy_get(dev, string);
567 if (!IS_ERR(phy)) {
568 *ptr = phy;
569 devres_add(dev, ptr);
570 } else {
571 devres_free(ptr);
572 }
573
574 return phy;
575}
576EXPORT_SYMBOL_GPL(devm_phy_get);
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591struct phy *devm_phy_optional_get(struct device *dev, const char *string)
592{
593 struct phy *phy = devm_phy_get(dev, string);
594
595 if (IS_ERR(phy) && (PTR_ERR(phy) == -ENODEV))
596 phy = NULL;
597
598 return phy;
599}
600EXPORT_SYMBOL_GPL(devm_phy_optional_get);
601
602
603
604
605
606
607
608
609
610
611
612struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
613 const char *con_id)
614{
615 struct phy **ptr, *phy;
616
617 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
618 if (!ptr)
619 return ERR_PTR(-ENOMEM);
620
621 phy = of_phy_get(np, con_id);
622 if (!IS_ERR(phy)) {
623 *ptr = phy;
624 devres_add(dev, ptr);
625 } else {
626 devres_free(ptr);
627 }
628
629 return phy;
630}
631EXPORT_SYMBOL_GPL(devm_of_phy_get);
632
633
634
635
636
637
638
639
640
641
642
643
644
645struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
646 int index)
647{
648 struct phy **ptr, *phy;
649
650 ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
651 if (!ptr)
652 return ERR_PTR(-ENOMEM);
653
654 phy = _of_phy_get(np, index);
655 if (IS_ERR(phy)) {
656 devres_free(ptr);
657 return phy;
658 }
659
660 if (!try_module_get(phy->ops->owner)) {
661 devres_free(ptr);
662 return ERR_PTR(-EPROBE_DEFER);
663 }
664
665 get_device(&phy->dev);
666
667 *ptr = phy;
668 devres_add(dev, ptr);
669
670 return phy;
671}
672EXPORT_SYMBOL_GPL(devm_of_phy_get_by_index);
673
674
675
676
677
678
679
680
681
682struct phy *phy_create(struct device *dev, struct device_node *node,
683 const struct phy_ops *ops)
684{
685 int ret;
686 int id;
687 struct phy *phy;
688
689 if (WARN_ON(!dev))
690 return ERR_PTR(-EINVAL);
691
692 phy = kzalloc(sizeof(*phy), GFP_KERNEL);
693 if (!phy)
694 return ERR_PTR(-ENOMEM);
695
696 id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
697 if (id < 0) {
698 dev_err(dev, "unable to get id\n");
699 ret = id;
700 goto free_phy;
701 }
702
703 device_initialize(&phy->dev);
704 mutex_init(&phy->mutex);
705
706 phy->dev.class = phy_class;
707 phy->dev.parent = dev;
708 phy->dev.of_node = node ?: dev->of_node;
709 phy->id = id;
710 phy->ops = ops;
711
712 ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
713 if (ret)
714 goto put_dev;
715
716
717 phy->pwr = regulator_get_optional(&phy->dev, "phy");
718 if (IS_ERR(phy->pwr)) {
719 ret = PTR_ERR(phy->pwr);
720 if (ret == -EPROBE_DEFER)
721 goto put_dev;
722
723 phy->pwr = NULL;
724 }
725
726 ret = device_add(&phy->dev);
727 if (ret)
728 goto put_dev;
729
730 if (pm_runtime_enabled(dev)) {
731 pm_runtime_enable(&phy->dev);
732 pm_runtime_no_callbacks(&phy->dev);
733 }
734
735 return phy;
736
737put_dev:
738 put_device(&phy->dev);
739 return ERR_PTR(ret);
740
741free_phy:
742 kfree(phy);
743 return ERR_PTR(ret);
744}
745EXPORT_SYMBOL_GPL(phy_create);
746
747
748
749
750
751
752
753
754
755
756
757
758struct phy *devm_phy_create(struct device *dev, struct device_node *node,
759 const struct phy_ops *ops)
760{
761 struct phy **ptr, *phy;
762
763 ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
764 if (!ptr)
765 return ERR_PTR(-ENOMEM);
766
767 phy = phy_create(dev, node, ops);
768 if (!IS_ERR(phy)) {
769 *ptr = phy;
770 devres_add(dev, ptr);
771 } else {
772 devres_free(ptr);
773 }
774
775 return phy;
776}
777EXPORT_SYMBOL_GPL(devm_phy_create);
778
779
780
781
782
783
784
785void phy_destroy(struct phy *phy)
786{
787 pm_runtime_disable(&phy->dev);
788 device_unregister(&phy->dev);
789}
790EXPORT_SYMBOL_GPL(phy_destroy);
791
792
793
794
795
796
797
798
799
800void devm_phy_destroy(struct device *dev, struct phy *phy)
801{
802 int r;
803
804 r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
805 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
806}
807EXPORT_SYMBOL_GPL(devm_phy_destroy);
808
809
810
811
812
813
814
815
816
817
818
819struct phy_provider *__of_phy_provider_register(struct device *dev,
820 struct module *owner, struct phy * (*of_xlate)(struct device *dev,
821 struct of_phandle_args *args))
822{
823 struct phy_provider *phy_provider;
824
825 phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
826 if (!phy_provider)
827 return ERR_PTR(-ENOMEM);
828
829 phy_provider->dev = dev;
830 phy_provider->owner = owner;
831 phy_provider->of_xlate = of_xlate;
832
833 mutex_lock(&phy_provider_mutex);
834 list_add_tail(&phy_provider->list, &phy_provider_list);
835 mutex_unlock(&phy_provider_mutex);
836
837 return phy_provider;
838}
839EXPORT_SYMBOL_GPL(__of_phy_provider_register);
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
855 struct module *owner, struct phy * (*of_xlate)(struct device *dev,
856 struct of_phandle_args *args))
857{
858 struct phy_provider **ptr, *phy_provider;
859
860 ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
861 if (!ptr)
862 return ERR_PTR(-ENOMEM);
863
864 phy_provider = __of_phy_provider_register(dev, owner, of_xlate);
865 if (!IS_ERR(phy_provider)) {
866 *ptr = phy_provider;
867 devres_add(dev, ptr);
868 } else {
869 devres_free(ptr);
870 }
871
872 return phy_provider;
873}
874EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
875
876
877
878
879
880
881
882void of_phy_provider_unregister(struct phy_provider *phy_provider)
883{
884 if (IS_ERR(phy_provider))
885 return;
886
887 mutex_lock(&phy_provider_mutex);
888 list_del(&phy_provider->list);
889 kfree(phy_provider);
890 mutex_unlock(&phy_provider_mutex);
891}
892EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
893
894
895
896
897
898
899
900
901void devm_of_phy_provider_unregister(struct device *dev,
902 struct phy_provider *phy_provider) {
903 int r;
904
905 r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
906 phy_provider);
907 dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
908}
909EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
910
911
912
913
914
915
916
917
918static void phy_release(struct device *dev)
919{
920 struct phy *phy;
921
922 phy = to_phy(dev);
923 dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
924 regulator_put(phy->pwr);
925 ida_simple_remove(&phy_ida, phy->id);
926 kfree(phy);
927}
928
929static int __init phy_core_init(void)
930{
931 phy_class = class_create(THIS_MODULE, "phy");
932 if (IS_ERR(phy_class)) {
933 pr_err("failed to create phy class --> %ld\n",
934 PTR_ERR(phy_class));
935 return PTR_ERR(phy_class);
936 }
937
938 phy_class->dev_release = phy_release;
939
940 return 0;
941}
942module_init(phy_core_init);
943
944static void __exit phy_core_exit(void)
945{
946 class_destroy(phy_class);
947}
948module_exit(phy_core_exit);
949
950MODULE_DESCRIPTION("Generic PHY Framework");
951MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
952MODULE_LICENSE("GPL v2");
953