This source file includes following definitions.
- mdiobus_register_gpiod
- mdiobus_register_reset
- mdiobus_register_device
- mdiobus_unregister_device
- mdiobus_get_phy
- mdiobus_is_registered_device
- mdiobus_alloc_size
- _devm_mdiobus_free
- devm_mdiobus_match
- devm_mdiobus_alloc_size
- devm_mdiobus_free
- mdiobus_release
- of_mdio_find_bus
- of_mdiobus_link_mdiodev
- of_mdiobus_link_mdiodev
- mdiobus_create_device
- __mdiobus_register
- mdiobus_unregister
- mdiobus_free
- mdiobus_scan
- __mdiobus_read
- __mdiobus_write
- mdiobus_read_nested
- mdiobus_read
- mdiobus_write_nested
- mdiobus_write
- mdio_bus_match
- mdio_uevent
- mdio_bus_init
- mdio_bus_exit
1
2
3
4
5
6
7
8
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11 #include <linux/kernel.h>
12 #include <linux/string.h>
13 #include <linux/errno.h>
14 #include <linux/unistd.h>
15 #include <linux/slab.h>
16 #include <linux/interrupt.h>
17 #include <linux/init.h>
18 #include <linux/delay.h>
19 #include <linux/device.h>
20 #include <linux/gpio.h>
21 #include <linux/gpio/consumer.h>
22 #include <linux/of_device.h>
23 #include <linux/of_mdio.h>
24 #include <linux/of_gpio.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/reset.h>
28 #include <linux/skbuff.h>
29 #include <linux/spinlock.h>
30 #include <linux/mm.h>
31 #include <linux/module.h>
32 #include <linux/mii.h>
33 #include <linux/ethtool.h>
34 #include <linux/phy.h>
35 #include <linux/io.h>
36 #include <linux/uaccess.h>
37
38 #define CREATE_TRACE_POINTS
39 #include <trace/events/mdio.h>
40
41 #include "mdio-boardinfo.h"
42
43 static int mdiobus_register_gpiod(struct mdio_device *mdiodev)
44 {
45 int error;
46
47
48 mdiodev->reset_gpio = gpiod_get_optional(&mdiodev->dev,
49 "reset", GPIOD_OUT_LOW);
50 error = PTR_ERR_OR_ZERO(mdiodev->reset_gpio);
51 if (error)
52 return error;
53
54 if (mdiodev->reset_gpio)
55 gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
56
57 return 0;
58 }
59
60 static int mdiobus_register_reset(struct mdio_device *mdiodev)
61 {
62 struct reset_control *reset = NULL;
63
64 if (mdiodev->dev.of_node)
65 reset = of_reset_control_get_exclusive(mdiodev->dev.of_node,
66 "phy");
67 if (IS_ERR(reset)) {
68 if (PTR_ERR(reset) == -ENOENT || PTR_ERR(reset) == -ENOTSUPP)
69 reset = NULL;
70 else
71 return PTR_ERR(reset);
72 }
73
74 mdiodev->reset_ctrl = reset;
75
76 return 0;
77 }
78
79 int mdiobus_register_device(struct mdio_device *mdiodev)
80 {
81 int err;
82
83 if (mdiodev->bus->mdio_map[mdiodev->addr])
84 return -EBUSY;
85
86 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
87 err = mdiobus_register_gpiod(mdiodev);
88 if (err)
89 return err;
90
91 err = mdiobus_register_reset(mdiodev);
92 if (err)
93 return err;
94
95
96 mdio_device_reset(mdiodev, 1);
97 }
98
99 mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;
100
101 return 0;
102 }
103 EXPORT_SYMBOL(mdiobus_register_device);
104
105 int mdiobus_unregister_device(struct mdio_device *mdiodev)
106 {
107 if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
108 return -EINVAL;
109
110 reset_control_put(mdiodev->reset_ctrl);
111
112 mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
113
114 return 0;
115 }
116 EXPORT_SYMBOL(mdiobus_unregister_device);
117
118 struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
119 {
120 struct mdio_device *mdiodev = bus->mdio_map[addr];
121
122 if (!mdiodev)
123 return NULL;
124
125 if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
126 return NULL;
127
128 return container_of(mdiodev, struct phy_device, mdio);
129 }
130 EXPORT_SYMBOL(mdiobus_get_phy);
131
132 bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
133 {
134 return bus->mdio_map[addr];
135 }
136 EXPORT_SYMBOL(mdiobus_is_registered_device);
137
138
139
140
141
142
143
144
145
146 struct mii_bus *mdiobus_alloc_size(size_t size)
147 {
148 struct mii_bus *bus;
149 size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
150 size_t alloc_size;
151 int i;
152
153
154 if (size)
155 alloc_size = aligned_size + size;
156 else
157 alloc_size = sizeof(*bus);
158
159 bus = kzalloc(alloc_size, GFP_KERNEL);
160 if (!bus)
161 return NULL;
162
163 bus->state = MDIOBUS_ALLOCATED;
164 if (size)
165 bus->priv = (void *)bus + aligned_size;
166
167
168 for (i = 0; i < PHY_MAX_ADDR; i++)
169 bus->irq[i] = PHY_POLL;
170
171 return bus;
172 }
173 EXPORT_SYMBOL(mdiobus_alloc_size);
174
175 static void _devm_mdiobus_free(struct device *dev, void *res)
176 {
177 mdiobus_free(*(struct mii_bus **)res);
178 }
179
180 static int devm_mdiobus_match(struct device *dev, void *res, void *data)
181 {
182 struct mii_bus **r = res;
183
184 if (WARN_ON(!r || !*r))
185 return 0;
186
187 return *r == data;
188 }
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204 struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv)
205 {
206 struct mii_bus **ptr, *bus;
207
208 ptr = devres_alloc(_devm_mdiobus_free, sizeof(*ptr), GFP_KERNEL);
209 if (!ptr)
210 return NULL;
211
212
213 bus = mdiobus_alloc_size(sizeof_priv);
214 if (bus) {
215 *ptr = bus;
216 devres_add(dev, ptr);
217 } else {
218 devres_free(ptr);
219 }
220
221 return bus;
222 }
223 EXPORT_SYMBOL_GPL(devm_mdiobus_alloc_size);
224
225
226
227
228
229
230
231
232 void devm_mdiobus_free(struct device *dev, struct mii_bus *bus)
233 {
234 int rc;
235
236 rc = devres_release(dev, _devm_mdiobus_free,
237 devm_mdiobus_match, bus);
238 WARN_ON(rc);
239 }
240 EXPORT_SYMBOL_GPL(devm_mdiobus_free);
241
242
243
244
245
246
247
248
249 static void mdiobus_release(struct device *d)
250 {
251 struct mii_bus *bus = to_mii_bus(d);
252 BUG_ON(bus->state != MDIOBUS_RELEASED &&
253
254 bus->state != MDIOBUS_ALLOCATED);
255 kfree(bus);
256 }
257
258 static struct class mdio_bus_class = {
259 .name = "mdio_bus",
260 .dev_release = mdiobus_release,
261 };
262
263 #if IS_ENABLED(CONFIG_OF_MDIO)
264
265
266
267
268
269
270
271
272
273
274
275
276
277 struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
278 {
279 struct device *d;
280
281 if (!mdio_bus_np)
282 return NULL;
283
284 d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
285 return d ? to_mii_bus(d) : NULL;
286 }
287 EXPORT_SYMBOL(of_mdio_find_bus);
288
289
290
291
292
293
294
295 static void of_mdiobus_link_mdiodev(struct mii_bus *bus,
296 struct mdio_device *mdiodev)
297 {
298 struct device *dev = &mdiodev->dev;
299 struct device_node *child;
300
301 if (dev->of_node || !bus->dev.of_node)
302 return;
303
304 for_each_available_child_of_node(bus->dev.of_node, child) {
305 int addr;
306
307 addr = of_mdio_parse_addr(dev, child);
308 if (addr < 0)
309 continue;
310
311 if (addr == mdiodev->addr) {
312 dev->of_node = child;
313 dev->fwnode = of_fwnode_handle(child);
314 return;
315 }
316 }
317 }
318 #else
319 static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio,
320 struct mdio_device *mdiodev)
321 {
322 }
323 #endif
324
325
326
327
328
329
330
331
332
333 static int mdiobus_create_device(struct mii_bus *bus,
334 struct mdio_board_info *bi)
335 {
336 struct mdio_device *mdiodev;
337 int ret = 0;
338
339 mdiodev = mdio_device_create(bus, bi->mdio_addr);
340 if (IS_ERR(mdiodev))
341 return -ENODEV;
342
343 strncpy(mdiodev->modalias, bi->modalias,
344 sizeof(mdiodev->modalias));
345 mdiodev->bus_match = mdio_device_bus_match;
346 mdiodev->dev.platform_data = (void *)bi->platform_data;
347
348 ret = mdio_device_register(mdiodev);
349 if (ret)
350 mdio_device_free(mdiodev);
351
352 return ret;
353 }
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369 int __mdiobus_register(struct mii_bus *bus, struct module *owner)
370 {
371 struct mdio_device *mdiodev;
372 int i, err;
373 struct gpio_desc *gpiod;
374
375 if (NULL == bus || NULL == bus->name ||
376 NULL == bus->read || NULL == bus->write)
377 return -EINVAL;
378
379 BUG_ON(bus->state != MDIOBUS_ALLOCATED &&
380 bus->state != MDIOBUS_UNREGISTERED);
381
382 bus->owner = owner;
383 bus->dev.parent = bus->parent;
384 bus->dev.class = &mdio_bus_class;
385 bus->dev.groups = NULL;
386 dev_set_name(&bus->dev, "%s", bus->id);
387
388 err = device_register(&bus->dev);
389 if (err) {
390 pr_err("mii_bus %s failed to register\n", bus->id);
391 return -EINVAL;
392 }
393
394 mutex_init(&bus->mdio_lock);
395
396
397 gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_LOW);
398 if (IS_ERR(gpiod)) {
399 dev_err(&bus->dev, "mii_bus %s couldn't get reset GPIO\n",
400 bus->id);
401 device_del(&bus->dev);
402 return PTR_ERR(gpiod);
403 } else if (gpiod) {
404 bus->reset_gpiod = gpiod;
405
406 gpiod_set_value_cansleep(gpiod, 1);
407 udelay(bus->reset_delay_us);
408 gpiod_set_value_cansleep(gpiod, 0);
409 }
410
411 if (bus->reset)
412 bus->reset(bus);
413
414 for (i = 0; i < PHY_MAX_ADDR; i++) {
415 if ((bus->phy_mask & (1 << i)) == 0) {
416 struct phy_device *phydev;
417
418 phydev = mdiobus_scan(bus, i);
419 if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV)) {
420 err = PTR_ERR(phydev);
421 goto error;
422 }
423 }
424 }
425
426 mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device);
427
428 bus->state = MDIOBUS_REGISTERED;
429 pr_info("%s: probed\n", bus->name);
430 return 0;
431
432 error:
433 while (--i >= 0) {
434 mdiodev = bus->mdio_map[i];
435 if (!mdiodev)
436 continue;
437
438 mdiodev->device_remove(mdiodev);
439 mdiodev->device_free(mdiodev);
440 }
441
442
443 if (bus->reset_gpiod)
444 gpiod_set_value_cansleep(bus->reset_gpiod, 1);
445
446 device_del(&bus->dev);
447 return err;
448 }
449 EXPORT_SYMBOL(__mdiobus_register);
450
451 void mdiobus_unregister(struct mii_bus *bus)
452 {
453 struct mdio_device *mdiodev;
454 int i;
455
456 BUG_ON(bus->state != MDIOBUS_REGISTERED);
457 bus->state = MDIOBUS_UNREGISTERED;
458
459 for (i = 0; i < PHY_MAX_ADDR; i++) {
460 mdiodev = bus->mdio_map[i];
461 if (!mdiodev)
462 continue;
463
464 if (mdiodev->reset_gpio)
465 gpiod_put(mdiodev->reset_gpio);
466
467 mdiodev->device_remove(mdiodev);
468 mdiodev->device_free(mdiodev);
469 }
470
471
472 if (bus->reset_gpiod)
473 gpiod_set_value_cansleep(bus->reset_gpiod, 1);
474
475 device_del(&bus->dev);
476 }
477 EXPORT_SYMBOL(mdiobus_unregister);
478
479
480
481
482
483
484
485
486
487 void mdiobus_free(struct mii_bus *bus)
488 {
489
490 if (bus->state == MDIOBUS_ALLOCATED) {
491 kfree(bus);
492 return;
493 }
494
495 BUG_ON(bus->state != MDIOBUS_UNREGISTERED);
496 bus->state = MDIOBUS_RELEASED;
497
498 put_device(&bus->dev);
499 }
500 EXPORT_SYMBOL(mdiobus_free);
501
502
503
504
505
506
507
508
509
510
511
512
513
514 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr)
515 {
516 struct phy_device *phydev;
517 int err;
518
519 phydev = get_phy_device(bus, addr, false);
520 if (IS_ERR(phydev))
521 return phydev;
522
523
524
525
526
527 of_mdiobus_link_mdiodev(bus, &phydev->mdio);
528
529 err = phy_device_register(phydev);
530 if (err) {
531 phy_device_free(phydev);
532 return ERR_PTR(-ENODEV);
533 }
534
535 return phydev;
536 }
537 EXPORT_SYMBOL(mdiobus_scan);
538
539
540
541
542
543
544
545
546
547
548
549 int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
550 {
551 int retval;
552
553 WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));
554
555 retval = bus->read(bus, addr, regnum);
556
557 trace_mdio_access(bus, 1, addr, regnum, retval, retval);
558
559 return retval;
560 }
561 EXPORT_SYMBOL(__mdiobus_read);
562
563
564
565
566
567
568
569
570
571
572
573
574 int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
575 {
576 int err;
577
578 WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));
579
580 err = bus->write(bus, addr, regnum, val);
581
582 trace_mdio_access(bus, 0, addr, regnum, val, err);
583
584 return err;
585 }
586 EXPORT_SYMBOL(__mdiobus_write);
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
602 {
603 int retval;
604
605 BUG_ON(in_interrupt());
606
607 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
608 retval = __mdiobus_read(bus, addr, regnum);
609 mutex_unlock(&bus->mdio_lock);
610
611 return retval;
612 }
613 EXPORT_SYMBOL(mdiobus_read_nested);
614
615
616
617
618
619
620
621
622
623
624
625 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
626 {
627 int retval;
628
629 BUG_ON(in_interrupt());
630
631 mutex_lock(&bus->mdio_lock);
632 retval = __mdiobus_read(bus, addr, regnum);
633 mutex_unlock(&bus->mdio_lock);
634
635 return retval;
636 }
637 EXPORT_SYMBOL(mdiobus_read);
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653 int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
654 {
655 int err;
656
657 BUG_ON(in_interrupt());
658
659 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
660 err = __mdiobus_write(bus, addr, regnum, val);
661 mutex_unlock(&bus->mdio_lock);
662
663 return err;
664 }
665 EXPORT_SYMBOL(mdiobus_write_nested);
666
667
668
669
670
671
672
673
674
675
676
677
678 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
679 {
680 int err;
681
682 BUG_ON(in_interrupt());
683
684 mutex_lock(&bus->mdio_lock);
685 err = __mdiobus_write(bus, addr, regnum, val);
686 mutex_unlock(&bus->mdio_lock);
687
688 return err;
689 }
690 EXPORT_SYMBOL(mdiobus_write);
691
692
693
694
695
696
697
698
699
700
701
702
703 static int mdio_bus_match(struct device *dev, struct device_driver *drv)
704 {
705 struct mdio_device *mdio = to_mdio_device(dev);
706
707 if (of_driver_match_device(dev, drv))
708 return 1;
709
710 if (mdio->bus_match)
711 return mdio->bus_match(dev, drv);
712
713 return 0;
714 }
715
716 static int mdio_uevent(struct device *dev, struct kobj_uevent_env *env)
717 {
718 int rc;
719
720
721 rc = of_device_uevent_modalias(dev, env);
722 if (rc != -ENODEV)
723 return rc;
724
725 return 0;
726 }
727
728 struct bus_type mdio_bus_type = {
729 .name = "mdio_bus",
730 .match = mdio_bus_match,
731 .uevent = mdio_uevent,
732 };
733 EXPORT_SYMBOL(mdio_bus_type);
734
735 int __init mdio_bus_init(void)
736 {
737 int ret;
738
739 ret = class_register(&mdio_bus_class);
740 if (!ret) {
741 ret = bus_register(&mdio_bus_type);
742 if (ret)
743 class_unregister(&mdio_bus_class);
744 }
745
746 return ret;
747 }
748 EXPORT_SYMBOL_GPL(mdio_bus_init);
749
750 #if IS_ENABLED(CONFIG_PHYLIB)
751 void mdio_bus_exit(void)
752 {
753 class_unregister(&mdio_bus_class);
754 bus_unregister(&mdio_bus_type);
755 }
756 EXPORT_SYMBOL_GPL(mdio_bus_exit);
757 #else
758 module_init(mdio_bus_init);
759
760 MODULE_LICENSE("GPL");
761 MODULE_DESCRIPTION("MDIO bus/device layer");
762 #endif