Pull platform-drivers into test branch
[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 static 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                                 /* Snap statistic counters */
616                                 (void)SkXmUpdateStats(pAC, IoC, 0);
617
618                                 (void)SkXmMacStatistic(pAC, IoC, 0, XM_TXO_OK_HI, &RegVal32);
619
620                                 pPrt->LastOctets = (SK_U64)RegVal32 << 32;
621                                 
622                                 (void)SkXmMacStatistic(pAC, IoC, 0, XM_TXO_OK_LO, &RegVal32);
623
624                                 pPrt->LastOctets += RegVal32;
625                                 
626                                 Para.Para32[0] = 0;
627                                 SkTimerStart(pAC, IoC, &pPrt->HalfDupChkTimer, SK_HALFDUP_CHK_TIME,
628                                         SKGE_HWAC, SK_HWEV_HALFDUP_CHK, Para);
629                         }
630                 }
631 #endif /* GENESIS */
632         }
633
634         if ((Istatus & IS_PA_TO_TX2) != 0) {
635                 
636                 pPrt = &pAC->GIni.GP[1];
637
638                 /* May be a normal situation in a server with a slow network */
639                 SK_OUT16(IoC, B3_PA_CTRL, PA_CLR_TO_TX2);
640
641 #ifdef GENESIS
642                 if (pAC->GIni.GIGenesis) {
643                         /* workaround: see above */
644                         if ((pPrt->PLinkModeStatus == SK_LMODE_STAT_HALF ||
645                                  pPrt->PLinkModeStatus == SK_LMODE_STAT_AUTOHALF) &&
646                                 !pPrt->HalfDupTimerActive) {
647                                 pPrt->HalfDupTimerActive = SK_TRUE;
648                                 /* Snap statistic counters */
649                                 (void)SkXmUpdateStats(pAC, IoC, 1);
650
651                                 (void)SkXmMacStatistic(pAC, IoC, 1, XM_TXO_OK_HI, &RegVal32);
652
653                                 pPrt->LastOctets = (SK_U64)RegVal32 << 32;
654                                 
655                                 (void)SkXmMacStatistic(pAC, IoC, 1, XM_TXO_OK_LO, &RegVal32);
656
657                                 pPrt->LastOctets += RegVal32;
658                                 
659                                 Para.Para32[0] = 1;
660                                 SkTimerStart(pAC, IoC, &pPrt->HalfDupChkTimer, SK_HALFDUP_CHK_TIME,
661                                         SKGE_HWAC, SK_HWEV_HALFDUP_CHK, Para);
662                         }
663                 }
664 #endif /* GENESIS */
665         }
666
667         /* Check interrupts of the particular queues */
668         if ((Istatus & IS_R1_C) != 0) {
669                 /* Clear IRQ */
670                 SK_OUT32(IoC, B0_R1_CSR, CSR_IRQ_CL_C);
671                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E006,
672                         SKERR_SIRQ_E006MSG);
673                 Para.Para64 = MAC_1;
674                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
675                 Para.Para32[0] = MAC_1;
676                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
677         }
678
679         if ((Istatus & IS_R2_C) != 0) {
680                 /* Clear IRQ */
681                 SK_OUT32(IoC, B0_R2_CSR, CSR_IRQ_CL_C);
682                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E007,
683                         SKERR_SIRQ_E007MSG);
684                 Para.Para64 = MAC_2;
685                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
686                 Para.Para32[0] = MAC_2;
687                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
688         }
689
690         if ((Istatus & IS_XS1_C) != 0) {
691                 /* Clear IRQ */
692                 SK_OUT32(IoC, B0_XS1_CSR, CSR_IRQ_CL_C);
693                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E008,
694                         SKERR_SIRQ_E008MSG);
695                 Para.Para64 = MAC_1;
696                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
697                 Para.Para32[0] = MAC_1;
698                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
699         }
700
701         if ((Istatus & IS_XA1_C) != 0) {
702                 /* Clear IRQ */
703                 SK_OUT32(IoC, B0_XA1_CSR, CSR_IRQ_CL_C);
704                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E009,
705                         SKERR_SIRQ_E009MSG);
706                 Para.Para64 = MAC_1;
707                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
708                 Para.Para32[0] = MAC_1;
709                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
710         }
711
712         if ((Istatus & IS_XS2_C) != 0) {
713                 /* Clear IRQ */
714                 SK_OUT32(IoC, B0_XS2_CSR, CSR_IRQ_CL_C);
715                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E010,
716                         SKERR_SIRQ_E010MSG);
717                 Para.Para64 = MAC_2;
718                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
719                 Para.Para32[0] = MAC_2;
720                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
721         }
722
723         if ((Istatus & IS_XA2_C) != 0) {
724                 /* Clear IRQ */
725                 SK_OUT32(IoC, B0_XA2_CSR, CSR_IRQ_CL_C);
726                 SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E011,
727                         SKERR_SIRQ_E011MSG);
728                 Para.Para64 = MAC_2;
729                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
730                 Para.Para32[0] = MAC_2;
731                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
732         }
733
734         /* External reg interrupt */
735         if ((Istatus & IS_EXT_REG) != 0) {
736                 /* Test IRQs from PHY */
737                 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
738                         
739                         pPrt = &pAC->GIni.GP[i];
740                         
741                         if (pPrt->PState == SK_PRT_RESET) {
742                                 continue;
743                         }
744                         
745 #ifdef GENESIS
746                         if (pAC->GIni.GIGenesis) {
747                                 
748                                 switch (pPrt->PhyType) {
749                                 
750                                 case SK_PHY_XMAC:
751                                         break;
752                                 
753                                 case SK_PHY_BCOM:
754                                         SkXmPhyRead(pAC, IoC, i, PHY_BCOM_INT_STAT, &PhyInt);
755         
756                                         if ((PhyInt & ~PHY_B_DEF_MSK) != 0) {
757                                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
758                                                         ("Port %d Bcom Int: 0x%04X\n",
759                                                         i, PhyInt));
760                                                 SkPhyIsrBcom(pAC, IoC, i, PhyInt);
761                                         }
762                                         break;
763 #ifdef OTHER_PHY
764                                 case SK_PHY_LONE:
765                                         SkXmPhyRead(pAC, IoC, i, PHY_LONE_INT_STAT, &PhyInt);
766                                         
767                                         if ((PhyInt & PHY_L_DEF_MSK) != 0) {
768                                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
769                                                         ("Port %d Lone Int: %x\n",
770                                                         i, PhyInt));
771                                                 SkPhyIsrLone(pAC, IoC, i, PhyInt);
772                                         }
773                                         break;
774 #endif /* OTHER_PHY */
775                                 }
776                         }
777 #endif /* GENESIS */
778         
779 #ifdef YUKON
780                         if (pAC->GIni.GIYukon) {
781                                 /* Read PHY Interrupt Status */
782                                 SkGmPhyRead(pAC, IoC, i, PHY_MARV_INT_STAT, &PhyInt);
783
784                                 if ((PhyInt & PHY_M_DEF_MSK) != 0) {
785                                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
786                                                 ("Port %d Marv Int: 0x%04X\n",
787                                                 i, PhyInt));
788                                         SkPhyIsrGmac(pAC, IoC, i, PhyInt);
789                                 }
790                         }
791 #endif /* YUKON */
792                 }
793         }
794
795         /* I2C Ready interrupt */
796         if ((Istatus & IS_I2C_READY) != 0) {
797 #ifdef SK_SLIM
798         SK_OUT32(IoC, B2_I2C_IRQ, I2C_CLR_IRQ);
799 #else           
800                 SkI2cIsr(pAC, IoC);
801 #endif          
802         }
803
804         /* SW forced interrupt */
805         if ((Istatus & IS_IRQ_SW) != 0) {
806                 /* clear the software IRQ */
807                 SK_OUT8(IoC, B0_CTST, CS_CL_SW_IRQ);
808         }
809
810         if ((Istatus & IS_LNK_SYNC_M1) != 0) {
811                 /*
812                  * We do NOT need the Link Sync interrupt, because it shows
813                  * us only a link going down.
814                  */
815                 /* clear interrupt */
816                 SK_OUT8(IoC, MR_ADDR(MAC_1, LNK_SYNC_CTRL), LED_CLR_IRQ);
817         }
818
819         /* Check MAC after link sync counter */
820         if ((Istatus & IS_MAC1) != 0) {
821                 /* IRQ from MAC 1 */
822                 SkMacIrq(pAC, IoC, MAC_1);
823         }
824
825         if ((Istatus & IS_LNK_SYNC_M2) != 0) {
826                 /*
827                  * We do NOT need the Link Sync interrupt, because it shows
828                  * us only a link going down.
829                  */
830                 /* clear interrupt */
831                 SK_OUT8(IoC, MR_ADDR(MAC_2, LNK_SYNC_CTRL), LED_CLR_IRQ);
832         }
833
834         /* Check MAC after link sync counter */
835         if ((Istatus & IS_MAC2) != 0) {
836                 /* IRQ from MAC 2 */
837                 SkMacIrq(pAC, IoC, MAC_2);
838         }
839
840         /* Timer interrupt (served last) */
841         if ((Istatus & IS_TIMINT) != 0) {
842                 /* check for HW Errors */
843                 if (((Istatus & IS_HW_ERR) & ~pAC->GIni.GIValIrqMask) != 0) {
844                         /* read the HW Error Interrupt source */
845                         SK_IN32(IoC, B0_HWE_ISRC, &RegVal32);
846
847                         SkGeHwErr(pAC, IoC, RegVal32);
848                 }
849
850                 SkHwtIsr(pAC, IoC);
851         }
852
853 }       /* SkGeSirqIsr */
854
855
856 #ifdef GENESIS
857 /******************************************************************************
858  *
859  * SkGePortCheckShorts() - Implementing XMAC Workaround Errata # 2
860  *
861  * return:
862  *      0       o.k. nothing needed
863  *      1       Restart needed on this port
864  */
865 static int SkGePortCheckShorts(
866 SK_AC   *pAC,           /* Adapter Context */
867 SK_IOC  IoC,            /* IO Context */
868 int             Port)           /* Which port should be checked */
869 {
870         SK_U32          Shorts;                 /* Short Event Counter */
871         SK_U32          CheckShorts;    /* Check value for Short Event Counter */
872         SK_U64          RxCts;                  /* Rx Counter (packets on network) */
873         SK_U32          RxTmp;                  /* Rx temp. Counter */
874         SK_U32          FcsErrCts;              /* FCS Error Counter */
875         SK_GEPORT       *pPrt;                  /* GIni Port struct pointer */
876         int                     Rtv;                    /* Return value */
877         int                     i;
878
879         pPrt = &pAC->GIni.GP[Port];
880
881         /* Default: no action */
882         Rtv = SK_HW_PS_NONE;
883
884         (void)SkXmUpdateStats(pAC, IoC, Port);
885
886         /* Extra precaution: check for short Event counter */
887         (void)SkXmMacStatistic(pAC, IoC, Port, XM_RXE_SHT_ERR, &Shorts);
888
889         /*
890          * Read Rx counters (packets seen on the network and not necessarily
891          * really received.
892          */
893         RxCts = 0;
894
895         for (i = 0; i < sizeof(SkGeRxRegs)/sizeof(SkGeRxRegs[0]); i++) {
896                 
897                 (void)SkXmMacStatistic(pAC, IoC, Port, SkGeRxRegs[i], &RxTmp);
898                 
899                 RxCts += (SK_U64)RxTmp;
900         }
901
902         /* On default: check shorts against zero */
903         CheckShorts = 0;
904
905         /* Extra precaution on active links */
906         if (pPrt->PHWLinkUp) {
907                 /* Reset Link Restart counter */
908                 pPrt->PLinkResCt = 0;
909                 pPrt->PAutoNegTOCt = 0;
910
911                 /* If link is up check for 2 */
912                 CheckShorts = 2;
913
914                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_RXF_FCS_ERR, &FcsErrCts);
915                 
916                 if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
917                     pPrt->PLipaAutoNeg == SK_LIPA_UNKNOWN &&
918                     (pPrt->PLinkMode == SK_LMODE_HALF ||
919                          pPrt->PLinkMode == SK_LMODE_FULL)) {
920                         /*
921                          * This is autosensing and we are in the fallback
922                          * manual full/half duplex mode.
923                          */
924                         if (RxCts == pPrt->PPrevRx) {
925                                 /* Nothing received, restart link */
926                                 pPrt->PPrevFcs = FcsErrCts;
927                                 pPrt->PPrevShorts = Shorts;
928                                 
929                                 return(SK_HW_PS_RESTART);
930                         }
931                         else {
932                                 pPrt->PLipaAutoNeg = SK_LIPA_MANUAL;
933                         }
934                 }
935
936                 if (((RxCts - pPrt->PPrevRx) > pPrt->PRxLim) ||
937                     (!(FcsErrCts - pPrt->PPrevFcs))) {
938                         /*
939                          * Note: The compare with zero above has to be done the way shown,
940                          * otherwise the Linux driver will have a problem.
941                          */
942                         /*
943                          * We received a bunch of frames or no CRC error occured on the
944                          * network -> ok.
945                          */
946                         pPrt->PPrevRx = RxCts;
947                         pPrt->PPrevFcs = FcsErrCts;
948                         pPrt->PPrevShorts = Shorts;
949
950                         return(SK_HW_PS_NONE);
951                 }
952
953                 pPrt->PPrevFcs = FcsErrCts;
954         }
955
956
957         if ((Shorts - pPrt->PPrevShorts) > CheckShorts) {
958                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
959                         ("Short Event Count Restart Port %d \n", Port));
960                 Rtv = SK_HW_PS_RESTART;
961         }
962
963         pPrt->PPrevShorts = Shorts;
964         pPrt->PPrevRx = RxCts;
965
966         return(Rtv);
967 }       /* SkGePortCheckShorts */
968 #endif /* GENESIS */
969
970
971 /******************************************************************************
972  *
973  * SkGePortCheckUp() - Check if the link is up
974  *
975  * return:
976  *      0       o.k. nothing needed
977  *      1       Restart needed on this port
978  *      2       Link came up
979  */
980 static int SkGePortCheckUp(
981 SK_AC   *pAC,           /* Adapter Context */
982 SK_IOC  IoC,            /* IO Context */
983 int             Port)           /* Which port should be checked */
984 {
985         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
986         SK_BOOL         AutoNeg;        /* Is Auto-negotiation used ? */
987         int                     Rtv;            /* Return value */
988
989         Rtv = SK_HW_PS_NONE;
990         
991         pPrt = &pAC->GIni.GP[Port];
992
993         if (pPrt->PLinkMode == SK_LMODE_HALF || pPrt->PLinkMode == SK_LMODE_FULL) {
994                 AutoNeg = SK_FALSE;
995         }
996         else {
997                 AutoNeg = SK_TRUE;
998         }
999
1000 #ifdef GENESIS
1001         if (pAC->GIni.GIGenesis) {
1002
1003                 switch (pPrt->PhyType) {
1004                 
1005                 case SK_PHY_XMAC:
1006                         Rtv = SkGePortCheckUpXmac(pAC, IoC, Port, AutoNeg);
1007                         break;
1008                 case SK_PHY_BCOM:
1009                         Rtv = SkGePortCheckUpBcom(pAC, IoC, Port, AutoNeg);
1010                         break;
1011 #ifdef OTHER_PHY
1012                 case SK_PHY_LONE:
1013                         Rtv = SkGePortCheckUpLone(pAC, IoC, Port, AutoNeg);
1014                         break;
1015                 case SK_PHY_NAT:
1016                         Rtv = SkGePortCheckUpNat(pAC, IoC, Port, AutoNeg);
1017                         break;
1018 #endif /* OTHER_PHY */
1019                 }
1020         }
1021 #endif /* GENESIS */
1022         
1023 #ifdef YUKON
1024         if (pAC->GIni.GIYukon) {
1025                 
1026                 Rtv = SkGePortCheckUpGmac(pAC, IoC, Port, AutoNeg);
1027         }
1028 #endif /* YUKON */
1029
1030         return(Rtv);    
1031 }       /* SkGePortCheckUp */
1032
1033
1034 #ifdef GENESIS
1035 /******************************************************************************
1036  *
1037  * SkGePortCheckUpXmac() - Implementing of the Workaround Errata # 2
1038  *
1039  * return:
1040  *      0       o.k. nothing needed
1041  *      1       Restart needed on this port
1042  *      2       Link came up
1043  */
1044 static int SkGePortCheckUpXmac(
1045 SK_AC   *pAC,           /* Adapter Context */
1046 SK_IOC  IoC,            /* IO Context */
1047 int             Port,           /* Which port should be checked */
1048 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1049 {
1050         SK_U32          Shorts;         /* Short Event Counter */
1051         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1052         int                     Done;
1053         SK_U32          GpReg;          /* General Purpose register value */
1054         SK_U16          Isrc;           /* Interrupt source register */
1055         SK_U16          IsrcSum;        /* Interrupt source register sum */
1056         SK_U16          LpAb;           /* Link Partner Ability */
1057         SK_U16          ResAb;          /* Resolved Ability */
1058         SK_U16          ExtStat;        /* Extended Status Register */
1059         SK_U8           NextMode;       /* Next AutoSensing Mode */
1060
1061         pPrt = &pAC->GIni.GP[Port];
1062
1063         if (pPrt->PHWLinkUp) {
1064                 if (pPrt->PhyType != SK_PHY_XMAC) {
1065                         return(SK_HW_PS_NONE);
1066                 }
1067                 else {
1068                         return(SkGePortCheckShorts(pAC, IoC, Port));
1069                 }
1070         }
1071
1072         IsrcSum = pPrt->PIsave;
1073         pPrt->PIsave = 0;
1074
1075         /* Now wait for each port's link */
1076         if (pPrt->PLinkBroken) {
1077                 /* Link was broken */
1078                 XM_IN32(IoC, Port, XM_GP_PORT, &GpReg);
1079
1080                 if ((GpReg & XM_GP_INP_ASS) == 0) {
1081                         /* The Link is in sync */
1082                         XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1083                         IsrcSum |= Isrc;
1084                         SkXmAutoNegLipaXmac(pAC, IoC, Port, IsrcSum);
1085                         
1086                         if ((Isrc & XM_IS_INP_ASS) == 0) {
1087                                 /* It has been in sync since last time */
1088                                 /* Restart the PORT */
1089                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1090                                         ("Link in sync Restart Port %d\n", Port));
1091
1092                                 (void)SkXmUpdateStats(pAC, IoC, Port);
1093
1094                                 /* We now need to reinitialize the PrevShorts counter */
1095                                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_RXE_SHT_ERR, &Shorts);
1096                                 pPrt->PPrevShorts = Shorts;
1097
1098                                 pPrt->PLinkBroken = SK_FALSE;
1099
1100                                 /*
1101                                  * Link Restart Workaround:
1102                                  *  it may be possible that the other Link side
1103                                  *  restarts its link as well an we detect
1104                                  *  another LinkBroken. To prevent this
1105                                  *  happening we check for a maximum number
1106                                  *  of consecutive restart. If those happens,
1107                                  *  we do NOT restart the active link and
1108                                  *  check whether the link is now o.k.
1109                                  */
1110                                 pPrt->PLinkResCt++;
1111                                 
1112                                 pPrt->PAutoNegTimeOut = 0;
1113
1114                                 if (pPrt->PLinkResCt < SK_MAX_LRESTART) {
1115                                         return(SK_HW_PS_RESTART);
1116                                 }
1117
1118                                 pPrt->PLinkResCt = 0;
1119                                 
1120                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1121                                         ("Do NOT restart on Port %d %x %x\n", Port, Isrc, IsrcSum));
1122                         }
1123                         else {
1124                                 pPrt->PIsave = (SK_U16)(IsrcSum & XM_IS_AND);
1125                                 
1126                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1127                                         ("Save Sync/nosync Port %d %x %x\n", Port, Isrc, IsrcSum));
1128
1129                                 /* Do nothing more if link is broken */
1130                                 return(SK_HW_PS_NONE);
1131                         }
1132                 }
1133                 else {
1134                         /* Do nothing more if link is broken */
1135                         return(SK_HW_PS_NONE);
1136                 }
1137
1138         }
1139         else {
1140                 /* Link was not broken, check if it is */
1141                 XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1142                 IsrcSum |= Isrc;
1143                 if ((Isrc & XM_IS_INP_ASS) != 0) {
1144                         XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1145                         IsrcSum |= Isrc;
1146                         if ((Isrc & XM_IS_INP_ASS) != 0) {
1147                                 XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1148                                 IsrcSum |= Isrc;
1149                                 if ((Isrc & XM_IS_INP_ASS) != 0) {
1150                                         pPrt->PLinkBroken = SK_TRUE;
1151                                         /* Re-Init Link partner Autoneg flag */
1152                                         pPrt->PLipaAutoNeg = SK_LIPA_UNKNOWN;
1153                                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1154                                                 ("Link broken Port %d\n", Port));
1155
1156                                         /* Cable removed-> reinit sense mode */
1157                                         SkHWInitDefSense(pAC, IoC, Port);
1158
1159                                         return(SK_HW_PS_RESTART);
1160                                 }
1161                         }
1162                 }
1163                 else {
1164                         SkXmAutoNegLipaXmac(pAC, IoC, Port, Isrc);
1165                         
1166                         if (SkGePortCheckShorts(pAC, IoC, Port) == SK_HW_PS_RESTART) {
1167                                 return(SK_HW_PS_RESTART);
1168                         }
1169                 }
1170         }
1171
1172         /*
1173          * here we usually can check whether the link is in sync and
1174          * auto-negotiation is done.
1175          */
1176         XM_IN32(IoC, Port, XM_GP_PORT, &GpReg);
1177         XM_IN16(IoC, Port, XM_ISRC, &Isrc);
1178         IsrcSum |= Isrc;
1179
1180         SkXmAutoNegLipaXmac(pAC, IoC, Port, IsrcSum);
1181         
1182         if ((GpReg & XM_GP_INP_ASS) != 0 || (IsrcSum & XM_IS_INP_ASS) != 0) {
1183                 if ((GpReg & XM_GP_INP_ASS) == 0) {
1184                         /* Save Auto-negotiation Done interrupt only if link is in sync */
1185                         pPrt->PIsave = (SK_U16)(IsrcSum & XM_IS_AND);
1186                 }
1187 #ifdef DEBUG
1188                 if ((pPrt->PIsave & XM_IS_AND) != 0) {
1189                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1190                                 ("AutoNeg done rescheduled Port %d\n", Port));
1191                 }
1192 #endif /* DEBUG */
1193                 return(SK_HW_PS_NONE);
1194         }
1195
1196         if (AutoNeg) {
1197                 if ((IsrcSum & XM_IS_AND) != 0) {
1198                         SkHWLinkUp(pAC, IoC, Port);
1199                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1200                         if (Done != SK_AND_OK) {
1201                                 /* Get PHY parameters, for debugging only */
1202                                 SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_AUNE_LP, &LpAb);
1203                                 SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_RES_ABI, &ResAb);
1204                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1205                                         ("AutoNeg FAIL Port %d (LpAb %x, ResAb %x)\n",
1206                                          Port, LpAb, ResAb));
1207                                         
1208                                 /* Try next possible mode */
1209                                 NextMode = SkHWSenseGetNext(pAC, IoC, Port);
1210                                 SkHWLinkDown(pAC, IoC, Port);
1211                                 if (Done == SK_AND_DUP_CAP) {
1212                                         /* GoTo next mode */
1213                                         SkHWSenseSetNext(pAC, IoC, Port, NextMode);
1214                                 }
1215
1216                                 return(SK_HW_PS_RESTART);
1217                         }
1218                         /*
1219                          * Dummy Read extended status to prevent extra link down/ups
1220                          * (clear Page Received bit if set)
1221                          */
1222                         SkXmPhyRead(pAC, IoC, Port, PHY_XMAC_AUNE_EXP, &ExtStat);
1223                         
1224                         return(SK_HW_PS_LINK);
1225                 }
1226                 
1227                 /* AutoNeg not done, but HW link is up. Check for timeouts */
1228                 pPrt->PAutoNegTimeOut++;
1229                 if (pPrt->PAutoNegTimeOut >= SK_AND_MAX_TO) {
1230                         /* Increase the Timeout counter */
1231                         pPrt->PAutoNegTOCt++;
1232
1233                         /* Timeout occured */
1234                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1235                                 ("AutoNeg timeout Port %d\n", Port));
1236                         if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
1237                                 pPrt->PLipaAutoNeg != SK_LIPA_AUTO) {
1238                                 /* Set Link manually up */
1239                                 SkHWSenseSetNext(pAC, IoC, Port, SK_LMODE_FULL);
1240                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1241                                         ("Set manual full duplex Port %d\n", Port));
1242                         }
1243
1244                         if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
1245                                 pPrt->PLipaAutoNeg == SK_LIPA_AUTO &&
1246                                 pPrt->PAutoNegTOCt >= SK_MAX_ANEG_TO) {
1247                                 /*
1248                                  * This is rather complicated.
1249                                  * we need to check here whether the LIPA_AUTO
1250                                  * we saw before is false alert. We saw at one
1251                                  * switch ( SR8800) that on boot time it sends
1252                                  * just one auto-neg packet and does no further
1253                                  * auto-negotiation.
1254                                  * Solution: we restart the autosensing after
1255                                  * a few timeouts.
1256                                  */
1257                                 pPrt->PAutoNegTOCt = 0;
1258                                 pPrt->PLipaAutoNeg = SK_LIPA_UNKNOWN;
1259                                 SkHWInitDefSense(pAC, IoC, Port);
1260                         }
1261
1262                         /* Do the restart */
1263                         return(SK_HW_PS_RESTART);
1264                 }
1265         }
1266         else {
1267                 /* Link is up and we don't need more */
1268 #ifdef DEBUG
1269                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1270                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1271                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1272                 }
1273 #endif /* DEBUG */
1274                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1275                         ("Link sync(GP), Port %d\n", Port));
1276                 SkHWLinkUp(pAC, IoC, Port);
1277                 
1278                 /*
1279                  * Link sync (GP) and so assume a good connection. But if not received
1280                  * a bunch of frames received in a time slot (maybe broken tx cable)
1281                  * the port is restart.
1282                  */
1283                 return(SK_HW_PS_LINK);
1284         }
1285
1286         return(SK_HW_PS_NONE);
1287 }       /* SkGePortCheckUpXmac */
1288
1289
1290 /******************************************************************************
1291  *
1292  * SkGePortCheckUpBcom() - Check if the link is up on Bcom PHY
1293  *
1294  * return:
1295  *      0       o.k. nothing needed
1296  *      1       Restart needed on this port
1297  *      2       Link came up
1298  */
1299 static int SkGePortCheckUpBcom(
1300 SK_AC   *pAC,           /* Adapter Context */
1301 SK_IOC  IoC,            /* IO Context */
1302 int             Port,           /* Which port should be checked */
1303 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1304 {
1305         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1306         int                     Done;
1307         SK_U16          Isrc;           /* Interrupt source register */
1308         SK_U16          PhyStat;        /* Phy Status Register */
1309         SK_U16          ResAb;          /* Master/Slave resolution */
1310         SK_U16          Ctrl;           /* Broadcom control flags */
1311 #ifdef DEBUG
1312         SK_U16          LpAb;
1313         SK_U16          ExtStat;
1314 #endif /* DEBUG */
1315
1316         pPrt = &pAC->GIni.GP[Port];
1317
1318         /* Check for No HCD Link events (#10523) */
1319         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_STAT, &Isrc);
1320
1321 #ifdef xDEBUG
1322         if ((Isrc & ~(PHY_B_IS_HCT | PHY_B_IS_LCT)) ==
1323                 (PHY_B_IS_SCR_S_ER | PHY_B_IS_RRS_CHANGE | PHY_B_IS_LRS_CHANGE)) {
1324
1325                 SK_U32  Stat1, Stat2, Stat3;
1326
1327                 Stat1 = 0;
1328                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_MASK, &Stat1);
1329                 CMSMPrintString(
1330                         pAC->pConfigTable,
1331                         MSG_TYPE_RUNTIME_INFO,
1332                         "CheckUp1 - Stat: %x, Mask: %x",
1333                         (void *)Isrc,
1334                         (void *)Stat1);
1335
1336                 Stat1 = 0;
1337                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_CTRL, &Stat1);
1338                 Stat2 = 0;
1339                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &Stat2);
1340                 Stat1 = Stat1 << 16 | Stat2;
1341                 Stat2 = 0;
1342                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_ADV, &Stat2);
1343                 Stat3 = 0;
1344                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_LP, &Stat3);
1345                 Stat2 = Stat2 << 16 | Stat3;
1346                 CMSMPrintString(
1347                         pAC->pConfigTable,
1348                         MSG_TYPE_RUNTIME_INFO,
1349                         "Ctrl/Stat: %x, AN Adv/LP: %x",
1350                         (void *)Stat1,
1351                         (void *)Stat2);
1352
1353                 Stat1 = 0;
1354                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_EXP, &Stat1);
1355                 Stat2 = 0;
1356                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_EXT_STAT, &Stat2);
1357                 Stat1 = Stat1 << 16 | Stat2;
1358                 Stat2 = 0;
1359                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_CTRL, &Stat2);
1360                 Stat3 = 0;
1361                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &Stat3);
1362                 Stat2 = Stat2 << 16 | Stat3;
1363                 CMSMPrintString(
1364                         pAC->pConfigTable,
1365                         MSG_TYPE_RUNTIME_INFO,
1366                         "AN Exp/IEEE Ext: %x, 1000T Ctrl/Stat: %x",
1367                         (void *)Stat1,
1368                         (void *)Stat2);
1369
1370                 Stat1 = 0;
1371                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_CTRL, &Stat1);
1372                 Stat2 = 0;
1373                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_STAT, &Stat2);
1374                 Stat1 = Stat1 << 16 | Stat2;
1375                 Stat2 = 0;
1376                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, &Stat2);
1377                 Stat3 = 0;
1378                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_STAT, &Stat3);
1379                 Stat2 = Stat2 << 16 | Stat3;
1380                 CMSMPrintString(
1381                         pAC->pConfigTable,
1382                         MSG_TYPE_RUNTIME_INFO,
1383                         "PHY Ext Ctrl/Stat: %x, Aux Ctrl/Stat: %x",
1384                         (void *)Stat1,
1385                         (void *)Stat2);
1386         }
1387 #endif /* DEBUG */
1388
1389         if ((Isrc & (PHY_B_IS_NO_HDCL /* | PHY_B_IS_NO_HDC */)) != 0) {
1390                 /*
1391                  * Workaround BCom Errata:
1392                  *      enable and disable loopback mode if "NO HCD" occurs.
1393                  */
1394                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_CTRL, &Ctrl);
1395                 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_CTRL,
1396                         (SK_U16)(Ctrl | PHY_CT_LOOP));
1397                 SkXmPhyWrite(pAC, IoC, Port, PHY_BCOM_CTRL,
1398                         (SK_U16)(Ctrl & ~PHY_CT_LOOP));
1399                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1400                         ("No HCD Link event, Port %d\n", Port));
1401 #ifdef xDEBUG
1402                 CMSMPrintString(
1403                         pAC->pConfigTable,
1404                         MSG_TYPE_RUNTIME_INFO,
1405                         "No HCD link event, port %d.",
1406                         (void *)Port,
1407                         (void *)NULL);
1408 #endif /* DEBUG */
1409         }
1410
1411         /* Not obsolete: link status bit is latched to 0 and autoclearing! */
1412         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &PhyStat);
1413
1414         if (pPrt->PHWLinkUp) {
1415                 return(SK_HW_PS_NONE);
1416         }
1417
1418 #ifdef xDEBUG
1419         {
1420                 SK_U32  Stat1, Stat2, Stat3;
1421
1422                 Stat1 = 0;
1423                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_MASK, &Stat1);
1424                 CMSMPrintString(
1425                         pAC->pConfigTable,
1426                         MSG_TYPE_RUNTIME_INFO,
1427                         "CheckUp1a - Stat: %x, Mask: %x",
1428                         (void *)Isrc,
1429                         (void *)Stat1);
1430
1431                 Stat1 = 0;
1432                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_CTRL, &Stat1);
1433                 Stat2 = 0;
1434                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &PhyStat);
1435                 Stat1 = Stat1 << 16 | PhyStat;
1436                 Stat2 = 0;
1437                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_ADV, &Stat2);
1438                 Stat3 = 0;
1439                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_LP, &Stat3);
1440                 Stat2 = Stat2 << 16 | Stat3;
1441                 CMSMPrintString(
1442                         pAC->pConfigTable,
1443                         MSG_TYPE_RUNTIME_INFO,
1444                         "Ctrl/Stat: %x, AN Adv/LP: %x",
1445                         (void *)Stat1,
1446                         (void *)Stat2);
1447
1448                 Stat1 = 0;
1449                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_EXP, &Stat1);
1450                 Stat2 = 0;
1451                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_EXT_STAT, &Stat2);
1452                 Stat1 = Stat1 << 16 | Stat2;
1453                 Stat2 = 0;
1454                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_CTRL, &Stat2);
1455                 Stat3 = 0;
1456                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &ResAb);
1457                 Stat2 = Stat2 << 16 | ResAb;
1458                 CMSMPrintString(
1459                         pAC->pConfigTable,
1460                         MSG_TYPE_RUNTIME_INFO,
1461                         "AN Exp/IEEE Ext: %x, 1000T Ctrl/Stat: %x",
1462                         (void *)Stat1,
1463                         (void *)Stat2);
1464
1465                 Stat1 = 0;
1466                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_CTRL, &Stat1);
1467                 Stat2 = 0;
1468                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_P_EXT_STAT, &Stat2);
1469                 Stat1 = Stat1 << 16 | Stat2;
1470                 Stat2 = 0;
1471                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_CTRL, &Stat2);
1472                 Stat3 = 0;
1473                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUX_STAT, &Stat3);
1474                 Stat2 = Stat2 << 16 | Stat3;
1475                 CMSMPrintString(
1476                         pAC->pConfigTable,
1477                         MSG_TYPE_RUNTIME_INFO,
1478                         "PHY Ext Ctrl/Stat: %x, Aux Ctrl/Stat: %x",
1479                         (void *)Stat1,
1480                         (void *)Stat2);
1481         }
1482 #endif /* DEBUG */
1483
1484         /*
1485          * Here we usually can check whether the link is in sync and
1486          * auto-negotiation is done.
1487          */
1488
1489         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_STAT, &PhyStat);
1490
1491         SkMacAutoNegLipaPhy(pAC, IoC, Port, PhyStat);
1492         
1493         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1494                 ("CheckUp Port %d, PhyStat: 0x%04X\n", Port, PhyStat));
1495
1496         SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &ResAb);
1497
1498         if ((ResAb & PHY_B_1000S_MSF) != 0) {
1499                 /* Error */
1500                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1501                         ("Master/Slave Fault port %d\n", Port));
1502                 
1503                 pPrt->PAutoNegFail = SK_TRUE;
1504                 pPrt->PMSStatus = SK_MS_STAT_FAULT;
1505                 
1506                 return(SK_HW_PS_RESTART);
1507         }
1508
1509         if ((PhyStat & PHY_ST_LSYNC) == 0) {
1510                 return(SK_HW_PS_NONE);
1511         }
1512         
1513         pPrt->PMSStatus = ((ResAb & PHY_B_1000S_MSR) != 0) ?
1514                 SK_MS_STAT_MASTER : SK_MS_STAT_SLAVE;
1515         
1516         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1517                 ("Port %d, ResAb: 0x%04X\n", Port, ResAb));
1518
1519         if (AutoNeg) {
1520                 if ((PhyStat & PHY_ST_AN_OVER) != 0) {
1521                         
1522                         SkHWLinkUp(pAC, IoC, Port);
1523                         
1524                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1525                         
1526                         if (Done != SK_AND_OK) {
1527 #ifdef DEBUG
1528                                 /* Get PHY parameters, for debugging only */
1529                                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_AUNE_LP, &LpAb);
1530                                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_1000T_STAT, &ExtStat);
1531                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1532                                         ("AutoNeg FAIL Port %d (LpAb %x, 1000TStat %x)\n",
1533                                         Port, LpAb, ExtStat));
1534 #endif /* DEBUG */
1535                                 return(SK_HW_PS_RESTART);
1536                         }
1537                         else {
1538 #ifdef xDEBUG
1539                                 /* Dummy read ISR to prevent extra link downs/ups */
1540                                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_STAT, &ExtStat);
1541
1542                                 if ((ExtStat & ~(PHY_B_IS_HCT | PHY_B_IS_LCT)) != 0) {
1543                                         CMSMPrintString(
1544                                                 pAC->pConfigTable,
1545                                                 MSG_TYPE_RUNTIME_INFO,
1546                                                 "CheckUp2 - Stat: %x",
1547                                                 (void *)ExtStat,
1548                                                 (void *)NULL);
1549                                 }
1550 #endif /* DEBUG */
1551                                 return(SK_HW_PS_LINK);
1552                         }
1553                 }
1554         }
1555         else {  /* !AutoNeg */
1556                 /* Link is up and we don't need more. */
1557 #ifdef DEBUG
1558                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1559                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1560                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1561                 }
1562 #endif /* DEBUG */
1563
1564 #ifdef xDEBUG
1565                 /* Dummy read ISR to prevent extra link downs/ups */
1566                 SkXmPhyRead(pAC, IoC, Port, PHY_BCOM_INT_STAT, &ExtStat);
1567
1568                 if ((ExtStat & ~(PHY_B_IS_HCT | PHY_B_IS_LCT)) != 0) {
1569                         CMSMPrintString(
1570                                 pAC->pConfigTable,
1571                                 MSG_TYPE_RUNTIME_INFO,
1572                                 "CheckUp3 - Stat: %x",
1573                                 (void *)ExtStat,
1574                                 (void *)NULL);
1575                 }
1576 #endif /* DEBUG */
1577                 
1578                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1579                         ("Link sync(GP), Port %d\n", Port));
1580                 SkHWLinkUp(pAC, IoC, Port);
1581                 
1582                 return(SK_HW_PS_LINK);
1583         }
1584
1585         return(SK_HW_PS_NONE);
1586 }       /* SkGePortCheckUpBcom */
1587 #endif /* GENESIS */
1588
1589
1590 #ifdef YUKON
1591 /******************************************************************************
1592  *
1593  * SkGePortCheckUpGmac() - Check if the link is up on Marvell PHY
1594  *
1595  * return:
1596  *      0       o.k. nothing needed
1597  *      1       Restart needed on this port
1598  *      2       Link came up
1599  */
1600 static int SkGePortCheckUpGmac(
1601 SK_AC   *pAC,           /* Adapter Context */
1602 SK_IOC  IoC,            /* IO Context */
1603 int             Port,           /* Which port should be checked */
1604 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1605 {
1606         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1607         int                     Done;
1608         SK_U16          PhyIsrc;        /* PHY Interrupt source */
1609         SK_U16          PhyStat;        /* PPY Status */
1610         SK_U16          PhySpecStat;/* PHY Specific Status */
1611         SK_U16          ResAb;          /* Master/Slave resolution */
1612         SK_EVPARA       Para;
1613 #ifdef DEBUG
1614         SK_U16          Word;           /* I/O helper */
1615 #endif /* DEBUG */
1616
1617         pPrt = &pAC->GIni.GP[Port];
1618
1619         if (pPrt->PHWLinkUp) {
1620                 return(SK_HW_PS_NONE);
1621         }
1622
1623         /* Read PHY Status */
1624         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_STAT, &PhyStat);
1625
1626         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1627                 ("CheckUp Port %d, PhyStat: 0x%04X\n", Port, PhyStat));
1628
1629         /* Read PHY Interrupt Status */
1630         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_INT_STAT, &PhyIsrc);
1631
1632         if ((PhyIsrc & PHY_M_IS_AN_COMPL) != 0) {
1633                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1634                         ("Auto-Negotiation Completed, PhyIsrc: 0x%04X\n", PhyIsrc));
1635         }
1636
1637         if ((PhyIsrc & PHY_M_IS_LSP_CHANGE) != 0) {
1638                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1639                         ("Link Speed Changed, PhyIsrc: 0x%04X\n", PhyIsrc));
1640         }
1641
1642         SkMacAutoNegLipaPhy(pAC, IoC, Port, PhyStat);
1643         
1644         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_1000T_STAT, &ResAb);
1645
1646         if ((ResAb & PHY_B_1000S_MSF) != 0) {
1647                 /* Error */
1648                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1649                         ("Master/Slave Fault port %d\n", Port));
1650                 
1651                 pPrt->PAutoNegFail = SK_TRUE;
1652                 pPrt->PMSStatus = SK_MS_STAT_FAULT;
1653                 
1654                 return(SK_HW_PS_RESTART);
1655         }
1656
1657         /* Read PHY Specific Status */
1658         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_PHY_STAT, &PhySpecStat);
1659         
1660         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1661                 ("Phy1000BT: 0x%04X, PhySpecStat: 0x%04X\n", ResAb, PhySpecStat));
1662
1663 #ifdef DEBUG
1664         SkGmPhyRead(pAC, IoC, Port, PHY_MARV_AUNE_EXP, &Word);
1665
1666         if ((PhyIsrc & PHY_M_IS_AN_PR) != 0 || (Word & PHY_ANE_RX_PG) != 0 ||
1667                 (PhySpecStat & PHY_M_PS_PAGE_REC) != 0)  {
1668                 /* Read PHY Next Page Link Partner */
1669                 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_NEPG_LP, &Word);
1670
1671                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1672                         ("Page Received, NextPage: 0x%04X\n", Word));
1673         }
1674 #endif /* DEBUG */
1675
1676         if ((PhySpecStat & PHY_M_PS_LINK_UP) == 0) {
1677                 return(SK_HW_PS_NONE);
1678         }
1679         
1680         if ((PhySpecStat & PHY_M_PS_DOWNS_STAT) != 0 ||
1681                 (PhyIsrc & PHY_M_IS_DOWNSH_DET) != 0) {
1682                 /* Downshift detected */
1683                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E025, SKERR_SIRQ_E025MSG);
1684                 
1685                 Para.Para64 = Port;
1686                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_DOWNSHIFT_DET, Para);
1687                 
1688                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1689                         ("Downshift detected, PhyIsrc: 0x%04X\n", PhyIsrc));
1690         }
1691
1692         pPrt->PMSStatus = ((ResAb & PHY_B_1000S_MSR) != 0) ?
1693                 SK_MS_STAT_MASTER : SK_MS_STAT_SLAVE;
1694         
1695         pPrt->PCableLen = (SK_U8)((PhySpecStat & PHY_M_PS_CABLE_MSK) >> 7);
1696         
1697         if (AutoNeg) {
1698                 /* Auto-Negotiation Over ? */
1699                 if ((PhyStat & PHY_ST_AN_OVER) != 0) {
1700                         
1701                         SkHWLinkUp(pAC, IoC, Port);
1702                         
1703                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1704                         
1705                         if (Done != SK_AND_OK) {
1706                                 return(SK_HW_PS_RESTART);
1707                         }
1708                         
1709                         return(SK_HW_PS_LINK);
1710                 }
1711         }
1712         else {  /* !AutoNeg */
1713                 /* Link is up and we don't need more */
1714 #ifdef DEBUG
1715                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1716                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1717                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1718                 }
1719 #endif /* DEBUG */
1720
1721                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1722                         ("Link sync, Port %d\n", Port));
1723                 SkHWLinkUp(pAC, IoC, Port);
1724                 
1725                 return(SK_HW_PS_LINK);
1726         }
1727
1728         return(SK_HW_PS_NONE);
1729 }       /* SkGePortCheckUpGmac */
1730 #endif /* YUKON */
1731
1732
1733 #ifdef OTHER_PHY
1734 /******************************************************************************
1735  *
1736  * SkGePortCheckUpLone() - Check if the link is up on Level One PHY
1737  *
1738  * return:
1739  *      0       o.k. nothing needed
1740  *      1       Restart needed on this port
1741  *      2       Link came up
1742  */
1743 static int SkGePortCheckUpLone(
1744 SK_AC   *pAC,           /* Adapter Context */
1745 SK_IOC  IoC,            /* IO Context */
1746 int             Port,           /* Which port should be checked */
1747 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1748 {
1749         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1750         int                     Done;
1751         SK_U16          Isrc;           /* Interrupt source register */
1752         SK_U16          LpAb;           /* Link Partner Ability */
1753         SK_U16          ExtStat;        /* Extended Status Register */
1754         SK_U16          PhyStat;        /* Phy Status Register */
1755         SK_U16          StatSum;
1756         SK_U8           NextMode;       /* Next AutoSensing Mode */
1757
1758         pPrt = &pAC->GIni.GP[Port];
1759
1760         if (pPrt->PHWLinkUp) {
1761                 return(SK_HW_PS_NONE);
1762         }
1763
1764         StatSum = pPrt->PIsave;
1765         pPrt->PIsave = 0;
1766
1767         /*
1768          * here we usually can check whether the link is in sync and
1769          * auto-negotiation is done.
1770          */
1771         SkXmPhyRead(pAC, IoC, Port, PHY_LONE_STAT, &PhyStat);
1772         StatSum |= PhyStat;
1773
1774         SkMacAutoNegLipaPhy(pAC, IoC, Port, PhyStat);
1775         
1776         if ((PhyStat & PHY_ST_LSYNC) == 0) {
1777                 /* Save Auto-negotiation Done bit */
1778                 pPrt->PIsave = (SK_U16)(StatSum & PHY_ST_AN_OVER);
1779 #ifdef DEBUG
1780                 if ((pPrt->PIsave & PHY_ST_AN_OVER) != 0) {
1781                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1782                                 ("AutoNeg done rescheduled Port %d\n", Port));
1783                 }
1784 #endif /* DEBUG */
1785                 return(SK_HW_PS_NONE);
1786         }
1787
1788         if (AutoNeg) {
1789                 if ((StatSum & PHY_ST_AN_OVER) != 0) {
1790                         SkHWLinkUp(pAC, IoC, Port);
1791                         Done = SkMacAutoNegDone(pAC, IoC, Port);
1792                         if (Done != SK_AND_OK) {
1793                                 /* Get PHY parameters, for debugging only */
1794                                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_AUNE_LP, &LpAb);
1795                                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_1000T_STAT, &ExtStat);
1796                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1797                                         ("AutoNeg FAIL Port %d (LpAb %x, 1000TStat %x)\n",
1798                                          Port, LpAb, ExtStat));
1799                                         
1800                                 /* Try next possible mode */
1801                                 NextMode = SkHWSenseGetNext(pAC, IoC, Port);
1802                                 SkHWLinkDown(pAC, IoC, Port);
1803                                 if (Done == SK_AND_DUP_CAP) {
1804                                         /* GoTo next mode */
1805                                         SkHWSenseSetNext(pAC, IoC, Port, NextMode);
1806                                 }
1807
1808                                 return(SK_HW_PS_RESTART);
1809
1810                         }
1811                         else {
1812                                 /*
1813                                  * Dummy Read interrupt status to prevent
1814                                  * extra link down/ups
1815                                  */
1816                                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_INT_STAT, &ExtStat);
1817                                 return(SK_HW_PS_LINK);
1818                         }
1819                 }
1820                 
1821                 /* AutoNeg not done, but HW link is up. Check for timeouts */
1822                 pPrt->PAutoNegTimeOut++;
1823                 if (pPrt->PAutoNegTimeOut >= SK_AND_MAX_TO) {
1824                         /* Timeout occured */
1825                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1826                                 ("AutoNeg timeout Port %d\n", Port));
1827                         if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE &&
1828                                 pPrt->PLipaAutoNeg != SK_LIPA_AUTO) {
1829                                 /* Set Link manually up */
1830                                 SkHWSenseSetNext(pAC, IoC, Port, SK_LMODE_FULL);
1831                                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1832                                         ("Set manual full duplex Port %d\n", Port));
1833                         }
1834
1835                         /* Do the restart */
1836                         return(SK_HW_PS_RESTART);
1837                 }
1838         }
1839         else {
1840                 /* Link is up and we don't need more */
1841 #ifdef DEBUG
1842                 if (pPrt->PLipaAutoNeg == SK_LIPA_AUTO) {
1843                         SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
1844                                 ("ERROR: Lipa auto detected on port %d\n", Port));
1845                 }
1846 #endif /* DEBUG */
1847
1848                 /*
1849                  * Dummy Read interrupt status to prevent
1850                  * extra link down/ups
1851                  */
1852                 SkXmPhyRead(pAC, IoC, Port, PHY_LONE_INT_STAT, &ExtStat);
1853                 
1854                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_IRQ,
1855                         ("Link sync(GP), Port %d\n", Port));
1856                 SkHWLinkUp(pAC, IoC, Port);
1857                 
1858                 return(SK_HW_PS_LINK);
1859         }
1860
1861         return(SK_HW_PS_NONE);
1862 }       /* SkGePortCheckUpLone */
1863
1864
1865 /******************************************************************************
1866  *
1867  * SkGePortCheckUpNat() - Check if the link is up on National PHY
1868  *
1869  * return:
1870  *      0       o.k. nothing needed
1871  *      1       Restart needed on this port
1872  *      2       Link came up
1873  */
1874 static int SkGePortCheckUpNat(
1875 SK_AC   *pAC,           /* Adapter Context */
1876 SK_IOC  IoC,            /* IO Context */
1877 int             Port,           /* Which port should be checked */
1878 SK_BOOL AutoNeg)        /* Is Auto-negotiation used ? */
1879 {
1880         /* todo: National */
1881         return(SK_HW_PS_NONE);
1882 }       /* SkGePortCheckUpNat */
1883 #endif /* OTHER_PHY */
1884
1885
1886 /******************************************************************************
1887  *
1888  *      SkGeSirqEvent() - Event Service Routine
1889  *
1890  * Description:
1891  *
1892  * Notes:
1893  */
1894 int     SkGeSirqEvent(
1895 SK_AC           *pAC,           /* Adapter Context */
1896 SK_IOC          IoC,            /* Io Context */
1897 SK_U32          Event,          /* Module specific Event */
1898 SK_EVPARA       Para)           /* Event specific Parameter */
1899 {
1900         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
1901         SK_U32          Port;
1902         SK_U32          Val32;
1903         int                     PortStat;
1904         SK_U8           Val8;
1905 #ifdef GENESIS
1906         SK_U64          Octets;
1907 #endif /* GENESIS */
1908
1909         Port = Para.Para32[0];
1910         pPrt = &pAC->GIni.GP[Port];
1911
1912         switch (Event) {
1913         case SK_HWEV_WATIM:
1914                 if (pPrt->PState == SK_PRT_RESET) {
1915                 
1916                         PortStat = SK_HW_PS_NONE;
1917                 }
1918                 else {
1919                         /* Check whether port came up */
1920                         PortStat = SkGePortCheckUp(pAC, IoC, (int)Port);
1921                 }
1922
1923                 switch (PortStat) {
1924                 case SK_HW_PS_RESTART:
1925                         if (pPrt->PHWLinkUp) {
1926                                 /* Set Link to down */
1927                                 SkHWLinkDown(pAC, IoC, (int)Port);
1928
1929                                 /*
1930                                  * Signal directly to RLMT to ensure correct
1931                                  * sequence of SWITCH and RESET event.
1932                                  */
1933                                 SkRlmtEvent(pAC, IoC, SK_RLMT_LINK_DOWN, Para);
1934                         }
1935
1936                         /* Restart needed */
1937                         SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_RESET, Para);
1938                         break;
1939
1940                 case SK_HW_PS_LINK:
1941                         /* Signal to RLMT */
1942                         SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_UP, Para);
1943                         break;
1944                 }
1945                 
1946                 /* Start again the check Timer */
1947                 if (pPrt->PHWLinkUp) {
1948                         Val32 = SK_WA_ACT_TIME;
1949                 }
1950                 else {
1951                         Val32 = SK_WA_INA_TIME;
1952                 }
1953
1954                 /* Todo: still needed for non-XMAC PHYs??? */
1955                 /* Start workaround Errata #2 timer */
1956                 SkTimerStart(pAC, IoC, &pPrt->PWaTimer, Val32,
1957                         SKGE_HWAC, SK_HWEV_WATIM, Para);
1958                 break;
1959
1960         case SK_HWEV_PORT_START:
1961                 if (pPrt->PHWLinkUp) {
1962                         /*
1963                          * Signal directly to RLMT to ensure correct
1964                          * sequence of SWITCH and RESET event.
1965                          */
1966                         SkRlmtEvent(pAC, IoC, SK_RLMT_LINK_DOWN, Para);
1967                 }
1968
1969                 SkHWLinkDown(pAC, IoC, (int)Port);
1970
1971                 /* Schedule Port RESET */
1972                 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_RESET, Para);
1973
1974                 /* Start workaround Errata #2 timer */
1975                 SkTimerStart(pAC, IoC, &pPrt->PWaTimer, SK_WA_INA_TIME,
1976                         SKGE_HWAC, SK_HWEV_WATIM, Para);
1977                 break;
1978
1979         case SK_HWEV_PORT_STOP:
1980                 if (pPrt->PHWLinkUp) {
1981                         /*
1982                          * Signal directly to RLMT to ensure correct
1983                          * sequence of SWITCH and RESET event.
1984                          */
1985                         SkRlmtEvent(pAC, IoC, SK_RLMT_LINK_DOWN, Para);
1986                 }
1987
1988                 /* Stop Workaround Timer */
1989                 SkTimerStop(pAC, IoC, &pPrt->PWaTimer);
1990
1991                 SkHWLinkDown(pAC, IoC, (int)Port);
1992                 break;
1993
1994         case SK_HWEV_UPDATE_STAT:
1995                 /* We do NOT need to update any statistics */
1996                 break;
1997
1998         case SK_HWEV_CLEAR_STAT:
1999                 /* We do NOT need to clear any statistics */
2000                 for (Port = 0; Port < (SK_U32)pAC->GIni.GIMacsFound; Port++) {
2001                         pPrt->PPrevRx = 0;
2002                         pPrt->PPrevFcs = 0;
2003                         pPrt->PPrevShorts = 0;
2004                 }
2005                 break;
2006
2007         case SK_HWEV_SET_LMODE:
2008                 Val8 = (SK_U8)Para.Para32[1];
2009                 if (pPrt->PLinkModeConf != Val8) {
2010                         /* Set New link mode */
2011                         pPrt->PLinkModeConf = Val8;
2012
2013                         /* Restart Port */
2014                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para);
2015                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
2016                 }
2017                 break;
2018
2019         case SK_HWEV_SET_FLOWMODE:
2020                 Val8 = (SK_U8)Para.Para32[1];
2021                 if (pPrt->PFlowCtrlMode != Val8) {
2022                         /* Set New Flow Control mode */
2023                         pPrt->PFlowCtrlMode = Val8;
2024
2025                         /* Restart Port */
2026                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para);
2027                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
2028                 }
2029                 break;
2030
2031         case SK_HWEV_SET_ROLE:
2032                 /* not possible for fiber */
2033                 if (!pAC->GIni.GICopperType) {
2034                         break;
2035                 }
2036                 Val8 = (SK_U8)Para.Para32[1];
2037                 if (pPrt->PMSMode != Val8) {
2038                         /* Set New Role (Master/Slave) mode */
2039                         pPrt->PMSMode = 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_SPEED:
2048                 if (pPrt->PhyType != SK_PHY_MARV_COPPER) {
2049                         break;
2050                 }
2051                 Val8 = (SK_U8)Para.Para32[1];
2052                 if (pPrt->PLinkSpeed != Val8) {
2053                         /* Set New Speed parameter */
2054                         pPrt->PLinkSpeed = Val8;
2055
2056                         /* Restart Port */
2057                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_STOP, Para);
2058                         SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_PORT_START, Para);
2059                 }
2060                 break;
2061
2062 #ifdef GENESIS
2063         case SK_HWEV_HALFDUP_CHK:
2064                 if (pAC->GIni.GIGenesis) {
2065                         /*
2066                          * half duplex hangup workaround.
2067                          * See packet arbiter timeout interrupt for description
2068                          */
2069                         pPrt->HalfDupTimerActive = SK_FALSE;
2070                         if (pPrt->PLinkModeStatus == SK_LMODE_STAT_HALF ||
2071                                 pPrt->PLinkModeStatus == SK_LMODE_STAT_AUTOHALF) {
2072                                 /* Snap statistic counters */
2073                                 (void)SkXmUpdateStats(pAC, IoC, Port);
2074
2075                                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_TXO_OK_HI, &Val32);
2076
2077                                 Octets = (SK_U64)Val32 << 32;
2078                                 
2079                                 (void)SkXmMacStatistic(pAC, IoC, Port, XM_TXO_OK_LO, &Val32);
2080
2081                                 Octets += Val32;
2082                                 
2083                                 if (pPrt->LastOctets == Octets) {
2084                                         /* Tx hanging, a FIFO flush restarts it */
2085                                         SkMacFlushTxFifo(pAC, IoC, Port);
2086                                 }
2087                         }
2088                 }
2089                 break;
2090 #endif /* GENESIS */
2091         
2092         default:
2093                 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_SIRQ_E001, SKERR_SIRQ_E001MSG);
2094                 break;
2095         }
2096
2097         return(0);
2098 }       /* SkGeSirqEvent */
2099
2100
2101 #ifdef GENESIS
2102 /******************************************************************************
2103  *
2104  *      SkPhyIsrBcom() - PHY interrupt service routine
2105  *
2106  * Description: handles all interrupts from BCom PHY
2107  *
2108  * Returns: N/A
2109  */
2110 static void SkPhyIsrBcom(
2111 SK_AC           *pAC,           /* Adapter Context */
2112 SK_IOC          IoC,            /* Io Context */
2113 int                     Port,           /* Port Num = PHY Num */
2114 SK_U16          IStatus)        /* Interrupt Status */
2115 {
2116         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
2117         SK_EVPARA       Para;
2118
2119         pPrt = &pAC->GIni.GP[Port];
2120
2121         if ((IStatus & PHY_B_IS_PSE) != 0) {
2122                 /* Incorrectable pair swap error */
2123                 SK_ERR_LOG(pAC, SK_ERRCL_HW | SK_ERRCL_INIT, SKERR_SIRQ_E022,
2124                         SKERR_SIRQ_E022MSG);
2125         }
2126         
2127         if ((IStatus & (PHY_B_IS_AN_PR | PHY_B_IS_LST_CHANGE)) != 0) {
2128
2129                 SkHWLinkDown(pAC, IoC, Port);
2130
2131                 Para.Para32[0] = (SK_U32)Port;
2132                 /* Signal to RLMT */
2133                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
2134
2135                 /* Start workaround Errata #2 timer */
2136                 SkTimerStart(pAC, IoC, &pPrt->PWaTimer, SK_WA_INA_TIME,
2137                         SKGE_HWAC, SK_HWEV_WATIM, Para);
2138         }
2139
2140 }       /* SkPhyIsrBcom */
2141 #endif /* GENESIS */
2142
2143
2144 #ifdef YUKON
2145 /******************************************************************************
2146  *
2147  *      SkPhyIsrGmac() - PHY interrupt service routine
2148  *
2149  * Description: handles all interrupts from Marvell PHY
2150  *
2151  * Returns: N/A
2152  */
2153 static void SkPhyIsrGmac(
2154 SK_AC           *pAC,           /* Adapter Context */
2155 SK_IOC          IoC,            /* Io Context */
2156 int                     Port,           /* Port Num = PHY Num */
2157 SK_U16          IStatus)        /* Interrupt Status */
2158 {
2159         SK_GEPORT       *pPrt;          /* GIni Port struct pointer */
2160         SK_EVPARA       Para;
2161         SK_U16          Word;
2162
2163         pPrt = &pAC->GIni.GP[Port];
2164
2165         if ((IStatus & (PHY_M_IS_AN_PR | PHY_M_IS_LST_CHANGE)) != 0) {
2166
2167                 SkHWLinkDown(pAC, IoC, Port);
2168
2169                 SkGmPhyRead(pAC, IoC, Port, PHY_MARV_AUNE_ADV, &Word);
2170
2171                 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_CTRL,
2172                         ("AutoNeg.Adv: 0x%04X\n", Word));
2173                 
2174                 /* Set Auto-negotiation advertisement */
2175                 if (pPrt->PFlowCtrlMode == SK_FLOW_MODE_SYM_OR_REM) {
2176                         /* restore Asymmetric Pause bit */
2177                         SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV,
2178                                 (SK_U16)(Word | PHY_M_AN_ASP));
2179                 }
2180                 
2181                 Para.Para32[0] = (SK_U32)Port;
2182                 /* Signal to RLMT */
2183                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
2184         }
2185         
2186         if ((IStatus & PHY_M_IS_AN_ERROR) != 0) {
2187                 /* Auto-Negotiation Error */
2188                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E023, SKERR_SIRQ_E023MSG);
2189         }
2190         
2191         if ((IStatus & PHY_M_IS_FIFO_ERROR) != 0) {
2192                 /* FIFO Overflow/Underrun Error */
2193                 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_SIRQ_E024, SKERR_SIRQ_E024MSG);
2194         }
2195         
2196 }       /* SkPhyIsrGmac */
2197 #endif /* YUKON */
2198
2199
2200 #ifdef OTHER_PHY
2201 /******************************************************************************
2202  *
2203  *      SkPhyIsrLone() - PHY interrupt service routine
2204  *
2205  * Description: handles all interrupts from LONE PHY
2206  *
2207  * Returns: N/A
2208  */
2209 static void SkPhyIsrLone(
2210 SK_AC   *pAC,           /* Adapter Context */
2211 SK_IOC  IoC,            /* Io Context */
2212 int             Port,           /* Port Num = PHY Num */
2213 SK_U16  IStatus)        /* Interrupt Status */
2214 {
2215         SK_EVPARA       Para;
2216
2217         if (IStatus & (PHY_L_IS_DUP | PHY_L_IS_ISOL)) {
2218                 
2219                 SkHWLinkDown(pAC, IoC, Port);
2220
2221                 Para.Para32[0] = (SK_U32)Port;
2222                 /* Signal to RLMT */
2223                 SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_LINK_DOWN, Para);
2224         }
2225
2226 }       /* SkPhyIsrLone */
2227 #endif /* OTHER_PHY */
2228
2229 /* End of File */