[PATCH] e1000: Enable polling before enabling interrupts
[linux-2.6] / drivers / net / sk98lin / skgesirq.c
1 /******************************************************************************
2  *
3  * Name:        skgesirq.c
4  * Project:     Gigabit Ethernet Adapters, Common Modules
5  * Version:     $Revision: 1.92 $
6  * Date:        $Date: 2003/09/16 14:37:07 $
7  * Purpose:     Special IRQ module
8  *
9  ******************************************************************************/
10
11 /******************************************************************************
12  *
13  *      (C)Copyright 1998-2002 SysKonnect.
14  *      (C)Copyright 2002-2003 Marvell.
15  *
16  *      This program is free software; you can redistribute it and/or modify
17  *      it under the terms of the GNU General Public License as published by
18  *      the Free Software Foundation; either version 2 of the License, or
19  *      (at your option) any later version.
20  *
21  *      The information in this file is provided "AS IS" without warranty.
22  *
23  ******************************************************************************/
24
25 /*
26  *      Special Interrupt handler
27  *
28  *      The following abstract should show how this module is included
29  *      in the driver path:
30  *
31  *      In the ISR of the driver the bits for frame transmission complete and
32  *      for receive complete are checked and handled by the driver itself.
33  *      The bits of the slow path mask are checked after that and then the
34  *      entry into the so-called "slow path" is prepared. It is an implementors
35  *      decision whether this is executed directly or just scheduled by
36  *      disabling the mask. In the interrupt service routine some events may be
37  *      generated, so it would be a good idea to call the EventDispatcher
38  *      right after this ISR.
39  *
40  *      The Interrupt source register of the adapter is NOT read by this module.
41  *  SO if the drivers implementor needs a while loop around the
42  *      slow data paths interrupt bits, he needs to call the SkGeSirqIsr() for
43  *      each loop entered.
44  *
45  *      However, the MAC Interrupt status registers are read in a while loop.
46  *
47  */
48
49 #if (defined(DEBUG) || ((!defined(LINT)) && (!defined(SK_SLIM))))
50 static const char SysKonnectFileId[] =
51         "@(#) $Id: skgesirq.c,v 1.92 2003/09/16 14:37:07 rschmidt Exp $ (C) Marvell.";
52 #endif
53
54 #include "h/skdrv1st.h"         /* Driver Specific Definitions */
55 #ifndef SK_SLIM
56 #include "h/skgepnmi.h"         /* PNMI Definitions */
57 #include "h/skrlmt.h"           /* RLMT Definitions */
58 #endif
59 #include "h/skdrv2nd.h"         /* Adapter Control and Driver specific Def. */
60
61 /* local function prototypes */
62 #ifdef GENESIS
63 static int      SkGePortCheckUpXmac(SK_AC*, SK_IOC, int, SK_BOOL);
64 static int      SkGePortCheckUpBcom(SK_AC*, SK_IOC, int, SK_BOOL);
65 static void     SkPhyIsrBcom(SK_AC*, SK_IOC, int, SK_U16);
66 #endif /* GENESIS */
67 #ifdef YUKON
68 static int      SkGePortCheckUpGmac(SK_AC*, SK_IOC, int, SK_BOOL);
69 static void     SkPhyIsrGmac(SK_AC*, SK_IOC, int, SK_U16);
70 #endif /* YUKON */
71 #ifdef OTHER_PHY
72 static int      SkGePortCheckUpLone(SK_AC*, SK_IOC, int, SK_BOOL);
73 static int      SkGePortCheckUpNat(SK_AC*, SK_IOC, int, SK_BOOL);
74 static void     SkPhyIsrLone(SK_AC*, SK_IOC, int, SK_U16);
75 #endif /* OTHER_PHY */
76
77 #ifdef GENESIS
78 /*
79  * array of Rx counter from XMAC which are checked
80  * in AutoSense mode to check whether a link is not able to auto-negotiate.
81  */
82 static const SK_U16 SkGeRxRegs[]= {
83         XM_RXF_64B,
84         XM_RXF_127B,
85         XM_RXF_255B,
86         XM_RXF_511B,
87         XM_RXF_1023B,
88         XM_RXF_MAX_SZ
89 } ;
90 #endif /* GENESIS */
91
92 #ifdef __C2MAN__
93 /*
94  *      Special IRQ function
95  *
96  *      General Description:
97  *
98  */
99 intro()
100 {}
101 #endif
102
103 /******************************************************************************
104  *
105  *      SkHWInitDefSense() - Default Autosensing mode initialization
106  *
107  * Description: sets the PLinkMode for HWInit
108  *
109  * Returns: N/A
110  */
111 static void SkHWInitDefSense(
112 SK_AC   *pAC,   /* adapter context */
113 SK_IOC  IoC,    /* IO context */
114 int             Port)   /* Port Index (MAC_1 + n) */
115 {
116         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
117
118         pPrt = &pAC->GIni.GP[Port];
119
120         pPrt->PAutoNegTimeOut = 0;
121
122         if (pPrt->PLinkModeConf != SK_LMODE_AUTOSENSE) {
123                 pPrt->PLinkMode = pPrt->PLinkModeConf;
124                 return;
125         }
126
127         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
128                 ("AutoSensing: First mode %d on Port %d\n",
129                 (int)SK_LMODE_AUTOFULL, Port));
130
131         pPrt->PLinkMode = (SK_U8)SK_LMODE_AUTOFULL;
132
133         return;
134 }       /* SkHWInitDefSense */
135
136
137 #ifdef GENESIS
138 /******************************************************************************
139  *
140  *      SkHWSenseGetNext() - Get Next Autosensing Mode
141  *
142  * Description: gets the appropriate next mode
143  *
144  * Note:
145  *
146  */
147 static SK_U8 SkHWSenseGetNext(
148 SK_AC   *pAC,   /* adapter context */
149 SK_IOC  IoC,    /* IO context */
150 int             Port)   /* Port Index (MAC_1 + n) */
151 {
152         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
153
154         pPrt = &pAC->GIni.GP[Port];
155
156         pPrt->PAutoNegTimeOut = 0;
157
158     if (pPrt->PLinkModeConf != (SK_U8)SK_LMODE_AUTOSENSE) {
159                 /* Leave all as configured */
160                 return(pPrt->PLinkModeConf);
161         }
162
163     if (pPrt->PLinkMode == (SK_U8)SK_LMODE_AUTOFULL) {
164                 /* Return next mode AUTOBOTH */
165         return ((SK_U8)SK_LMODE_AUTOBOTH);
166         }
167
168         /* Return default autofull */
169     return ((SK_U8)SK_LMODE_AUTOFULL);
170 }       /* SkHWSenseGetNext */
171
172
173 /******************************************************************************
174  *
175  *      SkHWSenseSetNext() - Autosensing Set next mode
176  *
177  * Description: sets the appropriate next mode
178  *
179  * Returns: N/A
180  */
181 static void SkHWSenseSetNext(
182 SK_AC   *pAC,           /* adapter context */
183 SK_IOC  IoC,            /* IO context */
184 int             Port,           /* Port Index (MAC_1 + n) */
185 SK_U8   NewMode)        /* New Mode to be written in sense mode */
186 {
187         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
188
189         pPrt = &pAC->GIni.GP[Port];
190
191         pPrt->PAutoNegTimeOut = 0;
192
193     if (pPrt->PLinkModeConf != (SK_U8)SK_LMODE_AUTOSENSE) {
194                 return;
195         }
196
197         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
198                 ("AutoSensing: next mode %d on Port %d\n",
199                 (int)NewMode, Port));
200
201         pPrt->PLinkMode = NewMode;
202
203         return;
204 }       /* SkHWSenseSetNext */
205 #endif /* GENESIS */
206
207
208 /******************************************************************************
209  *
210  *      SkHWLinkDown() - Link Down handling
211  *
212  * Description: handles the hardware link down signal
213  *
214  * Returns: N/A
215  */
216 void SkHWLinkDown(
217 SK_AC   *pAC,           /* adapter context */
218 SK_IOC  IoC,            /* IO context */
219 int             Port)           /* Port Index (MAC_1 + n) */
220 {
221         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
222
223         pPrt = &pAC->GIni.GP[Port];
224
225         /* Disable all MAC interrupts */
226         SkMacIrqDisable(pAC, IoC, Port);
227
228         /* Disable Receiver and Transmitter */
229         SkMacRxTxDisable(pAC, IoC, Port);
230         
231         /* Init default sense mode */
232         SkHWInitDefSense(pAC, IoC, Port);
233
234         if (pPrt->PHWLinkUp == SK_FALSE) {
235                 return;
236         }
237
238         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
239                 ("Link down Port %d\n", Port));
240
241         /* Set Link to DOWN */
242         pPrt->PHWLinkUp = SK_FALSE;
243
244         /* Reset Port stati */
245     pPrt->PLinkModeStatus = (SK_U8)SK_LMODE_STAT_UNKNOWN;
246     pPrt->PFlowCtrlStatus = (SK_U8)SK_FLOW_STAT_NONE;
247         pPrt->PLinkSpeedUsed = (SK_U8)SK_LSPEED_STAT_INDETERMINATED;
248
249         /* Re-init Phy especially when the AutoSense default is set now */
250         SkMacInitPhy(pAC, IoC, Port, SK_FALSE);
251
252         /* GP0: used for workaround of Rev. C Errata 2 */
253
254         /* Do NOT signal to RLMT */
255
256         /* Do NOT start the timer here */
257 }       /* SkHWLinkDown */
258
259
260 /******************************************************************************
261  *
262  *      SkHWLinkUp() - Link Up handling
263  *
264  * Description: handles the hardware link up signal
265  *
266  * Returns: N/A
267  */
268 void SkHWLinkUp(
269 SK_AC   *pAC,   /* adapter context */
270 SK_IOC  IoC,    /* IO context */
271 int             Port)   /* Port Index (MAC_1 + n) */
272 {
273         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
274
275         pPrt = &pAC->GIni.GP[Port];
276
277         if (pPrt->PHWLinkUp) {
278                 /* We do NOT need to proceed on active link */
279                 return;
280         }
281
282         pPrt->PHWLinkUp = SK_TRUE;
283         pPrt->PAutoNegFail = SK_FALSE;
284     pPrt->PLinkModeStatus = (SK_U8)SK_LMODE_STAT_UNKNOWN;
285
286     if (pPrt->PLinkMode != (SK_U8)SK_LMODE_AUTOHALF &&
287         pPrt->PLinkMode != (SK_U8)SK_LMODE_AUTOFULL &&
288         pPrt->PLinkMode != (SK_U8)SK_LMODE_AUTOBOTH) {
289                 /* Link is up and no Auto-negotiation should be done */
290
291                 /* Link speed should be the configured one */
292                 switch (pPrt->PLinkSpeed) {
293                 case SK_LSPEED_AUTO:
294                         /* default is 1000 Mbps */
295                 case SK_LSPEED_1000MBPS:
296                         pPrt->PLinkSpeedUsed = (SK_U8)SK_LSPEED_STAT_1000MBPS;
297                         break;
298                 case SK_LSPEED_100MBPS:
299                         pPrt->PLinkSpeedUsed = (SK_U8)SK_LSPEED_STAT_100MBPS;
300                         break;
301                 case SK_LSPEED_10MBPS:
302                         pPrt->PLinkSpeedUsed = (SK_U8)SK_LSPEED_STAT_10MBPS;
303                         break;
304                 }
305
306                 /* Set Link Mode Status */
307                 if (pPrt->PLinkMode == SK_LMODE_FULL) {
308                         pPrt->PLinkModeStatus = (SK_U8)SK_LMODE_STAT_FULL;
309                 }
310                 else {
311             pPrt->PLinkModeStatus = (SK_U8)SK_LMODE_STAT_HALF;
312                 }
313
314                 /* No flow control without auto-negotiation */
315         pPrt->PFlowCtrlStatus = (SK_U8)SK_FLOW_STAT_NONE;
316
317                 /* enable Rx/Tx */
318         (void)SkMacRxTxEnable(pAC, IoC, Port);
319         }
320 }       /* SkHWLinkUp */
321
322
323 /******************************************************************************
324  *
325  *      SkMacParity() - MAC parity workaround
326  *
327  * Description: handles MAC parity errors correctly
328  *
329  * Returns: N/A
330  */
331 static void SkMacParity(
332 SK_AC   *pAC,   /* adapter context */
333 SK_IOC  IoC,    /* IO context */
334 int             Port)   /* Port Index of the port failed */
335 {
336         SK_EVPARA       Para;
337         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
338         SK_U32          TxMax;          /* Tx Max Size Counter */
339
340         pPrt = &pAC->GIni.GP[Port];
341
342         /* Clear IRQ Tx Parity Error */
343 #ifdef GENESIS
344         if (pAC->GIni.GIGenesis) {
345
346                 SK_OUT16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), MFF_CLR_PERR);
347         }
348 #endif /* GENESIS */
349         
350 #ifdef YUKON
351         if (pAC->GIni.GIYukon) {
352                 /* HW-Bug #8: cleared by GMF_CLI_TX_FC instead of GMF_CLI_TX_PE */
353                 SK_OUT8(IoC, MR_ADDR(Port, TX_GMF_CTRL_T),
354                         (SK_U8)((pAC->GIni.GIChipId == CHIP_ID_YUKON &&
355                         pAC->GIni.GIChipRev == 0) ? GMF_CLI_TX_FC : GMF_CLI_TX_PE));
356         }
357 #endif /* YUKON */
358         
359         if (pPrt->PCheckPar) {
360
361                 if (Port == MAC_1) {
362                         SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E016, SKERR_SIRQ_E016MSG);
363                 }
364                 else {
365                         SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E017, SKERR_SIRQ_E017MSG);
366                 }
367                 Para.Para64 = Port;
368                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
369                 
370                 Para.Para32[0] = Port;
371                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
372
373                 return;
374         }
375
376         /* Check whether frames with a size of 1k were sent */
377 #ifdef GENESIS
378         if (pAC->GIni.GIGenesis) {
379                 /* Snap statistic counters */
380                 (void)SkXmUpdateStats(pAC, IoC, Port);
381                 
382                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_TXF_MAX_SZ, &TxMax);
383         }
384 #endif /* GENESIS */
385         
386 #ifdef YUKON
387         if (pAC->GIni.GIYukon) {
388
389                 (void)SkGmMacStatistic(pAC, IoC, Port, GM_TXF_1518B, &TxMax);
390         }
391 #endif /* YUKON */
392         
393         if (TxMax > 0) {
394                 /* From now on check the parity */
395                 pPrt->PCheckPar = SK_TRUE;
396         }
397 }       /* SkMacParity */
398
399
400 /******************************************************************************
401  *
402  *      SkGeHwErr() - Hardware Error service routine
403  *
404  * Description: handles all HW Error interrupts
405  *
406  * Returns: N/A
407  */
408 static void SkGeHwErr(
409 SK_AC   *pAC,           /* adapter context */
410 SK_IOC  IoC,            /* IO context */
411 SK_U32  HwStatus)       /* Interrupt status word */
412 {
413         SK_EVPARA       Para;
414         SK_U16          Word;
415
416         if ((HwStatus & (IS_IRQ_MST_ERR | IS_IRQ_STAT)) != 0) {
417                 /* PCI Errors occured */
418                 if ((HwStatus & IS_IRQ_STAT) != 0) {
419                         SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E013, SKERR_SIRQ_E013MSG);
420                 }
421                 else {
422                         SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E012, SKERR_SIRQ_E012MSG);
423                 }
424
425                 /* Reset all bits in the PCI STATUS register */
426                 SK_IN16(IoC, PCI_C(PCI_STATUS), &Word);
427                 
428                 SK_OUT8(IoC, B2_TST_CTRL1, TST_CFG_WRITE_ON);
429         SK_OUT16(IoC, PCI_C(PCI_STATUS), (SK_U16)(Word | PCI_ERRBITS));
430                 SK_OUT8(IoC, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
431
432                 Para.Para64 = 0;
433                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_ADAP_FAIL, Para);
434         }
435
436 #ifdef GENESIS
437         if (pAC->GIni.GIGenesis) {
438
439                 if ((HwStatus & IS_NO_STAT_M1) != 0) {
440                         /* Ignore it */
441                         /* This situation is also indicated in the descriptor */
442                         SK_OUT16(IoC, MR_ADDR(MAC_1, RX_MFF_CTRL1), MFF_CLR_INSTAT);
443                 }
444
445                 if ((HwStatus & IS_NO_STAT_M2) != 0) {
446                         /* Ignore it */
447                         /* This situation is also indicated in the descriptor */
448                         SK_OUT16(IoC, MR_ADDR(MAC_2, RX_MFF_CTRL1), MFF_CLR_INSTAT);
449                 }
450
451                 if ((HwStatus & IS_NO_TIST_M1) != 0) {
452                         /* Ignore it */
453                         /* This situation is also indicated in the descriptor */
454                         SK_OUT16(IoC, MR_ADDR(MAC_1, RX_MFF_CTRL1), MFF_CLR_INTIST);
455                 }
456
457                 if ((HwStatus & IS_NO_TIST_M2) != 0) {
458                         /* Ignore it */
459                         /* This situation is also indicated in the descriptor */
460                         SK_OUT16(IoC, MR_ADDR(MAC_2, RX_MFF_CTRL1), MFF_CLR_INTIST);
461                 }
462         }
463 #endif /* GENESIS */
464         
465 #ifdef YUKON
466         if (pAC->GIni.GIYukon) {
467                 /* This is necessary only for Rx timing measurements */
468                 if ((HwStatus & IS_IRQ_TIST_OV) != 0) {
469                         /* increment Time Stamp Timer counter (high) */
470                         pAC->GIni.GITimeStampCnt++;
471
472                         /* Clear Time Stamp Timer IRQ */
473                         SK_OUT8(IoC, GMAC_TI_ST_CTRL, (SK_U8)GMT_ST_CLR_IRQ);
474                 }
475
476                 if ((HwStatus & IS_IRQ_SENSOR) != 0) {
477                         /* no sensors on 32-bit Yukon */
478                         if (pAC->GIni.GIYukon32Bit) {
479                                 /* disable HW Error IRQ */
480                                 pAC->GIni.GIValIrqMask &= ~IS_HW_ERR;
481                         }
482                 }
483         }
484 #endif /* YUKON */
485
486         if ((HwStatus & IS_RAM_RD_PAR) != 0) {
487                 SK_OUT16(IoC, B3_RI_CTRL, RI_CLR_RD_PERR);
488                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E014, SKERR_SIRQ_E014MSG);
489                 Para.Para64 = 0;
490                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_ADAP_FAIL, Para);
491         }
492
493         if ((HwStatus & IS_RAM_WR_PAR) != 0) {
494                 SK_OUT16(IoC, B3_RI_CTRL, RI_CLR_WR_PERR);
495                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E015, SKERR_SIRQ_E015MSG);
496                 Para.Para64 = 0;
497                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_ADAP_FAIL, Para);
498         }
499
500         if ((HwStatus & IS_M1_PAR_ERR) != 0) {
501                 SkMacParity(pAC, IoC, MAC_1);
502         }
503
504         if ((HwStatus & IS_M2_PAR_ERR) != 0) {
505                 SkMacParity(pAC, IoC, MAC_2);
506         }
507
508         if ((HwStatus & IS_R1_PAR_ERR) != 0) {
509                 /* Clear IRQ */
510                 SK_OUT32(IoC, B0_R1_CSR, CSR_IRQ_CL_P);
511
512                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E018, SKERR_SIRQ_E018MSG);
513                 Para.Para64 = MAC_1;
514                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
515                 
516                 Para.Para32[0] = MAC_1;
517                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
518         }
519
520         if ((HwStatus & IS_R2_PAR_ERR) != 0) {
521                 /* Clear IRQ */
522                 SK_OUT32(IoC, B0_R2_CSR, CSR_IRQ_CL_P);
523
524                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E019, SKERR_SIRQ_E019MSG);
525                 Para.Para64 = MAC_2;
526                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
527                 
528                 Para.Para32[0] = MAC_2;
529                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
530         }
531 }       /* SkGeHwErr */
532
533
534 /******************************************************************************
535  *
536  *      SkGeSirqIsr() - Special Interrupt Service Routine
537  *
538  * Description: handles all non data transfer specific interrupts (slow path)
539  *
540  * Returns: N/A
541  */
542 void SkGeSirqIsr(
543 SK_AC   *pAC,           /* adapter context */
544 SK_IOC  IoC,            /* IO context */
545 SK_U32  Istatus)        /* Interrupt status word */
546 {
547         SK_EVPARA       Para;
548         SK_U32          RegVal32;       /* Read register value */
549         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
550         SK_U16          PhyInt;
551         int                     i;
552
553         if (((Istatus & IS_HW_ERR) & pAC->GIni.GIValIrqMask) != 0) {
554                 /* read the HW Error Interrupt source */
555                 SK_IN32(IoC, B0_HWE_ISRC, &RegVal32);
556                 
557                 SkGeHwErr(pAC, IoC, RegVal32);
558         }
559
560         /*
561          * Packet Timeout interrupts
562          */
563         /* Check whether MACs are correctly initialized */
564         if (((Istatus & (IS_PA_TO_RX1 | IS_PA_TO_TX1)) != 0) &&
565                 pAC->GIni.GP[MAC_1].PState == SK_PRT_RESET) {
566                 /* MAC 1 was not initialized but Packet timeout occured */
567                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E004,
568                         SKERR_SIRQ_E004MSG);
569         }
570
571         if (((Istatus & (IS_PA_TO_RX2 | IS_PA_TO_TX2)) != 0) &&
572             pAC->GIni.GP[MAC_2].PState == SK_PRT_RESET) {
573                 /* MAC 2 was not initialized but Packet timeout occured */
574                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E005,
575                         SKERR_SIRQ_E005MSG);
576         }
577
578         if ((Istatus & IS_PA_TO_RX1) != 0) {
579                 /* Means network is filling us up */
580                 SK_ERR_LOG(pAC, SK_ERRCL_HW | SK_ERRCL_INIT, SKERR_SIRQ_E002,
581                         SKERR_SIRQ_E002MSG);
582                 SK_OUT16(IoC, B3_PA_CTRL, PA_CLR_TO_RX1);
583         }
584
585         if ((Istatus & IS_PA_TO_RX2) != 0) {
586                 /* Means network is filling us up */
587                 SK_ERR_LOG(pAC, SK_ERRCL_HW | SK_ERRCL_INIT, SKERR_SIRQ_E003,
588                         SKERR_SIRQ_E003MSG);
589                 SK_OUT16(IoC, B3_PA_CTRL, PA_CLR_TO_RX2);
590         }
591
592         if ((Istatus & IS_PA_TO_TX1) != 0) {
593                 
594                 pPrt = &pAC->GIni.GP[0];
595
596                 /* May be a normal situation in a server with a slow network */
597                 SK_OUT16(IoC, B3_PA_CTRL, PA_CLR_TO_TX1);
598
599 #ifdef GENESIS
600                 if (pAC->GIni.GIGenesis) {
601                         /*
602                          * workaround: if in half duplex mode, check for Tx hangup.
603                          * Read number of TX'ed bytes, wait for 10 ms, then compare
604                          * the number with current value. If nothing changed, we assume
605                          * that Tx is hanging and do a FIFO flush (see event routine).
606                          */
607                         if ((pPrt->PLinkModeStatus == SK_LMODE_STAT_HALF ||
608                                 pPrt->PLinkModeStatus == SK_LMODE_STAT_AUTOHALF) &&
609                                 !pPrt->HalfDupTimerActive) {
610                                 /*
611                                  * many more pack. arb. timeouts may come in between,
612                                  * we ignore those
613                                  */
614                                 pPrt->HalfDupTimerActive = SK_TRUE;
615 #ifdef XXX
616                                 Len = sizeof(SK_U64);
617                                 SkPnmiGetVar(pAC, IoC, OID_SKGE_STAT_TX_OCTETS, (char *)&Octets,
618                                         &Len, (SK_U32)SK_PNMI_PORT_PHYS2INST(pAC, 0),
619                                         pAC->Rlmt.Port[0].Net->NetNumber);
620                                 
621                                 pPrt->LastOctets = Octets;
622 #endif /* XXX */
623                                 /* Snap statistic counters */
624                                 (void)SkXmUpdateStats(pAC, IoC, 0);
625
626                                 (void)SkXmMacStatistic(pAC, IoC, 0, XM_TXO_OK_HI, &RegVal32);
627
628                                 pPrt->LastOctets = (SK_U64)RegVal32 << 32;
629                                 
630                                 (void)SkXmMacStatistic(pAC, IoC, 0, XM_TXO_OK_LO, &RegVal32);
631
632                                 pPrt->LastOctets += RegVal32;
633                                 
634                                 Para.Para32[0] = 0;
635                                 SkTimerStart(pAC, IoC, &pPrt->HalfDupChkTimer, SK_HALFDUP_CHK_TIME,
636                                         SKGE_HWAC, SK_HWEV_HALFDUP_CHK, Para);
637                         }
638                 }
639 #endif /* GENESIS */
640         }
641
642         if ((Istatus & IS_PA_TO_TX2) != 0) {
643                 
644                 pPrt = &pAC->GIni.GP[1];
645
646                 /* May be a normal situation in a server with a slow network */
647                 SK_OUT16(IoC, B3_PA_CTRL, PA_CLR_TO_TX2);
648
649 #ifdef GENESIS
650                 if (pAC->GIni.GIGenesis) {
651                         /* workaround: see above */
652                         if ((pPrt->PLinkModeStatus == SK_LMODE_STAT_HALF ||
653                                  pPrt->PLinkModeStatus == SK_LMODE_STAT_AUTOHALF) &&
654                                 !pPrt->HalfDupTimerActive) {
655                                 pPrt->HalfDupTimerActive = SK_TRUE;
656 #ifdef XXX
657                                 Len = sizeof(SK_U64);
658                                 SkPnmiGetVar(pAC, IoC, OID_SKGE_STAT_TX_OCTETS, (char *)&Octets,
659                                         &Len, (SK_U32)SK_PNMI_PORT_PHYS2INST(pAC, 1),
660                                         pAC->Rlmt.Port[1].Net->NetNumber);
661                                 
662                                 pPrt->LastOctets = Octets;
663 #endif /* XXX */
664                                 /* Snap statistic counters */
665                                 (void)SkXmUpdateStats(pAC, IoC, 1);
666
667                                 (void)SkXmMacStatistic(pAC, IoC, 1, XM_TXO_OK_HI, &RegVal32);
668
669                                 pPrt->LastOctets = (SK_U64)RegVal32 << 32;
670                                 
671                                 (void)SkXmMacStatistic(pAC, IoC, 1, XM_TXO_OK_LO, &RegVal32);
672
673                                 pPrt->LastOctets += RegVal32;
674                                 
675                                 Para.Para32[0] = 1;
676                                 SkTimerStart(pAC, IoC, &pPrt->HalfDupChkTimer, SK_HALFDUP_CHK_TIME,
677                                         SKGE_HWAC, SK_HWEV_HALFDUP_CHK, Para);
678                         }
679                 }
680 #endif /* GENESIS */
681         }
682
683         /* Check interrupts of the particular queues */
684         if ((Istatus & IS_R1_C) != 0) {
685                 /* Clear IRQ */
686                 SK_OUT32(IoC, B0_R1_CSR, CSR_IRQ_CL_C);
687                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E006,
688                         SKERR_SIRQ_E006MSG);
689                 Para.Para64 = MAC_1;
690                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
691                 Para.Para32[0] = MAC_1;
692                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
693         }
694
695         if ((Istatus & IS_R2_C) != 0) {
696                 /* Clear IRQ */
697                 SK_OUT32(IoC, B0_R2_CSR, CSR_IRQ_CL_C);
698                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E007,
699                         SKERR_SIRQ_E007MSG);
700                 Para.Para64 = MAC_2;
701                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
702                 Para.Para32[0] = MAC_2;
703                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
704         }
705
706         if ((Istatus & IS_XS1_C) != 0) {
707                 /* Clear IRQ */
708                 SK_OUT32(IoC, B0_XS1_CSR, CSR_IRQ_CL_C);
709                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E008,
710                         SKERR_SIRQ_E008MSG);
711                 Para.Para64 = MAC_1;
712                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
713                 Para.Para32[0] = MAC_1;
714                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
715         }
716
717         if ((Istatus & IS_XA1_C) != 0) {
718                 /* Clear IRQ */
719                 SK_OUT32(IoC, B0_XA1_CSR, CSR_IRQ_CL_C);
720                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E009,
721                         SKERR_SIRQ_E009MSG);
722                 Para.Para64 = MAC_1;
723                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
724                 Para.Para32[0] = MAC_1;
725                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
726         }
727
728         if ((Istatus & IS_XS2_C) != 0) {
729                 /* Clear IRQ */
730                 SK_OUT32(IoC, B0_XS2_CSR, CSR_IRQ_CL_C);
731                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E010,
732                         SKERR_SIRQ_E010MSG);
733                 Para.Para64 = MAC_2;
734                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
735                 Para.Para32[0] = MAC_2;
736                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
737         }
738
739         if ((Istatus & IS_XA2_C) != 0) {
740                 /* Clear IRQ */
741                 SK_OUT32(IoC, B0_XA2_CSR, CSR_IRQ_CL_C);
742                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E011,
743                         SKERR_SIRQ_E011MSG);
744                 Para.Para64 = MAC_2;
745                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
746                 Para.Para32[0] = MAC_2;
747                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
748         }
749
750         /* External reg interrupt */
751         if ((Istatus & IS_EXT_REG) != 0) {
752                 /* Test IRQs from PHY */
753                 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
754                         
755                         pPrt = &pAC->GIni.GP[i];
756                         
757                         if (pPrt->PState == SK_PRT_RESET) {
758                                 continue;
759                         }
760                         
761 #ifdef GENESIS
762                         if (pAC->GIni.GIGenesis) {
763                                 
764                                 switch (pPrt->PhyType) {
765                                 
766                                 case SK_PHY_XMAC:
767                                         break;
768                                 
769                                 case SK_PHY_BCOM:
770                                         SkXmPhyRead(pAC, IoC, i, PHY_BCOM_INT_STAT, &PhyInt);
771         
772                                         if ((PhyInt & ~PHY_B_DEF_MSK) != 0) {
773                                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
774                                                         ("Port %d Bcom Int: 0x%04X\n",
775                                                         i, PhyInt));
776                                                 SkPhyIsrBcom(pAC, IoC, i, PhyInt);
777                                         }
778                                         break;
779 #ifdef OTHER_PHY
780                                 case SK_PHY_LONE:
781                                         SkXmPhyRead(pAC, IoC, i, PHY_LONE_INT_STAT, &PhyInt);
782                                         
783                                         if ((PhyInt & PHY_L_DEF_MSK) != 0) {
784                                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
785                                                         ("Port %d Lone Int: %x\n",
786                                                         i, PhyInt));
787                                                 SkPhyIsrLone(pAC, IoC, i, PhyInt);
788                                         }
789                                         break;
790 #endif /* OTHER_PHY */
791                                 }
792                         }
793 #endif /* GENESIS */
794         
795 #ifdef YUKON
796                         if (pAC->GIni.GIYukon) {
797                                 /* Read PHY Interrupt Status */
798                                 SkGmPhyRead(pAC, IoC, i, PHY_MARV_INT_STAT, &PhyInt);
799
800                                 if ((PhyInt & PHY_M_DEF_MSK) != 0) {
801                                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
802                                                 ("Port %d Marv Int: 0x%04X\n",
803                                                 i, PhyInt));
804                                         SkPhyIsrGmac(pAC, IoC, i, PhyInt);
805                                 }
806                         }
807 #endif /* YUKON */
808                 }
809         }
810
811         /* I2C Ready interrupt */
812         if ((Istatus & IS_I2C_READY) != 0) {
813 #ifdef SK_SLIM
814         SK_OUT32(IoC, B2_I2C_IRQ, I2C_CLR_IRQ);
815 #else           
816                 SkI2cIsr(pAC, IoC);
817 #endif          
818         }
819
820         /* SW forced interrupt */
821         if ((Istatus & IS_IRQ_SW) != 0) {
822                 /* clear the software IRQ */
823                 SK_OUT8(IoC, B0_CTST, CS_CL_SW_IRQ);
824         }
825
826         if ((Istatus & IS_LNK_SYNC_M1) != 0) {
827                 /*
828                  * We do NOT need the Link Sync interrupt, because it shows
829                  * us only a link going down.
830                  */
831                 /* clear interrupt */
832                 SK_OUT8(IoC, MR_ADDR(MAC_1, LNK_SYNC_CTRL), LED_CLR_IRQ);
833         }
834
835         /* Check MAC after link sync counter */
836         if ((Istatus & IS_MAC1) != 0) {
837                 /* IRQ from MAC 1 */
838                 SkMacIrq(pAC, IoC, MAC_1);
839         }
840
841         if ((Istatus & IS_LNK_SYNC_M2) != 0) {
842                 /*
843                  * We do NOT need the Link Sync interrupt, because it shows
844                  * us only a link going down.
845                  */
846                 /* clear interrupt */
847                 SK_OUT8(IoC, MR_ADDR(MAC_2, LNK_SYNC_CTRL), LED_CLR_IRQ);
848         }
849
850         /* Check MAC after link sync counter */
851         if ((Istatus & IS_MAC2) != 0) {
852                 /* IRQ from MAC 2 */
853                 SkMacIrq(pAC, IoC, MAC_2);
854         }
855
856         /* Timer interrupt (served last) */
857         if ((Istatus & IS_TIMINT) != 0) {
858                 /* check for HW Errors */
859                 if (((Istatus & IS_HW_ERR) & ~pAC->GIni.GIValIrqMask) != 0) {
860                         /* read the HW Error Interrupt source */
861                         SK_IN32(IoC, B0_HWE_ISRC, &RegVal32);
862
863                         SkGeHwErr(pAC, IoC, RegVal32);
864                 }
865
866                 SkHwtIsr(pAC, IoC);
867         }
868
869 }       /* SkGeSirqIsr */
870
871
872 #ifdef GENESIS
873 /******************************************************************************
874  *
875  * SkGePortCheckShorts() - Implementing XMAC Workaround Errata # 2
876  *
877  * return:
878  *      0       o.k. nothing needed
879  *      1       Restart needed on this port
880  */
881 static int SkGePortCheckShorts(
882 SK_AC   *pAC,           /* Adapter Context */
883 SK_IOC  IoC,            /* IO Context */
884 int             Port)           /* Which port should be checked */
885 {
886         SK_U32          Shorts;                 /* Short Event Counter */
887         SK_U32          CheckShorts;    /* Check value for Short Event Counter */
888         SK_U64          RxCts;                  /* Rx Counter (packets on network) */
889         SK_U32          RxTmp;                  /* Rx temp. Counter */
890         SK_U32          FcsErrCts;              /* FCS Error Counter */
891         SK_GEPORT       *pPrt;                  /* GIni Port struct pointer */
892         int                     Rtv;                    /* Return value */
893         int                     i;
894
895         pPrt = &pAC->GIni.GP[Port];
896
897         /* Default: no action */
898         Rtv = SK_HW_PS_NONE;
899
900         (void)SkXmUpdateStats(pAC, IoC, Port);
901
902         /* Extra precaution: check for short Event counter */
903         (void)SkXmMacStatistic(pAC, IoC, Port, XM_RXE_SHT_ERR, &Shorts);
904
905         /*
906          * Read Rx counters (packets seen on the network and not necessarily
907          * really received.
908          */
909         RxCts = 0;
910
911         for (i = 0; i < sizeof(SkGeRxRegs)/sizeof(SkGeRxRegs[0]); i++) {
912                 
913                 (void)SkXmMacStatistic(pAC, IoC, Port, SkGeRxRegs[i], &RxTmp);
914                 
915                 RxCts += (SK_U64)RxTmp;
916         }
917
918         /* On default: check shorts against zero */
919         CheckShorts = 0;
920
921         /* Extra precaution on active links */
922         if (pPrt->PHWLinkUp) {
923                 /* Reset Link Restart counter */
924                 pPrt->PLinkResCt = 0;
925                 pPrt->PAutoNegTOCt = 0;
926
927                 /* If link is up check for 2 */
928                 CheckShorts = 2;
929
930                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_RXF_FCS_ERR, &FcsErrCts);
931                 
932                 if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
933                     pPrt->PLipaAutoNeg == SK_LIPA_UNKNOWN &&
934                     (pPrt->PLinkMode == SK_LMODE_HALF ||
935                          pPrt->PLinkMode == SK_LMODE_FULL)) {
936                         /*
937                          * This is autosensing and we are in the fallback
938                          * manual full/half duplex mode.
939                          */
940                         if (RxCts == pPrt->PPrevRx) {
941                                 /* Nothing received, restart link */
942                                 pPrt->PPrevFcs = FcsErrCts;
943                                 pPrt->PPrevShorts = Shorts;
944                                 
945                                 return(SK_HW_PS_RESTART);
946                         }
947                         else {
948                                 pPrt->PLipaAutoNeg = SK_LIPA_MANUAL;
949                         }
950                 }
951
952                 if (((RxCts - pPrt->PPrevRx) > pPrt->PRxLim) ||
953                     (!(FcsErrCts - pPrt->PPrevFcs))) {
954                         /*
955                          * Note: The compare with zero above has to be done the way shown,
956                          * otherwise the Linux driver will have a problem.
957                          */
958                         /*
959                          * We received a bunch of frames or no CRC error occured on the
960                          * network -> ok.
961                          */
962                         pPrt->PPrevRx = RxCts;
963                         pPrt->PPrevFcs = FcsErrCts;
964                         pPrt->PPrevShorts = Shorts;
965
966                         return(SK_HW_PS_NONE);
967                 }
968
969                 pPrt->PPrevFcs = FcsErrCts;
970         }
971
972
973         if ((Shorts - pPrt->PPrevShorts) > CheckShorts) {
974                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
975                         ("Short Event Count Restart Port %d \n", Port));
976                 Rtv = SK_HW_PS_RESTART;
977         }
978
979         pPrt->PPrevShorts = Shorts;
980         pPrt->PPrevRx = RxCts;
981
982         return(Rtv);
983 }       /* SkGePortCheckShorts */
984 #endif /* GENESIS */
985
986
987 /******************************************************************************
988  *
989  * SkGePortCheckUp() - Check if the link is up
990  *
991  * return:
992  *      0       o.k. nothing needed
993  *      1       Restart needed on this port
994  *      2       Link came up
995  */
996 static int SkGePortCheckUp(
997 SK_AC   *pAC,           /* Adapter Context */
998 SK_IOC  IoC,            /* IO Context */
999 int             Port)           /* Which port should be checked */
1000 {
1001         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1002         SK_BOOL         AutoNeg;        /* Is Auto-negotiation used ? */
1003         int                     Rtv;            /* Return value */
1004
1005         Rtv = SK_HW_PS_NONE;
1006         
1007         pPrt = &pAC->GIni.GP[Port];
1008
1009         if (pPrt->PLinkMode == SK_LMODE_HALF || pPrt->PLinkMode == SK_LMODE_FULL) {
1010                 AutoNeg = SK_FALSE;
1011         }
1012         else {
1013                 AutoNeg = SK_TRUE;
1014         }
1015
1016 #ifdef GENESIS
1017         if (pAC->GIni.GIGenesis) {
1018
1019                 switch (pPrt->PhyType) {
1020                 
1021                 case SK_PHY_XMAC:
1022                         Rtv = SkGePortCheckUpXmac(pAC, IoC, Port, AutoNeg);
1023                         break;
1024                 case SK_PHY_BCOM:
1025                         Rtv = SkGePortCheckUpBcom(pAC, IoC, Port, AutoNeg);
1026                         break;
1027 #ifdef OTHER_PHY
1028                 case SK_PHY_LONE:
1029                         Rtv = SkGePortCheckUpLone(pAC, IoC, Port, AutoNeg);
1030                         break;
1031                 case SK_PHY_NAT:
1032                         Rtv = SkGePortCheckUpNat(pAC, IoC, Port, AutoNeg);
1033                         break;
1034 #endif /* OTHER_PHY */
1035                 }
1036         }
1037 #endif /* GENESIS */
1038         
1039 #ifdef YUKON
1040         if (pAC->GIni.GIYukon) {
1041                 
1042                 Rtv = SkGePortCheckUpGmac(pAC, IoC, Port, AutoNeg);
1043         }
1044 #endif /* YUKON */
1045
1046         return(Rtv);    
1047 }       /* SkGePortCheckUp */
1048
1049
1050 #ifdef GENESIS
1051 /******************************************************************************
1052  *
1053  * SkGePortCheckUpXmac() - Implementing of the Workaround Errata # 2
1054  *
1055  * return:
1056  *      0       o.k. nothing needed
1057  *      1       Restart needed on this port
1058  *      2       Link came up
1059  */
1060 static int SkGePortCheckUpXmac(
1061 SK_AC   *pAC,           /* Adapter Context */
1062 SK_IOC  IoC,            /* IO Context */
1063 int             Port,           /* Which port should be checked */
1064 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1065 {
1066         SK_U32          Shorts;         /* Short Event Counter */
1067         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1068         int                     Done;
1069         SK_U32          GpReg;          /* General Purpose register value */
1070         SK_U16          Isrc;           /* Interrupt source register */
1071         SK_U16          IsrcSum;        /* Interrupt source register sum */
1072         SK_U16          LpAb;           /* Link Partner Ability */
1073         SK_U16          ResAb;          /* Resolved Ability */
1074         SK_U16          ExtStat;        /* Extended Status Register */
1075         SK_U8           NextMode;       /* Next AutoSensing Mode */
1076
1077         pPrt = &pAC->GIni.GP[Port];
1078
1079         if (pPrt->PHWLinkUp) {
1080                 if (pPrt->PhyType != SK_PHY_XMAC) {
1081                         return(SK_HW_PS_NONE);
1082                 }
1083                 else {
1084                         return(SkGePortCheckShorts(pAC, IoC, Port));
1085                 }
1086         }
1087
1088         IsrcSum = pPrt->PIsave;
1089         pPrt->PIsave = 0;
1090
1091         /* Now wait for each port's link */
1092         if (pPrt->PLinkBroken) {
1093                 /* Link was broken */
1094                 XM_IN32(IoC, Port, XM_GP_PORT, &GpReg);
1095
1096                 if ((GpReg & XM_GP_INP_ASS) == 0) {
1097                         /* The Link is in sync */
1098                         XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1099                         IsrcSum |= Isrc;
1100                         SkXmAutoNegLipaXmac(pAC, IoC, Port, IsrcSum);
1101                         
1102                         if ((Isrc & XM_IS_INP_ASS) == 0) {
1103                                 /* It has been in sync since last time */
1104                                 /* Restart the PORT */
1105                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1106                                         ("Link in sync Restart Port %d\n", Port));
1107
1108                                 (void)SkXmUpdateStats(pAC, IoC, Port);
1109
1110                                 /* We now need to reinitialize the PrevShorts counter */
1111                                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_RXE_SHT_ERR, &Shorts);
1112                                 pPrt->PPrevShorts = Shorts;
1113
1114                                 pPrt->PLinkBroken = SK_FALSE;
1115
1116                                 /*
1117                                  * Link Restart Workaround:
1118                                  *  it may be possible that the other Link side
1119                                  *  restarts its link as well an we detect
1120                                  *  another LinkBroken. To prevent this
1121                                  *  happening we check for a maximum number
1122                                  *  of consecutive restart. If those happens,
1123                                  *  we do NOT restart the active link and
1124                                  *  check whether the link is now o.k.
1125                                  */
1126                                 pPrt->PLinkResCt++;
1127                                 
1128                                 pPrt->PAutoNegTimeOut = 0;
1129
1130                                 if (pPrt->PLinkResCt < SK_MAX_LRESTART) {
1131                                         return(SK_HW_PS_RESTART);
1132                                 }
1133
1134                                 pPrt->PLinkResCt = 0;
1135                                 
1136                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1137                                         ("Do NOT restart on Port %d %x %x\n", Port, Isrc, IsrcSum));
1138                         }
1139                         else {
1140                                 pPrt->PIsave = (SK_U16)(IsrcSum & XM_IS_AND);
1141                                 
1142                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1143                                         ("Save Sync/nosync Port %d %x %x\n", Port, Isrc, IsrcSum));
1144
1145                                 /* Do nothing more if link is broken */
1146                                 return(SK_HW_PS_NONE);
1147                         }
1148                 }
1149                 else {
1150                         /* Do nothing more if link is broken */
1151                         return(SK_HW_PS_NONE);
1152                 }
1153
1154         }
1155         else {
1156                 /* Link was not broken, check if it is */
1157                 XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1158                 IsrcSum |= Isrc;
1159                 if ((Isrc & XM_IS_INP_ASS) != 0) {
1160                         XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1161                         IsrcSum |= Isrc;
1162                         if ((Isrc & XM_IS_INP_ASS) != 0) {
1163                                 XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1164                                 IsrcSum |= Isrc;
1165                                 if ((Isrc & XM_IS_INP_ASS) != 0) {
1166                                         pPrt->PLinkBroken = SK_TRUE;
1167                                         /* Re-Init Link partner Autoneg flag */
1168                                         pPrt->PLipaAutoNeg = SK_LIPA_UNKNOWN;
1169                                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1170                                                 ("Link broken Port %d\n", Port));
1171
1172                                         /* Cable removed-> reinit sense mode */
1173                                         SkHWInitDefSense(pAC, IoC, Port);
1174
1175                                         return(SK_HW_PS_RESTART);
1176                                 }
1177                         }
1178                 }
1179                 else {
1180                         SkXmAutoNegLipaXmac(pAC, IoC, Port, Isrc);
1181                         
1182                         if (SkGePortCheckShorts(pAC, IoC, Port) == SK_HW_PS_RESTART) {
1183                                 return(SK_HW_PS_RESTART);
1184                         }
1185                 }
1186         }
1187
1188         /*
1189          * here we usually can check whether the link is in sync and
1190          * auto-negotiation is done.
1191          */
1192         XM_IN32(IoC, Port, XM_GP_PORT, &GpReg);
1193         XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1194         IsrcSum |= Isrc;
1195
1196         SkXmAutoNegLipaXmac(pAC, IoC, Port, IsrcSum);
1197         
1198         if ((GpReg & XM_GP_INP_ASS) != 0 || (IsrcSum & XM_IS_INP_ASS) != 0) {
1199                 if ((GpReg & XM_GP_INP_ASS) == 0) {
1200                         /* Save Auto-negotiation Done interrupt only if link is in sync */
1201                         pPrt->PIsave = (SK_U16)(IsrcSum & XM_IS_AND);
1202                 }
1203 #ifdef DEBUG
1204                 if ((pPrt->PIsave & XM_IS_AND) != 0) {
1205                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1206                                 ("AutoNeg done rescheduled Port %d\n", Port));
1207                 }
1208 #endif /* DEBUG */
1209                 return(SK_HW_PS_NONE);
1210         }
1211
1212         if (AutoNeg) {
1213                 if ((IsrcSum & XM_IS_AND) != 0) {
1214                         SkHWLinkUp(pAC, IoC, Port);
1215                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1216                         if (Done != SK_AND_OK) {
1217                                 /* Get PHY parameters, for debugging only */
1218                                 SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_AUNE_LP, &LpAb);
1219                                 SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_RES_ABI, &ResAb);
1220                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1221                                         ("AutoNeg FAIL Port %d (LpAb %x, ResAb %x)\n",
1222                                          Port, LpAb, ResAb));
1223                                         
1224                                 /* Try next possible mode */
1225                                 NextMode = SkHWSenseGetNext(pAC, IoC, Port);
1226                                 SkHWLinkDown(pAC, IoC, Port);
1227                                 if (Done == SK_AND_DUP_CAP) {
1228                                         /* GoTo next mode */
1229                                         SkHWSenseSetNext(pAC, IoC, Port, NextMode);
1230                                 }
1231
1232                                 return(SK_HW_PS_RESTART);
1233                         }
1234                         /*
1235                          * Dummy Read extended status to prevent extra link down/ups
1236                          * (clear Page Received bit if set)
1237                          */
1238                         SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_AUNE_EXP, &ExtStat);
1239                         
1240                         return(SK_HW_PS_LINK);
1241                 }
1242                 
1243                 /* AutoNeg not done, but HW link is up. Check for timeouts */
1244                 pPrt->PAutoNegTimeOut++;
1245                 if (pPrt->PAutoNegTimeOut >= SK_AND_MAX_TO) {
1246                         /* Increase the Timeout counter */
1247                         pPrt->PAutoNegTOCt++;
1248
1249                         /* Timeout occured */
1250                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1251                                 ("AutoNeg timeout Port %d\n", Port));
1252                         if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
1253                                 pPrt->PLipaAutoNeg != SK_LIPA_AUTO) {
1254                                 /* Set Link manually up */
1255                                 SkHWSenseSetNext(pAC, IoC, Port, SK_LMODE_FULL);
1256                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1257                                         ("Set manual full duplex Port %d\n", Port));
1258                         }
1259
1260                         if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
1261                                 pPrt->PLipaAutoNeg == SK_LIPA_AUTO &&
1262                                 pPrt->PAutoNegTOCt >= SK_MAX_ANEG_TO) {
1263                                 /*
1264                                  * This is rather complicated.
1265                                  * we need to check here whether the LIPA_AUTO
1266                                  * we saw before is false alert. We saw at one
1267                                  * switch ( SR8800) that on boot time it sends
1268                                  * just one auto-neg packet and does no further
1269                                  * auto-negotiation.
1270                                  * Solution: we restart the autosensing after
1271                                  * a few timeouts.
1272                                  */
1273                                 pPrt->PAutoNegTOCt = 0;
1274                                 pPrt->PLipaAutoNeg = SK_LIPA_UNKNOWN;
1275                                 SkHWInitDefSense(pAC, IoC, Port);
1276                         }
1277
1278                         /* Do the restart */
1279                         return(SK_HW_PS_RESTART);
1280                 }
1281         }
1282         else {
1283                 /* Link is up and we don't need more */
1284 #ifdef DEBUG
1285                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1286                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1287                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1288                 }
1289 #endif /* DEBUG */
1290                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1291                         ("Link sync(GP), Port %d\n", Port));
1292                 SkHWLinkUp(pAC, IoC, Port);
1293                 
1294                 /*
1295                  * Link sync (GP) and so assume a good connection. But if not received
1296                  * a bunch of frames received in a time slot (maybe broken tx cable)
1297                  * the port is restart.
1298                  */
1299                 return(SK_HW_PS_LINK);
1300         }
1301
1302         return(SK_HW_PS_NONE);
1303 }       /* SkGePortCheckUpXmac */
1304
1305
1306 /******************************************************************************
1307  *
1308  * SkGePortCheckUpBcom() - Check if the link is up on Bcom PHY
1309  *
1310  * return:
1311  *      0       o.k. nothing needed
1312  *      1       Restart needed on this port
1313  *      2       Link came up
1314  */
1315 static int SkGePortCheckUpBcom(
1316 SK_AC   *pAC,           /* Adapter Context */
1317 SK_IOC  IoC,            /* IO Context */
1318 int             Port,           /* Which port should be checked */
1319 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1320 {
1321         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1322         int                     Done;
1323         SK_U16          Isrc;           /* Interrupt source register */
1324         SK_U16          PhyStat;        /* Phy Status Register */
1325         SK_U16          ResAb;          /* Master/Slave resolution */
1326         SK_U16          Ctrl;           /* Broadcom control flags */
1327 #ifdef DEBUG
1328         SK_U16          LpAb;
1329         SK_U16          ExtStat;
1330 #endif /* DEBUG */
1331
1332         pPrt = &pAC->GIni.GP[Port];
1333
1334         /* Check for No HCD Link events (#10523) */
1335         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_STAT, &Isrc);
1336
1337 #ifdef xDEBUG
1338         if ((Isrc & ~(PHY_B_IS_HCT | PHY_B_IS_LCT) ==
1339                 (PHY_B_IS_SCR_S_ER | PHY_B_IS_RRS_CHANGE | PHY_B_IS_LRS_CHANGE)) {
1340
1341                 SK_U32  Stat1, Stat2, Stat3;
1342
1343                 Stat1 = 0;
1344                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_MASK, &Stat1);
1345                 CMSMPrintString(
1346                         pAC->pConfigTable,
1347                         MSG_TYPE_RUNTIME_INFO,
1348                         "CheckUp1 - Stat: %x, Mask: %x",
1349                         (void *)Isrc,
1350                         (void *)Stat1);
1351
1352                 Stat1 = 0;
1353                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_CTRL, &Stat1);
1354                 Stat2 = 0;
1355                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &Stat2);
1356                 Stat1 = Stat1 << 16 | Stat2;
1357                 Stat2 = 0;
1358                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_ADV, &Stat2);
1359                 Stat3 = 0;
1360                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_LP, &Stat3);
1361                 Stat2 = Stat2 << 16 | Stat3;
1362                 CMSMPrintString(
1363                         pAC->pConfigTable,
1364                         MSG_TYPE_RUNTIME_INFO,
1365                         "Ctrl/Stat: %x, AN Adv/LP: %x",
1366                         (void *)Stat1,
1367                         (void *)Stat2);
1368
1369                 Stat1 = 0;
1370                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_EXP, &Stat1);
1371                 Stat2 = 0;
1372                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_EXT_STAT, &Stat2);
1373                 Stat1 = Stat1 << 16 | Stat2;
1374                 Stat2 = 0;
1375                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_CTRL, &Stat2);
1376                 Stat3 = 0;
1377                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &Stat3);
1378                 Stat2 = Stat2 << 16 | Stat3;
1379                 CMSMPrintString(
1380                         pAC->pConfigTable,
1381                         MSG_TYPE_RUNTIME_INFO,
1382                         "AN Exp/IEEE Ext: %x, 1000T Ctrl/Stat: %x",
1383                         (void *)Stat1,
1384                         (void *)Stat2);
1385
1386                 Stat1 = 0;
1387                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_CTRL, &Stat1);
1388                 Stat2 = 0;
1389                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_STAT, &Stat2);
1390                 Stat1 = Stat1 << 16 | Stat2;
1391                 Stat2 = 0;
1392                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, &Stat2);
1393                 Stat3 = 0;
1394                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_STAT, &Stat3);
1395                 Stat2 = Stat2 << 16 | Stat3;
1396                 CMSMPrintString(
1397                         pAC->pConfigTable,
1398                         MSG_TYPE_RUNTIME_INFO,
1399                         "PHY Ext Ctrl/Stat: %x, Aux Ctrl/Stat: %x",
1400                         (void *)Stat1,
1401                         (void *)Stat2);
1402         }
1403 #endif /* DEBUG */
1404
1405         if ((Isrc & (PHY_B_IS_NO_HDCL /* | PHY_B_IS_NO_HDC */)) != 0) {
1406                 /*
1407                  * Workaround BCom Errata:
1408                  *      enable and disable loopback mode if "NO HCD" occurs.
1409                  */
1410                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_CTRL, &Ctrl);
1411                 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_CTRL,
1412                         (SK_U16)(Ctrl | PHY_CT_LOOP));
1413                 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_CTRL,
1414                         (SK_U16)(Ctrl & ~PHY_CT_LOOP));
1415                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1416                         ("No HCD Link event, Port %d\n", Port));
1417 #ifdef xDEBUG
1418                 CMSMPrintString(
1419                         pAC->pConfigTable,
1420                         MSG_TYPE_RUNTIME_INFO,
1421                         "No HCD link event, port %d.",
1422                         (void *)Port,
1423                         (void *)NULL);
1424 #endif /* DEBUG */
1425         }
1426
1427         /* Not obsolete: link status bit is latched to 0 and autoclearing! */
1428         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &PhyStat);
1429
1430         if (pPrt->PHWLinkUp) {
1431                 return(SK_HW_PS_NONE);
1432         }
1433
1434 #ifdef xDEBUG
1435         {
1436                 SK_U32  Stat1, Stat2, Stat3;
1437
1438                 Stat1 = 0;
1439                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_MASK, &Stat1);
1440                 CMSMPrintString(
1441                         pAC->pConfigTable,
1442                         MSG_TYPE_RUNTIME_INFO,
1443                         "CheckUp1a - Stat: %x, Mask: %x",
1444                         (void *)Isrc,
1445                         (void *)Stat1);
1446
1447                 Stat1 = 0;
1448                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_CTRL, &Stat1);
1449                 Stat2 = 0;
1450                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &PhyStat);
1451                 Stat1 = Stat1 << 16 | PhyStat;
1452                 Stat2 = 0;
1453                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_ADV, &Stat2);
1454                 Stat3 = 0;
1455                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_LP, &Stat3);
1456                 Stat2 = Stat2 << 16 | Stat3;
1457                 CMSMPrintString(
1458                         pAC->pConfigTable,
1459                         MSG_TYPE_RUNTIME_INFO,
1460                         "Ctrl/Stat: %x, AN Adv/LP: %x",
1461                         (void *)Stat1,
1462                         (void *)Stat2);
1463
1464                 Stat1 = 0;
1465                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_EXP, &Stat1);
1466                 Stat2 = 0;
1467                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_EXT_STAT, &Stat2);
1468                 Stat1 = Stat1 << 16 | Stat2;
1469                 Stat2 = 0;
1470                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_CTRL, &Stat2);
1471                 Stat3 = 0;
1472                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &ResAb);
1473                 Stat2 = Stat2 << 16 | ResAb;
1474                 CMSMPrintString(
1475                         pAC->pConfigTable,
1476                         MSG_TYPE_RUNTIME_INFO,
1477                         "AN Exp/IEEE Ext: %x, 1000T Ctrl/Stat: %x",
1478                         (void *)Stat1,
1479                         (void *)Stat2);
1480
1481                 Stat1 = 0;
1482                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_CTRL, &Stat1);
1483                 Stat2 = 0;
1484                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_STAT, &Stat2);
1485                 Stat1 = Stat1 << 16 | Stat2;
1486                 Stat2 = 0;
1487                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, &Stat2);
1488                 Stat3 = 0;
1489                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_STAT, &Stat3);
1490                 Stat2 = Stat2 << 16 | Stat3;
1491                 CMSMPrintString(
1492                         pAC->pConfigTable,
1493                         MSG_TYPE_RUNTIME_INFO,
1494                         "PHY Ext Ctrl/Stat: %x, Aux Ctrl/Stat: %x",
1495                         (void *)Stat1,
1496                         (void *)Stat2);
1497         }
1498 #endif /* DEBUG */
1499
1500         /*
1501          * Here we usually can check whether the link is in sync and
1502          * auto-negotiation is done.
1503          */
1504
1505         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &PhyStat);
1506
1507         SkMacAutoNegLipaPhy(pAC, IoC, Port, PhyStat);
1508         
1509         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1510                 ("CheckUp Port %d, PhyStat: 0x%04X\n", Port, PhyStat));
1511
1512         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &ResAb);
1513
1514         if ((ResAb & PHY_B_1000S_MSF) != 0) {
1515                 /* Error */
1516                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1517                         ("Master/Slave Fault port %d\n", Port));
1518                 
1519                 pPrt->PAutoNegFail = SK_TRUE;
1520                 pPrt->PMSStatus = SK_MS_STAT_FAULT;
1521                 
1522                 return(SK_HW_PS_RESTART);
1523         }
1524
1525         if ((PhyStat & PHY_ST_LSYNC) == 0) {
1526                 return(SK_HW_PS_NONE);
1527         }
1528         
1529         pPrt->PMSStatus = ((ResAb & PHY_B_1000S_MSR) != 0) ?
1530                 SK_MS_STAT_MASTER : SK_MS_STAT_SLAVE;
1531         
1532         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1533                 ("Port %d, ResAb: 0x%04X\n", Port, ResAb));
1534
1535         if (AutoNeg) {
1536                 if ((PhyStat & PHY_ST_AN_OVER) != 0) {
1537                         
1538                         SkHWLinkUp(pAC, IoC, Port);
1539                         
1540                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1541                         
1542                         if (Done != SK_AND_OK) {
1543 #ifdef DEBUG
1544                                 /* Get PHY parameters, for debugging only */
1545                                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_LP, &LpAb);
1546                                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &ExtStat);
1547                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1548                                         ("AutoNeg FAIL Port %d (LpAb %x, 1000TStat %x)\n",
1549                                         Port, LpAb, ExtStat));
1550 #endif /* DEBUG */
1551                                 return(SK_HW_PS_RESTART);
1552                         }
1553                         else {
1554 #ifdef xDEBUG
1555                                 /* Dummy read ISR to prevent extra link downs/ups */
1556                                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_STAT, &ExtStat);
1557
1558                                 if ((ExtStat & ~(PHY_B_IS_HCT | PHY_B_IS_LCT)) != 0) {
1559                                         CMSMPrintString(
1560                                                 pAC->pConfigTable,
1561                                                 MSG_TYPE_RUNTIME_INFO,
1562                                                 "CheckUp2 - Stat: %x",
1563                                                 (void *)ExtStat,
1564                                                 (void *)NULL);
1565                                 }
1566 #endif /* DEBUG */
1567                                 return(SK_HW_PS_LINK);
1568                         }
1569                 }
1570         }
1571         else {  /* !AutoNeg */
1572                 /* Link is up and we don't need more. */
1573 #ifdef DEBUG
1574                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1575                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1576                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1577                 }
1578 #endif /* DEBUG */
1579
1580 #ifdef xDEBUG
1581                 /* Dummy read ISR to prevent extra link downs/ups */
1582                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_STAT, &ExtStat);
1583
1584                 if ((ExtStat & ~(PHY_B_IS_HCT | PHY_B_IS_LCT)) != 0) {
1585                         CMSMPrintString(
1586                                 pAC->pConfigTable,
1587                                 MSG_TYPE_RUNTIME_INFO,
1588                                 "CheckUp3 - Stat: %x",
1589                                 (void *)ExtStat,
1590                                 (void *)NULL);
1591                 }
1592 #endif /* DEBUG */
1593                 
1594                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1595                         ("Link sync(GP), Port %d\n", Port));
1596                 SkHWLinkUp(pAC, IoC, Port);
1597                 
1598                 return(SK_HW_PS_LINK);
1599         }
1600
1601         return(SK_HW_PS_NONE);
1602 }       /* SkGePortCheckUpBcom */
1603 #endif /* GENESIS */
1604
1605
1606 #ifdef YUKON
1607 /******************************************************************************
1608  *
1609  * SkGePortCheckUpGmac() - Check if the link is up on Marvell PHY
1610  *
1611  * return:
1612  *      0       o.k. nothing needed
1613  *      1       Restart needed on this port
1614  *      2       Link came up
1615  */
1616 static int SkGePortCheckUpGmac(
1617 SK_AC   *pAC,           /* Adapter Context */
1618 SK_IOC  IoC,            /* IO Context */
1619 int             Port,           /* Which port should be checked */
1620 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1621 {
1622         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1623         int                     Done;
1624         SK_U16          PhyIsrc;        /* PHY Interrupt source */
1625         SK_U16          PhyStat;        /* PPY Status */
1626         SK_U16          PhySpecStat;/* PHY Specific Status */
1627         SK_U16          ResAb;          /* Master/Slave resolution */
1628         SK_EVPARA       Para;
1629 #ifdef DEBUG
1630         SK_U16          Word;           /* I/O helper */
1631 #endif /* DEBUG */
1632
1633         pPrt = &pAC->GIni.GP[Port];
1634
1635         if (pPrt->PHWLinkUp) {
1636                 return(SK_HW_PS_NONE);
1637         }
1638
1639         /* Read PHY Status */
1640         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_STAT, &PhyStat);
1641
1642         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1643                 ("CheckUp Port %d, PhyStat: 0x%04X\n", Port, PhyStat));
1644
1645         /* Read PHY Interrupt Status */
1646         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_INT_STAT, &PhyIsrc);
1647
1648         if ((PhyIsrc & PHY_M_IS_AN_COMPL) != 0) {
1649                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1650                         ("Auto-Negotiation Completed, PhyIsrc: 0x%04X\n", PhyIsrc));
1651         }
1652
1653         if ((PhyIsrc & PHY_M_IS_LSP_CHANGE) != 0) {
1654                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1655                         ("Link Speed Changed, PhyIsrc: 0x%04X\n", PhyIsrc));
1656         }
1657
1658         SkMacAutoNegLipaPhy(pAC, IoC, Port, PhyStat);
1659         
1660         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_1000T_STAT, &ResAb);
1661
1662         if ((ResAb & PHY_B_1000S_MSF) != 0) {
1663                 /* Error */
1664                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1665                         ("Master/Slave Fault port %d\n", Port));
1666                 
1667                 pPrt->PAutoNegFail = SK_TRUE;
1668                 pPrt->PMSStatus = SK_MS_STAT_FAULT;
1669                 
1670                 return(SK_HW_PS_RESTART);
1671         }
1672
1673         /* Read PHY Specific Status */
1674         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_PHY_STAT, &PhySpecStat);
1675         
1676         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1677                 ("Phy1000BT: 0x%04X, PhySpecStat: 0x%04X\n", ResAb, PhySpecStat));
1678
1679 #ifdef DEBUG
1680         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_AUNE_EXP, &Word);
1681
1682         if ((PhyIsrc & PHY_M_IS_AN_PR) != 0 || (Word & PHY_ANE_RX_PG) != 0 ||
1683                 (PhySpecStat & PHY_M_PS_PAGE_REC) != 0)  {
1684                 /* Read PHY Next Page Link Partner */
1685                 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_NEPG_LP, &Word);
1686
1687                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1688                         ("Page Received, NextPage: 0x%04X\n", Word));
1689         }
1690 #endif /* DEBUG */
1691
1692         if ((PhySpecStat & PHY_M_PS_LINK_UP) == 0) {
1693                 return(SK_HW_PS_NONE);
1694         }
1695         
1696         if ((PhySpecStat & PHY_M_PS_DOWNS_STAT) != 0 ||
1697                 (PhyIsrc & PHY_M_IS_DOWNSH_DET) != 0) {
1698                 /* Downshift detected */
1699                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E025, SKERR_SIRQ_E025MSG);
1700                 
1701                 Para.Para64 = Port;
1702                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_DOWNSHIFT_DET, Para);
1703                 
1704                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1705                         ("Downshift detected, PhyIsrc: 0x%04X\n", PhyIsrc));
1706         }
1707
1708         pPrt->PMSStatus = ((ResAb & PHY_B_1000S_MSR) != 0) ?
1709                 SK_MS_STAT_MASTER : SK_MS_STAT_SLAVE;
1710         
1711         pPrt->PCableLen = (SK_U8)((PhySpecStat & PHY_M_PS_CABLE_MSK) >> 7);
1712         
1713         if (AutoNeg) {
1714                 /* Auto-Negotiation Over ? */
1715                 if ((PhyStat & PHY_ST_AN_OVER) != 0) {
1716                         
1717                         SkHWLinkUp(pAC, IoC, Port);
1718                         
1719                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1720                         
1721                         if (Done != SK_AND_OK) {
1722                                 return(SK_HW_PS_RESTART);
1723                         }
1724                         
1725                         return(SK_HW_PS_LINK);
1726                 }
1727         }
1728         else {  /* !AutoNeg */
1729                 /* Link is up and we don't need more */
1730 #ifdef DEBUG
1731                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1732                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1733                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1734                 }
1735 #endif /* DEBUG */
1736
1737                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1738                         ("Link sync, Port %d\n", Port));
1739                 SkHWLinkUp(pAC, IoC, Port);
1740                 
1741                 return(SK_HW_PS_LINK);
1742         }
1743
1744         return(SK_HW_PS_NONE);
1745 }       /* SkGePortCheckUpGmac */
1746 #endif /* YUKON */
1747
1748
1749 #ifdef OTHER_PHY
1750 /******************************************************************************
1751  *
1752  * SkGePortCheckUpLone() - Check if the link is up on Level One PHY
1753  *
1754  * return:
1755  *      0       o.k. nothing needed
1756  *      1       Restart needed on this port
1757  *      2       Link came up
1758  */
1759 static int SkGePortCheckUpLone(
1760 SK_AC   *pAC,           /* Adapter Context */
1761 SK_IOC  IoC,            /* IO Context */
1762 int             Port,           /* Which port should be checked */
1763 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1764 {
1765         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1766         int                     Done;
1767         SK_U16          Isrc;           /* Interrupt source register */
1768         SK_U16          LpAb;           /* Link Partner Ability */
1769         SK_U16          ExtStat;        /* Extended Status Register */
1770         SK_U16          PhyStat;        /* Phy Status Register */
1771         SK_U16          StatSum;
1772         SK_U8           NextMode;       /* Next AutoSensing Mode */
1773
1774         pPrt = &pAC->GIni.GP[Port];
1775
1776         if (pPrt->PHWLinkUp) {
1777                 return(SK_HW_PS_NONE);
1778         }
1779
1780         StatSum = pPrt->PIsave;
1781         pPrt->PIsave = 0;
1782
1783         /*
1784          * here we usually can check whether the link is in sync and
1785          * auto-negotiation is done.
1786          */
1787         SkXmPhyRead(pAC, IoC, Port, PHY_LONE_STAT, &PhyStat);
1788         StatSum |= PhyStat;
1789
1790         SkMacAutoNegLipaPhy(pAC, IoC, Port, PhyStat);
1791         
1792         if ((PhyStat & PHY_ST_LSYNC) == 0) {
1793                 /* Save Auto-negotiation Done bit */
1794                 pPrt->PIsave = (SK_U16)(StatSum & PHY_ST_AN_OVER);
1795 #ifdef DEBUG
1796                 if ((pPrt->PIsave & PHY_ST_AN_OVER) != 0) {
1797                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1798                                 ("AutoNeg done rescheduled Port %d\n", Port));
1799                 }
1800 #endif /* DEBUG */
1801                 return(SK_HW_PS_NONE);
1802         }
1803
1804         if (AutoNeg) {
1805                 if ((StatSum & PHY_ST_AN_OVER) != 0) {
1806                         SkHWLinkUp(pAC, IoC, Port);
1807                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1808                         if (Done != SK_AND_OK) {
1809                                 /* Get PHY parameters, for debugging only */
1810                                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_AUNE_LP, &LpAb);
1811                                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_1000T_STAT, &ExtStat);
1812                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1813                                         ("AutoNeg FAIL Port %d (LpAb %x, 1000TStat %x)\n",
1814                                          Port, LpAb, ExtStat));
1815                                         
1816                                 /* Try next possible mode */
1817                                 NextMode = SkHWSenseGetNext(pAC, IoC, Port);
1818                                 SkHWLinkDown(pAC, IoC, Port);
1819                                 if (Done == SK_AND_DUP_CAP) {
1820                                         /* GoTo next mode */
1821                                         SkHWSenseSetNext(pAC, IoC, Port, NextMode);
1822                                 }
1823
1824                                 return(SK_HW_PS_RESTART);
1825
1826                         }
1827                         else {
1828                                 /*
1829                                  * Dummy Read interrupt status to prevent
1830                                  * extra link down/ups
1831                                  */
1832                                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_INT_STAT, &ExtStat);
1833                                 return(SK_HW_PS_LINK);
1834                         }
1835                 }
1836                 
1837                 /* AutoNeg not done, but HW link is up. Check for timeouts */
1838                 pPrt->PAutoNegTimeOut++;
1839                 if (pPrt->PAutoNegTimeOut >= SK_AND_MAX_TO) {
1840                         /* Timeout occured */
1841                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1842                                 ("AutoNeg timeout Port %d\n", Port));
1843                         if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
1844                                 pPrt->PLipaAutoNeg != SK_LIPA_AUTO) {
1845                                 /* Set Link manually up */
1846                                 SkHWSenseSetNext(pAC, IoC, Port, SK_LMODE_FULL);
1847                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1848                                         ("Set manual full duplex Port %d\n", Port));
1849                         }
1850
1851                         /* Do the restart */
1852                         return(SK_HW_PS_RESTART);
1853                 }
1854         }
1855         else {
1856                 /* Link is up and we don't need more */
1857 #ifdef DEBUG
1858                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1859                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1860                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1861                 }
1862 #endif /* DEBUG */
1863
1864                 /*
1865                  * Dummy Read interrupt status to prevent
1866                  * extra link down/ups
1867                  */
1868                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_INT_STAT, &ExtStat);
1869                 
1870                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1871                         ("Link sync(GP), Port %d\n", Port));
1872                 SkHWLinkUp(pAC, IoC, Port);
1873                 
1874                 return(SK_HW_PS_LINK);
1875         }
1876
1877         return(SK_HW_PS_NONE);
1878 }       /* SkGePortCheckUpLone */
1879
1880
1881 /******************************************************************************
1882  *
1883  * SkGePortCheckUpNat() - Check if the link is up on National PHY
1884  *
1885  * return:
1886  *      0       o.k. nothing needed
1887  *      1       Restart needed on this port
1888  *      2       Link came up
1889  */
1890 static int SkGePortCheckUpNat(
1891 SK_AC   *pAC,           /* Adapter Context */
1892 SK_IOC  IoC,            /* IO Context */
1893 int             Port,           /* Which port should be checked */
1894 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1895 {
1896         /* todo: National */
1897         return(SK_HW_PS_NONE);
1898 }       /* SkGePortCheckUpNat */
1899 #endif /* OTHER_PHY */
1900
1901
1902 /******************************************************************************
1903  *
1904  *      SkGeSirqEvent() - Event Service Routine
1905  *
1906  * Description:
1907  *
1908  * Notes:
1909  */
1910 int     SkGeSirqEvent(
1911 SK_AC           *pAC,           /* Adapter Context */
1912 SK_IOC          IoC,            /* Io Context */
1913 SK_U32          Event,          /* Module specific Event */
1914 SK_EVPARA       Para)           /* Event specific Parameter */
1915 {
1916         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1917         SK_U32          Port;
1918         SK_U32          Val32;
1919         int                     PortStat;
1920         SK_U8           Val8;
1921 #ifdef GENESIS
1922         SK_U64          Octets;
1923 #endif /* GENESIS */
1924
1925         Port = Para.Para32[0];
1926         pPrt = &pAC->GIni.GP[Port];
1927
1928         switch (Event) {
1929         case SK_HWEV_WATIM:
1930                 if (pPrt->PState == SK_PRT_RESET) {
1931                 
1932                         PortStat = SK_HW_PS_NONE;
1933                 }
1934                 else {
1935                         /* Check whether port came up */
1936                         PortStat = SkGePortCheckUp(pAC, IoC, (int)Port);
1937                 }
1938
1939                 switch (PortStat) {
1940                 case SK_HW_PS_RESTART:
1941                         if (pPrt->PHWLinkUp) {
1942                                 /* Set Link to down */
1943                                 SkHWLinkDown(pAC, IoC, (int)Port);
1944
1945                                 /*
1946                                  * Signal directly to RLMT to ensure correct
1947                                  * sequence of SWITCH and RESET event.
1948                                  */
1949                                 SkRlmtEvent(pAC, IoC, SK_RLMT_LINK_DOWN, Para);
1950                         }
1951
1952                         /* Restart needed */
1953                         SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_RESET, Para);
1954                         break;
1955
1956                 case SK_HW_PS_LINK:
1957                         /* Signal to RLMT */
1958                         SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_UP, Para);
1959                         break;
1960                 }
1961                 
1962                 /* Start again the check Timer */
1963                 if (pPrt->PHWLinkUp) {
1964                         Val32 = SK_WA_ACT_TIME;
1965                 }
1966                 else {
1967                         Val32 = SK_WA_INA_TIME;
1968                 }
1969
1970                 /* Todo: still needed for non-XMAC PHYs??? */
1971                 /* Start workaround Errata #2 timer */
1972                 SkTimerStart(pAC, IoC, &pPrt->PWaTimer, Val32,
1973                         SKGE_HWAC, SK_HWEV_WATIM, Para);
1974                 break;
1975
1976         case SK_HWEV_PORT_START:
1977                 if (pPrt->PHWLinkUp) {
1978                         /*
1979                          * Signal directly to RLMT to ensure correct
1980                          * sequence of SWITCH and RESET event.
1981                          */
1982                         SkRlmtEvent(pAC, IoC, SK_RLMT_LINK_DOWN, Para);
1983                 }
1984
1985                 SkHWLinkDown(pAC, IoC, (int)Port);
1986
1987                 /* Schedule Port RESET */
1988                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_RESET, Para);
1989
1990                 /* Start workaround Errata #2 timer */
1991                 SkTimerStart(pAC, IoC, &pPrt->PWaTimer, SK_WA_INA_TIME,
1992                         SKGE_HWAC, SK_HWEV_WATIM, Para);
1993                 break;
1994
1995         case SK_HWEV_PORT_STOP:
1996                 if (pPrt->PHWLinkUp) {
1997                         /*
1998                          * Signal directly to RLMT to ensure correct
1999                          * sequence of SWITCH and RESET event.
2000                          */
2001                         SkRlmtEvent(pAC, IoC, SK_RLMT_LINK_DOWN, Para);
2002                 }
2003
2004                 /* Stop Workaround Timer */
2005                 SkTimerStop(pAC, IoC, &pPrt->PWaTimer);
2006
2007                 SkHWLinkDown(pAC, IoC, (int)Port);
2008                 break;
2009
2010         case SK_HWEV_UPDATE_STAT:
2011                 /* We do NOT need to update any statistics */
2012                 break;
2013
2014         case SK_HWEV_CLEAR_STAT:
2015                 /* We do NOT need to clear any statistics */
2016                 for (Port = 0; Port < (SK_U32)pAC->GIni.GIMacsFound; Port++) {
2017                         pPrt->PPrevRx = 0;
2018                         pPrt->PPrevFcs = 0;
2019                         pPrt->PPrevShorts = 0;
2020                 }
2021                 break;
2022
2023         case SK_HWEV_SET_LMODE:
2024                 Val8 = (SK_U8)Para.Para32[1];
2025                 if (pPrt->PLinkModeConf != Val8) {
2026                         /* Set New link mode */
2027                         pPrt->PLinkModeConf = Val8;
2028
2029                         /* Restart Port */
2030                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para);
2031                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
2032                 }
2033                 break;
2034
2035         case SK_HWEV_SET_FLOWMODE:
2036                 Val8 = (SK_U8)Para.Para32[1];
2037                 if (pPrt->PFlowCtrlMode != Val8) {
2038                         /* Set New Flow Control mode */
2039                         pPrt->PFlowCtrlMode = Val8;
2040
2041                         /* Restart Port */
2042                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para);
2043                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
2044                 }
2045                 break;
2046
2047         case SK_HWEV_SET_ROLE:
2048                 /* not possible for fiber */
2049                 if (!pAC->GIni.GICopperType) {
2050                         break;
2051                 }
2052                 Val8 = (SK_U8)Para.Para32[1];
2053                 if (pPrt->PMSMode != Val8) {
2054                         /* Set New Role (Master/Slave) mode */
2055                         pPrt->PMSMode = Val8;
2056
2057                         /* Restart Port */
2058                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para);
2059                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
2060                 }
2061                 break;
2062
2063         case SK_HWEV_SET_SPEED:
2064                 if (pPrt->PhyType != SK_PHY_MARV_COPPER) {
2065                         break;
2066                 }
2067                 Val8 = (SK_U8)Para.Para32[1];
2068                 if (pPrt->PLinkSpeed != Val8) {
2069                         /* Set New Speed parameter */
2070                         pPrt->PLinkSpeed = Val8;
2071
2072                         /* Restart Port */
2073                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para);
2074                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
2075                 }
2076                 break;
2077
2078 #ifdef GENESIS
2079         case SK_HWEV_HALFDUP_CHK:
2080                 if (pAC->GIni.GIGenesis) {
2081                         /*
2082                          * half duplex hangup workaround.
2083                          * See packet arbiter timeout interrupt for description
2084                          */
2085                         pPrt->HalfDupTimerActive = SK_FALSE;
2086                         if (pPrt->PLinkModeStatus == SK_LMODE_STAT_HALF ||
2087                                 pPrt->PLinkModeStatus == SK_LMODE_STAT_AUTOHALF) {
2088 #ifdef XXX
2089                                 Len = sizeof(SK_U64);
2090                                 SkPnmiGetVar(pAC, IoC, OID_SKGE_STAT_TX_OCTETS, (char *)&Octets,
2091                                         &Len, (SK_U32)SK_PNMI_PORT_PHYS2INST(pAC, Port),
2092                                         pAC->Rlmt.Port[Port].Net->NetNumber);
2093 #endif /* XXX */
2094                                 /* Snap statistic counters */
2095                                 (void)SkXmUpdateStats(pAC, IoC, Port);
2096
2097                                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_TXO_OK_HI, &Val32);
2098
2099                                 Octets = (SK_U64)Val32 << 32;
2100                                 
2101                                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_TXO_OK_LO, &Val32);
2102
2103                                 Octets += Val32;
2104                                 
2105                                 if (pPrt->LastOctets == Octets) {
2106                                         /* Tx hanging, a FIFO flush restarts it */
2107                                         SkMacFlushTxFifo(pAC, IoC, Port);
2108                                 }
2109                         }
2110                 }
2111                 break;
2112 #endif /* GENESIS */
2113         
2114         default:
2115                 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_SIRQ_E001, SKERR_SIRQ_E001MSG);
2116                 break;
2117         }
2118
2119         return(0);
2120 }       /* SkGeSirqEvent */
2121
2122
2123 #ifdef GENESIS
2124 /******************************************************************************
2125  *
2126  *      SkPhyIsrBcom() - PHY interrupt service routine
2127  *
2128  * Description: handles all interrupts from BCom PHY
2129  *
2130  * Returns: N/A
2131  */
2132 static void SkPhyIsrBcom(
2133 SK_AC           *pAC,           /* Adapter Context */
2134 SK_IOC          IoC,            /* Io Context */
2135 int                     Port,           /* Port Num = PHY Num */
2136 SK_U16          IStatus)        /* Interrupt Status */
2137 {
2138         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
2139         SK_EVPARA       Para;
2140
2141         pPrt = &pAC->GIni.GP[Port];
2142
2143         if ((IStatus & PHY_B_IS_PSE) != 0) {
2144                 /* Incorrectable pair swap error */
2145                 SK_ERR_LOG(pAC, SK_ERRCL_HW | SK_ERRCL_INIT, SKERR_SIRQ_E022,
2146                         SKERR_SIRQ_E022MSG);
2147         }
2148         
2149         if ((IStatus & (PHY_B_IS_AN_PR | PHY_B_IS_LST_CHANGE)) != 0) {
2150
2151                 SkHWLinkDown(pAC, IoC, Port);
2152
2153                 Para.Para32[0] = (SK_U32)Port;
2154                 /* Signal to RLMT */
2155                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
2156
2157                 /* Start workaround Errata #2 timer */
2158                 SkTimerStart(pAC, IoC, &pPrt->PWaTimer, SK_WA_INA_TIME,
2159                         SKGE_HWAC, SK_HWEV_WATIM, Para);
2160         }
2161
2162 }       /* SkPhyIsrBcom */
2163 #endif /* GENESIS */
2164
2165
2166 #ifdef YUKON
2167 /******************************************************************************
2168  *
2169  *      SkPhyIsrGmac() - PHY interrupt service routine
2170  *
2171  * Description: handles all interrupts from Marvell PHY
2172  *
2173  * Returns: N/A
2174  */
2175 static void SkPhyIsrGmac(
2176 SK_AC           *pAC,           /* Adapter Context */
2177 SK_IOC          IoC,            /* Io Context */
2178 int                     Port,           /* Port Num = PHY Num */
2179 SK_U16          IStatus)        /* Interrupt Status */
2180 {
2181         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
2182         SK_EVPARA       Para;
2183         SK_U16          Word;
2184
2185         pPrt = &pAC->GIni.GP[Port];
2186
2187         if ((IStatus & (PHY_M_IS_AN_PR | PHY_M_IS_LST_CHANGE)) != 0) {
2188
2189                 SkHWLinkDown(pAC, IoC, Port);
2190
2191                 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_AUNE_ADV, &Word);
2192
2193                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2194                         ("AutoNeg.Adv: 0x%04X\n", Word));
2195                 
2196                 /* Set Auto-negotiation advertisement */
2197                 if (pPrt->PFlowCtrlMode == SK_FLOW_MODE_SYM_OR_REM) {
2198                         /* restore Asymmetric Pause bit */
2199                         SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV,
2200                                 (SK_U16)(Word | PHY_M_AN_ASP));
2201                 }
2202                 
2203                 Para.Para32[0] = (SK_U32)Port;
2204                 /* Signal to RLMT */
2205                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
2206         }
2207         
2208         if ((IStatus & PHY_M_IS_AN_ERROR) != 0) {
2209                 /* Auto-Negotiation Error */
2210                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E023, SKERR_SIRQ_E023MSG);
2211         }
2212         
2213         if ((IStatus & PHY_M_IS_FIFO_ERROR) != 0) {
2214                 /* FIFO Overflow/Underrun Error */
2215                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E024, SKERR_SIRQ_E024MSG);
2216         }
2217         
2218 }       /* SkPhyIsrGmac */
2219 #endif /* YUKON */
2220
2221
2222 #ifdef OTHER_PHY
2223 /******************************************************************************
2224  *
2225  *      SkPhyIsrLone() - PHY interrupt service routine
2226  *
2227  * Description: handles all interrupts from LONE PHY
2228  *
2229  * Returns: N/A
2230  */
2231 static void SkPhyIsrLone(
2232 SK_AC   *pAC,           /* Adapter Context */
2233 SK_IOC  IoC,            /* Io Context */
2234 int             Port,           /* Port Num = PHY Num */
2235 SK_U16  IStatus)        /* Interrupt Status */
2236 {
2237         SK_EVPARA       Para;
2238
2239         if (IStatus & (PHY_L_IS_DUP | PHY_L_IS_ISOL)) {
2240                 
2241                 SkHWLinkDown(pAC, IoC, Port);
2242
2243                 Para.Para32[0] = (SK_U32)Port;
2244                 /* Signal to RLMT */
2245                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
2246         }
2247
2248 }       /* SkPhyIsrLone */
2249 #endif /* OTHER_PHY */
2250
2251 /* End of File */