1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/kernel.h>
19#include <linux/string.h>
20#include <linux/errno.h>
21#include <linux/unistd.h>
22#include <linux/slab.h>
23#include <linux/interrupt.h>
24#include <linux/init.h>
25#include <linux/delay.h>
26#include <linux/netdevice.h>
27#include <linux/etherdevice.h>
28#include <linux/skbuff.h>
29#include <linux/mm.h>
30#include <linux/module.h>
31#include <linux/mii.h>
32#include <linux/ethtool.h>
33#include <linux/phy.h>
34#include <linux/timer.h>
35#include <linux/workqueue.h>
36
37#include <asm/atomic.h>
38#include <asm/io.h>
39#include <asm/irq.h>
40#include <asm/uaccess.h>
41
42
43
44
45
46void phy_print_status(struct phy_device *phydev)
47{
48 pr_info("PHY: %s - Link is %s", dev_name(&phydev->dev),
49 phydev->link ? "Up" : "Down");
50 if (phydev->link)
51 printk(" - %d/%s", phydev->speed,
52 DUPLEX_FULL == phydev->duplex ?
53 "Full" : "Half");
54
55 printk("\n");
56}
57EXPORT_SYMBOL(phy_print_status);
58
59
60
61
62
63
64
65
66
67
68
69int phy_clear_interrupt(struct phy_device *phydev)
70{
71 int err = 0;
72
73 if (phydev->drv->ack_interrupt)
74 err = phydev->drv->ack_interrupt(phydev);
75
76 return err;
77}
78
79
80
81
82
83
84
85
86int phy_config_interrupt(struct phy_device *phydev, u32 interrupts)
87{
88 int err = 0;
89
90 phydev->interrupts = interrupts;
91 if (phydev->drv->config_intr)
92 err = phydev->drv->config_intr(phydev);
93
94 return err;
95}
96
97
98
99
100
101
102
103
104
105
106static inline int phy_aneg_done(struct phy_device *phydev)
107{
108 int retval;
109
110 retval = phy_read(phydev, MII_BMSR);
111
112 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
113}
114
115
116
117struct phy_setting {
118 int speed;
119 int duplex;
120 u32 setting;
121};
122
123
124static const struct phy_setting settings[] = {
125 {
126 .speed = 10000,
127 .duplex = DUPLEX_FULL,
128 .setting = SUPPORTED_10000baseT_Full,
129 },
130 {
131 .speed = SPEED_1000,
132 .duplex = DUPLEX_FULL,
133 .setting = SUPPORTED_1000baseT_Full,
134 },
135 {
136 .speed = SPEED_1000,
137 .duplex = DUPLEX_HALF,
138 .setting = SUPPORTED_1000baseT_Half,
139 },
140 {
141 .speed = SPEED_100,
142 .duplex = DUPLEX_FULL,
143 .setting = SUPPORTED_100baseT_Full,
144 },
145 {
146 .speed = SPEED_100,
147 .duplex = DUPLEX_HALF,
148 .setting = SUPPORTED_100baseT_Half,
149 },
150 {
151 .speed = SPEED_10,
152 .duplex = DUPLEX_FULL,
153 .setting = SUPPORTED_10baseT_Full,
154 },
155 {
156 .speed = SPEED_10,
157 .duplex = DUPLEX_HALF,
158 .setting = SUPPORTED_10baseT_Half,
159 },
160};
161
162#define MAX_NUM_SETTINGS ARRAY_SIZE(settings)
163
164
165
166
167
168
169
170
171
172
173
174static inline int phy_find_setting(int speed, int duplex)
175{
176 int idx = 0;
177
178 while (idx < ARRAY_SIZE(settings) &&
179 (settings[idx].speed != speed ||
180 settings[idx].duplex != duplex))
181 idx++;
182
183 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
184}
185
186
187
188
189
190
191
192
193
194
195
196static inline int phy_find_valid(int idx, u32 features)
197{
198 while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features))
199 idx++;
200
201 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;
202}
203
204
205
206
207
208
209
210
211
212void phy_sanitize_settings(struct phy_device *phydev)
213{
214 u32 features = phydev->supported;
215 int idx;
216
217
218 if ((features & SUPPORTED_Autoneg) == 0)
219 phydev->autoneg = AUTONEG_DISABLE;
220
221 idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex),
222 features);
223
224 phydev->speed = settings[idx].speed;
225 phydev->duplex = settings[idx].duplex;
226}
227EXPORT_SYMBOL(phy_sanitize_settings);
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 if (cmd->phy_address != phydev->addr)
244 return -EINVAL;
245
246
247
248 cmd->advertising &= phydev->supported;
249
250
251 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE)
252 return -EINVAL;
253
254 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0)
255 return -EINVAL;
256
257 if (cmd->autoneg == AUTONEG_DISABLE
258 && ((cmd->speed != SPEED_1000
259 && cmd->speed != SPEED_100
260 && cmd->speed != SPEED_10)
261 || (cmd->duplex != DUPLEX_HALF
262 && cmd->duplex != DUPLEX_FULL)))
263 return -EINVAL;
264
265 phydev->autoneg = cmd->autoneg;
266
267 phydev->speed = cmd->speed;
268
269 phydev->advertising = cmd->advertising;
270
271 if (AUTONEG_ENABLE == cmd->autoneg)
272 phydev->advertising |= ADVERTISED_Autoneg;
273 else
274 phydev->advertising &= ~ADVERTISED_Autoneg;
275
276 phydev->duplex = cmd->duplex;
277
278
279 phy_start_aneg(phydev);
280
281 return 0;
282}
283EXPORT_SYMBOL(phy_ethtool_sset);
284
285int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd)
286{
287 cmd->supported = phydev->supported;
288
289 cmd->advertising = phydev->advertising;
290
291 cmd->speed = phydev->speed;
292 cmd->duplex = phydev->duplex;
293 cmd->port = PORT_MII;
294 cmd->phy_address = phydev->addr;
295 cmd->transceiver = XCVR_EXTERNAL;
296 cmd->autoneg = phydev->autoneg;
297
298 return 0;
299}
300EXPORT_SYMBOL(phy_ethtool_gset);
301
302
303
304
305
306
307
308
309
310
311
312int phy_mii_ioctl(struct phy_device *phydev,
313 struct mii_ioctl_data *mii_data, int cmd)
314{
315 u16 val = mii_data->val_in;
316
317 switch (cmd) {
318 case SIOCGMIIPHY:
319 mii_data->phy_id = phydev->addr;
320
321
322 case SIOCGMIIREG:
323 mii_data->val_out = phy_read(phydev, mii_data->reg_num);
324 break;
325
326 case SIOCSMIIREG:
327 if (mii_data->phy_id == phydev->addr) {
328 switch(mii_data->reg_num) {
329 case MII_BMCR:
330 if ((val & (BMCR_RESET|BMCR_ANENABLE)) == 0)
331 phydev->autoneg = AUTONEG_DISABLE;
332 else
333 phydev->autoneg = AUTONEG_ENABLE;
334 if ((!phydev->autoneg) && (val & BMCR_FULLDPLX))
335 phydev->duplex = DUPLEX_FULL;
336 else
337 phydev->duplex = DUPLEX_HALF;
338 if ((!phydev->autoneg) &&
339 (val & BMCR_SPEED1000))
340 phydev->speed = SPEED_1000;
341 else if ((!phydev->autoneg) &&
342 (val & BMCR_SPEED100))
343 phydev->speed = SPEED_100;
344 break;
345 case MII_ADVERTISE:
346 phydev->advertising = val;
347 break;
348 default:
349
350 break;
351 }
352 }
353
354 phy_write(phydev, mii_data->reg_num, val);
355
356 if (mii_data->reg_num == MII_BMCR
357 && val & BMCR_RESET
358 && phydev->drv->config_init) {
359 phy_scan_fixups(phydev);
360 phydev->drv->config_init(phydev);
361 }
362 break;
363
364 default:
365 return -EOPNOTSUPP;
366 }
367
368 return 0;
369}
370EXPORT_SYMBOL(phy_mii_ioctl);
371
372
373
374
375
376
377
378
379
380
381int phy_start_aneg(struct phy_device *phydev)
382{
383 int err;
384
385 mutex_lock(&phydev->lock);
386
387 if (AUTONEG_DISABLE == phydev->autoneg)
388 phy_sanitize_settings(phydev);
389
390 err = phydev->drv->config_aneg(phydev);
391
392 if (err < 0)
393 goto out_unlock;
394
395 if (phydev->state != PHY_HALTED) {
396 if (AUTONEG_ENABLE == phydev->autoneg) {
397 phydev->state = PHY_AN;
398 phydev->link_timeout = PHY_AN_TIMEOUT;
399 } else {
400 phydev->state = PHY_FORCING;
401 phydev->link_timeout = PHY_FORCE_TIMEOUT;
402 }
403 }
404
405out_unlock:
406 mutex_unlock(&phydev->lock);
407 return err;
408}
409EXPORT_SYMBOL(phy_start_aneg);
410
411
412static void phy_change(struct work_struct *work);
413static void phy_state_machine(struct work_struct *work);
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428void phy_start_machine(struct phy_device *phydev,
429 void (*handler)(struct net_device *))
430{
431 phydev->adjust_state = handler;
432
433 INIT_DELAYED_WORK(&phydev->state_queue, phy_state_machine);
434 schedule_delayed_work(&phydev->state_queue, HZ);
435}
436
437
438
439
440
441
442
443
444
445void phy_stop_machine(struct phy_device *phydev)
446{
447 cancel_delayed_work_sync(&phydev->state_queue);
448
449 mutex_lock(&phydev->lock);
450 if (phydev->state > PHY_UP)
451 phydev->state = PHY_UP;
452 mutex_unlock(&phydev->lock);
453
454 phydev->adjust_state = NULL;
455}
456
457
458
459
460
461
462
463
464
465
466static void phy_force_reduction(struct phy_device *phydev)
467{
468 int idx;
469
470 idx = phy_find_setting(phydev->speed, phydev->duplex);
471
472 idx++;
473
474 idx = phy_find_valid(idx, phydev->supported);
475
476 phydev->speed = settings[idx].speed;
477 phydev->duplex = settings[idx].duplex;
478
479 pr_info("Trying %d/%s\n", phydev->speed,
480 DUPLEX_FULL == phydev->duplex ?
481 "FULL" : "HALF");
482}
483
484
485
486
487
488
489
490
491
492
493
494static void phy_error(struct phy_device *phydev)
495{
496 mutex_lock(&phydev->lock);
497 phydev->state = PHY_HALTED;
498 mutex_unlock(&phydev->lock);
499}
500
501
502
503
504
505
506
507
508
509static irqreturn_t phy_interrupt(int irq, void *phy_dat)
510{
511 struct phy_device *phydev = phy_dat;
512
513 if (PHY_HALTED == phydev->state)
514 return IRQ_NONE;
515
516
517
518
519
520 disable_irq_nosync(irq);
521 atomic_inc(&phydev->irq_disable);
522
523 schedule_work(&phydev->phy_queue);
524
525 return IRQ_HANDLED;
526}
527
528
529
530
531
532int phy_enable_interrupts(struct phy_device *phydev)
533{
534 int err;
535
536 err = phy_clear_interrupt(phydev);
537
538 if (err < 0)
539 return err;
540
541 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
542
543 return err;
544}
545EXPORT_SYMBOL(phy_enable_interrupts);
546
547
548
549
550
551int phy_disable_interrupts(struct phy_device *phydev)
552{
553 int err;
554
555
556 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
557
558 if (err)
559 goto phy_err;
560
561
562 err = phy_clear_interrupt(phydev);
563
564 if (err)
565 goto phy_err;
566
567 return 0;
568
569phy_err:
570 phy_error(phydev);
571
572 return err;
573}
574EXPORT_SYMBOL(phy_disable_interrupts);
575
576
577
578
579
580
581
582
583
584
585
586int phy_start_interrupts(struct phy_device *phydev)
587{
588 int err = 0;
589
590 INIT_WORK(&phydev->phy_queue, phy_change);
591
592 atomic_set(&phydev->irq_disable, 0);
593 if (request_irq(phydev->irq, phy_interrupt,
594 IRQF_SHARED,
595 "phy_interrupt",
596 phydev) < 0) {
597 printk(KERN_WARNING "%s: Can't get IRQ %d (PHY)\n",
598 phydev->bus->name,
599 phydev->irq);
600 phydev->irq = PHY_POLL;
601 return 0;
602 }
603
604 err = phy_enable_interrupts(phydev);
605
606 return err;
607}
608EXPORT_SYMBOL(phy_start_interrupts);
609
610
611
612
613
614int phy_stop_interrupts(struct phy_device *phydev)
615{
616 int err;
617
618 err = phy_disable_interrupts(phydev);
619
620 if (err)
621 phy_error(phydev);
622
623 free_irq(phydev->irq, phydev);
624
625
626
627
628
629
630
631 cancel_work_sync(&phydev->phy_queue);
632
633
634
635
636
637 while (atomic_dec_return(&phydev->irq_disable) >= 0)
638 enable_irq(phydev->irq);
639
640 return err;
641}
642EXPORT_SYMBOL(phy_stop_interrupts);
643
644
645
646
647
648
649static void phy_change(struct work_struct *work)
650{
651 int err;
652 struct phy_device *phydev =
653 container_of(work, struct phy_device, phy_queue);
654
655 if (phydev->drv->did_interrupt &&
656 !phydev->drv->did_interrupt(phydev))
657 goto ignore;
658
659 err = phy_disable_interrupts(phydev);
660
661 if (err)
662 goto phy_err;
663
664 mutex_lock(&phydev->lock);
665 if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))
666 phydev->state = PHY_CHANGELINK;
667 mutex_unlock(&phydev->lock);
668
669 atomic_dec(&phydev->irq_disable);
670 enable_irq(phydev->irq);
671
672
673 if (PHY_HALTED != phydev->state)
674 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
675
676 if (err)
677 goto irq_enable_err;
678
679
680 cancel_delayed_work_sync(&phydev->state_queue);
681 schedule_delayed_work(&phydev->state_queue, 0);
682
683 return;
684
685ignore:
686 atomic_dec(&phydev->irq_disable);
687 enable_irq(phydev->irq);
688 return;
689
690irq_enable_err:
691 disable_irq(phydev->irq);
692 atomic_inc(&phydev->irq_disable);
693phy_err:
694 phy_error(phydev);
695}
696
697
698
699
700
701void phy_stop(struct phy_device *phydev)
702{
703 mutex_lock(&phydev->lock);
704
705 if (PHY_HALTED == phydev->state)
706 goto out_unlock;
707
708 if (phydev->irq != PHY_POLL) {
709
710 phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
711
712
713 phy_clear_interrupt(phydev);
714 }
715
716 phydev->state = PHY_HALTED;
717
718out_unlock:
719 mutex_unlock(&phydev->lock);
720
721
722
723
724
725
726}
727
728
729
730
731
732
733
734
735
736
737
738
739void phy_start(struct phy_device *phydev)
740{
741 mutex_lock(&phydev->lock);
742
743 switch (phydev->state) {
744 case PHY_STARTING:
745 phydev->state = PHY_PENDING;
746 break;
747 case PHY_READY:
748 phydev->state = PHY_UP;
749 break;
750 case PHY_HALTED:
751 phydev->state = PHY_RESUMING;
752 default:
753 break;
754 }
755 mutex_unlock(&phydev->lock);
756}
757EXPORT_SYMBOL(phy_stop);
758EXPORT_SYMBOL(phy_start);
759
760
761
762
763
764static void phy_state_machine(struct work_struct *work)
765{
766 struct delayed_work *dwork = to_delayed_work(work);
767 struct phy_device *phydev =
768 container_of(dwork, struct phy_device, state_queue);
769 int needs_aneg = 0;
770 int err = 0;
771
772 mutex_lock(&phydev->lock);
773
774 if (phydev->adjust_state)
775 phydev->adjust_state(phydev->attached_dev);
776
777 switch(phydev->state) {
778 case PHY_DOWN:
779 case PHY_STARTING:
780 case PHY_READY:
781 case PHY_PENDING:
782 break;
783 case PHY_UP:
784 needs_aneg = 1;
785
786 phydev->link_timeout = PHY_AN_TIMEOUT;
787
788 break;
789 case PHY_AN:
790 err = phy_read_status(phydev);
791
792 if (err < 0)
793 break;
794
795
796
797 if (!phydev->link) {
798 phydev->state = PHY_NOLINK;
799 netif_carrier_off(phydev->attached_dev);
800 phydev->adjust_link(phydev->attached_dev);
801 break;
802 }
803
804
805
806 err = phy_aneg_done(phydev);
807 if (err < 0)
808 break;
809
810
811 if (err > 0) {
812 phydev->state = PHY_RUNNING;
813 netif_carrier_on(phydev->attached_dev);
814 phydev->adjust_link(phydev->attached_dev);
815
816 } else if (0 == phydev->link_timeout--) {
817 int idx;
818
819 needs_aneg = 1;
820
821
822 if (phydev->drv->flags & PHY_HAS_MAGICANEG)
823 break;
824
825
826
827
828
829
830 idx = phy_find_valid(0, phydev->supported);
831
832 phydev->speed = settings[idx].speed;
833 phydev->duplex = settings[idx].duplex;
834
835 phydev->autoneg = AUTONEG_DISABLE;
836
837 pr_info("Trying %d/%s\n", phydev->speed,
838 DUPLEX_FULL ==
839 phydev->duplex ?
840 "FULL" : "HALF");
841 }
842 break;
843 case PHY_NOLINK:
844 err = phy_read_status(phydev);
845
846 if (err)
847 break;
848
849 if (phydev->link) {
850 phydev->state = PHY_RUNNING;
851 netif_carrier_on(phydev->attached_dev);
852 phydev->adjust_link(phydev->attached_dev);
853 }
854 break;
855 case PHY_FORCING:
856 err = genphy_update_link(phydev);
857
858 if (err)
859 break;
860
861 if (phydev->link) {
862 phydev->state = PHY_RUNNING;
863 netif_carrier_on(phydev->attached_dev);
864 } else {
865 if (0 == phydev->link_timeout--) {
866 phy_force_reduction(phydev);
867 needs_aneg = 1;
868 }
869 }
870
871 phydev->adjust_link(phydev->attached_dev);
872 break;
873 case PHY_RUNNING:
874
875
876 if (PHY_POLL == phydev->irq)
877 phydev->state = PHY_CHANGELINK;
878 break;
879 case PHY_CHANGELINK:
880 err = phy_read_status(phydev);
881
882 if (err)
883 break;
884
885 if (phydev->link) {
886 phydev->state = PHY_RUNNING;
887 netif_carrier_on(phydev->attached_dev);
888 } else {
889 phydev->state = PHY_NOLINK;
890 netif_carrier_off(phydev->attached_dev);
891 }
892
893 phydev->adjust_link(phydev->attached_dev);
894
895 if (PHY_POLL != phydev->irq)
896 err = phy_config_interrupt(phydev,
897 PHY_INTERRUPT_ENABLED);
898 break;
899 case PHY_HALTED:
900 if (phydev->link) {
901 phydev->link = 0;
902 netif_carrier_off(phydev->attached_dev);
903 phydev->adjust_link(phydev->attached_dev);
904 }
905 break;
906 case PHY_RESUMING:
907
908 err = phy_clear_interrupt(phydev);
909
910 if (err)
911 break;
912
913 err = phy_config_interrupt(phydev,
914 PHY_INTERRUPT_ENABLED);
915
916 if (err)
917 break;
918
919 if (AUTONEG_ENABLE == phydev->autoneg) {
920 err = phy_aneg_done(phydev);
921 if (err < 0)
922 break;
923
924
925
926
927 if (err > 0) {
928 err = phy_read_status(phydev);
929 if (err)
930 break;
931
932 if (phydev->link) {
933 phydev->state = PHY_RUNNING;
934 netif_carrier_on(phydev->attached_dev);
935 } else
936 phydev->state = PHY_NOLINK;
937 phydev->adjust_link(phydev->attached_dev);
938 } else {
939 phydev->state = PHY_AN;
940 phydev->link_timeout = PHY_AN_TIMEOUT;
941 }
942 } else {
943 err = phy_read_status(phydev);
944 if (err)
945 break;
946
947 if (phydev->link) {
948 phydev->state = PHY_RUNNING;
949 netif_carrier_on(phydev->attached_dev);
950 } else
951 phydev->state = PHY_NOLINK;
952 phydev->adjust_link(phydev->attached_dev);
953 }
954 break;
955 }
956
957 mutex_unlock(&phydev->lock);
958
959 if (needs_aneg)
960 err = phy_start_aneg(phydev);
961
962 if (err < 0)
963 phy_error(phydev);
964
965 schedule_delayed_work(&phydev->state_queue, PHY_STATE_TIME * HZ);
966}
967