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