1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413#include <config.h>
414
415#include "h/skdrv1st.h"
416#include "h/skdrv2nd.h"
417
418
419
420
421typedef struct s_PhyHack {
422 int PhyReg;
423 SK_U16 PhyVal;
424} BCOM_HACK;
425
426
427static const char SysKonnectFileId[] =
428 "@(#)$Id: skxmac2.c,v 1.91 2003/02/05 15:09:34 rschmidt Exp $ (C) SK ";
429
430BCOM_HACK BcomRegA1Hack[] = {
431 { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1104 }, { 0x17, 0x0013 },
432 { 0x15, 0x0404 }, { 0x17, 0x8006 }, { 0x15, 0x0132 }, { 0x17, 0x8006 },
433 { 0x15, 0x0232 }, { 0x17, 0x800D }, { 0x15, 0x000F }, { 0x18, 0x0420 },
434 { 0, 0 }
435};
436BCOM_HACK BcomRegC0Hack[] = {
437 { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1204 }, { 0x17, 0x0013 },
438 { 0x15, 0x0A04 }, { 0x18, 0x0420 },
439 { 0, 0 }
440};
441
442
443static void SkXmInitPhyXmac(SK_AC*, SK_IOC, int, SK_BOOL);
444static void SkXmInitPhyBcom(SK_AC*, SK_IOC, int, SK_BOOL);
445static void SkGmInitPhyMarv(SK_AC*, SK_IOC, int, SK_BOOL);
446static int SkXmAutoNegDoneXmac(SK_AC*, SK_IOC, int);
447static int SkXmAutoNegDoneBcom(SK_AC*, SK_IOC, int);
448static int SkGmAutoNegDoneMarv(SK_AC*, SK_IOC, int);
449#ifdef OTHER_PHY
450static void SkXmInitPhyLone(SK_AC*, SK_IOC, int, SK_BOOL);
451static void SkXmInitPhyNat (SK_AC*, SK_IOC, int, SK_BOOL);
452static int SkXmAutoNegDoneLone(SK_AC*, SK_IOC, int);
453static int SkXmAutoNegDoneNat (SK_AC*, SK_IOC, int);
454#endif
455
456
457
458
459
460
461
462
463
464
465
466void SkXmPhyRead(
467SK_AC *pAC,
468SK_IOC IoC,
469int Port,
470int PhyReg,
471SK_U16 *pVal)
472{
473 SK_U16 Mmu;
474 SK_GEPORT *pPrt;
475
476 pPrt = &pAC->GIni.GP[Port];
477
478
479 XM_OUT16(IoC, Port, XM_PHY_ADDR, PhyReg | pPrt->PhyAddr);
480
481
482 XM_IN16(IoC, Port, XM_PHY_DATA, pVal);
483
484 if (pPrt->PhyType != SK_PHY_XMAC) {
485 do {
486 XM_IN16(IoC, Port, XM_MMU_CMD, &Mmu);
487
488 } while ((Mmu & XM_MMU_PHY_RDY) == 0);
489
490
491 XM_IN16(IoC, Port, XM_PHY_DATA, pVal);
492 }
493}
494
495
496
497
498
499
500
501
502
503
504
505void SkXmPhyWrite(
506SK_AC *pAC,
507SK_IOC IoC,
508int Port,
509int PhyReg,
510SK_U16 Val)
511{
512 SK_U16 Mmu;
513 SK_GEPORT *pPrt;
514
515 pPrt = &pAC->GIni.GP[Port];
516
517 if (pPrt->PhyType != SK_PHY_XMAC) {
518 do {
519 XM_IN16(IoC, Port, XM_MMU_CMD, &Mmu);
520
521 } while ((Mmu & XM_MMU_PHY_BUSY) != 0);
522 }
523
524
525 XM_OUT16(IoC, Port, XM_PHY_ADDR, PhyReg | pPrt->PhyAddr);
526
527
528 XM_OUT16(IoC, Port, XM_PHY_DATA, Val);
529
530 if (pPrt->PhyType != SK_PHY_XMAC) {
531 do {
532 XM_IN16(IoC, Port, XM_MMU_CMD, &Mmu);
533
534 } while ((Mmu & XM_MMU_PHY_BUSY) != 0);
535 }
536}
537
538
539
540
541
542
543
544
545
546
547
548void SkGmPhyRead(
549SK_AC *pAC,
550SK_IOC IoC,
551int Port,
552int PhyReg,
553SK_U16 *pVal)
554{
555 SK_U16 Ctrl;
556 SK_GEPORT *pPrt;
557#ifdef VCPU
558 u_long SimCyle;
559 u_long SimLowTime;
560
561 VCPUgetTime(&SimCyle, &SimLowTime);
562 VCPUprintf(0, "SkGmPhyRead(%u), SimCyle=%u, SimLowTime=%u\n",
563 PhyReg, SimCyle, SimLowTime);
564#endif
565
566 pPrt = &pAC->GIni.GP[Port];
567
568
569 *pVal = (SK_U16)(GM_SMI_CT_PHY_AD(pPrt->PhyAddr) |
570 GM_SMI_CT_REG_AD(PhyReg) | GM_SMI_CT_OP_RD);
571
572 GM_OUT16(IoC, Port, GM_SMI_CTRL, *pVal);
573
574 GM_IN16(IoC, Port, GM_SMI_CTRL, &Ctrl);
575
576
577 if ((Ctrl & GM_SMI_CT_BUSY) == 0) {
578 *pVal = 0;
579 return;
580 }
581
582 *pVal |= GM_SMI_CT_BUSY;
583
584 do {
585#ifdef VCPU
586 VCPUwaitTime(1000);
587#endif
588
589 GM_IN16(IoC, Port, GM_SMI_CTRL, &Ctrl);
590
591
592 } while (Ctrl == *pVal);
593
594
595 GM_IN16(IoC, Port, GM_SMI_DATA, pVal);
596
597#ifdef VCPU
598 VCPUgetTime(&SimCyle, &SimLowTime);
599 VCPUprintf(0, "VCPUgetTime(), SimCyle=%u, SimLowTime=%u\n",
600 SimCyle, SimLowTime);
601#endif
602}
603
604
605
606
607
608
609
610
611
612
613
614void SkGmPhyWrite(
615SK_AC *pAC,
616SK_IOC IoC,
617int Port,
618int PhyReg,
619SK_U16 Val)
620{
621 SK_U16 Ctrl;
622 SK_GEPORT *pPrt;
623#ifdef VCPU
624 SK_U32 DWord;
625 u_long SimCyle;
626 u_long SimLowTime;
627
628 VCPUgetTime(&SimCyle, &SimLowTime);
629 VCPUprintf(0, "SkGmPhyWrite(Reg=%u, Val=0x%04x), SimCyle=%u, SimLowTime=%u\n",
630 PhyReg, Val, SimCyle, SimLowTime);
631#endif
632
633 pPrt = &pAC->GIni.GP[Port];
634
635
636 GM_OUT16(IoC, Port, GM_SMI_DATA, Val);
637
638
639 Val = GM_SMI_CT_PHY_AD(pPrt->PhyAddr) | GM_SMI_CT_REG_AD(PhyReg);
640
641 GM_OUT16(IoC, Port, GM_SMI_CTRL, Val);
642
643 GM_IN16(IoC, Port, GM_SMI_CTRL, &Ctrl);
644
645
646 if ((Ctrl & GM_SMI_CT_BUSY) == 0) {
647 return;
648 }
649
650 Val |= GM_SMI_CT_BUSY;
651
652 do {
653#ifdef VCPU
654
655 SK_IN32(IoC, B2_TI_VAL, &DWord);
656
657 VCPUwaitTime(1000);
658#endif
659
660 GM_IN16(IoC, Port, GM_SMI_CTRL, &Ctrl);
661
662
663 } while (Ctrl == Val);
664
665#ifdef VCPU
666 VCPUgetTime(&SimCyle, &SimLowTime);
667 VCPUprintf(0, "VCPUgetTime(), SimCyle=%u, SimLowTime=%u\n",
668 SimCyle, SimLowTime);
669#endif
670}
671
672
673
674
675
676
677
678
679
680
681
682void SkGePhyRead(
683SK_AC *pAC,
684SK_IOC IoC,
685int Port,
686int PhyReg,
687SK_U16 *pVal)
688{
689 void (*r_func)(SK_AC *pAC, SK_IOC IoC, int Port, int Reg, SK_U16 *pVal);
690
691 if (pAC->GIni.GIGenesis) {
692 r_func = SkXmPhyRead;
693 }
694 else {
695 r_func = SkGmPhyRead;
696 }
697
698 r_func(pAC, IoC, Port, PhyReg, pVal);
699}
700
701
702
703
704
705
706
707
708
709
710
711void SkGePhyWrite(
712SK_AC *pAC,
713SK_IOC IoC,
714int Port,
715int PhyReg,
716SK_U16 Val)
717{
718 void (*w_func)(SK_AC *pAC, SK_IOC IoC, int Port, int Reg, SK_U16 Val);
719
720 if (pAC->GIni.GIGenesis) {
721 w_func = SkXmPhyWrite;
722 }
723 else {
724 w_func = SkGmPhyWrite;
725 }
726
727 w_func(pAC, IoC, Port, PhyReg, Val);
728}
729
730
731
732
733
734
735
736
737
738
739
740
741
742void SkMacPromiscMode(
743SK_AC *pAC,
744SK_IOC IoC,
745int Port,
746SK_BOOL Enable)
747{
748 SK_U16 RcReg;
749 SK_U32 MdReg;
750
751 if (pAC->GIni.GIGenesis) {
752
753 XM_IN32(IoC, Port, XM_MODE, &MdReg);
754
755 if (Enable) {
756 MdReg |= XM_MD_ENA_PROM;
757 }
758 else {
759 MdReg &= ~XM_MD_ENA_PROM;
760 }
761
762 XM_OUT32(IoC, Port, XM_MODE, MdReg);
763 }
764 else {
765
766 GM_IN16(IoC, Port, GM_RX_CTRL, &RcReg);
767
768
769 if (Enable) {
770 RcReg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
771 }
772 else {
773 RcReg |= (GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
774 }
775
776 GM_OUT16(IoC, Port, GM_RX_CTRL, RcReg);
777 }
778}
779
780
781
782
783
784
785
786
787
788
789
790
791
792void SkMacHashing(
793SK_AC *pAC,
794SK_IOC IoC,
795int Port,
796SK_BOOL Enable)
797{
798 SK_U16 RcReg;
799 SK_U32 MdReg;
800
801 if (pAC->GIni.GIGenesis) {
802
803 XM_IN32(IoC, Port, XM_MODE, &MdReg);
804
805 if (Enable) {
806 MdReg |= XM_MD_ENA_HASH;
807 }
808 else {
809 MdReg &= ~XM_MD_ENA_HASH;
810 }
811
812 XM_OUT32(IoC, Port, XM_MODE, MdReg);
813 }
814 else {
815
816 GM_IN16(IoC, Port, GM_RX_CTRL, &RcReg);
817
818
819 if (Enable) {
820 RcReg |= GM_RXCR_MCF_ENA;
821 }
822 else {
823 RcReg &= ~GM_RXCR_MCF_ENA;
824 }
825
826 GM_OUT16(IoC, Port, GM_RX_CTRL, RcReg);
827 }
828}
829
830
831#ifdef SK_DIAG
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854static void SkXmSetRxCmd(
855SK_AC *pAC,
856SK_IOC IoC,
857int Port,
858int Mode)
859
860{
861 SK_U16 OldRxCmd;
862 SK_U16 RxCmd;
863
864 XM_IN16(IoC, Port, XM_RX_CMD, &OldRxCmd);
865
866 RxCmd = OldRxCmd;
867
868 switch (Mode & (SK_STRIP_FCS_ON | SK_STRIP_FCS_OFF)) {
869 case SK_STRIP_FCS_ON:
870 RxCmd |= XM_RX_STRIP_FCS;
871 break;
872 case SK_STRIP_FCS_OFF:
873 RxCmd &= ~XM_RX_STRIP_FCS;
874 break;
875 }
876
877 switch (Mode & (SK_STRIP_PAD_ON | SK_STRIP_PAD_OFF)) {
878 case SK_STRIP_PAD_ON:
879 RxCmd |= XM_RX_STRIP_PAD;
880 break;
881 case SK_STRIP_PAD_OFF:
882 RxCmd &= ~XM_RX_STRIP_PAD;
883 break;
884 }
885
886 switch (Mode & (SK_LENERR_OK_ON | SK_LENERR_OK_OFF)) {
887 case SK_LENERR_OK_ON:
888 RxCmd |= XM_RX_LENERR_OK;
889 break;
890 case SK_LENERR_OK_OFF:
891 RxCmd &= ~XM_RX_LENERR_OK;
892 break;
893 }
894
895 switch (Mode & (SK_BIG_PK_OK_ON | SK_BIG_PK_OK_OFF)) {
896 case SK_BIG_PK_OK_ON:
897 RxCmd |= XM_RX_BIG_PK_OK;
898 break;
899 case SK_BIG_PK_OK_OFF:
900 RxCmd &= ~XM_RX_BIG_PK_OK;
901 break;
902 }
903
904 switch (Mode & (SK_SELF_RX_ON | SK_SELF_RX_OFF)) {
905 case SK_SELF_RX_ON:
906 RxCmd |= XM_RX_SELF_RX;
907 break;
908 case SK_SELF_RX_OFF:
909 RxCmd &= ~XM_RX_SELF_RX;
910 break;
911 }
912
913
914 if (OldRxCmd != RxCmd) {
915 XM_OUT16(IoC, Port, XM_RX_CMD, RxCmd);
916 }
917}
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939static void SkGmSetRxCmd(
940SK_AC *pAC,
941SK_IOC IoC,
942int Port,
943int Mode)
944
945{
946 SK_U16 OldRxCmd;
947 SK_U16 RxCmd;
948
949 if ((Mode & (SK_STRIP_FCS_ON | SK_STRIP_FCS_OFF)) != 0) {
950
951 GM_IN16(IoC, Port, GM_RX_CTRL, &OldRxCmd);
952
953 RxCmd = OldRxCmd;
954
955 if ((Mode & SK_STRIP_FCS_ON) != 0) {
956 RxCmd |= GM_RXCR_CRC_DIS;
957 }
958 else {
959 RxCmd &= ~GM_RXCR_CRC_DIS;
960 }
961
962 if (OldRxCmd != RxCmd) {
963 GM_OUT16(IoC, Port, GM_RX_CTRL, RxCmd);
964 }
965 }
966
967 if ((Mode & (SK_BIG_PK_OK_ON | SK_BIG_PK_OK_OFF)) != 0) {
968
969 GM_IN16(IoC, Port, GM_SERIAL_MODE, &OldRxCmd);
970
971 RxCmd = OldRxCmd;
972
973 if ((Mode & SK_BIG_PK_OK_ON) != 0) {
974 RxCmd |= GM_SMOD_JUMBO_ENA;
975 }
976 else {
977 RxCmd &= ~GM_SMOD_JUMBO_ENA;
978 }
979
980 if (OldRxCmd != RxCmd) {
981 GM_OUT16(IoC, Port, GM_SERIAL_MODE, RxCmd);
982 }
983 }
984}
985
986
987
988
989
990
991
992
993
994
995
996void SkMacSetRxCmd(
997SK_AC *pAC,
998SK_IOC IoC,
999int Port,
1000int Mode)
1001{
1002 if (pAC->GIni.GIGenesis) {
1003
1004 SkXmSetRxCmd(pAC, IoC, Port, Mode);
1005 }
1006 else {
1007
1008 SkGmSetRxCmd(pAC, IoC, Port, Mode);
1009 }
1010}
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022void SkMacCrcGener(
1023SK_AC *pAC,
1024SK_IOC IoC,
1025int Port,
1026SK_BOOL Enable)
1027{
1028 SK_U16 Word;
1029
1030 if (pAC->GIni.GIGenesis) {
1031
1032 XM_IN16(IoC, Port, XM_TX_CMD, &Word);
1033
1034 if (Enable) {
1035 Word &= ~XM_TX_NO_CRC;
1036 }
1037 else {
1038 Word |= XM_TX_NO_CRC;
1039 }
1040
1041 XM_OUT16(pAC, Port, XM_TX_CMD, Word);
1042 }
1043 else {
1044
1045 GM_IN16(IoC, Port, GM_TX_CTRL, &Word);
1046
1047 if (Enable) {
1048 Word &= ~GM_TXCR_CRC_DIS;
1049 }
1050 else {
1051 Word |= GM_TXCR_CRC_DIS;
1052 }
1053
1054 GM_OUT16(IoC, Port, GM_TX_CTRL, Word);
1055 }
1056}
1057
1058#endif
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073void SkXmClrExactAddr(
1074SK_AC *pAC,
1075SK_IOC IoC,
1076int Port,
1077int StartNum,
1078int StopNum)
1079{
1080 int i;
1081 SK_U16 ZeroAddr[3] = {0x0000, 0x0000, 0x0000};
1082
1083 if ((unsigned)StartNum > 15 || (unsigned)StopNum > 15 ||
1084 StartNum > StopNum) {
1085
1086 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E001, SKERR_HWI_E001MSG);
1087 return;
1088 }
1089
1090 for (i = StartNum; i <= StopNum; i++) {
1091 XM_OUTADDR(IoC, Port, XM_EXM(i), &ZeroAddr[0]);
1092 }
1093}
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106void SkMacFlushTxFifo(
1107SK_AC *pAC,
1108SK_IOC IoC,
1109int Port)
1110{
1111 SK_U32 MdReg;
1112
1113 if (pAC->GIni.GIGenesis) {
1114
1115 XM_IN32(IoC, Port, XM_MODE, &MdReg);
1116
1117 XM_OUT32(IoC, Port, XM_MODE, MdReg | XM_MD_FTF);
1118 }
1119 else {
1120
1121
1122 }
1123}
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136void SkMacFlushRxFifo(
1137SK_AC *pAC,
1138SK_IOC IoC,
1139int Port)
1140{
1141 SK_U32 MdReg;
1142
1143 if (pAC->GIni.GIGenesis) {
1144
1145 XM_IN32(IoC, Port, XM_MODE, &MdReg);
1146
1147 XM_OUT32(IoC, Port, XM_MODE, MdReg | XM_MD_FRF);
1148 }
1149 else {
1150
1151
1152 }
1153}
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191static void SkXmSoftRst(
1192SK_AC *pAC,
1193SK_IOC IoC,
1194int Port)
1195{
1196 SK_U16 ZeroAddr[4] = {0x0000, 0x0000, 0x0000, 0x0000};
1197
1198
1199 XM_OUT32(IoC, Port, XM_GP_PORT, XM_GP_RES_STAT);
1200
1201
1202 XM_OUT16(IoC, Port, XM_IMSK, 0xffff);
1203
1204 XM_OUT32(IoC, Port, XM_MODE, 0);
1205
1206 XM_OUT16(IoC, Port, XM_TX_CMD, 0);
1207 XM_OUT16(IoC, Port, XM_RX_CMD, 0);
1208
1209
1210 switch (pAC->GIni.GP[Port].PhyType) {
1211 case SK_PHY_BCOM:
1212 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_INT_MASK, 0xffff);
1213 break;
1214#ifdef OTHER_PHY
1215 case SK_PHY_LONE:
1216 SkXmPhyWrite(pAC, IoC, Port, PHY_LONE_INT_ENAB, 0);
1217 break;
1218 case SK_PHY_NAT:
1219
1220
1221 break;
1222#endif
1223 }
1224
1225
1226 XM_OUTHASH(IoC, Port, XM_HSM, &ZeroAddr);
1227
1228
1229 SkXmClrExactAddr(pAC, IoC, Port, 0, 15);
1230
1231
1232 XM_OUTHASH(IoC, Port, XM_SRC_CHK, &ZeroAddr);
1233
1234}
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254static void SkXmHardRst(
1255SK_AC *pAC,
1256SK_IOC IoC,
1257int Port)
1258{
1259 SK_U32 Reg;
1260 int i;
1261 int TOut;
1262 SK_U16 Word;
1263
1264 for (i = 0; i < 4; i++) {
1265
1266 SK_OUT16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), MFF_CLR_MAC_RST);
1267
1268 TOut = 0;
1269 do {
1270 if (TOut++ > 10000) {
1271
1272
1273
1274
1275 return;
1276 }
1277
1278 SK_OUT16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), MFF_SET_MAC_RST);
1279
1280 SK_IN16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), &Word);
1281
1282 } while ((Word & MFF_SET_MAC_RST) == 0);
1283 }
1284
1285
1286 if (pAC->GIni.GP[Port].PhyType != SK_PHY_XMAC) {
1287
1288 SK_IN32(IoC, B2_GP_IO, &Reg);
1289 if (Port == 0) {
1290 Reg |= GP_DIR_0;
1291 Reg &= ~GP_IO_0;
1292 }
1293 else {
1294 Reg |= GP_DIR_2;
1295 Reg &= ~GP_IO_2;
1296 }
1297 SK_OUT32(IoC, B2_GP_IO, Reg);
1298
1299
1300 SK_IN32(IoC, B2_GP_IO, &Reg);
1301 }
1302
1303}
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317static void SkGmSoftRst(
1318SK_AC *pAC,
1319SK_IOC IoC,
1320int Port)
1321{
1322 SK_U16 EmptyHash[4] = {0x0000, 0x0000, 0x0000, 0x0000};
1323 SK_U16 RxCtrl;
1324
1325
1326
1327
1328 SK_OUT8(IoC, GMAC_IRQ_MSK, 0);
1329
1330
1331 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_INT_MASK, 0);
1332
1333
1334 GM_OUTHASH(IoC, Port, GM_MC_ADDR_H1, EmptyHash);
1335
1336
1337 GM_IN16(IoC, Port, GM_RX_CTRL, &RxCtrl);
1338
1339 GM_OUT16(IoC, Port, GM_RX_CTRL,
1340 RxCtrl | GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
1341
1342}
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358static void SkGmHardRst(
1359SK_AC *pAC,
1360SK_IOC IoC,
1361int Port)
1362{
1363
1364 SK_OUT32(IoC, MR_ADDR(Port, GPHY_CTRL), GPC_RST_SET);
1365
1366
1367 SK_OUT32(IoC, MR_ADDR(Port, GMAC_CTRL), GMC_RST_SET);
1368
1369}
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381void SkMacSoftRst(
1382SK_AC *pAC,
1383SK_IOC IoC,
1384int Port)
1385{
1386 SK_GEPORT *pPrt;
1387
1388 pPrt = &pAC->GIni.GP[Port];
1389
1390
1391 SkMacRxTxDisable(pAC, IoC, Port);
1392
1393 if (pAC->GIni.GIGenesis) {
1394
1395 SkXmSoftRst(pAC, IoC, Port);
1396 }
1397 else {
1398
1399 SkGmSoftRst(pAC, IoC, Port);
1400 }
1401
1402
1403 SkMacFlushTxFifo(pAC, IoC, Port);
1404
1405 SkMacFlushRxFifo(pAC, IoC, Port);
1406
1407 pPrt->PState = SK_PRT_STOP;
1408
1409}
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421void SkMacHardRst(
1422SK_AC *pAC,
1423SK_IOC IoC,
1424int Port)
1425{
1426
1427 if (pAC->GIni.GIGenesis) {
1428
1429 SkXmHardRst(pAC, IoC, Port);
1430 }
1431 else {
1432
1433 SkGmHardRst(pAC, IoC, Port);
1434 }
1435
1436 pAC->GIni.GP[Port].PState = SK_PRT_RESET;
1437
1438}
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455void SkXmInitMac(
1456SK_AC *pAC,
1457SK_IOC IoC,
1458int Port)
1459{
1460 SK_GEPORT *pPrt;
1461 SK_U32 Reg;
1462 int i;
1463 SK_U16 SWord;
1464
1465 pPrt = &pAC->GIni.GP[Port];
1466
1467 if (pPrt->PState == SK_PRT_STOP) {
1468
1469
1470 SK_IN16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), &SWord);
1471
1472 if ((SWord & MFF_SET_MAC_RST) != 0) {
1473
1474 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E006, SKERR_HWI_E006MSG);
1475
1476 pPrt->PState = SK_PRT_RESET;
1477 }
1478 }
1479
1480 if (pPrt->PState == SK_PRT_RESET) {
1481
1482
1483
1484
1485
1486 SK_OUT16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), MFF_CLR_MAC_RST);
1487
1488
1489 SK_IN16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), &SWord);
1490
1491
1492 if (pPrt->PhyType != SK_PHY_XMAC) {
1493
1494 SK_IN32(IoC, B2_GP_IO, &Reg);
1495
1496 if (Port == 0) {
1497 Reg |= (GP_DIR_0 | GP_IO_0);
1498 }
1499 else {
1500 Reg |= (GP_DIR_2 | GP_IO_2);
1501 }
1502 SK_OUT32(IoC, B2_GP_IO, Reg);
1503
1504
1505 XM_OUT16(IoC, Port, XM_HW_CFG, XM_HW_GMII_MD);
1506
1507
1508 SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_ID1, &pPrt->PhyId1);
1509
1510
1511
1512
1513
1514 XM_IN16(IoC, Port, XM_MMU_CMD, &SWord);
1515
1516 XM_OUT16(IoC, Port, XM_MMU_CMD, SWord | XM_MMU_NO_PRE);
1517
1518 if (pPrt->PhyId1 == PHY_BCOM_ID1_C0) {
1519
1520
1521
1522
1523 i = 0;
1524 while (BcomRegC0Hack[i].PhyReg != 0) {
1525 SkXmPhyWrite(pAC, IoC, Port, BcomRegC0Hack[i].PhyReg,
1526 BcomRegC0Hack[i].PhyVal);
1527 i++;
1528 }
1529 }
1530 else if (pPrt->PhyId1 == PHY_BCOM_ID1_A1) {
1531
1532
1533
1534
1535 i = 0;
1536 while (BcomRegA1Hack[i].PhyReg != 0) {
1537 SkXmPhyWrite(pAC, IoC, Port, BcomRegA1Hack[i].PhyReg,
1538 BcomRegA1Hack[i].PhyVal);
1539 i++;
1540 }
1541 }
1542
1543
1544
1545
1546
1547 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, &SWord);
1548
1549 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_AUX_CTRL,
1550 (SK_U16)(SWord | PHY_B_AC_DIS_PM));
1551
1552
1553 }
1554
1555
1556 XM_IN16(IoC, Port, XM_ISRC, &SWord);
1557
1558
1559
1560
1561
1562
1563 SkMacInitPhy(pAC, IoC, Port, SK_FALSE);
1564
1565#if 0
1566
1567
1568 XM_OUT16(pAC, Port, XM_HW_CFG, XM_HW_COM4SIG);
1569#endif
1570 }
1571
1572
1573
1574
1575
1576
1577 for (i = 0; i < 3; i++) {
1578
1579
1580
1581
1582 SK_IN16(IoC, (B2_MAC_2 + Port * 8 + i * 2), &SWord);
1583
1584 XM_OUT16(IoC, Port, (XM_SA + i * 2), SWord);
1585 }
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595 XM_OUT16(IoC, Port, XM_RX_HI_WM, SK_XM_RX_HI_WM);
1596
1597
1598 SWord = SK_XM_THR_SL;
1599
1600 if (pAC->GIni.GIMacsFound > 1) {
1601 switch (pAC->GIni.GIPortUsage) {
1602 case SK_RED_LINK:
1603 SWord = SK_XM_THR_REDL;
1604 break;
1605 case SK_MUL_LINK:
1606 SWord = SK_XM_THR_MULL;
1607 break;
1608 case SK_JUMBO_LINK:
1609 SWord = SK_XM_THR_JUMBO;
1610 break;
1611 default:
1612 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E014, SKERR_HWI_E014MSG);
1613 break;
1614 }
1615 }
1616 XM_OUT16(IoC, Port, XM_TX_THR, SWord);
1617
1618
1619 XM_OUT16(IoC, Port, XM_TX_CMD, XM_TX_AUTO_PAD);
1620
1621
1622 SWord = XM_RX_STRIP_FCS | XM_RX_LENERR_OK;
1623
1624 if (pAC->GIni.GIPortUsage == SK_JUMBO_LINK) {
1625 SWord |= XM_RX_BIG_PK_OK;
1626 }
1627
1628 if (pPrt->PLinkModeConf == SK_LMODE_HALF) {
1629
1630
1631
1632
1633
1634 SWord |= XM_RX_DIS_CEXT;
1635 }
1636
1637 XM_OUT16(IoC, Port, XM_RX_CMD, SWord);
1638
1639
1640
1641
1642
1643
1644
1645
1646 XM_OUT32(IoC, Port, XM_MODE, XM_DEF_MODE);
1647
1648
1649
1650
1651
1652
1653 XM_OUT32(IoC, Port, XM_RX_EV_MSK, XMR_DEF_MSK);
1654
1655
1656
1657
1658
1659
1660 XM_OUT32(IoC, Port, XM_TX_EV_MSK, XMT_DEF_MSK);
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673}
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689void SkGmInitMac(
1690SK_AC *pAC,
1691SK_IOC IoC,
1692int Port)
1693{
1694 SK_GEPORT *pPrt;
1695 int i;
1696 SK_U16 SWord;
1697 SK_U32 DWord;
1698
1699 pPrt = &pAC->GIni.GP[Port];
1700
1701 if (pPrt->PState == SK_PRT_STOP) {
1702
1703
1704 SK_IN32(IoC, MR_ADDR(Port, GMAC_CTRL), &DWord);
1705
1706 if ((DWord & GMC_RST_SET) != 0) {
1707
1708 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E006, SKERR_HWI_E006MSG);
1709
1710 pPrt->PState = SK_PRT_RESET;
1711 }
1712 }
1713
1714 if (pPrt->PState == SK_PRT_RESET) {
1715
1716 SK_OUT32(IoC, MR_ADDR(Port, GPHY_CTRL), GPC_RST_SET);
1717
1718
1719 SK_OUT32(IoC, MR_ADDR(Port, GMAC_CTRL), GMC_RST_SET);
1720
1721
1722 SK_OUT32(IoC, MR_ADDR(Port, GMAC_CTRL), GMC_RST_CLR);
1723
1724
1725 SK_OUT32(IoC, MR_ADDR(Port, GMAC_CTRL), GMC_RST_SET);
1726
1727
1728 DWord = GPC_INT_POL_HI | GPC_DIS_FC | GPC_DIS_SLEEP |
1729 GPC_ENA_XC | GPC_ANEG_ADV_ALL_M | GPC_ENA_PAUSE |
1730 (pAC->GIni.GICopperType ? GPC_HWCFG_GMII_COP :
1731 GPC_HWCFG_GMII_FIB);
1732
1733
1734 SK_OUT32(IoC, MR_ADDR(Port, GPHY_CTRL), DWord | GPC_RST_SET);
1735
1736
1737 SK_OUT32(IoC, MR_ADDR(Port, GPHY_CTRL), DWord | GPC_RST_CLR);
1738
1739
1740 SK_OUT32(IoC, MR_ADDR(Port, GMAC_CTRL), GMC_PAUSE_ON | GMC_RST_CLR);
1741
1742
1743 SK_IN16(IoC, GMAC_IRQ_SRC, &SWord);
1744
1745#ifndef VCPU
1746
1747 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_ID1, &pPrt->PhyId1);
1748
1749 SkGmInitPhyMarv(pAC, IoC, Port, SK_FALSE);
1750#endif
1751 }
1752
1753 (void)SkGmResetCounter(pAC, IoC, Port);
1754
1755 SWord = 0;
1756
1757
1758 switch (pPrt->PLinkSpeed) {
1759 case SK_LSPEED_AUTO:
1760 case SK_LSPEED_1000MBPS:
1761 SWord |= GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100;
1762 break;
1763 case SK_LSPEED_100MBPS:
1764 SWord |= GM_GPCR_SPEED_100;
1765 break;
1766 case SK_LSPEED_10MBPS:
1767 break;
1768 }
1769
1770
1771 if (pPrt->PLinkMode != SK_LMODE_HALF) {
1772
1773 SWord |= GM_GPCR_DUP_FULL;
1774 }
1775
1776
1777 switch (pPrt->PFlowCtrlMode) {
1778 case SK_FLOW_MODE_NONE:
1779
1780 SWord |= GM_GPCR_FC_TX_DIS | GM_GPCR_FC_RX_DIS;
1781 break;
1782 case SK_FLOW_MODE_LOC_SEND:
1783 SWord |= GM_GPCR_FC_RX_DIS;
1784 break;
1785 case SK_FLOW_MODE_SYMMETRIC:
1786
1787 case SK_FLOW_MODE_SYM_OR_REM:
1788
1789
1790 break;
1791 }
1792
1793
1794 if (pPrt->PLinkMode == SK_LMODE_HALF || pPrt->PLinkMode == SK_LMODE_FULL) {
1795
1796 SWord |= GM_GPCR_AU_ALL_DIS;
1797 }
1798
1799
1800 GM_OUT16(IoC, Port, GM_GP_CTRL, SWord);
1801
1802
1803 GM_OUT16(IoC, Port, GM_TX_CTRL, GM_TXCR_COL_THR);
1804
1805
1806 GM_OUT16(IoC, Port, GM_RX_CTRL, GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA |
1807 GM_RXCR_CRC_DIS);
1808
1809
1810 GM_OUT16(IoC, Port, GM_TX_FLOW_CTRL, 0xffff);
1811
1812
1813#ifdef VCPU
1814 GM_IN16(IoC, Port, GM_TX_PARAM, &SWord);
1815#endif
1816
1817 SWord = JAM_LEN_VAL(3) | JAM_IPG_VAL(11) | IPG_JAM_DATA(26);
1818
1819 GM_OUT16(IoC, Port, GM_TX_PARAM, SWord);
1820
1821
1822#ifdef VCPU
1823 GM_IN16(IoC, Port, GM_SERIAL_MODE, &SWord);
1824#endif
1825
1826 SWord = GM_SMOD_VLAN_ENA | IPG_VAL_FAST_ETH;
1827
1828 if (pAC->GIni.GIPortUsage == SK_JUMBO_LINK) {
1829
1830 SWord |= GM_SMOD_JUMBO_ENA;
1831 }
1832
1833 GM_OUT16(IoC, Port, GM_SERIAL_MODE, SWord);
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843 for (i = 0; i < 3; i++) {
1844
1845
1846
1847
1848
1849 SK_IN16(IoC, (B2_MAC_2 + Port * 8 + i * 2), &SWord);
1850
1851#ifdef WA_DEV_16
1852
1853 if (pAC->GIni.GIChipRev == 0) {
1854
1855 SWord = ((SWord & 0xff00) >> 8) | ((SWord & 0x00ff) << 8);
1856
1857
1858 GM_OUT16(IoC, Port, (GM_SRC_ADDR_1L + (2 - i) * 4), SWord);
1859 }
1860 else {
1861 GM_OUT16(IoC, Port, (GM_SRC_ADDR_1L + i * 4), SWord);
1862 }
1863#else
1864 GM_OUT16(IoC, Port, (GM_SRC_ADDR_1L + i * 4), SWord);
1865#endif
1866
1867
1868 SK_IN16(IoC, (B2_MAC_1 + Port * 8 + i * 2), &SWord);
1869
1870 GM_OUT16(IoC, Port, (GM_SRC_ADDR_2L + i * 4), SWord);
1871
1872
1873 GM_OUT16(IoC, Port, GM_MC_ADDR_H1 + 4*i, 0);
1874 }
1875
1876
1877 GM_OUT16(IoC, Port, GM_MC_ADDR_H4, 0);
1878
1879
1880 GM_OUT16(IoC, Port, GM_TX_IRQ_MSK, 0);
1881 GM_OUT16(IoC, Port, GM_RX_IRQ_MSK, 0);
1882 GM_OUT16(IoC, Port, GM_TR_IRQ_MSK, 0);
1883
1884
1885 GM_IN16(IoC, Port, GM_GP_STAT, &SWord);
1886
1887 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1888 ("MAC Stat Reg=0x%04X\n", SWord));
1889
1890#ifdef SK_DIAG
1891 c_print("MAC Stat Reg=0x%04X\n", SWord);
1892#endif
1893
1894}
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909void SkXmInitDupMd(
1910SK_AC *pAC,
1911SK_IOC IoC,
1912int Port)
1913{
1914 switch (pAC->GIni.GP[Port].PLinkModeStatus) {
1915 case SK_LMODE_STAT_AUTOHALF:
1916 case SK_LMODE_STAT_HALF:
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926 break;
1927 case SK_LMODE_STAT_AUTOFULL:
1928 case SK_LMODE_STAT_FULL:
1929
1930
1931
1932
1933
1934
1935 break;
1936 case SK_LMODE_STAT_UNKNOWN:
1937 default:
1938 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E007, SKERR_HWI_E007MSG);
1939 break;
1940 }
1941}
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957void SkXmInitPauseMd(
1958SK_AC *pAC,
1959SK_IOC IoC,
1960int Port)
1961{
1962 SK_GEPORT *pPrt;
1963 SK_U32 DWord;
1964 SK_U16 Word;
1965
1966 pPrt = &pAC->GIni.GP[Port];
1967
1968 XM_IN16(IoC, Port, XM_MMU_CMD, &Word);
1969
1970 if (pPrt->PFlowCtrlStatus == SK_FLOW_STAT_NONE ||
1971 pPrt->PFlowCtrlStatus == SK_FLOW_STAT_LOC_SEND) {
1972
1973
1974 Word |= XM_MMU_IGN_PF;
1975 }
1976 else {
1977
1978
1979
1980
1981
1982 Word &= ~XM_MMU_IGN_PF;
1983 }
1984
1985 XM_OUT16(IoC, Port, XM_MMU_CMD, Word);
1986
1987 XM_IN32(IoC, Port, XM_MODE, &DWord);
1988
1989 if (pPrt->PFlowCtrlStatus == SK_FLOW_STAT_SYMMETRIC ||
1990 pPrt->PFlowCtrlStatus == SK_FLOW_STAT_LOC_SEND) {
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005 XM_OUT16(IoC, Port, XM_MAC_PTIME, 0xffff);
2006
2007
2008 DWord |= XM_PAUSE_MODE;
2009
2010
2011 SK_OUT16(IoC, MR_ADDR(Port, RX_MFF_CTRL1), MFF_ENA_PAUSE);
2012 }
2013 else {
2014
2015
2016
2017
2018
2019 DWord &= ~XM_PAUSE_MODE;
2020
2021
2022 SK_OUT16(IoC, MR_ADDR(Port, RX_MFF_CTRL1), MFF_DIS_PAUSE);
2023 }
2024
2025 XM_OUT32(IoC, Port, XM_MODE, DWord);
2026}
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040static void SkXmInitPhyXmac(
2041SK_AC *pAC,
2042SK_IOC IoC,
2043int Port,
2044SK_BOOL DoLoop)
2045{
2046 SK_GEPORT *pPrt;
2047 SK_U16 Ctrl;
2048
2049 pPrt = &pAC->GIni.GP[Port];
2050 Ctrl = 0;
2051
2052
2053 if (pPrt->PLinkMode == SK_LMODE_HALF || pPrt->PLinkMode == SK_LMODE_FULL) {
2054 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2055 ("InitPhyXmac: no auto-negotiation Port %d\n", Port));
2056
2057 if (pPrt->PLinkMode == SK_LMODE_FULL) {
2058 Ctrl |= PHY_CT_DUP_MD;
2059 }
2060
2061
2062
2063
2064
2065 }
2066 else {
2067 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2068 ("InitPhyXmac: with auto-negotiation Port %d\n", Port));
2069
2070
2071
2072 switch (pPrt->PLinkMode) {
2073 case SK_LMODE_AUTOHALF:
2074 Ctrl |= PHY_X_AN_HD;
2075 break;
2076 case SK_LMODE_AUTOFULL:
2077 Ctrl |= PHY_X_AN_FD;
2078 break;
2079 case SK_LMODE_AUTOBOTH:
2080 Ctrl |= PHY_X_AN_FD | PHY_X_AN_HD;
2081 break;
2082 default:
2083 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E015,
2084 SKERR_HWI_E015MSG);
2085 }
2086
2087 switch (pPrt->PFlowCtrlMode) {
2088 case SK_FLOW_MODE_NONE:
2089 Ctrl |= PHY_X_P_NO_PAUSE;
2090 break;
2091 case SK_FLOW_MODE_LOC_SEND:
2092 Ctrl |= PHY_X_P_ASYM_MD;
2093 break;
2094 case SK_FLOW_MODE_SYMMETRIC:
2095 Ctrl |= PHY_X_P_SYM_MD;
2096 break;
2097 case SK_FLOW_MODE_SYM_OR_REM:
2098 Ctrl |= PHY_X_P_BOTH_MD;
2099 break;
2100 default:
2101 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E016,
2102 SKERR_HWI_E016MSG);
2103 }
2104
2105
2106 SkXmPhyWrite(pAC, IoC, Port, PHY_XMAC_AUNE_ADV, Ctrl);
2107
2108
2109 Ctrl = PHY_CT_ANE | PHY_CT_RE_CFG;
2110 }
2111
2112 if (DoLoop) {
2113
2114 Ctrl |= PHY_CT_LOOP;
2115 }
2116
2117
2118 SkXmPhyWrite(pAC, IoC, Port, PHY_XMAC_CTRL, Ctrl);
2119}
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133static void SkXmInitPhyBcom(
2134SK_AC *pAC,
2135SK_IOC IoC,
2136int Port,
2137SK_BOOL DoLoop)
2138{
2139 SK_GEPORT *pPrt;
2140 SK_U16 Ctrl1;
2141 SK_U16 Ctrl2;
2142 SK_U16 Ctrl3;
2143 SK_U16 Ctrl4;
2144 SK_U16 Ctrl5;
2145
2146 Ctrl1 = PHY_CT_SP1000;
2147 Ctrl2 = 0;
2148 Ctrl3 = PHY_SEL_TYPE;
2149 Ctrl4 = PHY_B_PEC_EN_LTR;
2150 Ctrl5 = PHY_B_AC_TX_TST;
2151
2152 pPrt = &pAC->GIni.GP[Port];
2153
2154
2155 if (pPrt->PMSMode != SK_MS_MODE_AUTO) {
2156 Ctrl2 |= PHY_B_1000C_MSE;
2157
2158 if (pPrt->PMSMode == SK_MS_MODE_MASTER) {
2159 Ctrl2 |= PHY_B_1000C_MSC;
2160 }
2161 }
2162
2163 if (pPrt->PLinkMode == SK_LMODE_HALF || pPrt->PLinkMode == SK_LMODE_FULL) {
2164 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2165 ("InitPhyBcom: no auto-negotiation Port %d\n", Port));
2166
2167 Ctrl1 |= (pPrt->PLinkMode == SK_LMODE_FULL ? PHY_CT_DUP_MD : 0);
2168
2169
2170 if (pPrt->PMSMode == SK_MS_MODE_AUTO) {
2171 Ctrl2 |= PHY_B_1000C_MSE;
2172 }
2173
2174
2175
2176
2177
2178 }
2179 else {
2180 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2181 ("InitPhyBcom: with auto-negotiation Port %d\n", Port));
2182
2183
2184
2185
2186
2187
2188
2189 Ctrl2 |= PHY_B_1000C_RD;
2190
2191
2192 switch (pPrt->PLinkMode) {
2193 case SK_LMODE_AUTOHALF:
2194 Ctrl2 |= PHY_B_1000C_AHD;
2195 break;
2196 case SK_LMODE_AUTOFULL:
2197 Ctrl2 |= PHY_B_1000C_AFD;
2198 break;
2199 case SK_LMODE_AUTOBOTH:
2200 Ctrl2 |= PHY_B_1000C_AFD | PHY_B_1000C_AHD;
2201 break;
2202 default:
2203 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E015,
2204 SKERR_HWI_E015MSG);
2205 }
2206
2207 switch (pPrt->PFlowCtrlMode) {
2208 case SK_FLOW_MODE_NONE:
2209 Ctrl3 |= PHY_B_P_NO_PAUSE;
2210 break;
2211 case SK_FLOW_MODE_LOC_SEND:
2212 Ctrl3 |= PHY_B_P_ASYM_MD;
2213 break;
2214 case SK_FLOW_MODE_SYMMETRIC:
2215 Ctrl3 |= PHY_B_P_SYM_MD;
2216 break;
2217 case SK_FLOW_MODE_SYM_OR_REM:
2218 Ctrl3 |= PHY_B_P_BOTH_MD;
2219 break;
2220 default:
2221 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E016,
2222 SKERR_HWI_E016MSG);
2223 }
2224
2225
2226 Ctrl1 |= PHY_CT_ANE | PHY_CT_RE_CFG;
2227 }
2228
2229
2230
2231
2232
2233
2234 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_1000T_CTRL, Ctrl2);
2235 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2236 ("1000B-T Ctrl Reg=0x%04X\n", Ctrl2));
2237
2238
2239 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_AUNE_ADV, Ctrl3);
2240 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2241 ("Auto-Neg. Adv. Reg=0x%04X\n", Ctrl3));
2242
2243 if (DoLoop) {
2244
2245 Ctrl1 |= PHY_CT_LOOP;
2246 }
2247
2248 if (pAC->GIni.GIPortUsage == SK_JUMBO_LINK) {
2249
2250 Ctrl4 |= PHY_B_PEC_HIGH_LA;
2251
2252
2253 Ctrl5 |= PHY_B_AC_LONG_PACK;
2254
2255 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, Ctrl5);
2256 }
2257
2258
2259 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_P_EXT_CTRL, Ctrl4);
2260
2261
2262 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_CTRL, Ctrl1);
2263 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2264 ("PHY Control Reg=0x%04X\n", Ctrl1));
2265}
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279static void SkGmInitPhyMarv(
2280SK_AC *pAC,
2281SK_IOC IoC,
2282int Port,
2283SK_BOOL DoLoop)
2284{
2285 SK_GEPORT *pPrt;
2286 SK_U16 PhyCtrl;
2287 SK_U16 C1000BaseT;
2288 SK_U16 AutoNegAdv;
2289 SK_U16 ExtPhyCtrl;
2290 SK_U16 PhyStat;
2291 SK_U16 PhyStat1;
2292 SK_U16 PhySpecStat;
2293 SK_U16 LedCtrl;
2294 SK_BOOL AutoNeg;
2295
2296#ifdef VCPU
2297 VCPUprintf(0, "SkGmInitPhyMarv(), Port=%u, DoLoop=%u\n",
2298 Port, DoLoop);
2299#else
2300
2301 pPrt = &pAC->GIni.GP[Port];
2302
2303
2304 if (pPrt->PLinkMode == SK_LMODE_HALF || pPrt->PLinkMode == SK_LMODE_FULL) {
2305 AutoNeg = SK_FALSE;
2306 }
2307 else {
2308 AutoNeg = SK_TRUE;
2309 }
2310
2311 if (!DoLoop) {
2312
2313 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_EXT_CTRL, &ExtPhyCtrl);
2314
2315 ExtPhyCtrl &= ~(PHY_M_EC_M_DSC_MSK | PHY_M_EC_S_DSC_MSK |
2316 PHY_M_EC_MAC_S_MSK);
2317
2318 ExtPhyCtrl |= PHY_M_EC_M_DSC(1) | PHY_M_EC_S_DSC(1) |
2319 PHY_M_EC_MAC_S(MAC_TX_CLK_25_MHZ);
2320
2321 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_EXT_CTRL, ExtPhyCtrl);
2322 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2323 ("Ext.PHYCtrl=0x%04X\n", ExtPhyCtrl));
2324
2325
2326 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_CTRL, &PhyCtrl);
2327
2328
2329 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL,
2330 (SK_U16)(PhyCtrl | PHY_CT_RESET));
2331 }
2332#endif
2333
2334 PhyCtrl = 0 ;
2335 C1000BaseT = 0;
2336 AutoNegAdv = PHY_SEL_TYPE;
2337
2338
2339 if (pPrt->PMSMode != SK_MS_MODE_AUTO) {
2340
2341 C1000BaseT |= PHY_M_1000C_MSE;
2342
2343 if (pPrt->PMSMode == SK_MS_MODE_MASTER) {
2344 C1000BaseT |= PHY_M_1000C_MSC;
2345 }
2346 }
2347
2348
2349 if (!AutoNeg) {
2350 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2351 ("InitPhyMarv: no auto-negotiation Port %d\n", Port));
2352
2353 if (pPrt->PLinkMode == SK_LMODE_FULL) {
2354
2355 PhyCtrl |= PHY_CT_DUP_MD;
2356 }
2357
2358
2359 if (pPrt->PMSMode == SK_MS_MODE_AUTO) {
2360 C1000BaseT |= PHY_M_1000C_MSE;
2361 }
2362
2363
2364 switch (pPrt->PLinkSpeed) {
2365 case SK_LSPEED_AUTO:
2366 case SK_LSPEED_1000MBPS:
2367 PhyCtrl |= PHY_CT_SP1000;
2368 break;
2369 case SK_LSPEED_100MBPS:
2370 PhyCtrl |= PHY_CT_SP100;
2371 break;
2372 case SK_LSPEED_10MBPS:
2373 break;
2374 default:
2375 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E019,
2376 SKERR_HWI_E019MSG);
2377 }
2378
2379 if (!DoLoop) {
2380 PhyCtrl |= PHY_CT_RESET;
2381 }
2382
2383
2384
2385
2386 }
2387 else {
2388 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2389 ("InitPhyMarv: with auto-negotiation Port %d\n", Port));
2390
2391 PhyCtrl |= PHY_CT_ANE;
2392
2393 if (pAC->GIni.GICopperType) {
2394
2395 switch (pPrt->PLinkSpeed) {
2396 case SK_LSPEED_AUTO:
2397 C1000BaseT |= PHY_M_1000C_AHD | PHY_M_1000C_AFD;
2398 AutoNegAdv |= PHY_M_AN_100_FD | PHY_M_AN_100_HD |
2399 PHY_M_AN_10_FD | PHY_M_AN_10_HD;
2400 break;
2401 case SK_LSPEED_1000MBPS:
2402 C1000BaseT |= PHY_M_1000C_AHD | PHY_M_1000C_AFD;
2403 break;
2404 case SK_LSPEED_100MBPS:
2405 AutoNegAdv |= PHY_M_AN_100_FD | PHY_M_AN_100_HD |
2406 PHY_M_AN_10_FD | PHY_M_AN_10_HD;
2407 break;
2408 case SK_LSPEED_10MBPS:
2409 AutoNegAdv |= PHY_M_AN_10_FD | PHY_M_AN_10_HD;
2410 break;
2411 default:
2412 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E019,
2413 SKERR_HWI_E019MSG);
2414 }
2415
2416
2417 switch (pPrt->PLinkMode) {
2418 case SK_LMODE_AUTOHALF:
2419 C1000BaseT &= ~PHY_M_1000C_AFD;
2420 AutoNegAdv &= ~(PHY_M_AN_100_FD | PHY_M_AN_10_FD);
2421 break;
2422 case SK_LMODE_AUTOFULL:
2423 C1000BaseT &= ~PHY_M_1000C_AHD;
2424 AutoNegAdv &= ~(PHY_M_AN_100_HD | PHY_M_AN_10_HD);
2425 break;
2426 case SK_LMODE_AUTOBOTH:
2427 break;
2428 default:
2429 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E015,
2430 SKERR_HWI_E015MSG);
2431 }
2432
2433
2434 switch (pPrt->PFlowCtrlMode) {
2435 case SK_FLOW_MODE_NONE:
2436 AutoNegAdv |= PHY_B_P_NO_PAUSE;
2437 break;
2438 case SK_FLOW_MODE_LOC_SEND:
2439 AutoNegAdv |= PHY_B_P_ASYM_MD;
2440 break;
2441 case SK_FLOW_MODE_SYMMETRIC:
2442 AutoNegAdv |= PHY_B_P_SYM_MD;
2443 break;
2444 case SK_FLOW_MODE_SYM_OR_REM:
2445 AutoNegAdv |= PHY_B_P_BOTH_MD;
2446 break;
2447 default:
2448 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E016,
2449 SKERR_HWI_E016MSG);
2450 }
2451 }
2452 else {
2453
2454
2455 switch (pPrt->PLinkMode) {
2456 case SK_LMODE_AUTOHALF:
2457 AutoNegAdv |= PHY_M_AN_1000X_AHD;
2458 break;
2459 case SK_LMODE_AUTOFULL:
2460 AutoNegAdv |= PHY_M_AN_1000X_AFD;
2461 break;
2462 case SK_LMODE_AUTOBOTH:
2463 AutoNegAdv |= PHY_M_AN_1000X_AHD | PHY_M_AN_1000X_AFD;
2464 break;
2465 default:
2466 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E015,
2467 SKERR_HWI_E015MSG);
2468 }
2469
2470
2471 switch (pPrt->PFlowCtrlMode) {
2472 case SK_FLOW_MODE_NONE:
2473 AutoNegAdv |= PHY_M_P_NO_PAUSE_X;
2474 break;
2475 case SK_FLOW_MODE_LOC_SEND:
2476 AutoNegAdv |= PHY_M_P_ASYM_MD_X;
2477 break;
2478 case SK_FLOW_MODE_SYMMETRIC:
2479 AutoNegAdv |= PHY_M_P_SYM_MD_X;
2480 break;
2481 case SK_FLOW_MODE_SYM_OR_REM:
2482 AutoNegAdv |= PHY_M_P_BOTH_MD_X;
2483 break;
2484 default:
2485 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E016,
2486 SKERR_HWI_E016MSG);
2487 }
2488 }
2489
2490 if (!DoLoop) {
2491
2492 PhyCtrl |= PHY_CT_RE_CFG;
2493 }
2494 }
2495
2496#ifdef VCPU
2497
2498
2499
2500
2501
2502 SkGmPhyWrite(pAC, IoC, Port, 30, 0x0708);
2503
2504 VCpuWait(2000);
2505
2506#else
2507
2508
2509 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, C1000BaseT);
2510 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2511 ("1000B-T Ctrl=0x%04X\n", C1000BaseT));
2512
2513
2514 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV, AutoNegAdv);
2515 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2516 ("Auto-Neg.Ad.=0x%04X\n", AutoNegAdv));
2517#endif
2518
2519 if (DoLoop) {
2520
2521 PhyCtrl |= PHY_CT_LOOP;
2522
2523
2524 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_PHY_CTRL, PHY_M_PC_FL_GOOD);
2525
2526#if 0
2527 if (pPrt->PLinkSpeed != SK_LSPEED_AUTO) {
2528
2529 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_EXT_CTRL,
2530 (SK_U16)((pPrt->PLinkSpeed + 2) << 4));
2531 }
2532 }
2533 else if (pPrt->PLinkSpeed == SK_LSPEED_10MBPS) {
2534
2535 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_PHY_CTRL, PHY_M_PC_EN_DET_MSK);
2536 }
2537#endif
2538 }
2539
2540
2541 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, PhyCtrl);
2542
2543#ifdef VCPU
2544 VCpuWait(2000);
2545#else
2546
2547 LedCtrl = PHY_M_LED_PULS_DUR(PULS_170MS) | PHY_M_LED_BLINK_RT(BLINK_84MS);
2548
2549#ifdef ACT_LED_BLINK
2550 LedCtrl |= PHY_M_LEDC_RX_CTRL | PHY_M_LEDC_TX_CTRL;
2551#endif
2552
2553#ifdef DUP_LED_NORMAL
2554 LedCtrl |= PHY_M_LEDC_DP_CTRL;
2555#endif
2556
2557 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_LED_CTRL, LedCtrl);
2558
2559#endif
2560
2561#ifdef SK_DIAG
2562 c_print("Set PHY Ctrl=0x%04X\n", PhyCtrl);
2563 c_print("Set 1000 B-T=0x%04X\n", C1000BaseT);
2564 c_print("Set Auto-Neg=0x%04X\n", AutoNegAdv);
2565 c_print("Set Ext Ctrl=0x%04X\n", ExtPhyCtrl);
2566#endif
2567
2568#ifndef xDEBUG
2569
2570 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_CTRL, &PhyCtrl);
2571 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2572 ("PHY Ctrl Reg.=0x%04X\n", PhyCtrl));
2573
2574
2575 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_1000T_CTRL, &C1000BaseT);
2576 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2577 ("1000B-T Ctrl =0x%04X\n", C1000BaseT));
2578
2579
2580 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_AUNE_ADV, &AutoNegAdv);
2581 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2582 ("Auto-Neg. Ad.=0x%04X\n", AutoNegAdv));
2583
2584
2585 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_EXT_CTRL, &ExtPhyCtrl);
2586 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2587 ("Ext PHY Ctrl=0x%04X\n", ExtPhyCtrl));
2588
2589
2590 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_STAT, &PhyStat);
2591 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2592 ("PHY Stat Reg.=0x%04X\n", PhyStat));
2593 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_STAT, &PhyStat1);
2594 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2595 ("PHY Stat Reg.=0x%04X\n", PhyStat1));
2596
2597
2598 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_PHY_STAT, &PhySpecStat);
2599 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2600 ("PHY Spec Stat=0x%04X\n", PhySpecStat));
2601#endif
2602
2603#ifdef SK_DIAG
2604 c_print("PHY Ctrl Reg=0x%04X\n", PhyCtrl);
2605 c_print("PHY 1000 Reg=0x%04X\n", C1000BaseT);
2606 c_print("PHY AnAd Reg=0x%04X\n", AutoNegAdv);
2607 c_print("Ext Ctrl Reg=0x%04X\n", ExtPhyCtrl);
2608 c_print("PHY Stat Reg=0x%04X\n", PhyStat);
2609 c_print("PHY Stat Reg=0x%04X\n", PhyStat1);
2610 c_print("PHY Spec Reg=0x%04X\n", PhySpecStat);
2611#endif
2612
2613}
2614
2615
2616#ifdef OTHER_PHY
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628static void SkXmInitPhyLone(
2629SK_AC *pAC,
2630SK_IOC IoC,
2631int Port,
2632SK_BOOL DoLoop)
2633{
2634 SK_GEPORT *pPrt;
2635 SK_U16 Ctrl1;
2636 SK_U16 Ctrl2;
2637 SK_U16 Ctrl3;
2638
2639 Ctrl1 = PHY_CT_SP1000;
2640 Ctrl2 = 0;
2641 Ctrl3 = PHY_SEL_TYPE;
2642
2643 pPrt = &pAC->GIni.GP[Port];
2644
2645
2646 if (pPrt->PMSMode != SK_MS_MODE_AUTO) {
2647 Ctrl2 |= PHY_L_1000C_MSE;
2648
2649 if (pPrt->PMSMode == SK_MS_MODE_MASTER) {
2650 Ctrl2 |= PHY_L_1000C_MSC;
2651 }
2652 }
2653
2654 if (pPrt->PLinkMode == SK_LMODE_HALF || pPrt->PLinkMode == SK_LMODE_FULL) {
2655
2656
2657
2658
2659 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2660 ("InitPhyLone: no auto-negotiation Port %d\n", Port));
2661
2662 Ctrl1 = (pPrt->PLinkMode == SK_LMODE_FULL ? PHY_CT_DUP_MD : 0);
2663
2664
2665 if (pPrt->PMSMode == SK_MS_MODE_AUTO) {
2666 Ctrl2 |= PHY_L_1000C_MSE;
2667 }
2668
2669
2670
2671
2672
2673 }
2674 else {
2675 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2676 ("InitPhyLone: with auto-negotiation Port %d\n", Port));
2677
2678
2679
2680 switch (pPrt->PLinkMode) {
2681 case SK_LMODE_AUTOHALF:
2682 Ctrl2 |= PHY_L_1000C_AHD;
2683 break;
2684 case SK_LMODE_AUTOFULL:
2685 Ctrl2 |= PHY_L_1000C_AFD;
2686 break;
2687 case SK_LMODE_AUTOBOTH:
2688 Ctrl2 |= PHY_L_1000C_AFD | PHY_L_1000C_AHD;
2689 break;
2690 default:
2691 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E015,
2692 SKERR_HWI_E015MSG);
2693 }
2694
2695 switch (pPrt->PFlowCtrlMode) {
2696 case SK_FLOW_MODE_NONE:
2697 Ctrl3 |= PHY_L_P_NO_PAUSE;
2698 break;
2699 case SK_FLOW_MODE_LOC_SEND:
2700 Ctrl3 |= PHY_L_P_ASYM_MD;
2701 break;
2702 case SK_FLOW_MODE_SYMMETRIC:
2703 Ctrl3 |= PHY_L_P_SYM_MD;
2704 break;
2705 case SK_FLOW_MODE_SYM_OR_REM:
2706 Ctrl3 |= PHY_L_P_BOTH_MD;
2707 break;
2708 default:
2709 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E016,
2710 SKERR_HWI_E016MSG);
2711 }
2712
2713
2714 Ctrl1 = PHY_CT_ANE | PHY_CT_RE_CFG;
2715
2716 }
2717
2718
2719
2720
2721
2722
2723 SkXmPhyWrite(pAC, IoC, Port, PHY_LONE_1000T_CTRL, Ctrl2);
2724 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2725 ("1000B-T Ctrl Reg=0x%04X\n", Ctrl2));
2726
2727
2728 SkXmPhyWrite(pAC, IoC, Port, PHY_LONE_AUNE_ADV, Ctrl3);
2729 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2730 ("Auto-Neg. Adv. Reg=0x%04X\n", Ctrl3));
2731
2732
2733 if (DoLoop) {
2734
2735 Ctrl1 |= PHY_CT_LOOP;
2736 }
2737
2738
2739 SkXmPhyWrite(pAC, IoC, Port, PHY_LONE_CTRL, Ctrl1);
2740 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2741 ("PHY Control Reg=0x%04X\n", Ctrl1));
2742}
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756static void SkXmInitPhyNat(
2757SK_AC *pAC,
2758SK_IOC IoC,
2759int Port,
2760SK_BOOL DoLoop)
2761{
2762
2763}
2764#endif
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778void SkMacInitPhy(
2779SK_AC *pAC,
2780SK_IOC IoC,
2781int Port,
2782SK_BOOL DoLoop)
2783{
2784 SK_GEPORT *pPrt;
2785
2786 pPrt = &pAC->GIni.GP[Port];
2787
2788 switch (pPrt->PhyType) {
2789 case SK_PHY_XMAC:
2790 SkXmInitPhyXmac(pAC, IoC, Port, DoLoop);
2791 break;
2792 case SK_PHY_BCOM:
2793 SkXmInitPhyBcom(pAC, IoC, Port, DoLoop);
2794 break;
2795 case SK_PHY_MARV_COPPER:
2796 case SK_PHY_MARV_FIBER:
2797 SkGmInitPhyMarv(pAC, IoC, Port, DoLoop);
2798 break;
2799#ifdef OTHER_PHY
2800 case SK_PHY_LONE:
2801 SkXmInitPhyLone(pAC, IoC, Port, DoLoop);
2802 break;
2803 case SK_PHY_NAT:
2804 SkXmInitPhyNat(pAC, IoC, Port, DoLoop);
2805 break;
2806#endif
2807 }
2808}
2809
2810
2811#ifndef SK_DIAG
2812
2813
2814
2815
2816
2817
2818
2819
2820void SkXmAutoNegLipaXmac(
2821SK_AC *pAC,
2822SK_IOC IoC,
2823int Port,
2824SK_U16 IStatus)
2825{
2826 SK_GEPORT *pPrt;
2827
2828 pPrt = &pAC->GIni.GP[Port];
2829
2830 if (pPrt->PLipaAutoNeg != SK_LIPA_AUTO &&
2831 (IStatus & (XM_IS_LIPA_RC | XM_IS_RX_PAGE | XM_IS_AND)) != 0) {
2832
2833 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2834 ("AutoNegLipa: AutoNeg detected on Port %d, IStatus=0x%04x\n",
2835 Port, IStatus));
2836 pPrt->PLipaAutoNeg = SK_LIPA_AUTO;
2837 }
2838}
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849void SkMacAutoNegLipaPhy(
2850SK_AC *pAC,
2851SK_IOC IoC,
2852int Port,
2853SK_U16 PhyStat)
2854{
2855 SK_GEPORT *pPrt;
2856
2857 pPrt = &pAC->GIni.GP[Port];
2858
2859 if (pPrt->PLipaAutoNeg != SK_LIPA_AUTO &&
2860 (PhyStat & PHY_ST_AN_OVER) != 0) {
2861
2862 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2863 ("AutoNegLipa: AutoNeg detected on Port %d, PhyStat=0x%04x\n",
2864 Port, PhyStat));
2865 pPrt->PLipaAutoNeg = SK_LIPA_AUTO;
2866 }
2867}
2868#endif
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883static int SkXmAutoNegDoneXmac(
2884SK_AC *pAC,
2885SK_IOC IoC,
2886int Port)
2887{
2888 SK_GEPORT *pPrt;
2889 SK_U16 ResAb;
2890 SK_U16 LPAb;
2891
2892 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2893 ("AutoNegDoneXmac, Port %d\n",Port));
2894
2895 pPrt = &pAC->GIni.GP[Port];
2896
2897
2898 SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_AUNE_LP, &LPAb);
2899 SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_RES_ABI, &ResAb);
2900
2901 if ((LPAb & PHY_X_AN_RFB) != 0) {
2902
2903
2904 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2905 ("AutoNegFail: Remote fault bit set Port %d\n", Port));
2906 pPrt->PAutoNegFail = SK_TRUE;
2907 return(SK_AND_OTHER);
2908 }
2909
2910
2911 if ((ResAb & (PHY_X_RS_HD | PHY_X_RS_FD)) == PHY_X_RS_FD) {
2912 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOFULL;
2913 }
2914 else if ((ResAb & (PHY_X_RS_HD | PHY_X_RS_FD)) == PHY_X_RS_HD) {
2915 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOHALF;
2916 }
2917 else {
2918
2919 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2920 ("AutoNegFail: Duplex mode mismatch Port %d\n", Port));
2921 pPrt->PAutoNegFail = SK_TRUE;
2922 return(SK_AND_DUP_CAP);
2923 }
2924
2925
2926
2927
2928 if ((pPrt->PFlowCtrlMode == SK_FLOW_MODE_SYMMETRIC ||
2929 pPrt->PFlowCtrlMode == SK_FLOW_MODE_SYM_OR_REM) &&
2930 (LPAb & PHY_X_P_SYM_MD) != 0) {
2931
2932 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_SYMMETRIC;
2933 }
2934 else if (pPrt->PFlowCtrlMode == SK_FLOW_MODE_SYM_OR_REM &&
2935 (LPAb & PHY_X_RS_PAUSE) == PHY_X_P_ASYM_MD) {
2936
2937 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_REM_SEND;
2938 }
2939 else if (pPrt->PFlowCtrlMode == SK_FLOW_MODE_LOC_SEND &&
2940 (LPAb & PHY_X_RS_PAUSE) == PHY_X_P_BOTH_MD) {
2941
2942 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_LOC_SEND;
2943 }
2944 else {
2945
2946 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_NONE;
2947 }
2948 pPrt->PLinkSpeedUsed = SK_LSPEED_STAT_1000MBPS;
2949
2950 return(SK_AND_OK);
2951}
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966static int SkXmAutoNegDoneBcom(
2967SK_AC *pAC,
2968SK_IOC IoC,
2969int Port)
2970{
2971 SK_GEPORT *pPrt;
2972 SK_U16 LPAb;
2973 SK_U16 AuxStat;
2974
2975#if 0
297601-Sep-2000 RA;:;:
2977 SK_U16 ResAb;
2978#endif
2979
2980 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2981 ("AutoNegDoneBcom, Port %d\n", Port));
2982 pPrt = &pAC->GIni.GP[Port];
2983
2984
2985 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_LP, &LPAb);
2986#if 0
298701-Sep-2000 RA;:;:
2988 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &ResAb);
2989#endif
2990
2991 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_STAT, &AuxStat);
2992
2993 if ((LPAb & PHY_B_AN_RF) != 0) {
2994
2995 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2996 ("AutoNegFail: Remote fault bit set Port %d\n", Port));
2997 pPrt->PAutoNegFail = SK_TRUE;
2998 return(SK_AND_OTHER);
2999 }
3000
3001
3002 if ((AuxStat & PHY_B_AS_AN_RES_MSK) == PHY_B_RES_1000FD) {
3003 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOFULL;
3004 }
3005 else if ((AuxStat & PHY_B_AS_AN_RES_MSK) == PHY_B_RES_1000HD) {
3006 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOHALF;
3007 }
3008 else {
3009
3010 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3011 ("AutoNegFail: Duplex mode mismatch Port %d\n", Port));
3012 pPrt->PAutoNegFail = SK_TRUE;
3013 return(SK_AND_DUP_CAP);
3014 }
3015
3016#if 0
301701-Sep-2000 RA;:;:
3018
3019 if ((ResAb & PHY_B_1000S_MSF) != 0) {
3020 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3021 ("Master/Slave Fault Port %d\n", Port));
3022 pPrt->PAutoNegFail = SK_TRUE;
3023 pPrt->PMSStatus = SK_MS_STAT_FAULT;
3024 return(SK_AND_OTHER);
3025 }
3026
3027 pPrt->PMSStatus = ((ResAb & PHY_B_1000S_MSR) != 0) ?
3028 SK_MS_STAT_MASTER : SK_MS_STAT_SLAVE;
3029#endif
3030
3031
3032
3033 if ((AuxStat & PHY_B_AS_PAUSE_MSK) == PHY_B_AS_PAUSE_MSK) {
3034
3035 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_SYMMETRIC;
3036 }
3037 else if ((AuxStat & PHY_B_AS_PAUSE_MSK) == PHY_B_AS_PRR) {
3038
3039 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_REM_SEND;
3040 }
3041 else if ((AuxStat & PHY_B_AS_PAUSE_MSK) == PHY_B_AS_PRT) {
3042
3043 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_LOC_SEND;
3044 }
3045 else {
3046
3047 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_NONE;
3048 }
3049 pPrt->PLinkSpeedUsed = SK_LSPEED_STAT_1000MBPS;
3050
3051 return(SK_AND_OK);
3052}
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067static int SkGmAutoNegDoneMarv(
3068SK_AC *pAC,
3069SK_IOC IoC,
3070int Port)
3071{
3072 SK_GEPORT *pPrt;
3073 SK_U16 LPAb;
3074 SK_U16 ResAb;
3075 SK_U16 AuxStat;
3076
3077 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3078 ("AutoNegDoneMarv, Port %d\n", Port));
3079 pPrt = &pAC->GIni.GP[Port];
3080
3081
3082 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_AUNE_LP, &LPAb);
3083
3084 if ((LPAb & PHY_M_AN_RF) != 0) {
3085 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3086 ("AutoNegFail: Remote fault bit set Port %d\n", Port));
3087 pPrt->PAutoNegFail = SK_TRUE;
3088 return(SK_AND_OTHER);
3089 }
3090
3091 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_1000T_STAT, &ResAb);
3092
3093
3094 if ((ResAb & PHY_B_1000S_MSF) != 0) {
3095 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3096 ("Master/Slave Fault Port %d\n", Port));
3097 pPrt->PAutoNegFail = SK_TRUE;
3098 pPrt->PMSStatus = SK_MS_STAT_FAULT;
3099 return(SK_AND_OTHER);
3100 }
3101
3102 pPrt->PMSStatus = ((ResAb & PHY_B_1000S_MSR) != 0) ?
3103 (SK_U8)SK_MS_STAT_MASTER : (SK_U8)SK_MS_STAT_SLAVE;
3104
3105
3106 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_PHY_STAT, &AuxStat);
3107
3108
3109 if ((AuxStat & PHY_M_PS_SPDUP_RES) == 0) {
3110 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3111 ("AutoNegFail: Speed & Duplex not resolved Port %d\n", Port));
3112 pPrt->PAutoNegFail = SK_TRUE;
3113 pPrt->PLinkModeStatus = SK_LMODE_STAT_UNKNOWN;
3114 return(SK_AND_DUP_CAP);
3115 }
3116
3117 if ((AuxStat & PHY_M_PS_FULL_DUP) != 0) {
3118 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOFULL;
3119 }
3120 else {
3121 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOHALF;
3122 }
3123
3124
3125
3126 if ((AuxStat & PHY_M_PS_PAUSE_MSK) == PHY_M_PS_PAUSE_MSK) {
3127
3128 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_SYMMETRIC;
3129 }
3130 else if ((AuxStat & PHY_M_PS_PAUSE_MSK) == PHY_M_PS_RX_P_EN) {
3131
3132 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_REM_SEND;
3133 }
3134 else if ((AuxStat & PHY_M_PS_PAUSE_MSK) == PHY_M_PS_TX_P_EN) {
3135
3136 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_LOC_SEND;
3137 }
3138 else {
3139
3140 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_NONE;
3141 }
3142
3143
3144 switch ((unsigned)(AuxStat & PHY_M_PS_SPEED_MSK)) {
3145 case (unsigned)PHY_M_PS_SPEED_1000:
3146 pPrt->PLinkSpeedUsed = SK_LSPEED_STAT_1000MBPS;
3147 break;
3148 case PHY_M_PS_SPEED_100:
3149 pPrt->PLinkSpeedUsed = SK_LSPEED_STAT_100MBPS;
3150 break;
3151 default:
3152 pPrt->PLinkSpeedUsed = SK_LSPEED_STAT_10MBPS;
3153 }
3154
3155 return(SK_AND_OK);
3156}
3157
3158
3159#ifdef OTHER_PHY
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172static int SkXmAutoNegDoneLone(
3173SK_AC *pAC,
3174SK_IOC IoC,
3175int Port)
3176{
3177 SK_GEPORT *pPrt;
3178 SK_U16 ResAb;
3179 SK_U16 LPAb;
3180 SK_U16 QuickStat;
3181
3182 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3183 ("AutoNegDoneLone, Port %d\n",Port));
3184 pPrt = &pAC->GIni.GP[Port];
3185
3186
3187 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_AUNE_LP, &LPAb);
3188 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_1000T_STAT, &ResAb);
3189 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_Q_STAT, &QuickStat);
3190
3191 if ((LPAb & PHY_L_AN_RF) != 0) {
3192
3193
3194 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3195 ("AutoNegFail: Remote fault bit set Port %d\n", Port));
3196 pPrt->PAutoNegFail = SK_TRUE;
3197 return(SK_AND_OTHER);
3198 }
3199
3200
3201 if ((QuickStat & PHY_L_QS_DUP_MOD) != 0) {
3202 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOFULL;
3203 }
3204 else {
3205 pPrt->PLinkModeStatus = SK_LMODE_STAT_AUTOHALF;
3206 }
3207
3208
3209 if ((ResAb & PHY_L_1000S_MSF) != 0) {
3210
3211 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
3212 ("Master/Slave Fault Port %d\n", Port));
3213 pPrt->PAutoNegFail = SK_TRUE;
3214 pPrt->PMSStatus = SK_MS_STAT_FAULT;
3215 return(SK_AND_OTHER);
3216 }
3217 else if (ResAb & PHY_L_1000S_MSR) {
3218 pPrt->PMSStatus = SK_MS_STAT_MASTER;
3219 }
3220 else {
3221 pPrt->PMSStatus = SK_MS_STAT_SLAVE;
3222 }
3223
3224
3225
3226
3227 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_NONE;
3228 switch (pPrt->PFlowCtrlMode) {
3229 case SK_FLOW_MODE_NONE:
3230
3231 break;
3232 case SK_FLOW_MODE_LOC_SEND:
3233 if ((QuickStat & (PHY_L_QS_PAUSE | PHY_L_QS_AS_PAUSE)) ==
3234 (PHY_L_QS_PAUSE | PHY_L_QS_AS_PAUSE)) {
3235
3236 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_LOC_SEND;
3237 }
3238 break;
3239 case SK_FLOW_MODE_SYMMETRIC:
3240 if ((QuickStat & PHY_L_QS_PAUSE) != 0) {
3241
3242 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_SYMMETRIC;
3243 }
3244 break;
3245 case SK_FLOW_MODE_SYM_OR_REM:
3246 if ((QuickStat & (PHY_L_QS_PAUSE | PHY_L_QS_AS_PAUSE)) ==
3247 PHY_L_QS_AS_PAUSE) {
3248
3249 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_REM_SEND;
3250 }
3251 else if ((QuickStat & PHY_L_QS_PAUSE) != 0) {
3252
3253 pPrt->PFlowCtrlStatus = SK_FLOW_STAT_SYMMETRIC;
3254 }
3255 break;
3256 default:
3257 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_HWI_E016,
3258 SKERR_HWI_E016MSG);
3259 }
3260
3261 return(SK_AND_OK);
3262}
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277static int SkXmAutoNegDoneNat(
3278SK_AC *pAC,
3279SK_IOC IoC,
3280int Port)
3281{
3282
3283 return(SK_AND_OK);
3284}
3285#endif
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299int SkMacAutoNegDone(
3300SK_AC *pAC,
3301SK_IOC IoC,
3302int Port)
3303{
3304 SK_GEPORT *pPrt;
3305 int Rtv;
3306
3307 pPrt = &pAC->GIni.GP[Port];
3308
3309 switch (pPrt->PhyType) {
3310 case SK_PHY_XMAC:
3311 Rtv = SkXmAutoNegDoneXmac(pAC, IoC, Port);
3312 break;
3313 case SK_PHY_BCOM:
3314 Rtv = SkXmAutoNegDoneBcom(pAC, IoC, Port);
3315 break;
3316 case SK_PHY_MARV_COPPER:
3317 case SK_PHY_MARV_FIBER:
3318 Rtv = SkGmAutoNegDoneMarv(pAC, IoC, Port);
3319 break;
3320#ifdef OTHER_PHY
3321 case SK_PHY_LONE:
3322 Rtv = SkXmAutoNegDoneLone(pAC, IoC, Port);
3323 break;
3324 case SK_PHY_NAT:
3325 Rtv = SkXmAutoNegDoneNat(pAC, IoC, Port);
3326 break;
3327#endif
3328 default:
3329 return(SK_AND_OTHER);
3330 }
3331
3332 if (Rtv != SK_AND_OK) {
3333 return(Rtv);
3334 }
3335
3336
3337 pPrt->PAutoNegFail = SK_FALSE;
3338
3339 SkMacRxTxEnable(pAC, IoC, Port);
3340
3341 return(SK_AND_OK);
3342}
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355static void SkXmSetRxTxEn(
3356SK_AC *pAC,
3357SK_IOC IoC,
3358int Port,
3359int Para)
3360{
3361 SK_U16 Word;
3362
3363 XM_IN16(IoC, Port, XM_MMU_CMD, &Word);
3364
3365 switch (Para & (SK_MAC_LOOPB_ON | SK_MAC_LOOPB_OFF)) {
3366 case SK_MAC_LOOPB_ON:
3367 Word |= XM_MMU_MAC_LB;
3368 break;
3369 case SK_MAC_LOOPB_OFF:
3370 Word &= ~XM_MMU_MAC_LB;
3371 break;
3372 }
3373
3374 switch (Para & (SK_PHY_LOOPB_ON | SK_PHY_LOOPB_OFF)) {
3375 case SK_PHY_LOOPB_ON:
3376 Word |= XM_MMU_GMII_LOOP;
3377 break;
3378 case SK_PHY_LOOPB_OFF:
3379 Word &= ~XM_MMU_GMII_LOOP;
3380 break;
3381 }
3382
3383 switch (Para & (SK_PHY_FULLD_ON | SK_PHY_FULLD_OFF)) {
3384 case SK_PHY_FULLD_ON:
3385 Word |= XM_MMU_GMII_FD;
3386 break;
3387 case SK_PHY_FULLD_OFF:
3388 Word &= ~XM_MMU_GMII_FD;
3389 break;
3390 }
3391
3392 XM_OUT16(IoC, Port, XM_MMU_CMD, Word | XM_MMU_ENA_RX | XM_MMU_ENA_TX);
3393
3394
3395 XM_IN16(IoC, Port, XM_MMU_CMD, &Word);
3396
3397}
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410static void SkGmSetRxTxEn(
3411SK_AC *pAC,
3412SK_IOC IoC,
3413int Port,
3414int Para)
3415{
3416 SK_U16 Ctrl;
3417
3418 GM_IN16(IoC, Port, GM_GP_CTRL, &Ctrl);
3419
3420 switch (Para & (SK_MAC_LOOPB_ON | SK_MAC_LOOPB_OFF)) {
3421 case SK_MAC_LOOPB_ON:
3422 Ctrl |= GM_GPCR_LOOP_ENA;
3423 break;
3424 case SK_MAC_LOOPB_OFF:
3425 Ctrl &= ~GM_GPCR_LOOP_ENA;
3426 break;
3427 }
3428
3429 switch (Para & (SK_PHY_FULLD_ON | SK_PHY_FULLD_OFF)) {
3430 case SK_PHY_FULLD_ON:
3431 Ctrl |= GM_GPCR_DUP_FULL;
3432 break;
3433 case SK_PHY_FULLD_OFF:
3434 Ctrl &= ~GM_GPCR_DUP_FULL;
3435 break;
3436 }
3437
3438 GM_OUT16(IoC, Port, GM_GP_CTRL, Ctrl | GM_GPCR_RX_ENA | GM_GPCR_TX_ENA);
3439
3440
3441 GM_IN16(IoC, Port, GM_GP_CTRL, &Ctrl);
3442
3443}
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454void SkMacSetRxTxEn(
3455SK_AC *pAC,
3456SK_IOC IoC,
3457int Port,
3458int Para)
3459{
3460 if (pAC->GIni.GIGenesis) {
3461
3462 SkXmSetRxTxEn(pAC, IoC, Port, Para);
3463 }
3464 else {
3465
3466 SkGmSetRxTxEn(pAC, IoC, Port, Para);
3467 }
3468
3469}
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482int SkMacRxTxEnable(
3483SK_AC *pAC,
3484SK_IOC IoC,
3485int Port)
3486{
3487 SK_GEPORT *pPrt;
3488 SK_U16 Reg;
3489 SK_U16 IntMask;
3490 SK_U16 SWord;
3491
3492 pPrt = &pAC->GIni.GP[Port];
3493
3494 if (!pPrt->PHWLinkUp) {
3495
3496 return(0);
3497 }
3498
3499 if ((pPrt->PLinkMode == SK_LMODE_AUTOHALF ||
3500 pPrt->PLinkMode == SK_LMODE_AUTOFULL ||
3501 pPrt->PLinkMode == SK_LMODE_AUTOBOTH) &&
3502 pPrt->PAutoNegFail) {
3503
3504 return(0);
3505 }
3506
3507 if (pAC->GIni.GIGenesis) {
3508
3509 SkXmInitDupMd(pAC, IoC, Port);
3510
3511 SkXmInitPauseMd(pAC, IoC, Port);
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522 IntMask = XM_DEF_MSK;
3523
3524#ifdef DEBUG
3525
3526 IntMask &= ~XM_IS_RXF_OV;
3527#endif
3528
3529 if (pPrt->PhyType != SK_PHY_XMAC) {
3530
3531 IntMask |= XM_IS_INP_ASS;
3532 }
3533 XM_OUT16(IoC, Port, XM_IMSK, IntMask);
3534
3535
3536 XM_IN16(IoC, Port, XM_MMU_CMD, &Reg);
3537
3538 if (pPrt->PhyType != SK_PHY_XMAC &&
3539 (pPrt->PLinkModeStatus == SK_LMODE_STAT_FULL ||
3540 pPrt->PLinkModeStatus == SK_LMODE_STAT_AUTOFULL)) {
3541
3542 Reg |= XM_MMU_GMII_FD;
3543 }
3544
3545 switch (pPrt->PhyType) {
3546 case SK_PHY_BCOM:
3547
3548
3549
3550
3551 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, &SWord);
3552 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_AUX_CTRL,
3553 (SK_U16)(SWord & ~PHY_B_AC_DIS_PM));
3554 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_INT_MASK, PHY_B_DEF_MSK);
3555 break;
3556#ifdef OTHER_PHY
3557 case SK_PHY_LONE:
3558 SkXmPhyWrite(pAC, IoC, Port, PHY_LONE_INT_ENAB, PHY_L_DEF_MSK);
3559 break;
3560 case SK_PHY_NAT:
3561
3562
3563
3564 break;
3565#endif
3566 }
3567
3568
3569 XM_OUT16(IoC, Port, XM_MMU_CMD, Reg | XM_MMU_ENA_RX | XM_MMU_ENA_TX);
3570 }
3571 else {
3572
3573
3574
3575
3576
3577
3578 IntMask = GMAC_DEF_MSK;
3579
3580#ifdef DEBUG
3581
3582 IntMask |= GM_IS_RX_FF_OR;
3583#endif
3584
3585 SK_OUT8(IoC, GMAC_IRQ_MSK, (SK_U8)IntMask);
3586
3587
3588 GM_IN16(IoC, Port, GM_GP_CTRL, &Reg);
3589
3590 if (pPrt->PLinkModeStatus == SK_LMODE_STAT_FULL ||
3591 pPrt->PLinkModeStatus == SK_LMODE_STAT_AUTOFULL) {
3592
3593 Reg |= GM_GPCR_DUP_FULL;
3594 }
3595
3596
3597 GM_OUT16(IoC, Port, GM_GP_CTRL, Reg | GM_GPCR_RX_ENA | GM_GPCR_TX_ENA);
3598
3599#ifndef VCPU
3600
3601 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK);
3602#endif
3603 }
3604
3605 return(0);
3606
3607}
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618void SkMacRxTxDisable(
3619SK_AC *pAC,
3620SK_IOC IoC,
3621int Port)
3622{
3623 SK_U16 Word;
3624
3625 if (pAC->GIni.GIGenesis) {
3626
3627 XM_IN16(IoC, Port, XM_MMU_CMD, &Word);
3628
3629 XM_OUT16(IoC, Port, XM_MMU_CMD, Word & ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX));
3630
3631
3632 XM_IN16(IoC, Port, XM_MMU_CMD, &Word);
3633 }
3634 else {
3635
3636 GM_IN16(IoC, Port, GM_GP_CTRL, &Word);
3637
3638 GM_OUT16(IoC, Port, GM_GP_CTRL, Word & ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA));
3639
3640
3641 GM_IN16(IoC, Port, GM_GP_CTRL, &Word);
3642 }
3643}
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654void SkMacIrqDisable(
3655SK_AC *pAC,
3656SK_IOC IoC,
3657int Port)
3658{
3659 SK_GEPORT *pPrt;
3660 SK_U16 Word;
3661
3662 pPrt = &pAC->GIni.GP[Port];
3663
3664 if (pAC->GIni.GIGenesis) {
3665
3666
3667 XM_OUT16(IoC, Port, XM_IMSK, 0xffff);
3668
3669
3670 switch (pPrt->PhyType) {
3671 case SK_PHY_BCOM:
3672
3673 if (pPrt->PState != SK_PRT_RESET) {
3674
3675
3676
3677 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, &Word);
3678 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_AUX_CTRL,
3679 (SK_U16)(Word | PHY_B_AC_DIS_PM));
3680 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_INT_MASK, 0xffff);
3681 }
3682 break;
3683#ifdef OTHER_PHY
3684 case SK_PHY_LONE:
3685 SkXmPhyWrite(pAC, IoC, Port, PHY_LONE_INT_ENAB, 0);
3686 break;
3687 case SK_PHY_NAT:
3688
3689
3690 break;
3691#endif
3692 }
3693 }
3694 else {
3695
3696 SK_OUT8(IoC, GMAC_IRQ_MSK, 0);
3697
3698#ifndef VCPU
3699
3700 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_INT_MASK, 0);
3701#endif
3702 }
3703}
3704
3705
3706#ifdef SK_DIAG
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716void SkXmSendCont(
3717SK_AC *pAC,
3718SK_IOC IoC,
3719int Port,
3720SK_BOOL Enable)
3721{
3722 SK_U32 MdReg;
3723
3724 XM_IN32(IoC, Port, XM_MODE, &MdReg);
3725
3726 if (Enable) {
3727 MdReg |= XM_MD_TX_CONT;
3728 }
3729 else {
3730 MdReg &= ~XM_MD_TX_CONT;
3731 }
3732
3733 XM_OUT32(IoC, Port, XM_MODE, MdReg);
3734
3735}
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746void SkMacTimeStamp(
3747SK_AC *pAC,
3748SK_IOC IoC,
3749int Port,
3750SK_BOOL Enable)
3751{
3752 SK_U32 MdReg;
3753 SK_U8 TimeCtrl;
3754
3755 if (pAC->GIni.GIGenesis) {
3756
3757 XM_IN32(IoC, Port, XM_MODE, &MdReg);
3758
3759 if (Enable) {
3760 MdReg |= XM_MD_ATS;
3761 }
3762 else {
3763 MdReg &= ~XM_MD_ATS;
3764 }
3765
3766 XM_OUT32(IoC, Port, XM_MODE, MdReg);
3767 }
3768 else {
3769 if (Enable) {
3770 TimeCtrl = GMT_ST_START | GMT_ST_CLR_IRQ;
3771 }
3772 else {
3773 TimeCtrl = GMT_ST_STOP | GMT_ST_CLR_IRQ;
3774 }
3775
3776 SK_OUT8(pAC, GMAC_TI_ST_CTRL, TimeCtrl);
3777 }
3778}
3779
3780#else
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801void SkXmIrq(
3802SK_AC *pAC,
3803SK_IOC IoC,
3804int Port)
3805{
3806 SK_GEPORT *pPrt;
3807 SK_EVPARA Para;
3808 SK_U16 IStatus;
3809 SK_U16 IStatus2;
3810
3811 pPrt = &pAC->GIni.GP[Port];
3812
3813 XM_IN16(IoC, Port, XM_ISRC, &IStatus);
3814
3815
3816 if (pPrt->PhyType == SK_PHY_XMAC) {
3817 SkXmAutoNegLipaXmac(pAC, IoC, Port, IStatus);
3818 }
3819 else {
3820
3821 IStatus &= ~(XM_IS_LNK_AE | XM_IS_LIPA_RC |
3822 XM_IS_RX_PAGE | XM_IS_TX_PAGE |
3823 XM_IS_AND | XM_IS_INP_ASS);
3824 }
3825
3826 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
3827 ("XmacIrq Port %d Isr 0x%04x\n", Port, IStatus));
3828
3829 if (!pPrt->PHWLinkUp) {
3830
3831 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
3832 ("SkXmIrq: spurious interrupt on Port %d\n", Port));
3833 return;
3834 }
3835
3836 if ((IStatus & XM_IS_INP_ASS) != 0) {
3837
3838 XM_IN16(IoC, Port, XM_ISRC, &IStatus2);
3839
3840 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
3841 ("SkXmIrq: Link async. Double check Port %d 0x%04x 0x%04x\n",
3842 Port, IStatus, IStatus2));
3843 IStatus &= ~XM_IS_INP_ASS;
3844 IStatus |= IStatus2;
3845 }
3846
3847 if ((IStatus & XM_IS_LNK_AE) != 0) {
3848
3849 }
3850
3851 if ((IStatus & XM_IS_TX_ABORT) != 0) {
3852
3853 }
3854
3855 if ((IStatus & XM_IS_FRC_INT) != 0) {
3856
3857 }
3858
3859 if ((IStatus & (XM_IS_INP_ASS | XM_IS_LIPA_RC | XM_IS_RX_PAGE)) != 0) {
3860 SkHWLinkDown(pAC, IoC, Port);
3861
3862
3863 Para.Para32[0] = (SK_U32)Port;
3864 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
3865
3866
3867 SkTimerStart(pAC, IoC, &pPrt->PWaTimer, SK_WA_INA_TIME,
3868 SKGE_HWAC, SK_HWEV_WATIM, Para);
3869 }
3870
3871 if ((IStatus & XM_IS_RX_PAGE) != 0) {
3872
3873 }
3874
3875 if ((IStatus & XM_IS_TX_PAGE) != 0) {
3876
3877 }
3878
3879 if ((IStatus & XM_IS_AND) != 0) {
3880 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
3881 ("SkXmIrq: AND on link that is up Port %d\n", Port));
3882 }
3883
3884 if ((IStatus & XM_IS_TSC_OV) != 0) {
3885
3886 }
3887
3888
3889 if ((IStatus & (XM_IS_RXC_OV | XM_IS_TXC_OV)) != 0) {
3890 Para.Para32[0] = (SK_U32)Port;
3891 Para.Para32[1] = (SK_U32)IStatus;
3892 SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_SIRQ_OVERFLOW, Para);
3893 }
3894
3895 if ((IStatus & XM_IS_RXF_OV) != 0) {
3896
3897#ifdef DEBUG
3898 pPrt->PRxOverCnt++;
3899#endif
3900 }
3901
3902 if ((IStatus & XM_IS_TXF_UR) != 0) {
3903
3904 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E020, SKERR_SIRQ_E020MSG);
3905 }
3906
3907 if ((IStatus & XM_IS_TX_COMP) != 0) {
3908
3909 }
3910
3911 if ((IStatus & XM_IS_RX_COMP) != 0) {
3912
3913 }
3914}
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928void SkGmIrq(
3929SK_AC *pAC,
3930SK_IOC IoC,
3931int Port)
3932{
3933 SK_GEPORT *pPrt;
3934 SK_EVPARA Para;
3935 SK_U8 IStatus;
3936
3937 pPrt = &pAC->GIni.GP[Port];
3938
3939 SK_IN8(IoC, GMAC_IRQ_SRC, &IStatus);
3940
3941
3942 SkMacAutoNegLipaPhy(pAC, IoC, Port, IStatus);
3943
3944 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
3945 ("GmacIrq Port %d Isr 0x%04x\n", Port, IStatus));
3946
3947
3948 if (IStatus & (GM_IS_RX_CO_OV | GM_IS_TX_CO_OV)) {
3949
3950 Para.Para32[0] = (SK_U32)Port;
3951 Para.Para32[1] = (SK_U32)IStatus;
3952 SkPnmiEvent(pAC, IoC, SK_PNMI_EVT_SIRQ_OVERFLOW, Para);
3953 }
3954
3955 if (IStatus & GM_IS_RX_FF_OR) {
3956
3957 SK_OUT8(IoC, MR_ADDR(Port, RX_GMF_CTRL_T), (SK_U8)GMF_CLI_RX_FO);
3958#ifdef DEBUG
3959 pPrt->PRxOverCnt++;
3960#endif
3961 }
3962
3963 if (IStatus & GM_IS_TX_FF_UR) {
3964
3965 SK_OUT8(IoC, MR_ADDR(Port, TX_GMF_CTRL_T), (SK_U8)GMF_CLI_TX_FU);
3966
3967 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E020, SKERR_SIRQ_E020MSG);
3968 }
3969
3970 if (IStatus & GM_IS_TX_COMPL) {
3971
3972 }
3973
3974 if (IStatus & GM_IS_RX_COMPL) {
3975
3976 }
3977}
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988void SkMacIrq(
3989SK_AC *pAC,
3990SK_IOC IoC,
3991int Port)
3992{
3993
3994 if (pAC->GIni.GIGenesis) {
3995
3996 SkXmIrq(pAC, IoC, Port);
3997 }
3998 else {
3999
4000 SkGmIrq(pAC, IoC, Port);
4001 }
4002}
4003
4004#endif
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019int SkXmUpdateStats(
4020SK_AC *pAC,
4021SK_IOC IoC,
4022unsigned int Port)
4023{
4024 SK_GEPORT *pPrt;
4025 SK_U16 StatReg;
4026 int WaitIndex;
4027
4028 pPrt = &pAC->GIni.GP[Port];
4029 WaitIndex = 0;
4030
4031
4032 XM_OUT16(IoC, Port, XM_STAT_CMD, XM_SC_SNP_TXC | XM_SC_SNP_RXC);
4033
4034
4035
4036
4037
4038
4039
4040 do {
4041
4042 XM_IN16(IoC, Port, XM_STAT_CMD, &StatReg);
4043
4044 if (++WaitIndex > 10) {
4045
4046 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_HWI_E021, SKERR_HWI_E021MSG);
4047
4048 return(1);
4049 }
4050 } while ((StatReg & (XM_SC_SNP_TXC | XM_SC_SNP_RXC)) != 0);
4051
4052 return(0);
4053}
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066int SkGmUpdateStats(
4067SK_AC *pAC,
4068SK_IOC IoC,
4069unsigned int Port)
4070{
4071 return(0);
4072}
4073
4074
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086
4087int SkXmMacStatistic(
4088SK_AC *pAC,
4089SK_IOC IoC,
4090unsigned int Port,
4091SK_U16 StatAddr,
4092SK_U32 *pVal)
4093{
4094 if ((StatAddr < XM_TXF_OK) || (StatAddr > XM_RXF_MAX_SZ)) {
4095
4096 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E022, SKERR_HWI_E022MSG);
4097
4098 return(1);
4099 }
4100
4101 XM_IN32(IoC, Port, StatAddr, pVal);
4102
4103 return(0);
4104}
4105
4106
4107
4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119int SkGmMacStatistic(
4120SK_AC *pAC,
4121SK_IOC IoC,
4122unsigned int Port,
4123SK_U16 StatAddr,
4124SK_U32 *pVal)
4125{
4126
4127 if ((StatAddr < GM_RXF_UC_OK) || (StatAddr > GM_TXE_FIFO_UR)) {
4128
4129 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E022, SKERR_HWI_E022MSG);
4130
4131 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
4132 ("SkGmMacStat: wrong MIB counter 0x%04X\n", StatAddr));
4133 return(1);
4134 }
4135
4136 GM_IN32(IoC, Port, StatAddr, pVal);
4137
4138 return(0);
4139}
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149
4150
4151
4152int SkXmResetCounter(
4153SK_AC *pAC,
4154SK_IOC IoC,
4155unsigned int Port)
4156{
4157 XM_OUT16(IoC, Port, XM_STAT_CMD, XM_SC_CLR_RXC | XM_SC_CLR_TXC);
4158
4159 XM_OUT16(IoC, Port, XM_STAT_CMD, XM_SC_CLR_RXC | XM_SC_CLR_TXC);
4160
4161 return(0);
4162}
4163
4164
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174
4175int SkGmResetCounter(
4176SK_AC *pAC,
4177SK_IOC IoC,
4178unsigned int Port)
4179{
4180 SK_U16 Reg;
4181 SK_U16 Word;
4182 int i;
4183
4184 GM_IN16(IoC, Port, GM_PHY_ADDR, &Reg);
4185
4186#ifndef VCPU
4187
4188 GM_OUT16(IoC, Port, GM_PHY_ADDR, Reg | GM_PAR_MIB_CLR);
4189
4190
4191 for (i = 0; i < GM_MIB_CNT_SIZE; i++) {
4192
4193 GM_IN16(IoC, Port, GM_MIB_CNT_BASE + 8*i, &Word);
4194 }
4195
4196
4197 GM_OUT16(IoC, Port, GM_PHY_ADDR, Reg);
4198#endif
4199
4200 return(0);
4201}
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222int SkXmOverflowStatus(
4223SK_AC *pAC,
4224SK_IOC IoC,
4225unsigned int Port,
4226SK_U16 IStatus,
4227SK_U64 *pStatus)
4228{
4229 SK_U64 Status;
4230 SK_U32 RegVal;
4231
4232 Status = 0;
4233
4234 if ((IStatus & XM_IS_RXC_OV) != 0) {
4235
4236 XM_IN32(IoC, Port, XM_RX_CNT_EV, &RegVal);
4237 Status |= (SK_U64)RegVal << 32;
4238 }
4239
4240 if ((IStatus & XM_IS_TXC_OV) != 0) {
4241
4242 XM_IN32(IoC, Port, XM_TX_CNT_EV, &RegVal);
4243 Status |= (SK_U64)RegVal;
4244 }
4245
4246 *pStatus = Status;
4247
4248 return(0);
4249}
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261
4262
4263
4264
4265
4266
4267
4268
4269
4270
4271int SkGmOverflowStatus(
4272SK_AC *pAC,
4273SK_IOC IoC,
4274unsigned int Port,
4275SK_U16 IStatus,
4276SK_U64 *pStatus)
4277{
4278 SK_U64 Status;
4279 SK_U16 RegVal;
4280
4281 Status = 0;
4282
4283 if ((IStatus & GM_IS_RX_CO_OV) != 0) {
4284
4285 GM_IN16(IoC, Port, GM_RX_IRQ_SRC, &RegVal);
4286 Status |= (SK_U64)RegVal << 32;
4287 }
4288
4289 if ((IStatus & GM_IS_TX_CO_OV) != 0) {
4290
4291 GM_IN16(IoC, Port, GM_TX_IRQ_SRC, &RegVal);
4292 Status |= (SK_U64)RegVal;
4293 }
4294
4295
4296 GM_IN16(IoC, Port, GM_TR_IRQ_SRC, &RegVal);
4297
4298 Status |= (SK_U64)((SK_U8)RegVal) << 48;
4299
4300 Status |= (SK_U64)(RegVal >> 8) << 16;
4301
4302 *pStatus = Status;
4303
4304 return(0);
4305}
4306
4307
4308
4309
4310
4311
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322int SkGmCableDiagStatus(
4323SK_AC *pAC,
4324SK_IOC IoC,
4325int Port,
4326SK_BOOL StartTest)
4327{
4328 int i;
4329 SK_U16 RegVal;
4330 SK_GEPORT *pPrt;
4331
4332 pPrt = &pAC->GIni.GP[Port];
4333
4334 if (pPrt->PhyType != SK_PHY_MARV_COPPER) {
4335
4336 return(1);
4337 }
4338
4339 if (StartTest) {
4340
4341 if ((pPrt->PhyId1 & PHY_I1_REV_MSK) < 4) {
4342
4343 SkGmPhyWrite(pAC, IoC, Port, 29, 0x001e);
4344
4345 SkGmPhyWrite(pAC, IoC, Port, 30, 0xcc00);
4346 SkGmPhyWrite(pAC, IoC, Port, 30, 0xc800);
4347 SkGmPhyWrite(pAC, IoC, Port, 30, 0xc400);
4348 SkGmPhyWrite(pAC, IoC, Port, 30, 0xc000);
4349 SkGmPhyWrite(pAC, IoC, Port, 30, 0xc100);
4350 }
4351
4352
4353 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_EXT_ADR, 0);
4354
4355
4356 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_CABLE_DIAG, &RegVal);
4357
4358
4359 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CABLE_DIAG,
4360 (SK_U16)(RegVal | PHY_M_CABD_ENA_TEST));
4361
4362 return(0);
4363 }
4364
4365
4366 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_CABLE_DIAG, &RegVal);
4367
4368 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
4369 ("PHY Cable Diag.=0x%04X\n", RegVal));
4370
4371 if ((RegVal & PHY_M_CABD_ENA_TEST) != 0) {
4372
4373 return(2);
4374 }
4375
4376
4377 for (i = 0; i < 4; i++) {
4378
4379 SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_EXT_ADR, (SK_U16)i);
4380
4381
4382 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_CABLE_DIAG, &RegVal);
4383
4384 pPrt->PMdiPairLen[i] = (SK_U8)(RegVal & PHY_M_CABD_DIST_MSK);
4385
4386 pPrt->PMdiPairSts[i] = (SK_U8)((RegVal & PHY_M_CABD_STAT_MSK) >> 13);
4387 }
4388
4389 return(0);
4390}
4391
4392
4393