1
2
3
4
5
6
7
8
9
10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12#include <linux/acpi.h>
13#include <linux/bitmap.h>
14#include <linux/delay.h>
15#include <linux/errno.h>
16#include <linux/etherdevice.h>
17#include <linux/ethtool.h>
18#include <linux/init.h>
19#include <linux/interrupt.h>
20#include <linux/io.h>
21#include <linux/kernel.h>
22#include <linux/mdio.h>
23#include <linux/mii.h>
24#include <linux/mm.h>
25#include <linux/module.h>
26#include <linux/netdevice.h>
27#include <linux/phy.h>
28#include <linux/phy_led_triggers.h>
29#include <linux/property.h>
30#include <linux/sfp.h>
31#include <linux/skbuff.h>
32#include <linux/slab.h>
33#include <linux/string.h>
34#include <linux/uaccess.h>
35#include <linux/unistd.h>
36
37MODULE_DESCRIPTION("PHY library");
38MODULE_AUTHOR("Andy Fleming");
39MODULE_LICENSE("GPL");
40
41__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
42EXPORT_SYMBOL_GPL(phy_basic_features);
43
44__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
45EXPORT_SYMBOL_GPL(phy_basic_t1_features);
46
47__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
48EXPORT_SYMBOL_GPL(phy_gbit_features);
49
50__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
51EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
52
53__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
54EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
55
56__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
57EXPORT_SYMBOL_GPL(phy_10gbit_features);
58
59__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
60EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
61
62const int phy_basic_ports_array[3] = {
63 ETHTOOL_LINK_MODE_Autoneg_BIT,
64 ETHTOOL_LINK_MODE_TP_BIT,
65 ETHTOOL_LINK_MODE_MII_BIT,
66};
67EXPORT_SYMBOL_GPL(phy_basic_ports_array);
68
69const int phy_fibre_port_array[1] = {
70 ETHTOOL_LINK_MODE_FIBRE_BIT,
71};
72EXPORT_SYMBOL_GPL(phy_fibre_port_array);
73
74const int phy_all_ports_features_array[7] = {
75 ETHTOOL_LINK_MODE_Autoneg_BIT,
76 ETHTOOL_LINK_MODE_TP_BIT,
77 ETHTOOL_LINK_MODE_MII_BIT,
78 ETHTOOL_LINK_MODE_FIBRE_BIT,
79 ETHTOOL_LINK_MODE_AUI_BIT,
80 ETHTOOL_LINK_MODE_BNC_BIT,
81 ETHTOOL_LINK_MODE_Backplane_BIT,
82};
83EXPORT_SYMBOL_GPL(phy_all_ports_features_array);
84
85const int phy_10_100_features_array[4] = {
86 ETHTOOL_LINK_MODE_10baseT_Half_BIT,
87 ETHTOOL_LINK_MODE_10baseT_Full_BIT,
88 ETHTOOL_LINK_MODE_100baseT_Half_BIT,
89 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
90};
91EXPORT_SYMBOL_GPL(phy_10_100_features_array);
92
93const int phy_basic_t1_features_array[2] = {
94 ETHTOOL_LINK_MODE_TP_BIT,
95 ETHTOOL_LINK_MODE_100baseT1_Full_BIT,
96};
97EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);
98
99const int phy_gbit_features_array[2] = {
100 ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
101 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
102};
103EXPORT_SYMBOL_GPL(phy_gbit_features_array);
104
105const int phy_10gbit_features_array[1] = {
106 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
107};
108EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
109
110static const int phy_10gbit_fec_features_array[1] = {
111 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
112};
113
114__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
115EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
116
117static const int phy_10gbit_full_features_array[] = {
118 ETHTOOL_LINK_MODE_10baseT_Full_BIT,
119 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
120 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
121 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
122};
123
124static void features_init(void)
125{
126
127 linkmode_set_bit_array(phy_basic_ports_array,
128 ARRAY_SIZE(phy_basic_ports_array),
129 phy_basic_features);
130 linkmode_set_bit_array(phy_10_100_features_array,
131 ARRAY_SIZE(phy_10_100_features_array),
132 phy_basic_features);
133
134
135 linkmode_set_bit_array(phy_basic_t1_features_array,
136 ARRAY_SIZE(phy_basic_t1_features_array),
137 phy_basic_t1_features);
138
139
140 linkmode_set_bit_array(phy_basic_ports_array,
141 ARRAY_SIZE(phy_basic_ports_array),
142 phy_gbit_features);
143 linkmode_set_bit_array(phy_10_100_features_array,
144 ARRAY_SIZE(phy_10_100_features_array),
145 phy_gbit_features);
146 linkmode_set_bit_array(phy_gbit_features_array,
147 ARRAY_SIZE(phy_gbit_features_array),
148 phy_gbit_features);
149
150
151 linkmode_set_bit_array(phy_basic_ports_array,
152 ARRAY_SIZE(phy_basic_ports_array),
153 phy_gbit_fibre_features);
154 linkmode_set_bit_array(phy_10_100_features_array,
155 ARRAY_SIZE(phy_10_100_features_array),
156 phy_gbit_fibre_features);
157 linkmode_set_bit_array(phy_gbit_features_array,
158 ARRAY_SIZE(phy_gbit_features_array),
159 phy_gbit_fibre_features);
160 linkmode_set_bit_array(phy_fibre_port_array,
161 ARRAY_SIZE(phy_fibre_port_array),
162 phy_gbit_fibre_features);
163
164
165 linkmode_set_bit_array(phy_all_ports_features_array,
166 ARRAY_SIZE(phy_all_ports_features_array),
167 phy_gbit_all_ports_features);
168 linkmode_set_bit_array(phy_10_100_features_array,
169 ARRAY_SIZE(phy_10_100_features_array),
170 phy_gbit_all_ports_features);
171 linkmode_set_bit_array(phy_gbit_features_array,
172 ARRAY_SIZE(phy_gbit_features_array),
173 phy_gbit_all_ports_features);
174
175
176 linkmode_set_bit_array(phy_all_ports_features_array,
177 ARRAY_SIZE(phy_all_ports_features_array),
178 phy_10gbit_features);
179 linkmode_set_bit_array(phy_10_100_features_array,
180 ARRAY_SIZE(phy_10_100_features_array),
181 phy_10gbit_features);
182 linkmode_set_bit_array(phy_gbit_features_array,
183 ARRAY_SIZE(phy_gbit_features_array),
184 phy_10gbit_features);
185 linkmode_set_bit_array(phy_10gbit_features_array,
186 ARRAY_SIZE(phy_10gbit_features_array),
187 phy_10gbit_features);
188
189
190 linkmode_set_bit_array(phy_all_ports_features_array,
191 ARRAY_SIZE(phy_all_ports_features_array),
192 phy_10gbit_full_features);
193 linkmode_set_bit_array(phy_10gbit_full_features_array,
194 ARRAY_SIZE(phy_10gbit_full_features_array),
195 phy_10gbit_full_features);
196
197 linkmode_set_bit_array(phy_10gbit_fec_features_array,
198 ARRAY_SIZE(phy_10gbit_fec_features_array),
199 phy_10gbit_fec_features);
200}
201
202void phy_device_free(struct phy_device *phydev)
203{
204 put_device(&phydev->mdio.dev);
205}
206EXPORT_SYMBOL(phy_device_free);
207
208static void phy_mdio_device_free(struct mdio_device *mdiodev)
209{
210 struct phy_device *phydev;
211
212 phydev = container_of(mdiodev, struct phy_device, mdio);
213 phy_device_free(phydev);
214}
215
216static void phy_device_release(struct device *dev)
217{
218 kfree(to_phy_device(dev));
219}
220
221static void phy_mdio_device_remove(struct mdio_device *mdiodev)
222{
223 struct phy_device *phydev;
224
225 phydev = container_of(mdiodev, struct phy_device, mdio);
226 phy_device_remove(phydev);
227}
228
229static struct phy_driver genphy_driver;
230
231static LIST_HEAD(phy_fixup_list);
232static DEFINE_MUTEX(phy_fixup_lock);
233
234static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
235{
236 struct device_driver *drv = phydev->mdio.dev.driver;
237 struct phy_driver *phydrv = to_phy_driver(drv);
238 struct net_device *netdev = phydev->attached_dev;
239
240 if (!drv || !phydrv->suspend)
241 return false;
242
243
244
245
246
247
248 if (!netdev)
249 goto out;
250
251 if (netdev->wol_enabled)
252 return false;
253
254
255
256
257
258
259 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
260 return false;
261
262
263
264
265
266 if (device_may_wakeup(&netdev->dev))
267 return false;
268
269out:
270 return !phydev->suspended;
271}
272
273static __maybe_unused int mdio_bus_phy_suspend(struct device *dev)
274{
275 struct phy_device *phydev = to_phy_device(dev);
276
277 if (phydev->mac_managed_pm)
278 return 0;
279
280
281
282
283
284
285 if (phydev->attached_dev && phydev->adjust_link)
286 phy_stop_machine(phydev);
287
288 if (!mdio_bus_phy_may_suspend(phydev))
289 return 0;
290
291 phydev->suspended_by_mdio_bus = 1;
292
293 return phy_suspend(phydev);
294}
295
296static __maybe_unused int mdio_bus_phy_resume(struct device *dev)
297{
298 struct phy_device *phydev = to_phy_device(dev);
299 int ret;
300
301 if (phydev->mac_managed_pm)
302 return 0;
303
304 if (!phydev->suspended_by_mdio_bus)
305 goto no_resume;
306
307 phydev->suspended_by_mdio_bus = 0;
308
309 ret = phy_init_hw(phydev);
310 if (ret < 0)
311 return ret;
312
313 ret = phy_resume(phydev);
314 if (ret < 0)
315 return ret;
316no_resume:
317 if (phydev->attached_dev && phydev->adjust_link)
318 phy_start_machine(phydev);
319
320 return 0;
321}
322
323static SIMPLE_DEV_PM_OPS(mdio_bus_phy_pm_ops, mdio_bus_phy_suspend,
324 mdio_bus_phy_resume);
325
326
327
328
329
330
331
332
333
334
335int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
336 int (*run)(struct phy_device *))
337{
338 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
339
340 if (!fixup)
341 return -ENOMEM;
342
343 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
344 fixup->phy_uid = phy_uid;
345 fixup->phy_uid_mask = phy_uid_mask;
346 fixup->run = run;
347
348 mutex_lock(&phy_fixup_lock);
349 list_add_tail(&fixup->list, &phy_fixup_list);
350 mutex_unlock(&phy_fixup_lock);
351
352 return 0;
353}
354EXPORT_SYMBOL(phy_register_fixup);
355
356
357int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
358 int (*run)(struct phy_device *))
359{
360 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
361}
362EXPORT_SYMBOL(phy_register_fixup_for_uid);
363
364
365int phy_register_fixup_for_id(const char *bus_id,
366 int (*run)(struct phy_device *))
367{
368 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
369}
370EXPORT_SYMBOL(phy_register_fixup_for_id);
371
372
373
374
375
376
377
378int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
379{
380 struct list_head *pos, *n;
381 struct phy_fixup *fixup;
382 int ret;
383
384 ret = -ENODEV;
385
386 mutex_lock(&phy_fixup_lock);
387 list_for_each_safe(pos, n, &phy_fixup_list) {
388 fixup = list_entry(pos, struct phy_fixup, list);
389
390 if ((!strcmp(fixup->bus_id, bus_id)) &&
391 ((fixup->phy_uid & phy_uid_mask) ==
392 (phy_uid & phy_uid_mask))) {
393 list_del(&fixup->list);
394 kfree(fixup);
395 ret = 0;
396 break;
397 }
398 }
399 mutex_unlock(&phy_fixup_lock);
400
401 return ret;
402}
403EXPORT_SYMBOL(phy_unregister_fixup);
404
405
406int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
407{
408 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
409}
410EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
411
412
413int phy_unregister_fixup_for_id(const char *bus_id)
414{
415 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
416}
417EXPORT_SYMBOL(phy_unregister_fixup_for_id);
418
419
420
421
422static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
423{
424 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
425 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
426 return 0;
427
428 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
429 (phydev->phy_id & fixup->phy_uid_mask))
430 if (fixup->phy_uid != PHY_ANY_UID)
431 return 0;
432
433 return 1;
434}
435
436
437static int phy_scan_fixups(struct phy_device *phydev)
438{
439 struct phy_fixup *fixup;
440
441 mutex_lock(&phy_fixup_lock);
442 list_for_each_entry(fixup, &phy_fixup_list, list) {
443 if (phy_needs_fixup(phydev, fixup)) {
444 int err = fixup->run(phydev);
445
446 if (err < 0) {
447 mutex_unlock(&phy_fixup_lock);
448 return err;
449 }
450 phydev->has_fixups = true;
451 }
452 }
453 mutex_unlock(&phy_fixup_lock);
454
455 return 0;
456}
457
458static int phy_bus_match(struct device *dev, struct device_driver *drv)
459{
460 struct phy_device *phydev = to_phy_device(dev);
461 struct phy_driver *phydrv = to_phy_driver(drv);
462 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
463 int i;
464
465 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
466 return 0;
467
468 if (phydrv->match_phy_device)
469 return phydrv->match_phy_device(phydev);
470
471 if (phydev->is_c45) {
472 for (i = 1; i < num_ids; i++) {
473 if (phydev->c45_ids.device_ids[i] == 0xffffffff)
474 continue;
475
476 if ((phydrv->phy_id & phydrv->phy_id_mask) ==
477 (phydev->c45_ids.device_ids[i] &
478 phydrv->phy_id_mask))
479 return 1;
480 }
481 return 0;
482 } else {
483 return (phydrv->phy_id & phydrv->phy_id_mask) ==
484 (phydev->phy_id & phydrv->phy_id_mask);
485 }
486}
487
488static ssize_t
489phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
490{
491 struct phy_device *phydev = to_phy_device(dev);
492
493 return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
494}
495static DEVICE_ATTR_RO(phy_id);
496
497static ssize_t
498phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
499{
500 struct phy_device *phydev = to_phy_device(dev);
501 const char *mode = NULL;
502
503 if (phy_is_internal(phydev))
504 mode = "internal";
505 else
506 mode = phy_modes(phydev->interface);
507
508 return sprintf(buf, "%s\n", mode);
509}
510static DEVICE_ATTR_RO(phy_interface);
511
512static ssize_t
513phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
514 char *buf)
515{
516 struct phy_device *phydev = to_phy_device(dev);
517
518 return sprintf(buf, "%d\n", phydev->has_fixups);
519}
520static DEVICE_ATTR_RO(phy_has_fixups);
521
522static ssize_t phy_dev_flags_show(struct device *dev,
523 struct device_attribute *attr,
524 char *buf)
525{
526 struct phy_device *phydev = to_phy_device(dev);
527
528 return sprintf(buf, "0x%08x\n", phydev->dev_flags);
529}
530static DEVICE_ATTR_RO(phy_dev_flags);
531
532static struct attribute *phy_dev_attrs[] = {
533 &dev_attr_phy_id.attr,
534 &dev_attr_phy_interface.attr,
535 &dev_attr_phy_has_fixups.attr,
536 &dev_attr_phy_dev_flags.attr,
537 NULL,
538};
539ATTRIBUTE_GROUPS(phy_dev);
540
541static const struct device_type mdio_bus_phy_type = {
542 .name = "PHY",
543 .groups = phy_dev_groups,
544 .release = phy_device_release,
545 .pm = pm_ptr(&mdio_bus_phy_pm_ops),
546};
547
548static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)
549{
550 int ret;
551
552 ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
553 MDIO_ID_ARGS(phy_id));
554
555
556
557
558
559 if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
560 phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n",
561 ret, (unsigned long)phy_id);
562 return ret;
563 }
564
565 return 0;
566}
567
568struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,
569 bool is_c45,
570 struct phy_c45_device_ids *c45_ids)
571{
572 struct phy_device *dev;
573 struct mdio_device *mdiodev;
574 int ret = 0;
575
576
577 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
578 if (!dev)
579 return ERR_PTR(-ENOMEM);
580
581 mdiodev = &dev->mdio;
582 mdiodev->dev.parent = &bus->dev;
583 mdiodev->dev.bus = &mdio_bus_type;
584 mdiodev->dev.type = &mdio_bus_phy_type;
585 mdiodev->bus = bus;
586 mdiodev->bus_match = phy_bus_match;
587 mdiodev->addr = addr;
588 mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
589 mdiodev->device_free = phy_mdio_device_free;
590 mdiodev->device_remove = phy_mdio_device_remove;
591
592 dev->speed = SPEED_UNKNOWN;
593 dev->duplex = DUPLEX_UNKNOWN;
594 dev->pause = 0;
595 dev->asym_pause = 0;
596 dev->link = 0;
597 dev->port = PORT_TP;
598 dev->interface = PHY_INTERFACE_MODE_GMII;
599
600 dev->autoneg = AUTONEG_ENABLE;
601
602 dev->is_c45 = is_c45;
603 dev->phy_id = phy_id;
604 if (c45_ids)
605 dev->c45_ids = *c45_ids;
606 dev->irq = bus->irq[addr];
607
608 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
609 device_initialize(&mdiodev->dev);
610
611 dev->state = PHY_DOWN;
612
613 mutex_init(&dev->lock);
614 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
615
616
617
618
619
620
621
622
623
624
625
626 if (is_c45 && c45_ids) {
627 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
628 int i;
629
630 for (i = 1; i < num_ids; i++) {
631 if (c45_ids->device_ids[i] == 0xffffffff)
632 continue;
633
634 ret = phy_request_driver_module(dev,
635 c45_ids->device_ids[i]);
636 if (ret)
637 break;
638 }
639 } else {
640 ret = phy_request_driver_module(dev, phy_id);
641 }
642
643 if (ret) {
644 put_device(&mdiodev->dev);
645 dev = ERR_PTR(ret);
646 }
647
648 return dev;
649}
650EXPORT_SYMBOL(phy_device_create);
651
652
653
654
655
656
657
658
659
660
661
662
663static int phy_c45_probe_present(struct mii_bus *bus, int prtad, int devad)
664{
665 int stat2;
666
667 stat2 = mdiobus_c45_read(bus, prtad, devad, MDIO_STAT2);
668 if (stat2 < 0)
669 return stat2;
670
671 return (stat2 & MDIO_STAT2_DEVPRST) == MDIO_STAT2_DEVPRST_VAL;
672}
673
674
675
676
677
678
679
680
681
682
683
684
685static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
686 u32 *devices_in_package)
687{
688 int phy_reg;
689
690 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS2);
691 if (phy_reg < 0)
692 return -EIO;
693 *devices_in_package = phy_reg << 16;
694
695 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS1);
696 if (phy_reg < 0)
697 return -EIO;
698 *devices_in_package |= phy_reg;
699
700 return 0;
701}
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716static int get_phy_c45_ids(struct mii_bus *bus, int addr,
717 struct phy_c45_device_ids *c45_ids)
718{
719 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
720 u32 devs_in_pkg = 0;
721 int i, ret, phy_reg;
722
723
724
725
726 for (i = 1; i < MDIO_MMD_NUM && (devs_in_pkg == 0 ||
727 (devs_in_pkg & 0x1fffffff) == 0x1fffffff); i++) {
728 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {
729
730
731
732
733
734
735 ret = phy_c45_probe_present(bus, addr, i);
736 if (ret < 0)
737 return -EIO;
738
739 if (!ret)
740 continue;
741 }
742 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, &devs_in_pkg);
743 if (phy_reg < 0)
744 return -EIO;
745 }
746
747 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff) {
748
749
750
751
752 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, &devs_in_pkg);
753 if (phy_reg < 0)
754 return -EIO;
755
756
757 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff)
758 return -ENODEV;
759 }
760
761
762 for (i = 1; i < num_ids; i++) {
763 if (!(devs_in_pkg & (1 << i)))
764 continue;
765
766 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {
767
768
769
770
771 ret = phy_c45_probe_present(bus, addr, i);
772 if (ret < 0)
773 return ret;
774
775 if (!ret)
776 continue;
777 }
778
779 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID1);
780 if (phy_reg < 0)
781 return -EIO;
782 c45_ids->device_ids[i] = phy_reg << 16;
783
784 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID2);
785 if (phy_reg < 0)
786 return -EIO;
787 c45_ids->device_ids[i] |= phy_reg;
788 }
789
790 c45_ids->devices_in_package = devs_in_pkg;
791
792 c45_ids->mmds_present = devs_in_pkg & ~BIT(0);
793
794 return 0;
795}
796
797
798
799
800
801
802
803
804
805
806
807
808static int get_phy_c22_id(struct mii_bus *bus, int addr, u32 *phy_id)
809{
810 int phy_reg;
811
812
813 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
814 if (phy_reg < 0) {
815
816 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
817 }
818
819 *phy_id = phy_reg << 16;
820
821
822 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
823 if (phy_reg < 0) {
824
825 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
826 }
827
828 *phy_id |= phy_reg;
829
830
831 if ((*phy_id & 0x1fffffff) == 0x1fffffff)
832 return -ENODEV;
833
834 return 0;
835}
836
837
838
839
840int fwnode_get_phy_id(struct fwnode_handle *fwnode, u32 *phy_id)
841{
842 unsigned int upper, lower;
843 const char *cp;
844 int ret;
845
846 ret = fwnode_property_read_string(fwnode, "compatible", &cp);
847 if (ret)
848 return ret;
849
850 if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) != 2)
851 return -EINVAL;
852
853 *phy_id = ((upper & GENMASK(15, 0)) << 16) | (lower & GENMASK(15, 0));
854 return 0;
855}
856EXPORT_SYMBOL(fwnode_get_phy_id);
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
878{
879 struct phy_c45_device_ids c45_ids;
880 u32 phy_id = 0;
881 int r;
882
883 c45_ids.devices_in_package = 0;
884 c45_ids.mmds_present = 0;
885 memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids));
886
887 if (is_c45)
888 r = get_phy_c45_ids(bus, addr, &c45_ids);
889 else
890 r = get_phy_c22_id(bus, addr, &phy_id);
891
892 if (r)
893 return ERR_PTR(r);
894
895
896
897
898
899
900 if (!is_c45 && phy_id == 0 && bus->probe_capabilities >= MDIOBUS_C45) {
901 r = get_phy_c45_ids(bus, addr, &c45_ids);
902 if (!r)
903 return phy_device_create(bus, addr, phy_id,
904 true, &c45_ids);
905 }
906
907 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
908}
909EXPORT_SYMBOL(get_phy_device);
910
911
912
913
914
915int phy_device_register(struct phy_device *phydev)
916{
917 int err;
918
919 err = mdiobus_register_device(&phydev->mdio);
920 if (err)
921 return err;
922
923
924 phy_device_reset(phydev, 0);
925
926
927 err = phy_scan_fixups(phydev);
928 if (err) {
929 phydev_err(phydev, "failed to initialize\n");
930 goto out;
931 }
932
933 err = device_add(&phydev->mdio.dev);
934 if (err) {
935 phydev_err(phydev, "failed to add\n");
936 goto out;
937 }
938
939 return 0;
940
941 out:
942
943 phy_device_reset(phydev, 1);
944
945 mdiobus_unregister_device(&phydev->mdio);
946 return err;
947}
948EXPORT_SYMBOL(phy_device_register);
949
950
951
952
953
954
955
956
957
958void phy_device_remove(struct phy_device *phydev)
959{
960 unregister_mii_timestamper(phydev->mii_ts);
961
962 device_del(&phydev->mdio.dev);
963
964
965 phy_device_reset(phydev, 1);
966
967 mdiobus_unregister_device(&phydev->mdio);
968}
969EXPORT_SYMBOL(phy_device_remove);
970
971
972
973
974
975
976
977
978int phy_get_c45_ids(struct phy_device *phydev)
979{
980 return get_phy_c45_ids(phydev->mdio.bus, phydev->mdio.addr,
981 &phydev->c45_ids);
982}
983EXPORT_SYMBOL(phy_get_c45_ids);
984
985
986
987
988
989struct phy_device *phy_find_first(struct mii_bus *bus)
990{
991 struct phy_device *phydev;
992 int addr;
993
994 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
995 phydev = mdiobus_get_phy(bus, addr);
996 if (phydev)
997 return phydev;
998 }
999 return NULL;
1000}
1001EXPORT_SYMBOL(phy_find_first);
1002
1003static void phy_link_change(struct phy_device *phydev, bool up)
1004{
1005 struct net_device *netdev = phydev->attached_dev;
1006
1007 if (up)
1008 netif_carrier_on(netdev);
1009 else
1010 netif_carrier_off(netdev);
1011 phydev->adjust_link(netdev);
1012 if (phydev->mii_ts && phydev->mii_ts->link_state)
1013 phydev->mii_ts->link_state(phydev->mii_ts, phydev);
1014}
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028static void phy_prepare_link(struct phy_device *phydev,
1029 void (*handler)(struct net_device *))
1030{
1031 phydev->adjust_link = handler;
1032}
1033
1034
1035
1036
1037
1038
1039
1040
1041int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
1042 void (*handler)(struct net_device *),
1043 phy_interface_t interface)
1044{
1045 int rc;
1046
1047 if (!dev)
1048 return -EINVAL;
1049
1050 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1051 if (rc)
1052 return rc;
1053
1054 phy_prepare_link(phydev, handler);
1055 if (phy_interrupt_is_valid(phydev))
1056 phy_request_interrupt(phydev);
1057
1058 return 0;
1059}
1060EXPORT_SYMBOL(phy_connect_direct);
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
1078 void (*handler)(struct net_device *),
1079 phy_interface_t interface)
1080{
1081 struct phy_device *phydev;
1082 struct device *d;
1083 int rc;
1084
1085
1086
1087
1088 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
1089 if (!d) {
1090 pr_err("PHY %s not found\n", bus_id);
1091 return ERR_PTR(-ENODEV);
1092 }
1093 phydev = to_phy_device(d);
1094
1095 rc = phy_connect_direct(dev, phydev, handler, interface);
1096 put_device(d);
1097 if (rc)
1098 return ERR_PTR(rc);
1099
1100 return phydev;
1101}
1102EXPORT_SYMBOL(phy_connect);
1103
1104
1105
1106
1107
1108
1109void phy_disconnect(struct phy_device *phydev)
1110{
1111 if (phy_is_started(phydev))
1112 phy_stop(phydev);
1113
1114 if (phy_interrupt_is_valid(phydev))
1115 phy_free_interrupt(phydev);
1116
1117 phydev->adjust_link = NULL;
1118
1119 phy_detach(phydev);
1120}
1121EXPORT_SYMBOL(phy_disconnect);
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141static int phy_poll_reset(struct phy_device *phydev)
1142{
1143
1144 int ret, val;
1145
1146 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
1147 50000, 600000, true);
1148 if (ret)
1149 return ret;
1150
1151
1152
1153 msleep(1);
1154 return 0;
1155}
1156
1157int phy_init_hw(struct phy_device *phydev)
1158{
1159 int ret = 0;
1160
1161
1162 phy_device_reset(phydev, 0);
1163
1164 if (!phydev->drv)
1165 return 0;
1166
1167 if (phydev->drv->soft_reset) {
1168 ret = phydev->drv->soft_reset(phydev);
1169
1170 if (!ret)
1171 phydev->suspended = 0;
1172 }
1173
1174 if (ret < 0)
1175 return ret;
1176
1177 ret = phy_scan_fixups(phydev);
1178 if (ret < 0)
1179 return ret;
1180
1181 if (phydev->drv->config_init) {
1182 ret = phydev->drv->config_init(phydev);
1183 if (ret < 0)
1184 return ret;
1185 }
1186
1187 if (phydev->drv->config_intr) {
1188 ret = phydev->drv->config_intr(phydev);
1189 if (ret < 0)
1190 return ret;
1191 }
1192
1193 return 0;
1194}
1195EXPORT_SYMBOL(phy_init_hw);
1196
1197void phy_attached_info(struct phy_device *phydev)
1198{
1199 phy_attached_print(phydev, NULL);
1200}
1201EXPORT_SYMBOL(phy_attached_info);
1202
1203#define ATTACHED_FMT "attached PHY driver %s(mii_bus:phy_addr=%s, irq=%s)"
1204char *phy_attached_info_irq(struct phy_device *phydev)
1205{
1206 char *irq_str;
1207 char irq_num[8];
1208
1209 switch(phydev->irq) {
1210 case PHY_POLL:
1211 irq_str = "POLL";
1212 break;
1213 case PHY_MAC_INTERRUPT:
1214 irq_str = "MAC";
1215 break;
1216 default:
1217 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1218 irq_str = irq_num;
1219 break;
1220 }
1221
1222 return kasprintf(GFP_KERNEL, "%s", irq_str);
1223}
1224EXPORT_SYMBOL(phy_attached_info_irq);
1225
1226void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1227{
1228 const char *unbound = phydev->drv ? "" : "[unbound] ";
1229 char *irq_str = phy_attached_info_irq(phydev);
1230
1231 if (!fmt) {
1232 phydev_info(phydev, ATTACHED_FMT "\n", unbound,
1233 phydev_name(phydev), irq_str);
1234 } else {
1235 va_list ap;
1236
1237 phydev_info(phydev, ATTACHED_FMT, unbound,
1238 phydev_name(phydev), irq_str);
1239
1240 va_start(ap, fmt);
1241 vprintk(fmt, ap);
1242 va_end(ap);
1243 }
1244 kfree(irq_str);
1245}
1246EXPORT_SYMBOL(phy_attached_print);
1247
1248static void phy_sysfs_create_links(struct phy_device *phydev)
1249{
1250 struct net_device *dev = phydev->attached_dev;
1251 int err;
1252
1253 if (!dev)
1254 return;
1255
1256 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1257 "attached_dev");
1258 if (err)
1259 return;
1260
1261 err = sysfs_create_link_nowarn(&dev->dev.kobj,
1262 &phydev->mdio.dev.kobj,
1263 "phydev");
1264 if (err) {
1265 dev_err(&dev->dev, "could not add device link to %s err %d\n",
1266 kobject_name(&phydev->mdio.dev.kobj),
1267 err);
1268
1269
1270
1271 }
1272
1273 phydev->sysfs_links = true;
1274}
1275
1276static ssize_t
1277phy_standalone_show(struct device *dev, struct device_attribute *attr,
1278 char *buf)
1279{
1280 struct phy_device *phydev = to_phy_device(dev);
1281
1282 return sprintf(buf, "%d\n", !phydev->attached_dev);
1283}
1284static DEVICE_ATTR_RO(phy_standalone);
1285
1286
1287
1288
1289
1290
1291
1292
1293void phy_sfp_attach(void *upstream, struct sfp_bus *bus)
1294{
1295 struct phy_device *phydev = upstream;
1296
1297 if (phydev->attached_dev)
1298 phydev->attached_dev->sfp_bus = bus;
1299 phydev->sfp_bus_attached = true;
1300}
1301EXPORT_SYMBOL(phy_sfp_attach);
1302
1303
1304
1305
1306
1307
1308
1309
1310void phy_sfp_detach(void *upstream, struct sfp_bus *bus)
1311{
1312 struct phy_device *phydev = upstream;
1313
1314 if (phydev->attached_dev)
1315 phydev->attached_dev->sfp_bus = NULL;
1316 phydev->sfp_bus_attached = false;
1317}
1318EXPORT_SYMBOL(phy_sfp_detach);
1319
1320
1321
1322
1323
1324
1325int phy_sfp_probe(struct phy_device *phydev,
1326 const struct sfp_upstream_ops *ops)
1327{
1328 struct sfp_bus *bus;
1329 int ret = 0;
1330
1331 if (phydev->mdio.dev.fwnode) {
1332 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1333 if (IS_ERR(bus))
1334 return PTR_ERR(bus);
1335
1336 phydev->sfp_bus = bus;
1337
1338 ret = sfp_bus_add_upstream(bus, phydev, ops);
1339 sfp_bus_put(bus);
1340 }
1341 return ret;
1342}
1343EXPORT_SYMBOL(phy_sfp_probe);
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1361 u32 flags, phy_interface_t interface)
1362{
1363 struct mii_bus *bus = phydev->mdio.bus;
1364 struct device *d = &phydev->mdio.dev;
1365 struct module *ndev_owner = NULL;
1366 bool using_genphy = false;
1367 int err;
1368
1369
1370
1371
1372
1373
1374 if (dev)
1375 ndev_owner = dev->dev.parent->driver->owner;
1376 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
1377 phydev_err(phydev, "failed to get the bus module\n");
1378 return -EIO;
1379 }
1380
1381 get_device(d);
1382
1383
1384
1385
1386 if (!d->driver) {
1387 if (phydev->is_c45)
1388 d->driver = &genphy_c45_driver.mdiodrv.driver;
1389 else
1390 d->driver = &genphy_driver.mdiodrv.driver;
1391
1392 using_genphy = true;
1393 }
1394
1395 if (!try_module_get(d->driver->owner)) {
1396 phydev_err(phydev, "failed to get the device driver module\n");
1397 err = -EIO;
1398 goto error_put_device;
1399 }
1400
1401 if (using_genphy) {
1402 err = d->driver->probe(d);
1403 if (err >= 0)
1404 err = device_bind_driver(d);
1405
1406 if (err)
1407 goto error_module_put;
1408 }
1409
1410 if (phydev->attached_dev) {
1411 dev_err(&dev->dev, "PHY already attached\n");
1412 err = -EBUSY;
1413 goto error;
1414 }
1415
1416 phydev->phy_link_change = phy_link_change;
1417 if (dev) {
1418 phydev->attached_dev = dev;
1419 dev->phydev = phydev;
1420
1421 if (phydev->sfp_bus_attached)
1422 dev->sfp_bus = phydev->sfp_bus;
1423 else if (dev->sfp_bus)
1424 phydev->is_on_sfp_module = true;
1425 }
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435 phydev->sysfs_links = false;
1436
1437 phy_sysfs_create_links(phydev);
1438
1439 if (!phydev->attached_dev) {
1440 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1441 &dev_attr_phy_standalone.attr);
1442 if (err)
1443 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1444 }
1445
1446 phydev->dev_flags |= flags;
1447
1448 phydev->interface = interface;
1449
1450 phydev->state = PHY_READY;
1451
1452
1453
1454
1455
1456
1457 if (using_genphy)
1458 phydev->port = PORT_MII;
1459
1460
1461
1462
1463 if (dev)
1464 netif_carrier_off(phydev->attached_dev);
1465
1466
1467
1468
1469
1470 err = phy_init_hw(phydev);
1471 if (err)
1472 goto error;
1473
1474 err = phy_disable_interrupts(phydev);
1475 if (err)
1476 return err;
1477
1478 phy_resume(phydev);
1479 phy_led_triggers_register(phydev);
1480
1481 return err;
1482
1483error:
1484
1485 phy_detach(phydev);
1486 return err;
1487
1488error_module_put:
1489 module_put(d->driver->owner);
1490error_put_device:
1491 put_device(d);
1492 if (ndev_owner != bus->owner)
1493 module_put(bus->owner);
1494 return err;
1495}
1496EXPORT_SYMBOL(phy_attach_direct);
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1508 phy_interface_t interface)
1509{
1510 struct bus_type *bus = &mdio_bus_type;
1511 struct phy_device *phydev;
1512 struct device *d;
1513 int rc;
1514
1515 if (!dev)
1516 return ERR_PTR(-EINVAL);
1517
1518
1519
1520
1521 d = bus_find_device_by_name(bus, NULL, bus_id);
1522 if (!d) {
1523 pr_err("PHY %s not found\n", bus_id);
1524 return ERR_PTR(-ENODEV);
1525 }
1526 phydev = to_phy_device(d);
1527
1528 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1529 put_device(d);
1530 if (rc)
1531 return ERR_PTR(rc);
1532
1533 return phydev;
1534}
1535EXPORT_SYMBOL(phy_attach);
1536
1537static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1538 struct device_driver *driver)
1539{
1540 struct device *d = &phydev->mdio.dev;
1541 bool ret = false;
1542
1543 if (!phydev->drv)
1544 return ret;
1545
1546 get_device(d);
1547 ret = d->driver == driver;
1548 put_device(d);
1549
1550 return ret;
1551}
1552
1553bool phy_driver_is_genphy(struct phy_device *phydev)
1554{
1555 return phy_driver_is_genphy_kind(phydev,
1556 &genphy_driver.mdiodrv.driver);
1557}
1558EXPORT_SYMBOL_GPL(phy_driver_is_genphy);
1559
1560bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1561{
1562 return phy_driver_is_genphy_kind(phydev,
1563 &genphy_c45_driver.mdiodrv.driver);
1564}
1565EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593int phy_package_join(struct phy_device *phydev, int addr, size_t priv_size)
1594{
1595 struct mii_bus *bus = phydev->mdio.bus;
1596 struct phy_package_shared *shared;
1597 int ret;
1598
1599 if (addr < 0 || addr >= PHY_MAX_ADDR)
1600 return -EINVAL;
1601
1602 mutex_lock(&bus->shared_lock);
1603 shared = bus->shared[addr];
1604 if (!shared) {
1605 ret = -ENOMEM;
1606 shared = kzalloc(sizeof(*shared), GFP_KERNEL);
1607 if (!shared)
1608 goto err_unlock;
1609 if (priv_size) {
1610 shared->priv = kzalloc(priv_size, GFP_KERNEL);
1611 if (!shared->priv)
1612 goto err_free;
1613 shared->priv_size = priv_size;
1614 }
1615 shared->addr = addr;
1616 refcount_set(&shared->refcnt, 1);
1617 bus->shared[addr] = shared;
1618 } else {
1619 ret = -EINVAL;
1620 if (priv_size && priv_size != shared->priv_size)
1621 goto err_unlock;
1622 refcount_inc(&shared->refcnt);
1623 }
1624 mutex_unlock(&bus->shared_lock);
1625
1626 phydev->shared = shared;
1627
1628 return 0;
1629
1630err_free:
1631 kfree(shared);
1632err_unlock:
1633 mutex_unlock(&bus->shared_lock);
1634 return ret;
1635}
1636EXPORT_SYMBOL_GPL(phy_package_join);
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646void phy_package_leave(struct phy_device *phydev)
1647{
1648 struct phy_package_shared *shared = phydev->shared;
1649 struct mii_bus *bus = phydev->mdio.bus;
1650
1651 if (!shared)
1652 return;
1653
1654 if (refcount_dec_and_mutex_lock(&shared->refcnt, &bus->shared_lock)) {
1655 bus->shared[shared->addr] = NULL;
1656 mutex_unlock(&bus->shared_lock);
1657 kfree(shared->priv);
1658 kfree(shared);
1659 }
1660
1661 phydev->shared = NULL;
1662}
1663EXPORT_SYMBOL_GPL(phy_package_leave);
1664
1665static void devm_phy_package_leave(struct device *dev, void *res)
1666{
1667 phy_package_leave(*(struct phy_device **)res);
1668}
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681int devm_phy_package_join(struct device *dev, struct phy_device *phydev,
1682 int addr, size_t priv_size)
1683{
1684 struct phy_device **ptr;
1685 int ret;
1686
1687 ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr),
1688 GFP_KERNEL);
1689 if (!ptr)
1690 return -ENOMEM;
1691
1692 ret = phy_package_join(phydev, addr, priv_size);
1693
1694 if (!ret) {
1695 *ptr = phydev;
1696 devres_add(dev, ptr);
1697 } else {
1698 devres_free(ptr);
1699 }
1700
1701 return ret;
1702}
1703EXPORT_SYMBOL_GPL(devm_phy_package_join);
1704
1705
1706
1707
1708
1709
1710
1711
1712void phy_detach(struct phy_device *phydev)
1713{
1714 struct net_device *dev = phydev->attached_dev;
1715 struct module *ndev_owner = NULL;
1716 struct mii_bus *bus;
1717
1718 if (phydev->sysfs_links) {
1719 if (dev)
1720 sysfs_remove_link(&dev->dev.kobj, "phydev");
1721 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1722 }
1723
1724 if (!phydev->attached_dev)
1725 sysfs_remove_file(&phydev->mdio.dev.kobj,
1726 &dev_attr_phy_standalone.attr);
1727
1728 phy_suspend(phydev);
1729 if (dev) {
1730 phydev->attached_dev->phydev = NULL;
1731 phydev->attached_dev = NULL;
1732 }
1733 phydev->phylink = NULL;
1734
1735 phy_led_triggers_unregister(phydev);
1736
1737 if (phydev->mdio.dev.driver)
1738 module_put(phydev->mdio.dev.driver->owner);
1739
1740
1741
1742
1743
1744
1745 if (phy_driver_is_genphy(phydev) ||
1746 phy_driver_is_genphy_10g(phydev))
1747 device_release_driver(&phydev->mdio.dev);
1748
1749
1750
1751
1752
1753 bus = phydev->mdio.bus;
1754
1755 put_device(&phydev->mdio.dev);
1756 if (dev)
1757 ndev_owner = dev->dev.parent->driver->owner;
1758 if (ndev_owner != bus->owner)
1759 module_put(bus->owner);
1760
1761
1762 phy_device_reset(phydev, 1);
1763}
1764EXPORT_SYMBOL(phy_detach);
1765
1766int phy_suspend(struct phy_device *phydev)
1767{
1768 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1769 struct net_device *netdev = phydev->attached_dev;
1770 struct phy_driver *phydrv = phydev->drv;
1771 int ret;
1772
1773 if (phydev->suspended)
1774 return 0;
1775
1776
1777 phy_ethtool_get_wol(phydev, &wol);
1778 if (wol.wolopts || (netdev && netdev->wol_enabled))
1779 return -EBUSY;
1780
1781 if (!phydrv || !phydrv->suspend)
1782 return 0;
1783
1784 ret = phydrv->suspend(phydev);
1785 if (!ret)
1786 phydev->suspended = true;
1787
1788 return ret;
1789}
1790EXPORT_SYMBOL(phy_suspend);
1791
1792int __phy_resume(struct phy_device *phydev)
1793{
1794 struct phy_driver *phydrv = phydev->drv;
1795 int ret;
1796
1797 lockdep_assert_held(&phydev->lock);
1798
1799 if (!phydrv || !phydrv->resume)
1800 return 0;
1801
1802 ret = phydrv->resume(phydev);
1803 if (!ret)
1804 phydev->suspended = false;
1805
1806 return ret;
1807}
1808EXPORT_SYMBOL(__phy_resume);
1809
1810int phy_resume(struct phy_device *phydev)
1811{
1812 int ret;
1813
1814 mutex_lock(&phydev->lock);
1815 ret = __phy_resume(phydev);
1816 mutex_unlock(&phydev->lock);
1817
1818 return ret;
1819}
1820EXPORT_SYMBOL(phy_resume);
1821
1822int phy_loopback(struct phy_device *phydev, bool enable)
1823{
1824 int ret = 0;
1825
1826 if (!phydev->drv)
1827 return -EIO;
1828
1829 mutex_lock(&phydev->lock);
1830
1831 if (enable && phydev->loopback_enabled) {
1832 ret = -EBUSY;
1833 goto out;
1834 }
1835
1836 if (!enable && !phydev->loopback_enabled) {
1837 ret = -EINVAL;
1838 goto out;
1839 }
1840
1841 if (phydev->drv->set_loopback)
1842 ret = phydev->drv->set_loopback(phydev, enable);
1843 else
1844 ret = genphy_loopback(phydev, enable);
1845
1846 if (ret)
1847 goto out;
1848
1849 phydev->loopback_enabled = enable;
1850
1851out:
1852 mutex_unlock(&phydev->lock);
1853 return ret;
1854}
1855EXPORT_SYMBOL(phy_loopback);
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866int phy_reset_after_clk_enable(struct phy_device *phydev)
1867{
1868 if (!phydev || !phydev->drv)
1869 return -ENODEV;
1870
1871 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1872 phy_device_reset(phydev, 1);
1873 phy_device_reset(phydev, 0);
1874 return 1;
1875 }
1876
1877 return 0;
1878}
1879EXPORT_SYMBOL(phy_reset_after_clk_enable);
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892static int genphy_config_advert(struct phy_device *phydev)
1893{
1894 int err, bmsr, changed = 0;
1895 u32 adv;
1896
1897
1898 linkmode_and(phydev->advertising, phydev->advertising,
1899 phydev->supported);
1900
1901 adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
1902
1903
1904 err = phy_modify_changed(phydev, MII_ADVERTISE,
1905 ADVERTISE_ALL | ADVERTISE_100BASE4 |
1906 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
1907 adv);
1908 if (err < 0)
1909 return err;
1910 if (err > 0)
1911 changed = 1;
1912
1913 bmsr = phy_read(phydev, MII_BMSR);
1914 if (bmsr < 0)
1915 return bmsr;
1916
1917
1918
1919
1920
1921 if (!(bmsr & BMSR_ESTATEN))
1922 return changed;
1923
1924 adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
1925
1926 err = phy_modify_changed(phydev, MII_CTRL1000,
1927 ADVERTISE_1000FULL | ADVERTISE_1000HALF,
1928 adv);
1929 if (err < 0)
1930 return err;
1931 if (err > 0)
1932 changed = 1;
1933
1934 return changed;
1935}
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947static int genphy_c37_config_advert(struct phy_device *phydev)
1948{
1949 u16 adv = 0;
1950
1951
1952 linkmode_and(phydev->advertising, phydev->advertising,
1953 phydev->supported);
1954
1955 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
1956 phydev->advertising))
1957 adv |= ADVERTISE_1000XFULL;
1958 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1959 phydev->advertising))
1960 adv |= ADVERTISE_1000XPAUSE;
1961 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1962 phydev->advertising))
1963 adv |= ADVERTISE_1000XPSE_ASYM;
1964
1965 return phy_modify_changed(phydev, MII_ADVERTISE,
1966 ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
1967 ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,
1968 adv);
1969}
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979int genphy_config_eee_advert(struct phy_device *phydev)
1980{
1981 int err;
1982
1983
1984 if (!phydev->eee_broken_modes)
1985 return 0;
1986
1987 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
1988 phydev->eee_broken_modes, 0);
1989
1990 return err < 0 ? 0 : err;
1991}
1992EXPORT_SYMBOL(genphy_config_eee_advert);
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002int genphy_setup_forced(struct phy_device *phydev)
2003{
2004 u16 ctl = 0;
2005
2006 phydev->pause = 0;
2007 phydev->asym_pause = 0;
2008
2009 if (SPEED_1000 == phydev->speed)
2010 ctl |= BMCR_SPEED1000;
2011 else if (SPEED_100 == phydev->speed)
2012 ctl |= BMCR_SPEED100;
2013
2014 if (DUPLEX_FULL == phydev->duplex)
2015 ctl |= BMCR_FULLDPLX;
2016
2017 return phy_modify(phydev, MII_BMCR,
2018 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
2019}
2020EXPORT_SYMBOL(genphy_setup_forced);
2021
2022static int genphy_setup_master_slave(struct phy_device *phydev)
2023{
2024 u16 ctl = 0;
2025
2026 if (!phydev->is_gigabit_capable)
2027 return 0;
2028
2029 switch (phydev->master_slave_set) {
2030 case MASTER_SLAVE_CFG_MASTER_PREFERRED:
2031 ctl |= CTL1000_PREFER_MASTER;
2032 break;
2033 case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
2034 break;
2035 case MASTER_SLAVE_CFG_MASTER_FORCE:
2036 ctl |= CTL1000_AS_MASTER;
2037 fallthrough;
2038 case MASTER_SLAVE_CFG_SLAVE_FORCE:
2039 ctl |= CTL1000_ENABLE_MASTER;
2040 break;
2041 case MASTER_SLAVE_CFG_UNKNOWN:
2042 case MASTER_SLAVE_CFG_UNSUPPORTED:
2043 return 0;
2044 default:
2045 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
2046 return -EOPNOTSUPP;
2047 }
2048
2049 return phy_modify_changed(phydev, MII_CTRL1000,
2050 (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |
2051 CTL1000_PREFER_MASTER), ctl);
2052}
2053
2054static int genphy_read_master_slave(struct phy_device *phydev)
2055{
2056 int cfg, state;
2057 int val;
2058
2059 if (!phydev->is_gigabit_capable) {
2060 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
2061 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
2062 return 0;
2063 }
2064
2065 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
2066 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
2067
2068 val = phy_read(phydev, MII_CTRL1000);
2069 if (val < 0)
2070 return val;
2071
2072 if (val & CTL1000_ENABLE_MASTER) {
2073 if (val & CTL1000_AS_MASTER)
2074 cfg = MASTER_SLAVE_CFG_MASTER_FORCE;
2075 else
2076 cfg = MASTER_SLAVE_CFG_SLAVE_FORCE;
2077 } else {
2078 if (val & CTL1000_PREFER_MASTER)
2079 cfg = MASTER_SLAVE_CFG_MASTER_PREFERRED;
2080 else
2081 cfg = MASTER_SLAVE_CFG_SLAVE_PREFERRED;
2082 }
2083
2084 val = phy_read(phydev, MII_STAT1000);
2085 if (val < 0)
2086 return val;
2087
2088 if (val & LPA_1000MSFAIL) {
2089 state = MASTER_SLAVE_STATE_ERR;
2090 } else if (phydev->link) {
2091
2092 if (val & LPA_1000MSRES)
2093 state = MASTER_SLAVE_STATE_MASTER;
2094 else
2095 state = MASTER_SLAVE_STATE_SLAVE;
2096 } else {
2097 state = MASTER_SLAVE_STATE_UNKNOWN;
2098 }
2099
2100 phydev->master_slave_get = cfg;
2101 phydev->master_slave_state = state;
2102
2103 return 0;
2104}
2105
2106
2107
2108
2109
2110int genphy_restart_aneg(struct phy_device *phydev)
2111{
2112
2113 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
2114 BMCR_ANENABLE | BMCR_ANRESTART);
2115}
2116EXPORT_SYMBOL(genphy_restart_aneg);
2117
2118
2119
2120
2121
2122
2123
2124
2125int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
2126{
2127 int ret;
2128
2129 if (!restart) {
2130
2131
2132
2133 ret = phy_read(phydev, MII_BMCR);
2134 if (ret < 0)
2135 return ret;
2136
2137 if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
2138 restart = true;
2139 }
2140
2141 if (restart)
2142 return genphy_restart_aneg(phydev);
2143
2144 return 0;
2145}
2146EXPORT_SYMBOL(genphy_check_and_restart_aneg);
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157int __genphy_config_aneg(struct phy_device *phydev, bool changed)
2158{
2159 int err;
2160
2161 if (genphy_config_eee_advert(phydev))
2162 changed = true;
2163
2164 err = genphy_setup_master_slave(phydev);
2165 if (err < 0)
2166 return err;
2167 else if (err)
2168 changed = true;
2169
2170 if (AUTONEG_ENABLE != phydev->autoneg)
2171 return genphy_setup_forced(phydev);
2172
2173 err = genphy_config_advert(phydev);
2174 if (err < 0)
2175 return err;
2176 else if (err)
2177 changed = true;
2178
2179 return genphy_check_and_restart_aneg(phydev, changed);
2180}
2181EXPORT_SYMBOL(__genphy_config_aneg);
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192int genphy_c37_config_aneg(struct phy_device *phydev)
2193{
2194 int err, changed;
2195
2196 if (phydev->autoneg != AUTONEG_ENABLE)
2197 return genphy_setup_forced(phydev);
2198
2199 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
2200 BMCR_SPEED1000);
2201 if (err)
2202 return err;
2203
2204 changed = genphy_c37_config_advert(phydev);
2205 if (changed < 0)
2206 return changed;
2207
2208 if (!changed) {
2209
2210
2211
2212 int ctl = phy_read(phydev, MII_BMCR);
2213
2214 if (ctl < 0)
2215 return ctl;
2216
2217 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
2218 changed = 1;
2219 }
2220
2221
2222
2223
2224 if (changed > 0)
2225 return genphy_restart_aneg(phydev);
2226
2227 return 0;
2228}
2229EXPORT_SYMBOL(genphy_c37_config_aneg);
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239int genphy_aneg_done(struct phy_device *phydev)
2240{
2241 int retval = phy_read(phydev, MII_BMSR);
2242
2243 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
2244}
2245EXPORT_SYMBOL(genphy_aneg_done);
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255int genphy_update_link(struct phy_device *phydev)
2256{
2257 int status = 0, bmcr;
2258
2259 bmcr = phy_read(phydev, MII_BMCR);
2260 if (bmcr < 0)
2261 return bmcr;
2262
2263
2264
2265
2266 if (bmcr & BMCR_ANRESTART)
2267 goto done;
2268
2269
2270
2271
2272
2273
2274 if (!phy_polling_mode(phydev) || !phydev->link) {
2275 status = phy_read(phydev, MII_BMSR);
2276 if (status < 0)
2277 return status;
2278 else if (status & BMSR_LSTATUS)
2279 goto done;
2280 }
2281
2282
2283 status = phy_read(phydev, MII_BMSR);
2284 if (status < 0)
2285 return status;
2286done:
2287 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
2288 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
2289
2290
2291
2292
2293 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
2294 phydev->link = 0;
2295
2296 return 0;
2297}
2298EXPORT_SYMBOL(genphy_update_link);
2299
2300int genphy_read_lpa(struct phy_device *phydev)
2301{
2302 int lpa, lpagb;
2303
2304 if (phydev->autoneg == AUTONEG_ENABLE) {
2305 if (!phydev->autoneg_complete) {
2306 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2307 0);
2308 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
2309 return 0;
2310 }
2311
2312 if (phydev->is_gigabit_capable) {
2313 lpagb = phy_read(phydev, MII_STAT1000);
2314 if (lpagb < 0)
2315 return lpagb;
2316
2317 if (lpagb & LPA_1000MSFAIL) {
2318 int adv = phy_read(phydev, MII_CTRL1000);
2319
2320 if (adv < 0)
2321 return adv;
2322
2323 if (adv & CTL1000_ENABLE_MASTER)
2324 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2325 else
2326 phydev_err(phydev, "Master/Slave resolution failed\n");
2327 return -ENOLINK;
2328 }
2329
2330 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2331 lpagb);
2332 }
2333
2334 lpa = phy_read(phydev, MII_LPA);
2335 if (lpa < 0)
2336 return lpa;
2337
2338 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2339 } else {
2340 linkmode_zero(phydev->lp_advertising);
2341 }
2342
2343 return 0;
2344}
2345EXPORT_SYMBOL(genphy_read_lpa);
2346
2347
2348
2349
2350
2351
2352
2353
2354int genphy_read_status_fixed(struct phy_device *phydev)
2355{
2356 int bmcr = phy_read(phydev, MII_BMCR);
2357
2358 if (bmcr < 0)
2359 return bmcr;
2360
2361 if (bmcr & BMCR_FULLDPLX)
2362 phydev->duplex = DUPLEX_FULL;
2363 else
2364 phydev->duplex = DUPLEX_HALF;
2365
2366 if (bmcr & BMCR_SPEED1000)
2367 phydev->speed = SPEED_1000;
2368 else if (bmcr & BMCR_SPEED100)
2369 phydev->speed = SPEED_100;
2370 else
2371 phydev->speed = SPEED_10;
2372
2373 return 0;
2374}
2375EXPORT_SYMBOL(genphy_read_status_fixed);
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386int genphy_read_status(struct phy_device *phydev)
2387{
2388 int err, old_link = phydev->link;
2389
2390
2391 err = genphy_update_link(phydev);
2392 if (err)
2393 return err;
2394
2395
2396 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2397 return 0;
2398
2399 phydev->speed = SPEED_UNKNOWN;
2400 phydev->duplex = DUPLEX_UNKNOWN;
2401 phydev->pause = 0;
2402 phydev->asym_pause = 0;
2403
2404 err = genphy_read_master_slave(phydev);
2405 if (err < 0)
2406 return err;
2407
2408 err = genphy_read_lpa(phydev);
2409 if (err < 0)
2410 return err;
2411
2412 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2413 phy_resolve_aneg_linkmode(phydev);
2414 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2415 err = genphy_read_status_fixed(phydev);
2416 if (err < 0)
2417 return err;
2418 }
2419
2420 return 0;
2421}
2422EXPORT_SYMBOL(genphy_read_status);
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432int genphy_c37_read_status(struct phy_device *phydev)
2433{
2434 int lpa, err, old_link = phydev->link;
2435
2436
2437 err = genphy_update_link(phydev);
2438 if (err)
2439 return err;
2440
2441
2442 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2443 return 0;
2444
2445 phydev->duplex = DUPLEX_UNKNOWN;
2446 phydev->pause = 0;
2447 phydev->asym_pause = 0;
2448
2449 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2450 lpa = phy_read(phydev, MII_LPA);
2451 if (lpa < 0)
2452 return lpa;
2453
2454 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2455 phydev->lp_advertising, lpa & LPA_LPACK);
2456 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2457 phydev->lp_advertising, lpa & LPA_1000XFULL);
2458 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2459 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2460 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2461 phydev->lp_advertising,
2462 lpa & LPA_1000XPAUSE_ASYM);
2463
2464 phy_resolve_aneg_linkmode(phydev);
2465 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2466 int bmcr = phy_read(phydev, MII_BMCR);
2467
2468 if (bmcr < 0)
2469 return bmcr;
2470
2471 if (bmcr & BMCR_FULLDPLX)
2472 phydev->duplex = DUPLEX_FULL;
2473 else
2474 phydev->duplex = DUPLEX_HALF;
2475 }
2476
2477 return 0;
2478}
2479EXPORT_SYMBOL(genphy_c37_read_status);
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490int genphy_soft_reset(struct phy_device *phydev)
2491{
2492 u16 res = BMCR_RESET;
2493 int ret;
2494
2495 if (phydev->autoneg == AUTONEG_ENABLE)
2496 res |= BMCR_ANRESTART;
2497
2498 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2499 if (ret < 0)
2500 return ret;
2501
2502
2503
2504
2505
2506 phydev->suspended = 0;
2507
2508 ret = phy_poll_reset(phydev);
2509 if (ret)
2510 return ret;
2511
2512
2513 if (phydev->autoneg == AUTONEG_DISABLE)
2514 ret = genphy_setup_forced(phydev);
2515
2516 return ret;
2517}
2518EXPORT_SYMBOL(genphy_soft_reset);
2519
2520irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)
2521{
2522
2523
2524
2525
2526
2527 phy_trigger_machine(phydev);
2528
2529 return 0;
2530}
2531EXPORT_SYMBOL(genphy_handle_interrupt_no_ack);
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542int genphy_read_abilities(struct phy_device *phydev)
2543{
2544 int val;
2545
2546 linkmode_set_bit_array(phy_basic_ports_array,
2547 ARRAY_SIZE(phy_basic_ports_array),
2548 phydev->supported);
2549
2550 val = phy_read(phydev, MII_BMSR);
2551 if (val < 0)
2552 return val;
2553
2554 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2555 val & BMSR_ANEGCAPABLE);
2556
2557 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2558 val & BMSR_100FULL);
2559 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2560 val & BMSR_100HALF);
2561 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2562 val & BMSR_10FULL);
2563 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2564 val & BMSR_10HALF);
2565
2566 if (val & BMSR_ESTATEN) {
2567 val = phy_read(phydev, MII_ESTATUS);
2568 if (val < 0)
2569 return val;
2570
2571 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2572 phydev->supported, val & ESTATUS_1000_TFULL);
2573 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2574 phydev->supported, val & ESTATUS_1000_THALF);
2575 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2576 phydev->supported, val & ESTATUS_1000_XFULL);
2577 }
2578
2579 return 0;
2580}
2581EXPORT_SYMBOL(genphy_read_abilities);
2582
2583
2584
2585
2586
2587int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
2588{
2589 return -EOPNOTSUPP;
2590}
2591EXPORT_SYMBOL(genphy_read_mmd_unsupported);
2592
2593int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
2594 u16 regnum, u16 val)
2595{
2596 return -EOPNOTSUPP;
2597}
2598EXPORT_SYMBOL(genphy_write_mmd_unsupported);
2599
2600int genphy_suspend(struct phy_device *phydev)
2601{
2602 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2603}
2604EXPORT_SYMBOL(genphy_suspend);
2605
2606int genphy_resume(struct phy_device *phydev)
2607{
2608 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2609}
2610EXPORT_SYMBOL(genphy_resume);
2611
2612int genphy_loopback(struct phy_device *phydev, bool enable)
2613{
2614 if (enable) {
2615 u16 val, ctl = BMCR_LOOPBACK;
2616 int ret;
2617
2618 if (phydev->speed == SPEED_1000)
2619 ctl |= BMCR_SPEED1000;
2620 else if (phydev->speed == SPEED_100)
2621 ctl |= BMCR_SPEED100;
2622
2623 if (phydev->duplex == DUPLEX_FULL)
2624 ctl |= BMCR_FULLDPLX;
2625
2626 phy_modify(phydev, MII_BMCR, ~0, ctl);
2627
2628 ret = phy_read_poll_timeout(phydev, MII_BMSR, val,
2629 val & BMSR_LSTATUS,
2630 5000, 500000, true);
2631 if (ret)
2632 return ret;
2633 } else {
2634 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);
2635
2636 phy_config_aneg(phydev);
2637 }
2638
2639 return 0;
2640}
2641EXPORT_SYMBOL(genphy_loopback);
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2653{
2654 linkmode_clear_bit(link_mode, phydev->supported);
2655 phy_advertise_supported(phydev);
2656}
2657EXPORT_SYMBOL(phy_remove_link_mode);
2658
2659static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
2660{
2661 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
2662 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
2663 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
2664 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
2665}
2666
2667
2668
2669
2670
2671
2672
2673
2674void phy_advertise_supported(struct phy_device *phydev)
2675{
2676 __ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2677
2678 linkmode_copy(new, phydev->supported);
2679 phy_copy_pause_bits(new, phydev->advertising);
2680 linkmode_copy(phydev->advertising, new);
2681}
2682EXPORT_SYMBOL(phy_advertise_supported);
2683
2684
2685
2686
2687
2688
2689
2690
2691void phy_support_sym_pause(struct phy_device *phydev)
2692{
2693 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2694 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2695}
2696EXPORT_SYMBOL(phy_support_sym_pause);
2697
2698
2699
2700
2701
2702
2703
2704void phy_support_asym_pause(struct phy_device *phydev)
2705{
2706 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2707}
2708EXPORT_SYMBOL(phy_support_asym_pause);
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2722 bool autoneg)
2723{
2724 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2725
2726 if (rx && tx && autoneg)
2727 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2728 phydev->supported);
2729
2730 linkmode_copy(phydev->advertising, phydev->supported);
2731}
2732EXPORT_SYMBOL(phy_set_sym_pause);
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
2746{
2747 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
2748
2749 linkmode_copy(oldadv, phydev->advertising);
2750 linkmode_set_pause(phydev->advertising, tx, rx);
2751
2752 if (!linkmode_equal(oldadv, phydev->advertising) &&
2753 phydev->autoneg)
2754 phy_start_aneg(phydev);
2755}
2756EXPORT_SYMBOL(phy_set_asym_pause);
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767bool phy_validate_pause(struct phy_device *phydev,
2768 struct ethtool_pauseparam *pp)
2769{
2770 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2771 phydev->supported) && pp->rx_pause)
2772 return false;
2773
2774 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2775 phydev->supported) &&
2776 pp->rx_pause != pp->tx_pause)
2777 return false;
2778
2779 return true;
2780}
2781EXPORT_SYMBOL(phy_validate_pause);
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
2796{
2797 if (phydev->duplex != DUPLEX_FULL) {
2798 *tx_pause = false;
2799 *rx_pause = false;
2800 return;
2801 }
2802
2803 return linkmode_resolve_pause(phydev->advertising,
2804 phydev->lp_advertising,
2805 tx_pause, rx_pause);
2806}
2807EXPORT_SYMBOL(phy_get_pause);
2808
2809#if IS_ENABLED(CONFIG_OF_MDIO)
2810static int phy_get_int_delay_property(struct device *dev, const char *name)
2811{
2812 s32 int_delay;
2813 int ret;
2814
2815 ret = device_property_read_u32(dev, name, &int_delay);
2816 if (ret)
2817 return ret;
2818
2819 return int_delay;
2820}
2821#else
2822static int phy_get_int_delay_property(struct device *dev, const char *name)
2823{
2824 return -EINVAL;
2825}
2826#endif
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev,
2845 const int *delay_values, int size, bool is_rx)
2846{
2847 s32 delay;
2848 int i;
2849
2850 if (is_rx) {
2851 delay = phy_get_int_delay_property(dev, "rx-internal-delay-ps");
2852 if (delay < 0 && size == 0) {
2853 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
2854 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
2855 return 1;
2856 else
2857 return 0;
2858 }
2859
2860 } else {
2861 delay = phy_get_int_delay_property(dev, "tx-internal-delay-ps");
2862 if (delay < 0 && size == 0) {
2863 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
2864 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
2865 return 1;
2866 else
2867 return 0;
2868 }
2869 }
2870
2871 if (delay < 0)
2872 return delay;
2873
2874 if (delay && size == 0)
2875 return delay;
2876
2877 if (delay < delay_values[0] || delay > delay_values[size - 1]) {
2878 phydev_err(phydev, "Delay %d is out of range\n", delay);
2879 return -EINVAL;
2880 }
2881
2882 if (delay == delay_values[0])
2883 return 0;
2884
2885 for (i = 1; i < size; i++) {
2886 if (delay == delay_values[i])
2887 return i;
2888
2889
2890 if (delay > delay_values[i - 1] &&
2891 delay < delay_values[i]) {
2892 if (delay - delay_values[i - 1] <
2893 delay_values[i] - delay)
2894 return i - 1;
2895 else
2896 return i;
2897 }
2898 }
2899
2900 phydev_err(phydev, "error finding internal delay index for %d\n",
2901 delay);
2902
2903 return -EINVAL;
2904}
2905EXPORT_SYMBOL(phy_get_internal_delay);
2906
2907static bool phy_drv_supports_irq(struct phy_driver *phydrv)
2908{
2909 return phydrv->config_intr && phydrv->handle_interrupt;
2910}
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920struct mdio_device *fwnode_mdio_find_device(struct fwnode_handle *fwnode)
2921{
2922 struct device *d;
2923
2924 if (!fwnode)
2925 return NULL;
2926
2927 d = bus_find_device_by_fwnode(&mdio_bus_type, fwnode);
2928 if (!d)
2929 return NULL;
2930
2931 return to_mdio_device(d);
2932}
2933EXPORT_SYMBOL(fwnode_mdio_find_device);
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943struct phy_device *fwnode_phy_find_device(struct fwnode_handle *phy_fwnode)
2944{
2945 struct mdio_device *mdiodev;
2946
2947 mdiodev = fwnode_mdio_find_device(phy_fwnode);
2948 if (!mdiodev)
2949 return NULL;
2950
2951 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
2952 return to_phy_device(&mdiodev->dev);
2953
2954 put_device(&mdiodev->dev);
2955
2956 return NULL;
2957}
2958EXPORT_SYMBOL(fwnode_phy_find_device);
2959
2960
2961
2962
2963
2964
2965
2966struct phy_device *device_phy_find_device(struct device *dev)
2967{
2968 return fwnode_phy_find_device(dev_fwnode(dev));
2969}
2970EXPORT_SYMBOL_GPL(device_phy_find_device);
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981struct fwnode_handle *fwnode_get_phy_node(struct fwnode_handle *fwnode)
2982{
2983 struct fwnode_handle *phy_node;
2984
2985
2986 phy_node = fwnode_find_reference(fwnode, "phy-handle", 0);
2987 if (is_acpi_node(fwnode) || !IS_ERR(phy_node))
2988 return phy_node;
2989 phy_node = fwnode_find_reference(fwnode, "phy", 0);
2990 if (IS_ERR(phy_node))
2991 phy_node = fwnode_find_reference(fwnode, "phy-device", 0);
2992 return phy_node;
2993}
2994EXPORT_SYMBOL_GPL(fwnode_get_phy_node);
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004static int phy_probe(struct device *dev)
3005{
3006 struct phy_device *phydev = to_phy_device(dev);
3007 struct device_driver *drv = phydev->mdio.dev.driver;
3008 struct phy_driver *phydrv = to_phy_driver(drv);
3009 int err = 0;
3010
3011 phydev->drv = phydrv;
3012
3013
3014
3015
3016 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
3017 phydev->irq = PHY_POLL;
3018
3019 if (phydrv->flags & PHY_IS_INTERNAL)
3020 phydev->is_internal = true;
3021
3022 mutex_lock(&phydev->lock);
3023
3024
3025 phy_device_reset(phydev, 0);
3026
3027 if (phydev->drv->probe) {
3028 err = phydev->drv->probe(phydev);
3029 if (err)
3030 goto out;
3031 }
3032
3033
3034
3035
3036
3037 if (phydrv->features)
3038 linkmode_copy(phydev->supported, phydrv->features);
3039 else if (phydrv->get_features)
3040 err = phydrv->get_features(phydev);
3041 else if (phydev->is_c45)
3042 err = genphy_c45_pma_read_abilities(phydev);
3043 else
3044 err = genphy_read_abilities(phydev);
3045
3046 if (err)
3047 goto out;
3048
3049 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
3050 phydev->supported))
3051 phydev->autoneg = 0;
3052
3053 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
3054 phydev->supported))
3055 phydev->is_gigabit_capable = 1;
3056 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
3057 phydev->supported))
3058 phydev->is_gigabit_capable = 1;
3059
3060 of_set_phy_supported(phydev);
3061 phy_advertise_supported(phydev);
3062
3063
3064
3065
3066 of_set_phy_eee_broken(phydev);
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
3080 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
3081 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3082 phydev->supported);
3083 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3084 phydev->supported);
3085 }
3086
3087
3088 phydev->state = PHY_READY;
3089
3090out:
3091
3092 if (err)
3093 phy_device_reset(phydev, 1);
3094
3095 mutex_unlock(&phydev->lock);
3096
3097 return err;
3098}
3099
3100static int phy_remove(struct device *dev)
3101{
3102 struct phy_device *phydev = to_phy_device(dev);
3103
3104 cancel_delayed_work_sync(&phydev->state_queue);
3105
3106 mutex_lock(&phydev->lock);
3107 phydev->state = PHY_DOWN;
3108 mutex_unlock(&phydev->lock);
3109
3110 sfp_bus_del_upstream(phydev->sfp_bus);
3111 phydev->sfp_bus = NULL;
3112
3113 if (phydev->drv && phydev->drv->remove)
3114 phydev->drv->remove(phydev);
3115
3116
3117 phy_device_reset(phydev, 1);
3118
3119 phydev->drv = NULL;
3120
3121 return 0;
3122}
3123
3124static void phy_shutdown(struct device *dev)
3125{
3126 struct phy_device *phydev = to_phy_device(dev);
3127
3128 if (phydev->state == PHY_READY || !phydev->attached_dev)
3129 return;
3130
3131 phy_disable_interrupts(phydev);
3132}
3133
3134
3135
3136
3137
3138
3139int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
3140{
3141 int retval;
3142
3143
3144
3145
3146 if (WARN_ON(new_driver->features && new_driver->get_features)) {
3147 pr_err("%s: features and get_features must not both be set\n",
3148 new_driver->name);
3149 return -EINVAL;
3150 }
3151
3152 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
3153 new_driver->mdiodrv.driver.name = new_driver->name;
3154 new_driver->mdiodrv.driver.bus = &mdio_bus_type;
3155 new_driver->mdiodrv.driver.probe = phy_probe;
3156 new_driver->mdiodrv.driver.remove = phy_remove;
3157 new_driver->mdiodrv.driver.shutdown = phy_shutdown;
3158 new_driver->mdiodrv.driver.owner = owner;
3159 new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
3160
3161 retval = driver_register(&new_driver->mdiodrv.driver);
3162 if (retval) {
3163 pr_err("%s: Error %d in registering driver\n",
3164 new_driver->name, retval);
3165
3166 return retval;
3167 }
3168
3169 pr_debug("%s: Registered new driver\n", new_driver->name);
3170
3171 return 0;
3172}
3173EXPORT_SYMBOL(phy_driver_register);
3174
3175int phy_drivers_register(struct phy_driver *new_driver, int n,
3176 struct module *owner)
3177{
3178 int i, ret = 0;
3179
3180 for (i = 0; i < n; i++) {
3181 ret = phy_driver_register(new_driver + i, owner);
3182 if (ret) {
3183 while (i-- > 0)
3184 phy_driver_unregister(new_driver + i);
3185 break;
3186 }
3187 }
3188 return ret;
3189}
3190EXPORT_SYMBOL(phy_drivers_register);
3191
3192void phy_driver_unregister(struct phy_driver *drv)
3193{
3194 driver_unregister(&drv->mdiodrv.driver);
3195}
3196EXPORT_SYMBOL(phy_driver_unregister);
3197
3198void phy_drivers_unregister(struct phy_driver *drv, int n)
3199{
3200 int i;
3201
3202 for (i = 0; i < n; i++)
3203 phy_driver_unregister(drv + i);
3204}
3205EXPORT_SYMBOL(phy_drivers_unregister);
3206
3207static struct phy_driver genphy_driver = {
3208 .phy_id = 0xffffffff,
3209 .phy_id_mask = 0xffffffff,
3210 .name = "Generic PHY",
3211 .get_features = genphy_read_abilities,
3212 .suspend = genphy_suspend,
3213 .resume = genphy_resume,
3214 .set_loopback = genphy_loopback,
3215};
3216
3217static const struct ethtool_phy_ops phy_ethtool_phy_ops = {
3218 .get_sset_count = phy_ethtool_get_sset_count,
3219 .get_strings = phy_ethtool_get_strings,
3220 .get_stats = phy_ethtool_get_stats,
3221 .start_cable_test = phy_start_cable_test,
3222 .start_cable_test_tdr = phy_start_cable_test_tdr,
3223};
3224
3225static int __init phy_init(void)
3226{
3227 int rc;
3228
3229 rc = mdio_bus_init();
3230 if (rc)
3231 return rc;
3232
3233 ethtool_set_ethtool_phy_ops(&phy_ethtool_phy_ops);
3234 features_init();
3235
3236 rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
3237 if (rc)
3238 goto err_c45;
3239
3240 rc = phy_driver_register(&genphy_driver, THIS_MODULE);
3241 if (rc) {
3242 phy_driver_unregister(&genphy_c45_driver);
3243err_c45:
3244 mdio_bus_exit();
3245 }
3246
3247 return rc;
3248}
3249
3250static void __exit phy_exit(void)
3251{
3252 phy_driver_unregister(&genphy_c45_driver);
3253 phy_driver_unregister(&genphy_driver);
3254 mdio_bus_exit();
3255 ethtool_set_ethtool_phy_ops(NULL);
3256}
3257
3258subsys_initcall(phy_init);
3259module_exit(phy_exit);
3260