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