1
2
3
4
5
6
7
8
9
10
11#include <linux/kernel.h>
12#include <linux/string.h>
13#include <linux/errno.h>
14#include <linux/unistd.h>
15#include <linux/interrupt.h>
16#include <linux/delay.h>
17#include <linux/netdevice.h>
18#include <linux/netlink.h>
19#include <linux/etherdevice.h>
20#include <linux/skbuff.h>
21#include <linux/mm.h>
22#include <linux/module.h>
23#include <linux/mii.h>
24#include <linux/ethtool.h>
25#include <linux/ethtool_netlink.h>
26#include <linux/phy.h>
27#include <linux/phy_led_triggers.h>
28#include <linux/sfp.h>
29#include <linux/workqueue.h>
30#include <linux/mdio.h>
31#include <linux/io.h>
32#include <linux/uaccess.h>
33#include <linux/atomic.h>
34#include <net/netlink.h>
35#include <net/genetlink.h>
36#include <net/sock.h>
37
38#define PHY_STATE_TIME HZ
39
40#define PHY_STATE_STR(_state) \
41 case PHY_##_state: \
42 return __stringify(_state); \
43
44static const char *phy_state_to_str(enum phy_state st)
45{
46 switch (st) {
47 PHY_STATE_STR(DOWN)
48 PHY_STATE_STR(READY)
49 PHY_STATE_STR(UP)
50 PHY_STATE_STR(RUNNING)
51 PHY_STATE_STR(NOLINK)
52 PHY_STATE_STR(CABLETEST)
53 PHY_STATE_STR(HALTED)
54 }
55
56 return NULL;
57}
58
59static void phy_link_up(struct phy_device *phydev)
60{
61 phydev->phy_link_change(phydev, true);
62 phy_led_trigger_change_speed(phydev);
63}
64
65static void phy_link_down(struct phy_device *phydev)
66{
67 phydev->phy_link_change(phydev, false);
68 phy_led_trigger_change_speed(phydev);
69}
70
71static const char *phy_pause_str(struct phy_device *phydev)
72{
73 bool local_pause, local_asym_pause;
74
75 if (phydev->autoneg == AUTONEG_DISABLE)
76 goto no_pause;
77
78 local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
79 phydev->advertising);
80 local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
81 phydev->advertising);
82
83 if (local_pause && phydev->pause)
84 return "rx/tx";
85
86 if (local_asym_pause && phydev->asym_pause) {
87 if (local_pause)
88 return "rx";
89 if (phydev->pause)
90 return "tx";
91 }
92
93no_pause:
94 return "off";
95}
96
97
98
99
100
101void phy_print_status(struct phy_device *phydev)
102{
103 if (phydev->link) {
104 netdev_info(phydev->attached_dev,
105 "Link is Up - %s/%s %s- flow control %s\n",
106 phy_speed_to_str(phydev->speed),
107 phy_duplex_to_str(phydev->duplex),
108 phydev->downshifted_rate ? "(downshifted) " : "",
109 phy_pause_str(phydev));
110 } else {
111 netdev_info(phydev->attached_dev, "Link is Down\n");
112 }
113}
114EXPORT_SYMBOL(phy_print_status);
115
116
117
118
119
120
121
122
123static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
124{
125 phydev->interrupts = interrupts ? 1 : 0;
126 if (phydev->drv->config_intr)
127 return phydev->drv->config_intr(phydev);
128
129 return 0;
130}
131
132
133
134
135
136
137
138
139int phy_restart_aneg(struct phy_device *phydev)
140{
141 int ret;
142
143 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
144 ret = genphy_c45_restart_aneg(phydev);
145 else
146 ret = genphy_restart_aneg(phydev);
147
148 return ret;
149}
150EXPORT_SYMBOL_GPL(phy_restart_aneg);
151
152
153
154
155
156
157
158
159
160int phy_aneg_done(struct phy_device *phydev)
161{
162 if (phydev->drv && phydev->drv->aneg_done)
163 return phydev->drv->aneg_done(phydev);
164 else if (phydev->is_c45)
165 return genphy_c45_aneg_done(phydev);
166 else
167 return genphy_aneg_done(phydev);
168}
169EXPORT_SYMBOL(phy_aneg_done);
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184static const struct phy_setting *
185phy_find_valid(int speed, int duplex, unsigned long *supported)
186{
187 return phy_lookup_setting(speed, duplex, supported, false);
188}
189
190
191
192
193
194
195
196
197
198
199
200unsigned int phy_supported_speeds(struct phy_device *phy,
201 unsigned int *speeds,
202 unsigned int size)
203{
204 return phy_speeds(speeds, size, phy->supported);
205}
206
207
208
209
210
211
212
213
214
215
216static inline bool phy_check_valid(int speed, int duplex,
217 unsigned long *features)
218{
219 return !!phy_lookup_setting(speed, duplex, features, true);
220}
221
222
223
224
225
226
227
228
229
230static void phy_sanitize_settings(struct phy_device *phydev)
231{
232 const struct phy_setting *setting;
233
234 setting = phy_find_valid(phydev->speed, phydev->duplex,
235 phydev->supported);
236 if (setting) {
237 phydev->speed = setting->speed;
238 phydev->duplex = setting->duplex;
239 } else {
240
241 phydev->speed = SPEED_UNKNOWN;
242 phydev->duplex = DUPLEX_UNKNOWN;
243 }
244}
245
246void phy_ethtool_ksettings_get(struct phy_device *phydev,
247 struct ethtool_link_ksettings *cmd)
248{
249 mutex_lock(&phydev->lock);
250 linkmode_copy(cmd->link_modes.supported, phydev->supported);
251 linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
252 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
253
254 cmd->base.speed = phydev->speed;
255 cmd->base.duplex = phydev->duplex;
256 cmd->base.master_slave_cfg = phydev->master_slave_get;
257 cmd->base.master_slave_state = phydev->master_slave_state;
258 if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
259 cmd->base.port = PORT_BNC;
260 else
261 cmd->base.port = phydev->port;
262 cmd->base.transceiver = phy_is_internal(phydev) ?
263 XCVR_INTERNAL : XCVR_EXTERNAL;
264 cmd->base.phy_address = phydev->mdio.addr;
265 cmd->base.autoneg = phydev->autoneg;
266 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
267 cmd->base.eth_tp_mdix = phydev->mdix;
268 mutex_unlock(&phydev->lock);
269}
270EXPORT_SYMBOL(phy_ethtool_ksettings_get);
271
272
273
274
275
276
277
278
279
280
281
282int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
283{
284 struct mii_ioctl_data *mii_data = if_mii(ifr);
285 u16 val = mii_data->val_in;
286 bool change_autoneg = false;
287 int prtad, devad;
288
289 switch (cmd) {
290 case SIOCGMIIPHY:
291 mii_data->phy_id = phydev->mdio.addr;
292 fallthrough;
293
294 case SIOCGMIIREG:
295 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
296 prtad = mdio_phy_id_prtad(mii_data->phy_id);
297 devad = mdio_phy_id_devad(mii_data->phy_id);
298 devad = mdiobus_c45_addr(devad, mii_data->reg_num);
299 } else {
300 prtad = mii_data->phy_id;
301 devad = mii_data->reg_num;
302 }
303 mii_data->val_out = mdiobus_read(phydev->mdio.bus, prtad,
304 devad);
305 return 0;
306
307 case SIOCSMIIREG:
308 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
309 prtad = mdio_phy_id_prtad(mii_data->phy_id);
310 devad = mdio_phy_id_devad(mii_data->phy_id);
311 devad = mdiobus_c45_addr(devad, mii_data->reg_num);
312 } else {
313 prtad = mii_data->phy_id;
314 devad = mii_data->reg_num;
315 }
316 if (prtad == phydev->mdio.addr) {
317 switch (devad) {
318 case MII_BMCR:
319 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
320 if (phydev->autoneg == AUTONEG_ENABLE)
321 change_autoneg = true;
322 phydev->autoneg = AUTONEG_DISABLE;
323 if (val & BMCR_FULLDPLX)
324 phydev->duplex = DUPLEX_FULL;
325 else
326 phydev->duplex = DUPLEX_HALF;
327 if (val & BMCR_SPEED1000)
328 phydev->speed = SPEED_1000;
329 else if (val & BMCR_SPEED100)
330 phydev->speed = SPEED_100;
331 else phydev->speed = SPEED_10;
332 } else {
333 if (phydev->autoneg == AUTONEG_DISABLE)
334 change_autoneg = true;
335 phydev->autoneg = AUTONEG_ENABLE;
336 }
337 break;
338 case MII_ADVERTISE:
339 mii_adv_mod_linkmode_adv_t(phydev->advertising,
340 val);
341 change_autoneg = true;
342 break;
343 case MII_CTRL1000:
344 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
345 val);
346 change_autoneg = true;
347 break;
348 default:
349
350 break;
351 }
352 }
353
354 mdiobus_write(phydev->mdio.bus, prtad, devad, val);
355
356 if (prtad == phydev->mdio.addr &&
357 devad == MII_BMCR &&
358 val & BMCR_RESET)
359 return phy_init_hw(phydev);
360
361 if (change_autoneg)
362 return phy_start_aneg(phydev);
363
364 return 0;
365
366 case SIOCSHWTSTAMP:
367 if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
368 return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
369 fallthrough;
370
371 default:
372 return -EOPNOTSUPP;
373 }
374}
375EXPORT_SYMBOL(phy_mii_ioctl);
376
377
378
379
380
381
382
383int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
384{
385 if (!dev->phydev)
386 return -ENODEV;
387
388 return phy_mii_ioctl(dev->phydev, ifr, cmd);
389}
390EXPORT_SYMBOL(phy_do_ioctl);
391
392
393
394
395
396
397
398
399
400
401
402int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
403{
404 if (!netif_running(dev))
405 return -ENODEV;
406
407 return phy_do_ioctl(dev, ifr, cmd);
408}
409EXPORT_SYMBOL(phy_do_ioctl_running);
410
411
412
413
414
415
416
417void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
418{
419 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
420 jiffies);
421}
422EXPORT_SYMBOL(phy_queue_state_machine);
423
424
425
426
427
428
429void phy_trigger_machine(struct phy_device *phydev)
430{
431 phy_queue_state_machine(phydev, 0);
432}
433EXPORT_SYMBOL(phy_trigger_machine);
434
435static void phy_abort_cable_test(struct phy_device *phydev)
436{
437 int err;
438
439 ethnl_cable_test_finished(phydev);
440
441 err = phy_init_hw(phydev);
442 if (err)
443 phydev_err(phydev, "Error while aborting cable test");
444}
445
446
447
448
449
450
451
452int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
453{
454 if (!phydev->drv)
455 return -EIO;
456
457 mutex_lock(&phydev->lock);
458 phydev->drv->get_strings(phydev, data);
459 mutex_unlock(&phydev->lock);
460
461 return 0;
462}
463EXPORT_SYMBOL(phy_ethtool_get_strings);
464
465
466
467
468
469
470int phy_ethtool_get_sset_count(struct phy_device *phydev)
471{
472 int ret;
473
474 if (!phydev->drv)
475 return -EIO;
476
477 if (phydev->drv->get_sset_count &&
478 phydev->drv->get_strings &&
479 phydev->drv->get_stats) {
480 mutex_lock(&phydev->lock);
481 ret = phydev->drv->get_sset_count(phydev);
482 mutex_unlock(&phydev->lock);
483
484 return ret;
485 }
486
487 return -EOPNOTSUPP;
488}
489EXPORT_SYMBOL(phy_ethtool_get_sset_count);
490
491
492
493
494
495
496
497
498int phy_ethtool_get_stats(struct phy_device *phydev,
499 struct ethtool_stats *stats, u64 *data)
500{
501 if (!phydev->drv)
502 return -EIO;
503
504 mutex_lock(&phydev->lock);
505 phydev->drv->get_stats(phydev, stats, data);
506 mutex_unlock(&phydev->lock);
507
508 return 0;
509}
510EXPORT_SYMBOL(phy_ethtool_get_stats);
511
512
513
514
515
516
517
518int phy_start_cable_test(struct phy_device *phydev,
519 struct netlink_ext_ack *extack)
520{
521 struct net_device *dev = phydev->attached_dev;
522 int err = -ENOMEM;
523
524 if (!(phydev->drv &&
525 phydev->drv->cable_test_start &&
526 phydev->drv->cable_test_get_status)) {
527 NL_SET_ERR_MSG(extack,
528 "PHY driver does not support cable testing");
529 return -EOPNOTSUPP;
530 }
531
532 mutex_lock(&phydev->lock);
533 if (phydev->state == PHY_CABLETEST) {
534 NL_SET_ERR_MSG(extack,
535 "PHY already performing a test");
536 err = -EBUSY;
537 goto out;
538 }
539
540 if (phydev->state < PHY_UP ||
541 phydev->state > PHY_CABLETEST) {
542 NL_SET_ERR_MSG(extack,
543 "PHY not configured. Try setting interface up");
544 err = -EBUSY;
545 goto out;
546 }
547
548 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
549 if (err)
550 goto out;
551
552
553 phy_link_down(phydev);
554
555 netif_testing_on(dev);
556 err = phydev->drv->cable_test_start(phydev);
557 if (err) {
558 netif_testing_off(dev);
559 phy_link_up(phydev);
560 goto out_free;
561 }
562
563 phydev->state = PHY_CABLETEST;
564
565 if (phy_polling_mode(phydev))
566 phy_trigger_machine(phydev);
567
568 mutex_unlock(&phydev->lock);
569
570 return 0;
571
572out_free:
573 ethnl_cable_test_free(phydev);
574out:
575 mutex_unlock(&phydev->lock);
576
577 return err;
578}
579EXPORT_SYMBOL(phy_start_cable_test);
580
581
582
583
584
585
586
587
588int phy_start_cable_test_tdr(struct phy_device *phydev,
589 struct netlink_ext_ack *extack,
590 const struct phy_tdr_config *config)
591{
592 struct net_device *dev = phydev->attached_dev;
593 int err = -ENOMEM;
594
595 if (!(phydev->drv &&
596 phydev->drv->cable_test_tdr_start &&
597 phydev->drv->cable_test_get_status)) {
598 NL_SET_ERR_MSG(extack,
599 "PHY driver does not support cable test TDR");
600 return -EOPNOTSUPP;
601 }
602
603 mutex_lock(&phydev->lock);
604 if (phydev->state == PHY_CABLETEST) {
605 NL_SET_ERR_MSG(extack,
606 "PHY already performing a test");
607 err = -EBUSY;
608 goto out;
609 }
610
611 if (phydev->state < PHY_UP ||
612 phydev->state > PHY_CABLETEST) {
613 NL_SET_ERR_MSG(extack,
614 "PHY not configured. Try setting interface up");
615 err = -EBUSY;
616 goto out;
617 }
618
619 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
620 if (err)
621 goto out;
622
623
624 phy_link_down(phydev);
625
626 netif_testing_on(dev);
627 err = phydev->drv->cable_test_tdr_start(phydev, config);
628 if (err) {
629 netif_testing_off(dev);
630 phy_link_up(phydev);
631 goto out_free;
632 }
633
634 phydev->state = PHY_CABLETEST;
635
636 if (phy_polling_mode(phydev))
637 phy_trigger_machine(phydev);
638
639 mutex_unlock(&phydev->lock);
640
641 return 0;
642
643out_free:
644 ethnl_cable_test_free(phydev);
645out:
646 mutex_unlock(&phydev->lock);
647
648 return err;
649}
650EXPORT_SYMBOL(phy_start_cable_test_tdr);
651
652int phy_config_aneg(struct phy_device *phydev)
653{
654 if (phydev->drv->config_aneg)
655 return phydev->drv->config_aneg(phydev);
656
657
658
659
660 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
661 return genphy_c45_config_aneg(phydev);
662
663 return genphy_config_aneg(phydev);
664}
665EXPORT_SYMBOL(phy_config_aneg);
666
667
668
669
670
671
672
673
674static int phy_check_link_status(struct phy_device *phydev)
675{
676 int err;
677
678 lockdep_assert_held(&phydev->lock);
679
680
681
682
683 if (phydev->loopback_enabled)
684 return 0;
685
686 err = phy_read_status(phydev);
687 if (err)
688 return err;
689
690 if (phydev->link && phydev->state != PHY_RUNNING) {
691 phy_check_downshift(phydev);
692 phydev->state = PHY_RUNNING;
693 phy_link_up(phydev);
694 } else if (!phydev->link && phydev->state != PHY_NOLINK) {
695 phydev->state = PHY_NOLINK;
696 phy_link_down(phydev);
697 }
698
699 return 0;
700}
701
702
703
704
705
706
707
708
709
710
711static int _phy_start_aneg(struct phy_device *phydev)
712{
713 int err;
714
715 lockdep_assert_held(&phydev->lock);
716
717 if (!phydev->drv)
718 return -EIO;
719
720 if (AUTONEG_DISABLE == phydev->autoneg)
721 phy_sanitize_settings(phydev);
722
723 err = phy_config_aneg(phydev);
724 if (err < 0)
725 return err;
726
727 if (phy_is_started(phydev))
728 err = phy_check_link_status(phydev);
729
730 return err;
731}
732
733
734
735
736
737
738
739
740
741
742int phy_start_aneg(struct phy_device *phydev)
743{
744 int err;
745
746 mutex_lock(&phydev->lock);
747 err = _phy_start_aneg(phydev);
748 mutex_unlock(&phydev->lock);
749
750 return err;
751}
752EXPORT_SYMBOL(phy_start_aneg);
753
754static int phy_poll_aneg_done(struct phy_device *phydev)
755{
756 unsigned int retries = 100;
757 int ret;
758
759 do {
760 msleep(100);
761 ret = phy_aneg_done(phydev);
762 } while (!ret && --retries);
763
764 if (!ret)
765 return -ETIMEDOUT;
766
767 return ret < 0 ? ret : 0;
768}
769
770int phy_ethtool_ksettings_set(struct phy_device *phydev,
771 const struct ethtool_link_ksettings *cmd)
772{
773 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
774 u8 autoneg = cmd->base.autoneg;
775 u8 duplex = cmd->base.duplex;
776 u32 speed = cmd->base.speed;
777
778 if (cmd->base.phy_address != phydev->mdio.addr)
779 return -EINVAL;
780
781 linkmode_copy(advertising, cmd->link_modes.advertising);
782
783
784 linkmode_and(advertising, advertising, phydev->supported);
785
786
787 if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
788 return -EINVAL;
789
790 if (autoneg == AUTONEG_ENABLE && linkmode_empty(advertising))
791 return -EINVAL;
792
793 if (autoneg == AUTONEG_DISABLE &&
794 ((speed != SPEED_1000 &&
795 speed != SPEED_100 &&
796 speed != SPEED_10) ||
797 (duplex != DUPLEX_HALF &&
798 duplex != DUPLEX_FULL)))
799 return -EINVAL;
800
801 mutex_lock(&phydev->lock);
802 phydev->autoneg = autoneg;
803
804 if (autoneg == AUTONEG_DISABLE) {
805 phydev->speed = speed;
806 phydev->duplex = duplex;
807 }
808
809 linkmode_copy(phydev->advertising, advertising);
810
811 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
812 phydev->advertising, autoneg == AUTONEG_ENABLE);
813
814 phydev->master_slave_set = cmd->base.master_slave_cfg;
815 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
816
817
818 _phy_start_aneg(phydev);
819
820 mutex_unlock(&phydev->lock);
821 return 0;
822}
823EXPORT_SYMBOL(phy_ethtool_ksettings_set);
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838int phy_speed_down(struct phy_device *phydev, bool sync)
839{
840 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
841 int ret;
842
843 if (phydev->autoneg != AUTONEG_ENABLE)
844 return 0;
845
846 linkmode_copy(adv_tmp, phydev->advertising);
847
848 ret = phy_speed_down_core(phydev);
849 if (ret)
850 return ret;
851
852 linkmode_copy(phydev->adv_old, adv_tmp);
853
854 if (linkmode_equal(phydev->advertising, adv_tmp))
855 return 0;
856
857 ret = phy_config_aneg(phydev);
858 if (ret)
859 return ret;
860
861 return sync ? phy_poll_aneg_done(phydev) : 0;
862}
863EXPORT_SYMBOL_GPL(phy_speed_down);
864
865
866
867
868
869
870
871int phy_speed_up(struct phy_device *phydev)
872{
873 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
874
875 if (phydev->autoneg != AUTONEG_ENABLE)
876 return 0;
877
878 if (linkmode_empty(phydev->adv_old))
879 return 0;
880
881 linkmode_copy(adv_tmp, phydev->advertising);
882 linkmode_copy(phydev->advertising, phydev->adv_old);
883 linkmode_zero(phydev->adv_old);
884
885 if (linkmode_equal(phydev->advertising, adv_tmp))
886 return 0;
887
888 return phy_config_aneg(phydev);
889}
890EXPORT_SYMBOL_GPL(phy_speed_up);
891
892
893
894
895
896
897
898
899
900
901
902void phy_start_machine(struct phy_device *phydev)
903{
904 phy_trigger_machine(phydev);
905}
906EXPORT_SYMBOL_GPL(phy_start_machine);
907
908
909
910
911
912
913
914
915
916void phy_stop_machine(struct phy_device *phydev)
917{
918 cancel_delayed_work_sync(&phydev->state_queue);
919
920 mutex_lock(&phydev->lock);
921 if (phy_is_started(phydev))
922 phydev->state = PHY_UP;
923 mutex_unlock(&phydev->lock);
924}
925
926
927
928
929
930
931
932
933
934
935void phy_error(struct phy_device *phydev)
936{
937 WARN_ON(1);
938
939 mutex_lock(&phydev->lock);
940 phydev->state = PHY_HALTED;
941 mutex_unlock(&phydev->lock);
942
943 phy_trigger_machine(phydev);
944}
945EXPORT_SYMBOL(phy_error);
946
947
948
949
950
951int phy_disable_interrupts(struct phy_device *phydev)
952{
953
954 return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
955}
956
957
958
959
960
961
962
963
964static irqreturn_t phy_interrupt(int irq, void *phy_dat)
965{
966 struct phy_device *phydev = phy_dat;
967 struct phy_driver *drv = phydev->drv;
968
969 return drv->handle_interrupt(phydev);
970}
971
972
973
974
975
976static int phy_enable_interrupts(struct phy_device *phydev)
977{
978 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
979}
980
981
982
983
984
985
986
987
988
989void phy_request_interrupt(struct phy_device *phydev)
990{
991 int err;
992
993 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
994 IRQF_ONESHOT | IRQF_SHARED,
995 phydev_name(phydev), phydev);
996 if (err) {
997 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
998 err, phydev->irq);
999 phydev->irq = PHY_POLL;
1000 } else {
1001 if (phy_enable_interrupts(phydev)) {
1002 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
1003 phy_free_interrupt(phydev);
1004 phydev->irq = PHY_POLL;
1005 }
1006 }
1007}
1008EXPORT_SYMBOL(phy_request_interrupt);
1009
1010
1011
1012
1013
1014
1015
1016
1017void phy_free_interrupt(struct phy_device *phydev)
1018{
1019 phy_disable_interrupts(phydev);
1020 free_irq(phydev->irq, phydev);
1021}
1022EXPORT_SYMBOL(phy_free_interrupt);
1023
1024
1025
1026
1027
1028void phy_stop(struct phy_device *phydev)
1029{
1030 struct net_device *dev = phydev->attached_dev;
1031
1032 if (!phy_is_started(phydev) && phydev->state != PHY_DOWN) {
1033 WARN(1, "called from state %s\n",
1034 phy_state_to_str(phydev->state));
1035 return;
1036 }
1037
1038 mutex_lock(&phydev->lock);
1039
1040 if (phydev->state == PHY_CABLETEST) {
1041 phy_abort_cable_test(phydev);
1042 netif_testing_off(dev);
1043 }
1044
1045 if (phydev->sfp_bus)
1046 sfp_upstream_stop(phydev->sfp_bus);
1047
1048 phydev->state = PHY_HALTED;
1049
1050 mutex_unlock(&phydev->lock);
1051
1052 phy_state_machine(&phydev->state_queue.work);
1053 phy_stop_machine(phydev);
1054
1055
1056
1057
1058
1059}
1060EXPORT_SYMBOL(phy_stop);
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072void phy_start(struct phy_device *phydev)
1073{
1074 mutex_lock(&phydev->lock);
1075
1076 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1077 WARN(1, "called from state %s\n",
1078 phy_state_to_str(phydev->state));
1079 goto out;
1080 }
1081
1082 if (phydev->sfp_bus)
1083 sfp_upstream_start(phydev->sfp_bus);
1084
1085
1086 __phy_resume(phydev);
1087
1088 phydev->state = PHY_UP;
1089
1090 phy_start_machine(phydev);
1091out:
1092 mutex_unlock(&phydev->lock);
1093}
1094EXPORT_SYMBOL(phy_start);
1095
1096
1097
1098
1099
1100void phy_state_machine(struct work_struct *work)
1101{
1102 struct delayed_work *dwork = to_delayed_work(work);
1103 struct phy_device *phydev =
1104 container_of(dwork, struct phy_device, state_queue);
1105 struct net_device *dev = phydev->attached_dev;
1106 bool needs_aneg = false, do_suspend = false;
1107 enum phy_state old_state;
1108 bool finished = false;
1109 int err = 0;
1110
1111 mutex_lock(&phydev->lock);
1112
1113 old_state = phydev->state;
1114
1115 switch (phydev->state) {
1116 case PHY_DOWN:
1117 case PHY_READY:
1118 break;
1119 case PHY_UP:
1120 needs_aneg = true;
1121
1122 break;
1123 case PHY_NOLINK:
1124 case PHY_RUNNING:
1125 err = phy_check_link_status(phydev);
1126 break;
1127 case PHY_CABLETEST:
1128 err = phydev->drv->cable_test_get_status(phydev, &finished);
1129 if (err) {
1130 phy_abort_cable_test(phydev);
1131 netif_testing_off(dev);
1132 needs_aneg = true;
1133 phydev->state = PHY_UP;
1134 break;
1135 }
1136
1137 if (finished) {
1138 ethnl_cable_test_finished(phydev);
1139 netif_testing_off(dev);
1140 needs_aneg = true;
1141 phydev->state = PHY_UP;
1142 }
1143 break;
1144 case PHY_HALTED:
1145 if (phydev->link) {
1146 phydev->link = 0;
1147 phy_link_down(phydev);
1148 }
1149 do_suspend = true;
1150 break;
1151 }
1152
1153 mutex_unlock(&phydev->lock);
1154
1155 if (needs_aneg)
1156 err = phy_start_aneg(phydev);
1157 else if (do_suspend)
1158 phy_suspend(phydev);
1159
1160 if (err == -ENODEV)
1161 return;
1162
1163 if (err < 0)
1164 phy_error(phydev);
1165
1166 if (old_state != phydev->state) {
1167 phydev_dbg(phydev, "PHY state change %s -> %s\n",
1168 phy_state_to_str(old_state),
1169 phy_state_to_str(phydev->state));
1170 if (phydev->drv && phydev->drv->link_change_notify)
1171 phydev->drv->link_change_notify(phydev);
1172 }
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182 mutex_lock(&phydev->lock);
1183 if (phy_polling_mode(phydev) && phy_is_started(phydev))
1184 phy_queue_state_machine(phydev, PHY_STATE_TIME);
1185 mutex_unlock(&phydev->lock);
1186}
1187
1188
1189
1190
1191
1192
1193
1194
1195void phy_mac_interrupt(struct phy_device *phydev)
1196{
1197
1198 phy_trigger_machine(phydev);
1199}
1200EXPORT_SYMBOL(phy_mac_interrupt);
1201
1202static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv)
1203{
1204 linkmode_zero(advertising);
1205
1206 if (eee_adv & MDIO_EEE_100TX)
1207 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1208 advertising);
1209 if (eee_adv & MDIO_EEE_1000T)
1210 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1211 advertising);
1212 if (eee_adv & MDIO_EEE_10GT)
1213 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1214 advertising);
1215 if (eee_adv & MDIO_EEE_1000KX)
1216 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
1217 advertising);
1218 if (eee_adv & MDIO_EEE_10GKX4)
1219 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
1220 advertising);
1221 if (eee_adv & MDIO_EEE_10GKR)
1222 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
1223 advertising);
1224}
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1237{
1238 if (!phydev->drv)
1239 return -EIO;
1240
1241
1242
1243 if (phydev->duplex == DUPLEX_FULL) {
1244 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
1245 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp);
1246 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
1247 int eee_lp, eee_cap, eee_adv;
1248 int status;
1249 u32 cap;
1250
1251
1252 status = phy_read_status(phydev);
1253 if (status)
1254 return status;
1255
1256
1257 eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1258 if (eee_cap <= 0)
1259 goto eee_exit_err;
1260
1261 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1262 if (!cap)
1263 goto eee_exit_err;
1264
1265
1266
1267
1268 eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1269 if (eee_lp <= 0)
1270 goto eee_exit_err;
1271
1272 eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1273 if (eee_adv <= 0)
1274 goto eee_exit_err;
1275
1276 mmd_eee_adv_to_linkmode(adv, eee_adv);
1277 mmd_eee_adv_to_linkmode(lp, eee_lp);
1278 linkmode_and(common, adv, lp);
1279
1280 if (!phy_check_valid(phydev->speed, phydev->duplex, common))
1281 goto eee_exit_err;
1282
1283 if (clk_stop_enable)
1284
1285
1286
1287 phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1288 MDIO_PCS_CTRL1_CLKSTOP_EN);
1289
1290 return 0;
1291 }
1292eee_exit_err:
1293 return -EPROTONOSUPPORT;
1294}
1295EXPORT_SYMBOL(phy_init_eee);
1296
1297
1298
1299
1300
1301
1302
1303
1304int phy_get_eee_err(struct phy_device *phydev)
1305{
1306 if (!phydev->drv)
1307 return -EIO;
1308
1309 return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1310}
1311EXPORT_SYMBOL(phy_get_eee_err);
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1322{
1323 int val;
1324
1325 if (!phydev->drv)
1326 return -EIO;
1327
1328
1329 val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1330 if (val < 0)
1331 return val;
1332 data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1333
1334
1335 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1336 if (val < 0)
1337 return val;
1338 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1339 data->eee_enabled = !!data->advertised;
1340
1341
1342 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1343 if (val < 0)
1344 return val;
1345 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1346
1347 data->eee_active = !!(data->advertised & data->lp_advertised);
1348
1349 return 0;
1350}
1351EXPORT_SYMBOL(phy_ethtool_get_eee);
1352
1353
1354
1355
1356
1357
1358
1359
1360int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1361{
1362 int cap, old_adv, adv = 0, ret;
1363
1364 if (!phydev->drv)
1365 return -EIO;
1366
1367
1368 cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1369 if (cap < 0)
1370 return cap;
1371
1372 old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1373 if (old_adv < 0)
1374 return old_adv;
1375
1376 if (data->eee_enabled) {
1377 adv = !data->advertised ? cap :
1378 ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1379
1380 adv &= ~phydev->eee_broken_modes;
1381 }
1382
1383 if (old_adv != adv) {
1384 ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1385 if (ret < 0)
1386 return ret;
1387
1388
1389
1390
1391 if (phydev->autoneg == AUTONEG_ENABLE) {
1392 ret = phy_restart_aneg(phydev);
1393 if (ret < 0)
1394 return ret;
1395 }
1396 }
1397
1398 return 0;
1399}
1400EXPORT_SYMBOL(phy_ethtool_set_eee);
1401
1402
1403
1404
1405
1406
1407
1408int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1409{
1410 if (phydev->drv && phydev->drv->set_wol)
1411 return phydev->drv->set_wol(phydev, wol);
1412
1413 return -EOPNOTSUPP;
1414}
1415EXPORT_SYMBOL(phy_ethtool_set_wol);
1416
1417
1418
1419
1420
1421
1422
1423void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1424{
1425 if (phydev->drv && phydev->drv->get_wol)
1426 phydev->drv->get_wol(phydev, wol);
1427}
1428EXPORT_SYMBOL(phy_ethtool_get_wol);
1429
1430int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1431 struct ethtool_link_ksettings *cmd)
1432{
1433 struct phy_device *phydev = ndev->phydev;
1434
1435 if (!phydev)
1436 return -ENODEV;
1437
1438 phy_ethtool_ksettings_get(phydev, cmd);
1439
1440 return 0;
1441}
1442EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1443
1444int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1445 const struct ethtool_link_ksettings *cmd)
1446{
1447 struct phy_device *phydev = ndev->phydev;
1448
1449 if (!phydev)
1450 return -ENODEV;
1451
1452 return phy_ethtool_ksettings_set(phydev, cmd);
1453}
1454EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1455
1456
1457
1458
1459
1460int phy_ethtool_nway_reset(struct net_device *ndev)
1461{
1462 struct phy_device *phydev = ndev->phydev;
1463
1464 if (!phydev)
1465 return -ENODEV;
1466
1467 if (!phydev->drv)
1468 return -EIO;
1469
1470 return phy_restart_aneg(phydev);
1471}
1472EXPORT_SYMBOL(phy_ethtool_nway_reset);
1473