1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21#include <linux/kernel.h>
22#include <linux/string.h>
23#include <linux/errno.h>
24#include <linux/unistd.h>
25#include <linux/interrupt.h>
26#include <linux/init.h>
27#include <linux/delay.h>
28#include <linux/netdevice.h>
29#include <linux/etherdevice.h>
30#include <linux/skbuff.h>
31#include <linux/mm.h>
32#include <linux/module.h>
33#include <linux/mii.h>
34#include <linux/ethtool.h>
35#include <linux/phy.h>
36#include <linux/timer.h>
37#include <linux/workqueue.h>
38#include <linux/mdio.h>
39
40#include <linux/atomic.h>
41#include <asm/io.h>
42#include <asm/irq.h>
43#include <asm/uaccess.h>
44
45
46
47
48
49void phy_print_status(struct phy_device *phydev)
50{
51 if (phydev->link)
52 pr_info("%s - Link is Up - %d/%s\n",
53 dev_name(&phydev->dev),
54 phydev->speed,
55 DUPLEX_FULL == phydev->duplex ? "Full" : "Half");
56 else
57 pr_info("%s - Link is Down\n", dev_name(&phydev->dev));
58}
59EXPORT_SYMBOL(phy_print_status);
60
61
62
63
64
65
66
67
68
69
70static int phy_clear_interrupt(struct phy_device *phydev)
71{
72 int err = 0;
73
74 if (phydev->drv->ack_interrupt)
75 err = phydev->drv->ack_interrupt(phydev);
76
77 return err;
78}
79
80
81
82
83
84
85
86
87static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts)
88{
89 int err = 0;
90
91 phydev->interrupts = interrupts;
92 if (phydev->drv->config_intr)
93 err = phydev->drv->config_intr(phydev);
94
95 return err;
96}
97
98
99
100
101
102
103
104
105
106
107static inline int phy_aneg_done(struct phy_device *phydev)
108{
109 int retval;
110
111 retval = phy_read(phydev, MII_BMSR);
112
113 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
114}
115
116
117
118struct phy_setting {
119 int speed;
120 int duplex;
121 u32 setting;
122};
123
124
125static const struct phy_setting settings[] = {
126 {
127 .speed = 10000,
128 .duplex = DUPLEX_FULL,
129 .setting = SUPPORTED_10000baseT_Full,
130 },
131 {
132 .speed = SPEED_1000,
133 .duplex = DUPLEX_FULL,
134 .setting = SUPPORTED_1000baseT_Full,
135 },
136 {
137 .speed = SPEED_1000,
138 .duplex = DUPLEX_HALF,
139 .setting = SUPPORTED_1000baseT_Half,
140 },
141 {
142 .speed = SPEED_100,
143 .duplex = DUPLEX_FULL,
144 .setting = SUPPORTED_100baseT_Full,
145 },
146 {
147 .speed = SPEED_100,
148 .duplex = DUPLEX_HALF,
149 .setting = SUPPORTED_100baseT_Half,
150 },
151 {
152 .speed = SPEED_10,
153 .duplex = DUPLEX_FULL,
154 .setting = SUPPORTED_10baseT_Full,
155 },
156 {
157 .speed = SPEED_10,
158 .duplex = DUPLEX_HALF,
159 .setting = SUPPORTED_10baseT_Half,
160 },
161};
162
163#define MAX_NUM_SETTINGS ARRAY_SIZE(settings)
164
165
166
167
168
169
170
171
172
173
174
175static inline int phy_find_setting(int speed, int duplex)
176{
177 int idx = 0;
178
179 while (idx < ARRAY_SIZE(settings) &&
180 (settings[idx].speed != speed ||
181 settings[idx].duplex != duplex))
182 idx++;
183
184 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
185}
186
187
188
189
190
191
192
193
194
195
196
197static inline int phy_find_valid(int idx, u32 features)
198{
199 while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))
200 idx++;
201
202 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
203}
204
205
206
207
208
209
210
211
212
213static void phy_sanitize_settings(struct phy_device *phydev)
214{
215 u32 features = phydev->supported;
216 int idx;
217
218
219 if ((features & SUPPORTED_Autoneg) == 0)
220 phydev->autoneg = AUTONEG_DISABLE;
221
222 idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex),
223 features);
224
225 phydev->speed = settings[idx].speed;
226 phydev->duplex = settings[idx].duplex;
227}
228
229
230
231
232
233
234
235
236
237
238
239
240
241int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd)
242{
243 u32 speed = ethtool_cmd_speed(cmd);
244
245 if (cmd->phy_address != phydev->addr)
246 return -EINVAL;
247
248
249
250 cmd->advertising &= phydev->supported;
251
252
253 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
254 return -EINVAL;
255
256 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
257 return -EINVAL;
258
259 if (cmd->autoneg == AUTONEG_DISABLE &&
260 ((speed != SPEED_1000 &&
261 speed != SPEED_100 &&
262 speed != SPEED_10) ||
263 (cmd->duplex != DUPLEX_HALF &&
264 cmd->duplex != DUPLEX_FULL)))
265 return -EINVAL;
266
267 phydev->autoneg = cmd->autoneg;
268
269 phydev->speed = speed;
270
271 phydev->advertising = cmd->advertising;
272
273 if (AUTONEG_ENABLE == cmd->autoneg)
274 phydev->advertising |= ADVERTISED_Autoneg;
275 else
276 phydev->advertising &= ~ADVERTISED_Autoneg;
277
278 phydev->duplex = cmd->duplex;
279
280
281 phy_start_aneg(phydev);
282
283 return 0;
284}
285EXPORT_SYMBOL(phy_ethtool_sset);
286
287int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
288{
289 cmd->supported = phydev->supported;
290
291 cmd->advertising = phydev->advertising;
292
293 ethtool_cmd_speed_set(cmd, phydev->speed);
294 cmd->duplex = phydev->duplex;
295 cmd->port = PORT_MII;
296 cmd->phy_address = phydev->addr;
297 cmd->transceiver = phy_is_internal(phydev) ?
298 XCVR_INTERNAL : XCVR_EXTERNAL;
299 cmd->autoneg = phydev->autoneg;
300
301 return 0;
302}
303EXPORT_SYMBOL(phy_ethtool_gset);
304
305
306
307
308
309
310
311
312
313
314
315int phy_mii_ioctl(struct phy_device *phydev,
316 struct ifreq *ifr, int cmd)
317{
318 struct mii_ioctl_data *mii_data = if_mii(ifr);
319 u16 val = mii_data->val_in;
320
321 switch (cmd) {
322 case SIOCGMIIPHY:
323 mii_data->phy_id = phydev->addr;
324
325
326 case SIOCGMIIREG:
327 mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id,
328 mii_data->reg_num);
329 break;
330
331 case SIOCSMIIREG:
332 if (mii_data->phy_id == phydev->addr) {
333 switch(mii_data->reg_num) {
334 case MII_BMCR:
335 if ((val & (BMCR_RESET|BMCR_ANENABLE)) == 0)
336 phydev->autoneg = AUTONEG_DISABLE;
337 else
338 phydev->autoneg = AUTONEG_ENABLE;
339 if ((!phydev->autoneg) && (val & BMCR_FULLDPLX))
340 phydev->duplex = DUPLEX_FULL;
341 else
342 phydev->duplex = DUPLEX_HALF;
343 if ((!phydev->autoneg) &&
344 (val & BMCR_SPEED1000))
345 phydev->speed = SPEED_1000;
346 else if ((!phydev->autoneg) &&
347 (val & BMCR_SPEED100))
348 phydev->speed = SPEED_100;
349 break;
350 case MII_ADVERTISE:
351 phydev->advertising = val;
352 break;
353 default:
354
355 break;
356 }
357 }
358
359 mdiobus_write(phydev->bus, mii_data->phy_id,
360 mii_data->reg_num, val);
361
362 if (mii_data->reg_num == MII_BMCR &&
363 val & BMCR_RESET &&
364 phydev->drv->config_init) {
365 phy_scan_fixups(phydev);
366 phydev->drv->config_init(phydev);
367 }
368 break;
369
370 case SIOCSHWTSTAMP:
371 if (phydev->drv->hwtstamp)
372 return phydev->drv->hwtstamp(phydev, ifr);
373
374
375 default:
376 return -EOPNOTSUPP;
377 }
378
379 return 0;
380}
381EXPORT_SYMBOL(phy_mii_ioctl);
382
383
384
385
386
387
388
389
390
391
392int phy_start_aneg(struct phy_device *phydev)
393{
394 int err;
395
396 mutex_lock(&phydev->lock);
397
398 if (AUTONEG_DISABLE == phydev->autoneg)
399 phy_sanitize_settings(phydev);
400
401 err = phydev->drv->config_aneg(phydev);
402
403 if (err < 0)
404 goto out_unlock;
405
406 if (phydev->state != PHY_HALTED) {
407 if (AUTONEG_ENABLE == phydev->autoneg) {
408 phydev->state = PHY_AN;
409 phydev->link_timeout = PHY_AN_TIMEOUT;
410 } else {
411 phydev->state = PHY_FORCING;
412 phydev->link_timeout = PHY_FORCE_TIMEOUT;
413 }
414 }
415
416out_unlock:
417 mutex_unlock(&phydev->lock);
418 return err;
419}
420EXPORT_SYMBOL(phy_start_aneg);
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436void phy_start_machine(struct phy_device *phydev,
437 void (*handler)(struct net_device *))
438{
439 phydev->adjust_state = handler;
440
441 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);
442}
443
444
445
446
447
448
449
450
451
452void phy_stop_machine(struct phy_device *phydev)
453{
454 cancel_delayed_work_sync(&phydev->state_queue);
455
456 mutex_lock(&phydev->lock);
457 if (phydev->state > PHY_UP)
458 phydev->state = PHY_UP;
459 mutex_unlock(&phydev->lock);
460
461 phydev->adjust_state = NULL;
462}
463
464
465
466
467
468
469
470
471
472
473static void phy_error(struct phy_device *phydev)
474{
475 mutex_lock(&phydev->lock);
476 phydev->state = PHY_HALTED;
477 mutex_unlock(&phydev->lock);
478}
479
480
481
482
483
484
485
486
487
488static irqreturn_t phy_interrupt(int irq, void *phy_dat)
489{
490 struct phy_device *phydev = phy_dat;
491
492 if (PHY_HALTED == phydev->state)
493 return IRQ_NONE;
494
495
496
497
498
499 disable_irq_nosync(irq);
500 atomic_inc(&phydev->irq_disable);
501
502 queue_work(system_power_efficient_wq, &phydev->phy_queue);
503
504 return IRQ_HANDLED;
505}
506
507
508
509
510
511static int phy_enable_interrupts(struct phy_device *phydev)
512{
513 int err;
514
515 err = phy_clear_interrupt(phydev);
516
517 if (err < 0)
518 return err;
519
520 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
521
522 return err;
523}
524
525
526
527
528
529static int phy_disable_interrupts(struct phy_device *phydev)
530{
531 int err;
532
533
534 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
535
536 if (err)
537 goto phy_err;
538
539
540 err = phy_clear_interrupt(phydev);
541
542 if (err)
543 goto phy_err;
544
545 return 0;
546
547phy_err:
548 phy_error(phydev);
549
550 return err;
551}
552
553
554
555
556
557
558
559
560
561
562
563int phy_start_interrupts(struct phy_device *phydev)
564{
565 int err = 0;
566
567 atomic_set(&phydev->irq_disable, 0);
568 if (request_irq(phydev->irq, phy_interrupt,
569 IRQF_SHARED,
570 "phy_interrupt",
571 phydev) < 0) {
572 pr_warn("%s: Can't get IRQ %d (PHY)\n",
573 phydev->bus->name, phydev->irq);
574 phydev->irq = PHY_POLL;
575 return 0;
576 }
577
578 err = phy_enable_interrupts(phydev);
579
580 return err;
581}
582EXPORT_SYMBOL(phy_start_interrupts);
583
584
585
586
587
588int phy_stop_interrupts(struct phy_device *phydev)
589{
590 int err;
591
592 err = phy_disable_interrupts(phydev);
593
594 if (err)
595 phy_error(phydev);
596
597 free_irq(phydev->irq, phydev);
598
599
600
601
602
603
604
605 cancel_work_sync(&phydev->phy_queue);
606
607
608
609
610
611 while (atomic_dec_return(&phydev->irq_disable) >= 0)
612 enable_irq(phydev->irq);
613
614 return err;
615}
616EXPORT_SYMBOL(phy_stop_interrupts);
617
618
619
620
621
622
623void phy_change(struct work_struct *work)
624{
625 int err;
626 struct phy_device *phydev =
627 container_of(work, struct phy_device, phy_queue);
628
629 if (phydev->drv->did_interrupt &&
630 !phydev->drv->did_interrupt(phydev))
631 goto ignore;
632
633 err = phy_disable_interrupts(phydev);
634
635 if (err)
636 goto phy_err;
637
638 mutex_lock(&phydev->lock);
639 if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
640 phydev->state = PHY_CHANGELINK;
641 mutex_unlock(&phydev->lock);
642
643 atomic_dec(&phydev->irq_disable);
644 enable_irq(phydev->irq);
645
646
647 if (PHY_HALTED != phydev->state)
648 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
649
650 if (err)
651 goto irq_enable_err;
652
653
654 cancel_delayed_work_sync(&phydev->state_queue);
655 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0);
656
657 return;
658
659ignore:
660 atomic_dec(&phydev->irq_disable);
661 enable_irq(phydev->irq);
662 return;
663
664irq_enable_err:
665 disable_irq(phydev->irq);
666 atomic_inc(&phydev->irq_disable);
667phy_err:
668 phy_error(phydev);
669}
670
671
672
673
674
675void phy_stop(struct phy_device *phydev)
676{
677 mutex_lock(&phydev->lock);
678
679 if (PHY_HALTED == phydev->state)
680 goto out_unlock;
681
682 if (phy_interrupt_is_valid(phydev)) {
683
684 phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
685
686
687 phy_clear_interrupt(phydev);
688 }
689
690 phydev->state = PHY_HALTED;
691
692out_unlock:
693 mutex_unlock(&phydev->lock);
694
695
696
697
698
699
700}
701
702
703
704
705
706
707
708
709
710
711
712
713void phy_start(struct phy_device *phydev)
714{
715 mutex_lock(&phydev->lock);
716
717 switch (phydev->state) {
718 case PHY_STARTING:
719 phydev->state = PHY_PENDING;
720 break;
721 case PHY_READY:
722 phydev->state = PHY_UP;
723 break;
724 case PHY_HALTED:
725 phydev->state = PHY_RESUMING;
726 default:
727 break;
728 }
729 mutex_unlock(&phydev->lock);
730}
731EXPORT_SYMBOL(phy_stop);
732EXPORT_SYMBOL(phy_start);
733
734
735
736
737
738void phy_state_machine(struct work_struct *work)
739{
740 struct delayed_work *dwork = to_delayed_work(work);
741 struct phy_device *phydev =
742 container_of(dwork, struct phy_device, state_queue);
743 int needs_aneg = 0;
744 int err = 0;
745
746 mutex_lock(&phydev->lock);
747
748 if (phydev->adjust_state)
749 phydev->adjust_state(phydev->attached_dev);
750
751 switch(phydev->state) {
752 case PHY_DOWN:
753 case PHY_STARTING:
754 case PHY_READY:
755 case PHY_PENDING:
756 break;
757 case PHY_UP:
758 needs_aneg = 1;
759
760 phydev->link_timeout = PHY_AN_TIMEOUT;
761
762 break;
763 case PHY_AN:
764 err = phy_read_status(phydev);
765
766 if (err < 0)
767 break;
768
769
770
771 if (!phydev->link) {
772 phydev->state = PHY_NOLINK;
773 netif_carrier_off(phydev->attached_dev);
774 phydev->adjust_link(phydev->attached_dev);
775 break;
776 }
777
778
779
780 err = phy_aneg_done(phydev);
781 if (err < 0)
782 break;
783
784
785 if (err > 0) {
786 phydev->state = PHY_RUNNING;
787 netif_carrier_on(phydev->attached_dev);
788 phydev->adjust_link(phydev->attached_dev);
789
790 } else if (0 == phydev->link_timeout--) {
791 needs_aneg = 1;
792
793
794 if (phydev->drv->flags & PHY_HAS_MAGICANEG)
795 break;
796 }
797 break;
798 case PHY_NOLINK:
799 err = phy_read_status(phydev);
800
801 if (err)
802 break;
803
804 if (phydev->link) {
805 phydev->state = PHY_RUNNING;
806 netif_carrier_on(phydev->attached_dev);
807 phydev->adjust_link(phydev->attached_dev);
808 }
809 break;
810 case PHY_FORCING:
811 err = genphy_update_link(phydev);
812
813 if (err)
814 break;
815
816 if (phydev->link) {
817 phydev->state = PHY_RUNNING;
818 netif_carrier_on(phydev->attached_dev);
819 } else {
820 if (0 == phydev->link_timeout--)
821 needs_aneg = 1;
822 }
823
824 phydev->adjust_link(phydev->attached_dev);
825 break;
826 case PHY_RUNNING:
827
828
829
830 if (!phy_interrupt_is_valid(phydev))
831 phydev->state = PHY_CHANGELINK;
832 break;
833 case PHY_CHANGELINK:
834 err = phy_read_status(phydev);
835
836 if (err)
837 break;
838
839 if (phydev->link) {
840 phydev->state = PHY_RUNNING;
841 netif_carrier_on(phydev->attached_dev);
842 } else {
843 phydev->state = PHY_NOLINK;
844 netif_carrier_off(phydev->attached_dev);
845 }
846
847 phydev->adjust_link(phydev->attached_dev);
848
849 if (phy_interrupt_is_valid(phydev))
850 err = phy_config_interrupt(phydev,
851 PHY_INTERRUPT_ENABLED);
852 break;
853 case PHY_HALTED:
854 if (phydev->link) {
855 phydev->link = 0;
856 netif_carrier_off(phydev->attached_dev);
857 phydev->adjust_link(phydev->attached_dev);
858 }
859 break;
860 case PHY_RESUMING:
861
862 err = phy_clear_interrupt(phydev);
863
864 if (err)
865 break;
866
867 err = phy_config_interrupt(phydev,
868 PHY_INTERRUPT_ENABLED);
869
870 if (err)
871 break;
872
873 if (AUTONEG_ENABLE == phydev->autoneg) {
874 err = phy_aneg_done(phydev);
875 if (err < 0)
876 break;
877
878
879
880
881 if (err > 0) {
882 err = phy_read_status(phydev);
883 if (err)
884 break;
885
886 if (phydev->link) {
887 phydev->state = PHY_RUNNING;
888 netif_carrier_on(phydev->attached_dev);
889 } else
890 phydev->state = PHY_NOLINK;
891 phydev->adjust_link(phydev->attached_dev);
892 } else {
893 phydev->state = PHY_AN;
894 phydev->link_timeout = PHY_AN_TIMEOUT;
895 }
896 } else {
897 err = phy_read_status(phydev);
898 if (err)
899 break;
900
901 if (phydev->link) {
902 phydev->state = PHY_RUNNING;
903 netif_carrier_on(phydev->attached_dev);
904 } else
905 phydev->state = PHY_NOLINK;
906 phydev->adjust_link(phydev->attached_dev);
907 }
908 break;
909 }
910
911 mutex_unlock(&phydev->lock);
912
913 if (needs_aneg)
914 err = phy_start_aneg(phydev);
915
916 if (err < 0)
917 phy_error(phydev);
918
919 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue,
920 PHY_STATE_TIME * HZ);
921}
922
923void phy_mac_interrupt(struct phy_device *phydev, int new_link)
924{
925 cancel_work_sync(&phydev->phy_queue);
926 phydev->link = new_link;
927 schedule_work(&phydev->phy_queue);
928}
929EXPORT_SYMBOL(phy_mac_interrupt);
930
931static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad,
932 int addr)
933{
934
935 bus->write(bus, addr, MII_MMD_CTRL, devad);
936
937
938 bus->write(bus, addr, MII_MMD_DATA, prtad);
939
940
941 bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR));
942}
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959static int phy_read_mmd_indirect(struct mii_bus *bus, int prtad, int devad,
960 int addr)
961{
962 u32 ret;
963
964 mmd_phy_indirect(bus, prtad, devad, addr);
965
966
967 ret = bus->read(bus, addr, MII_MMD_DATA);
968
969 return ret;
970}
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988static void phy_write_mmd_indirect(struct mii_bus *bus, int prtad, int devad,
989 int addr, u32 data)
990{
991 mmd_phy_indirect(bus, prtad, devad, addr);
992
993
994 bus->write(bus, addr, MII_MMD_DATA, data);
995}
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1008{
1009 int ret = -EPROTONOSUPPORT;
1010
1011
1012
1013
1014
1015 if ((phydev->duplex == DUPLEX_FULL) &&
1016 ((phydev->interface == PHY_INTERFACE_MODE_MII) ||
1017 (phydev->interface == PHY_INTERFACE_MODE_GMII) ||
1018 (phydev->interface == PHY_INTERFACE_MODE_RGMII))) {
1019 int eee_lp, eee_cap, eee_adv;
1020 u32 lp, cap, adv;
1021 int idx, status;
1022
1023
1024 status = phy_read_status(phydev);
1025 if (status)
1026 return status;
1027
1028
1029 eee_cap = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE,
1030 MDIO_MMD_PCS, phydev->addr);
1031 if (eee_cap < 0)
1032 return eee_cap;
1033
1034 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1035 if (!cap)
1036 goto eee_exit;
1037
1038
1039
1040
1041 eee_lp = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE,
1042 MDIO_MMD_AN, phydev->addr);
1043 if (eee_lp < 0)
1044 return eee_lp;
1045
1046 eee_adv = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV,
1047 MDIO_MMD_AN, phydev->addr);
1048 if (eee_adv < 0)
1049 return eee_adv;
1050
1051 adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
1052 lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
1053 idx = phy_find_setting(phydev->speed, phydev->duplex);
1054 if (!(lp & adv & settings[idx].setting))
1055 goto eee_exit;
1056
1057 if (clk_stop_enable) {
1058
1059
1060
1061 int val = phy_read_mmd_indirect(phydev->bus, MDIO_CTRL1,
1062 MDIO_MMD_PCS,
1063 phydev->addr);
1064 if (val < 0)
1065 return val;
1066
1067 val |= MDIO_PCS_CTRL1_CLKSTOP_EN;
1068 phy_write_mmd_indirect(phydev->bus, MDIO_CTRL1,
1069 MDIO_MMD_PCS, phydev->addr, val);
1070 }
1071
1072 ret = 0;
1073 }
1074
1075eee_exit:
1076 return ret;
1077}
1078EXPORT_SYMBOL(phy_init_eee);
1079
1080
1081
1082
1083
1084
1085
1086
1087int phy_get_eee_err(struct phy_device *phydev)
1088{
1089 return phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_WK_ERR,
1090 MDIO_MMD_PCS, phydev->addr);
1091
1092}
1093EXPORT_SYMBOL(phy_get_eee_err);
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1104{
1105 int val;
1106
1107
1108 val = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE,
1109 MDIO_MMD_PCS, phydev->addr);
1110 if (val < 0)
1111 return val;
1112 data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1113
1114
1115 val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV,
1116 MDIO_MMD_AN, phydev->addr);
1117 if (val < 0)
1118 return val;
1119 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1120
1121
1122 val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE,
1123 MDIO_MMD_AN, phydev->addr);
1124 if (val < 0)
1125 return val;
1126 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1127
1128 return 0;
1129}
1130EXPORT_SYMBOL(phy_ethtool_get_eee);
1131
1132
1133
1134
1135
1136
1137
1138
1139int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1140{
1141 int val;
1142
1143 val = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
1144 phy_write_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, MDIO_MMD_AN,
1145 phydev->addr, val);
1146
1147 return 0;
1148}
1149EXPORT_SYMBOL(phy_ethtool_set_eee);
1150
1151int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1152{
1153 if (phydev->drv->set_wol)
1154 return phydev->drv->set_wol(phydev, wol);
1155
1156 return -EOPNOTSUPP;
1157}
1158EXPORT_SYMBOL(phy_ethtool_set_wol);
1159
1160void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1161{
1162 if (phydev->drv->get_wol)
1163 phydev->drv->get_wol(phydev, wol);
1164}
1165EXPORT_SYMBOL(phy_ethtool_get_wol);
1166