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