]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/net/sk98lin/skgeinit.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[mirror_ubuntu-artful-kernel.git] / drivers / net / sk98lin / skgeinit.c
1 /******************************************************************************
2 *
3 * Name: skgeinit.c
4 * Project: Gigabit Ethernet Adapters, Common Modules
5 * Version: $Revision: 1.97 $
6 * Date: $Date: 2003/10/02 16:45:31 $
7 * Purpose: Contains functions to initialize the adapter
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 #include "h/skdrv1st.h"
26 #include "h/skdrv2nd.h"
27
28 /* global variables ***********************************************************/
29
30 /* local variables ************************************************************/
31
32 #if (defined(DEBUG) || ((!defined(LINT)) && (!defined(SK_SLIM))))
33 static const char SysKonnectFileId[] =
34 "@(#) $Id: skgeinit.c,v 1.97 2003/10/02 16:45:31 rschmidt Exp $ (C) Marvell.";
35 #endif
36
37 struct s_QOffTab {
38 int RxQOff; /* Receive Queue Address Offset */
39 int XsQOff; /* Sync Tx Queue Address Offset */
40 int XaQOff; /* Async Tx Queue Address Offset */
41 };
42 static struct s_QOffTab QOffTab[] = {
43 {Q_R1, Q_XS1, Q_XA1}, {Q_R2, Q_XS2, Q_XA2}
44 };
45
46 struct s_Config {
47 char ScanString[8];
48 SK_U32 Value;
49 };
50
51 static struct s_Config OemConfig = {
52 {'O','E','M','_','C','o','n','f'},
53 #ifdef SK_OEM_CONFIG
54 OEM_CONFIG_VALUE,
55 #else
56 0,
57 #endif
58 };
59
60 /******************************************************************************
61 *
62 * SkGePollRxD() - Enable / Disable Descriptor Polling of RxD Ring
63 *
64 * Description:
65 * Enable or disable the descriptor polling of the receive descriptor
66 * ring (RxD) for port 'Port'.
67 * The new configuration is *not* saved over any SkGeStopPort() and
68 * SkGeInitPort() calls.
69 *
70 * Returns:
71 * nothing
72 */
73 void SkGePollRxD(
74 SK_AC *pAC, /* adapter context */
75 SK_IOC IoC, /* IO context */
76 int Port, /* Port Index (MAC_1 + n) */
77 SK_BOOL PollRxD) /* SK_TRUE (enable pol.), SK_FALSE (disable pol.) */
78 {
79 SK_GEPORT *pPrt;
80
81 pPrt = &pAC->GIni.GP[Port];
82
83 SK_OUT32(IoC, Q_ADDR(pPrt->PRxQOff, Q_CSR), (PollRxD) ?
84 CSR_ENA_POL : CSR_DIS_POL);
85 } /* SkGePollRxD */
86
87
88 /******************************************************************************
89 *
90 * SkGePollTxD() - Enable / Disable Descriptor Polling of TxD Rings
91 *
92 * Description:
93 * Enable or disable the descriptor polling of the transmit descriptor
94 * ring(s) (TxD) for port 'Port'.
95 * The new configuration is *not* saved over any SkGeStopPort() and
96 * SkGeInitPort() calls.
97 *
98 * Returns:
99 * nothing
100 */
101 void SkGePollTxD(
102 SK_AC *pAC, /* adapter context */
103 SK_IOC IoC, /* IO context */
104 int Port, /* Port Index (MAC_1 + n) */
105 SK_BOOL PollTxD) /* SK_TRUE (enable pol.), SK_FALSE (disable pol.) */
106 {
107 SK_GEPORT *pPrt;
108 SK_U32 DWord;
109
110 pPrt = &pAC->GIni.GP[Port];
111
112 DWord = (SK_U32)(PollTxD ? CSR_ENA_POL : CSR_DIS_POL);
113
114 if (pPrt->PXSQSize != 0) {
115 SK_OUT32(IoC, Q_ADDR(pPrt->PXsQOff, Q_CSR), DWord);
116 }
117
118 if (pPrt->PXAQSize != 0) {
119 SK_OUT32(IoC, Q_ADDR(pPrt->PXaQOff, Q_CSR), DWord);
120 }
121 } /* SkGePollTxD */
122
123
124 /******************************************************************************
125 *
126 * SkGeYellowLED() - Switch the yellow LED on or off.
127 *
128 * Description:
129 * Switch the yellow LED on or off.
130 *
131 * Note:
132 * This function may be called any time after SkGeInit(Level 1).
133 *
134 * Returns:
135 * nothing
136 */
137 void SkGeYellowLED(
138 SK_AC *pAC, /* adapter context */
139 SK_IOC IoC, /* IO context */
140 int State) /* yellow LED state, 0 = OFF, 0 != ON */
141 {
142 if (State == 0) {
143 /* Switch yellow LED OFF */
144 SK_OUT8(IoC, B0_LED, LED_STAT_OFF);
145 }
146 else {
147 /* Switch yellow LED ON */
148 SK_OUT8(IoC, B0_LED, LED_STAT_ON);
149 }
150 } /* SkGeYellowLED */
151
152
153 #if (!defined(SK_SLIM) || defined(GENESIS))
154 /******************************************************************************
155 *
156 * SkGeXmitLED() - Modify the Operational Mode of a transmission LED.
157 *
158 * Description:
159 * The Rx or Tx LED which is specified by 'Led' will be
160 * enabled, disabled or switched on in test mode.
161 *
162 * Note:
163 * 'Led' must contain the address offset of the LEDs INI register.
164 *
165 * Usage:
166 * SkGeXmitLED(pAC, IoC, MR_ADDR(Port, TX_LED_INI), SK_LED_ENA);
167 *
168 * Returns:
169 * nothing
170 */
171 void SkGeXmitLED(
172 SK_AC *pAC, /* adapter context */
173 SK_IOC IoC, /* IO context */
174 int Led, /* offset to the LED Init Value register */
175 int Mode) /* Mode may be SK_LED_DIS, SK_LED_ENA, SK_LED_TST */
176 {
177 SK_U32 LedIni;
178
179 switch (Mode) {
180 case SK_LED_ENA:
181 LedIni = SK_XMIT_DUR * (SK_U32)pAC->GIni.GIHstClkFact / 100;
182 SK_OUT32(IoC, Led + XMIT_LED_INI, LedIni);
183 SK_OUT8(IoC, Led + XMIT_LED_CTRL, LED_START);
184 break;
185 case SK_LED_TST:
186 SK_OUT8(IoC, Led + XMIT_LED_TST, LED_T_ON);
187 SK_OUT32(IoC, Led + XMIT_LED_CNT, 100);
188 SK_OUT8(IoC, Led + XMIT_LED_CTRL, LED_START);
189 break;
190 case SK_LED_DIS:
191 default:
192 /*
193 * Do NOT stop the LED Timer here. The LED might be
194 * in on state. But it needs to go off.
195 */
196 SK_OUT32(IoC, Led + XMIT_LED_CNT, 0);
197 SK_OUT8(IoC, Led + XMIT_LED_TST, LED_T_OFF);
198 break;
199 }
200
201 /*
202 * 1000BT: The Transmit LED is driven by the PHY.
203 * But the default LED configuration is used for
204 * Level One and Broadcom PHYs.
205 * (Broadcom: It may be that PHY_B_PEC_EN_LTR has to be set.)
206 * (In this case it has to be added here. But we will see. XXX)
207 */
208 } /* SkGeXmitLED */
209 #endif /* !SK_SLIM || GENESIS */
210
211
212 /******************************************************************************
213 *
214 * DoCalcAddr() - Calculates the start and the end address of a queue.
215 *
216 * Description:
217 * This function calculates the start and the end address of a queue.
218 * Afterwards the 'StartVal' is incremented to the next start position.
219 * If the port is already initialized the calculated values
220 * will be checked against the configured values and an
221 * error will be returned, if they are not equal.
222 * If the port is not initialized the values will be written to
223 * *StartAdr and *EndAddr.
224 *
225 * Returns:
226 * 0: success
227 * 1: configuration error
228 */
229 static int DoCalcAddr(
230 SK_AC *pAC, /* adapter context */
231 SK_GEPORT SK_FAR *pPrt, /* port index */
232 int QuSize, /* size of the queue to configure in kB */
233 SK_U32 SK_FAR *StartVal, /* start value for address calculation */
234 SK_U32 SK_FAR *QuStartAddr,/* start addr to calculate */
235 SK_U32 SK_FAR *QuEndAddr) /* end address to calculate */
236 {
237 SK_U32 EndVal;
238 SK_U32 NextStart;
239 int Rtv;
240
241 Rtv = 0;
242 if (QuSize == 0) {
243 EndVal = *StartVal;
244 NextStart = EndVal;
245 }
246 else {
247 EndVal = *StartVal + ((SK_U32)QuSize * 1024) - 1;
248 NextStart = EndVal + 1;
249 }
250
251 if (pPrt->PState >= SK_PRT_INIT) {
252 if (*StartVal != *QuStartAddr || EndVal != *QuEndAddr) {
253 Rtv = 1;
254 }
255 }
256 else {
257 *QuStartAddr = *StartVal;
258 *QuEndAddr = EndVal;
259 }
260
261 *StartVal = NextStart;
262 return(Rtv);
263 } /* DoCalcAddr */
264
265 /******************************************************************************
266 *
267 * SkGeInitAssignRamToQueues() - allocate default queue sizes
268 *
269 * Description:
270 * This function assigns the memory to the different queues and ports.
271 * When DualNet is set to SK_TRUE all ports get the same amount of memory.
272 * Otherwise the first port gets most of the memory and all the
273 * other ports just the required minimum.
274 * This function can only be called when pAC->GIni.GIRamSize and
275 * pAC->GIni.GIMacsFound have been initialized, usually this happens
276 * at init level 1
277 *
278 * Returns:
279 * 0 - ok
280 * 1 - invalid input values
281 * 2 - not enough memory
282 */
283
284 int SkGeInitAssignRamToQueues(
285 SK_AC *pAC, /* Adapter context */
286 int ActivePort, /* Active Port in RLMT mode */
287 SK_BOOL DualNet) /* adapter context */
288 {
289 int i;
290 int UsedKilobytes; /* memory already assigned */
291 int ActivePortKilobytes; /* memory available for active port */
292 SK_GEPORT *pGePort;
293
294 UsedKilobytes = 0;
295
296 if (ActivePort >= pAC->GIni.GIMacsFound) {
297 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_INIT,
298 ("SkGeInitAssignRamToQueues: ActivePort (%d) invalid\n",
299 ActivePort));
300 return(1);
301 }
302 if (((pAC->GIni.GIMacsFound * (SK_MIN_RXQ_SIZE + SK_MIN_TXQ_SIZE)) +
303 ((RAM_QUOTA_SYNC == 0) ? 0 : SK_MIN_TXQ_SIZE)) > pAC->GIni.GIRamSize) {
304 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_INIT,
305 ("SkGeInitAssignRamToQueues: Not enough memory (%d)\n",
306 pAC->GIni.GIRamSize));
307 return(2);
308 }
309
310 if (DualNet) {
311 /* every port gets the same amount of memory */
312 ActivePortKilobytes = pAC->GIni.GIRamSize / pAC->GIni.GIMacsFound;
313 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
314
315 pGePort = &pAC->GIni.GP[i];
316
317 /* take away the minimum memory for active queues */
318 ActivePortKilobytes -= (SK_MIN_RXQ_SIZE + SK_MIN_TXQ_SIZE);
319
320 /* receive queue gets the minimum + 80% of the rest */
321 pGePort->PRxQSize = (int) (ROUND_QUEUE_SIZE_KB((
322 ActivePortKilobytes * (unsigned long) RAM_QUOTA_RX) / 100))
323 + SK_MIN_RXQ_SIZE;
324
325 ActivePortKilobytes -= (pGePort->PRxQSize - SK_MIN_RXQ_SIZE);
326
327 /* synchronous transmit queue */
328 pGePort->PXSQSize = 0;
329
330 /* asynchronous transmit queue */
331 pGePort->PXAQSize = (int) ROUND_QUEUE_SIZE_KB(ActivePortKilobytes +
332 SK_MIN_TXQ_SIZE);
333 }
334 }
335 else {
336 /* Rlmt Mode or single link adapter */
337
338 /* Set standby queue size defaults for all standby ports */
339 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
340
341 if (i != ActivePort) {
342 pGePort = &pAC->GIni.GP[i];
343
344 pGePort->PRxQSize = SK_MIN_RXQ_SIZE;
345 pGePort->PXAQSize = SK_MIN_TXQ_SIZE;
346 pGePort->PXSQSize = 0;
347
348 /* Count used RAM */
349 UsedKilobytes += pGePort->PRxQSize + pGePort->PXAQSize;
350 }
351 }
352 /* what's left? */
353 ActivePortKilobytes = pAC->GIni.GIRamSize - UsedKilobytes;
354
355 /* assign it to the active port */
356 /* first take away the minimum memory */
357 ActivePortKilobytes -= (SK_MIN_RXQ_SIZE + SK_MIN_TXQ_SIZE);
358 pGePort = &pAC->GIni.GP[ActivePort];
359
360 /* receive queue get's the minimum + 80% of the rest */
361 pGePort->PRxQSize = (int) (ROUND_QUEUE_SIZE_KB((ActivePortKilobytes *
362 (unsigned long) RAM_QUOTA_RX) / 100)) + SK_MIN_RXQ_SIZE;
363
364 ActivePortKilobytes -= (pGePort->PRxQSize - SK_MIN_RXQ_SIZE);
365
366 /* synchronous transmit queue */
367 pGePort->PXSQSize = 0;
368
369 /* asynchronous transmit queue */
370 pGePort->PXAQSize = (int) ROUND_QUEUE_SIZE_KB(ActivePortKilobytes) +
371 SK_MIN_TXQ_SIZE;
372 }
373 #ifdef VCPU
374 VCPUprintf(0, "PRxQSize=%u, PXSQSize=%u, PXAQSize=%u\n",
375 pGePort->PRxQSize, pGePort->PXSQSize, pGePort->PXAQSize);
376 #endif /* VCPU */
377
378 return(0);
379 } /* SkGeInitAssignRamToQueues */
380
381 /******************************************************************************
382 *
383 * SkGeCheckQSize() - Checks the Adapters Queue Size Configuration
384 *
385 * Description:
386 * This function verifies the Queue Size Configuration specified
387 * in the variables PRxQSize, PXSQSize, and PXAQSize of all
388 * used ports.
389 * This requirements must be fullfilled to have a valid configuration:
390 * - The size of all queues must not exceed GIRamSize.
391 * - The queue sizes must be specified in units of 8 kB.
392 * - The size of Rx queues of available ports must not be
393 * smaller than 16 kB.
394 * - The size of at least one Tx queue (synch. or asynch.)
395 * of available ports must not be smaller than 16 kB
396 * when Jumbo Frames are used.
397 * - The RAM start and end addresses must not be changed
398 * for ports which are already initialized.
399 * Furthermore SkGeCheckQSize() defines the Start and End Addresses
400 * of all ports and stores them into the HWAC port structure.
401 *
402 * Returns:
403 * 0: Queue Size Configuration valid
404 * 1: Queue Size Configuration invalid
405 */
406 static int SkGeCheckQSize(
407 SK_AC *pAC, /* adapter context */
408 int Port) /* port index */
409 {
410 SK_GEPORT *pPrt;
411 int i;
412 int Rtv;
413 int Rtv2;
414 SK_U32 StartAddr;
415 #ifndef SK_SLIM
416 int UsedMem; /* total memory used (max. found ports) */
417 #endif
418
419 Rtv = 0;
420
421 #ifndef SK_SLIM
422
423 UsedMem = 0;
424 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
425 pPrt = &pAC->GIni.GP[i];
426
427 if ((pPrt->PRxQSize & QZ_UNITS) != 0 ||
428 (pPrt->PXSQSize & QZ_UNITS) != 0 ||
429 (pPrt->PXAQSize & QZ_UNITS) != 0) {
430
431 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E012, SKERR_HWI_E012MSG);
432 return(1);
433 }
434
435 if (i == Port && pPrt->PRxQSize < SK_MIN_RXQ_SIZE) {
436 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E011, SKERR_HWI_E011MSG);
437 return(1);
438 }
439
440 /*
441 * the size of at least one Tx queue (synch. or asynch.) has to be > 0.
442 * if Jumbo Frames are used, this size has to be >= 16 kB.
443 */
444 if ((i == Port && pPrt->PXSQSize == 0 && pPrt->PXAQSize == 0) ||
445 (pAC->GIni.GIPortUsage == SK_JUMBO_LINK &&
446 ((pPrt->PXSQSize > 0 && pPrt->PXSQSize < SK_MIN_TXQ_SIZE) ||
447 (pPrt->PXAQSize > 0 && pPrt->PXAQSize < SK_MIN_TXQ_SIZE)))) {
448 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E023, SKERR_HWI_E023MSG);
449 return(1);
450 }
451
452 UsedMem += pPrt->PRxQSize + pPrt->PXSQSize + pPrt->PXAQSize;
453 }
454
455 if (UsedMem > pAC->GIni.GIRamSize) {
456 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E012, SKERR_HWI_E012MSG);
457 return(1);
458 }
459 #endif /* !SK_SLIM */
460
461 /* Now start address calculation */
462 StartAddr = pAC->GIni.GIRamOffs;
463 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
464 pPrt = &pAC->GIni.GP[i];
465
466 /* Calculate/Check values for the receive queue */
467 Rtv2 = DoCalcAddr(pAC, pPrt, pPrt->PRxQSize, &StartAddr,
468 &pPrt->PRxQRamStart, &pPrt->PRxQRamEnd);
469 Rtv |= Rtv2;
470
471 /* Calculate/Check values for the synchronous Tx queue */
472 Rtv2 = DoCalcAddr(pAC, pPrt, pPrt->PXSQSize, &StartAddr,
473 &pPrt->PXsQRamStart, &pPrt->PXsQRamEnd);
474 Rtv |= Rtv2;
475
476 /* Calculate/Check values for the asynchronous Tx queue */
477 Rtv2 = DoCalcAddr(pAC, pPrt, pPrt->PXAQSize, &StartAddr,
478 &pPrt->PXaQRamStart, &pPrt->PXaQRamEnd);
479 Rtv |= Rtv2;
480
481 if (Rtv) {
482 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E013, SKERR_HWI_E013MSG);
483 return(1);
484 }
485 }
486
487 return(0);
488 } /* SkGeCheckQSize */
489
490
491 #ifdef GENESIS
492 /******************************************************************************
493 *
494 * SkGeInitMacArb() - Initialize the MAC Arbiter
495 *
496 * Description:
497 * This function initializes the MAC Arbiter.
498 * It must not be called if there is still an
499 * initialized or active port.
500 *
501 * Returns:
502 * nothing
503 */
504 static void SkGeInitMacArb(
505 SK_AC *pAC, /* adapter context */
506 SK_IOC IoC) /* IO context */
507 {
508 /* release local reset */
509 SK_OUT16(IoC, B3_MA_TO_CTRL, MA_RST_CLR);
510
511 /* configure timeout values */
512 SK_OUT8(IoC, B3_MA_TOINI_RX1, SK_MAC_TO_53);
513 SK_OUT8(IoC, B3_MA_TOINI_RX2, SK_MAC_TO_53);
514 SK_OUT8(IoC, B3_MA_TOINI_TX1, SK_MAC_TO_53);
515 SK_OUT8(IoC, B3_MA_TOINI_TX2, SK_MAC_TO_53);
516
517 SK_OUT8(IoC, B3_MA_RCINI_RX1, 0);
518 SK_OUT8(IoC, B3_MA_RCINI_RX2, 0);
519 SK_OUT8(IoC, B3_MA_RCINI_TX1, 0);
520 SK_OUT8(IoC, B3_MA_RCINI_TX2, 0);
521
522 /* recovery values are needed for XMAC II Rev. B2 only */
523 /* Fast Output Enable Mode was intended to use with Rev. B2, but now? */
524
525 /*
526 * There is no start or enable button to push, therefore
527 * the MAC arbiter is configured and enabled now.
528 */
529 } /* SkGeInitMacArb */
530
531
532 /******************************************************************************
533 *
534 * SkGeInitPktArb() - Initialize the Packet Arbiter
535 *
536 * Description:
537 * This function initializes the Packet Arbiter.
538 * It must not be called if there is still an
539 * initialized or active port.
540 *
541 * Returns:
542 * nothing
543 */
544 static void SkGeInitPktArb(
545 SK_AC *pAC, /* adapter context */
546 SK_IOC IoC) /* IO context */
547 {
548 /* release local reset */
549 SK_OUT16(IoC, B3_PA_CTRL, PA_RST_CLR);
550
551 /* configure timeout values */
552 SK_OUT16(IoC, B3_PA_TOINI_RX1, SK_PKT_TO_MAX);
553 SK_OUT16(IoC, B3_PA_TOINI_RX2, SK_PKT_TO_MAX);
554 SK_OUT16(IoC, B3_PA_TOINI_TX1, SK_PKT_TO_MAX);
555 SK_OUT16(IoC, B3_PA_TOINI_TX2, SK_PKT_TO_MAX);
556
557 /*
558 * enable timeout timers if jumbo frames not used
559 * NOTE: the packet arbiter timeout interrupt is needed for
560 * half duplex hangup workaround
561 */
562 if (pAC->GIni.GIPortUsage != SK_JUMBO_LINK) {
563 if (pAC->GIni.GIMacsFound == 1) {
564 SK_OUT16(IoC, B3_PA_CTRL, PA_ENA_TO_TX1);
565 }
566 else {
567 SK_OUT16(IoC, B3_PA_CTRL, PA_ENA_TO_TX1 | PA_ENA_TO_TX2);
568 }
569 }
570 } /* SkGeInitPktArb */
571 #endif /* GENESIS */
572
573
574 /******************************************************************************
575 *
576 * SkGeInitMacFifo() - Initialize the MAC FIFOs
577 *
578 * Description:
579 * Initialize all MAC FIFOs of the specified port
580 *
581 * Returns:
582 * nothing
583 */
584 static void SkGeInitMacFifo(
585 SK_AC *pAC, /* adapter context */
586 SK_IOC IoC, /* IO context */
587 int Port) /* Port Index (MAC_1 + n) */
588 {
589 SK_U16 Word;
590 #ifdef VCPU
591 SK_U32 DWord;
592 #endif /* VCPU */
593 /*
594 * For each FIFO:
595 * - release local reset
596 * - use default value for MAC FIFO size
597 * - setup defaults for the control register
598 * - enable the FIFO
599 */
600
601 #ifdef GENESIS
602 if (pAC->GIni.GIGenesis) {
603 /* Configure Rx MAC FIFO */
604 SK_OUT8(IoC, MR_ADDR(Port, RX_MFF_CTRL2), MFF_RST_CLR);
605 SK_OUT16(IoC, MR_ADDR(Port, RX_MFF_CTRL1), MFF_RX_CTRL_DEF);
606 SK_OUT8(IoC, MR_ADDR(Port, RX_MFF_CTRL2), MFF_ENA_OP_MD);
607
608 /* Configure Tx MAC FIFO */
609 SK_OUT8(IoC, MR_ADDR(Port, TX_MFF_CTRL2), MFF_RST_CLR);
610 SK_OUT16(IoC, MR_ADDR(Port, TX_MFF_CTRL1), MFF_TX_CTRL_DEF);
611 SK_OUT8(IoC, MR_ADDR(Port, TX_MFF_CTRL2), MFF_ENA_OP_MD);
612
613 /* Enable frame flushing if jumbo frames used */
614 if (pAC->GIni.GIPortUsage == SK_JUMBO_LINK) {
615 SK_OUT16(IoC, MR_ADDR(Port, RX_MFF_CTRL1), MFF_ENA_FLUSH);
616 }
617 }
618 #endif /* GENESIS */
619
620 #ifdef YUKON
621 if (pAC->GIni.GIYukon) {
622 /* set Rx GMAC FIFO Flush Mask */
623 SK_OUT16(IoC, MR_ADDR(Port, RX_GMF_FL_MSK), (SK_U16)RX_FF_FL_DEF_MSK);
624
625 Word = (SK_U16)GMF_RX_CTRL_DEF;
626
627 /* disable Rx GMAC FIFO Flush for YUKON-Lite Rev. A0 only */
628 if (pAC->GIni.GIYukonLite && pAC->GIni.GIChipId == CHIP_ID_YUKON) {
629
630 Word &= ~GMF_RX_F_FL_ON;
631 }
632
633 /* Configure Rx MAC FIFO */
634 SK_OUT8(IoC, MR_ADDR(Port, RX_GMF_CTRL_T), (SK_U8)GMF_RST_CLR);
635 SK_OUT16(IoC, MR_ADDR(Port, RX_GMF_CTRL_T), Word);
636
637 /* set Rx GMAC FIFO Flush Threshold (default: 0x0a -> 56 bytes) */
638 SK_OUT16(IoC, MR_ADDR(Port, RX_GMF_FL_THR), RX_GMF_FL_THR_DEF);
639
640 /* Configure Tx MAC FIFO */
641 SK_OUT8(IoC, MR_ADDR(Port, TX_GMF_CTRL_T), (SK_U8)GMF_RST_CLR);
642 SK_OUT16(IoC, MR_ADDR(Port, TX_GMF_CTRL_T), (SK_U16)GMF_TX_CTRL_DEF);
643
644 #ifdef VCPU
645 SK_IN32(IoC, MR_ADDR(Port, RX_GMF_AF_THR), &DWord);
646 SK_IN32(IoC, MR_ADDR(Port, TX_GMF_AE_THR), &DWord);
647 #endif /* VCPU */
648
649 /* set Tx GMAC FIFO Almost Empty Threshold */
650 /* SK_OUT32(IoC, MR_ADDR(Port, TX_GMF_AE_THR), 0); */
651 }
652 #endif /* YUKON */
653
654 } /* SkGeInitMacFifo */
655
656 #ifdef SK_LNK_SYNC_CNT
657 /******************************************************************************
658 *
659 * SkGeLoadLnkSyncCnt() - Load the Link Sync Counter and starts counting
660 *
661 * Description:
662 * This function starts the Link Sync Counter of the specified
663 * port and enables the generation of an Link Sync IRQ.
664 * The Link Sync Counter may be used to detect an active link,
665 * if autonegotiation is not used.
666 *
667 * Note:
668 * o To ensure receiving the Link Sync Event the LinkSyncCounter
669 * should be initialized BEFORE clearing the XMAC's reset!
670 * o Enable IS_LNK_SYNC_M1 and IS_LNK_SYNC_M2 after calling this
671 * function.
672 *
673 * Returns:
674 * nothing
675 */
676 void SkGeLoadLnkSyncCnt(
677 SK_AC *pAC, /* adapter context */
678 SK_IOC IoC, /* IO context */
679 int Port, /* Port Index (MAC_1 + n) */
680 SK_U32 CntVal) /* Counter value */
681 {
682 SK_U32 OrgIMsk;
683 SK_U32 NewIMsk;
684 SK_U32 ISrc;
685 SK_BOOL IrqPend;
686
687 /* stop counter */
688 SK_OUT8(IoC, MR_ADDR(Port, LNK_SYNC_CTRL), LED_STOP);
689
690 /*
691 * ASIC problem:
692 * Each time starting the Link Sync Counter an IRQ is generated
693 * by the adapter. See problem report entry from 21.07.98
694 *
695 * Workaround: Disable Link Sync IRQ and clear the unexpeced IRQ
696 * if no IRQ is already pending.
697 */
698 IrqPend = SK_FALSE;
699 SK_IN32(IoC, B0_ISRC, &ISrc);
700 SK_IN32(IoC, B0_IMSK, &OrgIMsk);
701 if (Port == MAC_1) {
702 NewIMsk = OrgIMsk & ~IS_LNK_SYNC_M1;
703 if ((ISrc & IS_LNK_SYNC_M1) != 0) {
704 IrqPend = SK_TRUE;
705 }
706 }
707 else {
708 NewIMsk = OrgIMsk & ~IS_LNK_SYNC_M2;
709 if ((ISrc & IS_LNK_SYNC_M2) != 0) {
710 IrqPend = SK_TRUE;
711 }
712 }
713 if (!IrqPend) {
714 SK_OUT32(IoC, B0_IMSK, NewIMsk);
715 }
716
717 /* load counter */
718 SK_OUT32(IoC, MR_ADDR(Port, LNK_SYNC_INI), CntVal);
719
720 /* start counter */
721 SK_OUT8(IoC, MR_ADDR(Port, LNK_SYNC_CTRL), LED_START);
722
723 if (!IrqPend) {
724 /* clear the unexpected IRQ, and restore the interrupt mask */
725 SK_OUT8(IoC, MR_ADDR(Port, LNK_SYNC_CTRL), LED_CLR_IRQ);
726 SK_OUT32(IoC, B0_IMSK, OrgIMsk);
727 }
728 } /* SkGeLoadLnkSyncCnt*/
729 #endif /* SK_LNK_SYNC_CNT */
730
731 #if defined(SK_DIAG) || defined(SK_CFG_SYNC)
732 /******************************************************************************
733 *
734 * SkGeCfgSync() - Configure synchronous bandwidth for this port.
735 *
736 * Description:
737 * This function may be used to configure synchronous bandwidth
738 * to the specified port. This may be done any time after
739 * initializing the port. The configuration values are NOT saved
740 * in the HWAC port structure and will be overwritten any
741 * time when stopping and starting the port.
742 * Any values for the synchronous configuration will be ignored
743 * if the size of the synchronous queue is zero!
744 *
745 * The default configuration for the synchronous service is
746 * TXA_ENA_FSYNC. This means if the size of
747 * the synchronous queue is unequal zero but no specific
748 * synchronous bandwidth is configured, the synchronous queue
749 * will always have the 'unlimited' transmit priority!
750 *
751 * This mode will be restored if the synchronous bandwidth is
752 * deallocated ('IntTime' = 0 and 'LimCount' = 0).
753 *
754 * Returns:
755 * 0: success
756 * 1: parameter configuration error
757 * 2: try to configure quality of service although no
758 * synchronous queue is configured
759 */
760 int SkGeCfgSync(
761 SK_AC *pAC, /* adapter context */
762 SK_IOC IoC, /* IO context */
763 int Port, /* Port Index (MAC_1 + n) */
764 SK_U32 IntTime, /* Interval Timer Value in units of 8ns */
765 SK_U32 LimCount, /* Number of bytes to transfer during IntTime */
766 int SyncMode) /* Sync Mode: TXA_ENA_ALLOC | TXA_DIS_ALLOC | 0 */
767 {
768 int Rtv;
769
770 Rtv = 0;
771
772 /* check the parameters */
773 if (LimCount > IntTime ||
774 (LimCount == 0 && IntTime != 0) ||
775 (LimCount != 0 && IntTime == 0)) {
776
777 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E010, SKERR_HWI_E010MSG);
778 return(1);
779 }
780
781 if (pAC->GIni.GP[Port].PXSQSize == 0) {
782 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E009, SKERR_HWI_E009MSG);
783 return(2);
784 }
785
786 /* calculate register values */
787 IntTime = (IntTime / 2) * pAC->GIni.GIHstClkFact / 100;
788 LimCount = LimCount / 8;
789
790 if (IntTime > TXA_MAX_VAL || LimCount > TXA_MAX_VAL) {
791 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E010, SKERR_HWI_E010MSG);
792 return(1);
793 }
794
795 /*
796 * - Enable 'Force Sync' to ensure the synchronous queue
797 * has the priority while configuring the new values.
798 * - Also 'disable alloc' to ensure the settings complies
799 * to the SyncMode parameter.
800 * - Disable 'Rate Control' to configure the new values.
801 * - write IntTime and LimCount
802 * - start 'Rate Control' and disable 'Force Sync'
803 * if Interval Timer or Limit Counter not zero.
804 */
805 SK_OUT8(IoC, MR_ADDR(Port, TXA_CTRL),
806 TXA_ENA_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC);
807
808 SK_OUT32(IoC, MR_ADDR(Port, TXA_ITI_INI), IntTime);
809 SK_OUT32(IoC, MR_ADDR(Port, TXA_LIM_INI), LimCount);
810
811 SK_OUT8(IoC, MR_ADDR(Port, TXA_CTRL),
812 (SK_U8)(SyncMode & (TXA_ENA_ALLOC | TXA_DIS_ALLOC)));
813
814 if (IntTime != 0 || LimCount != 0) {
815 SK_OUT8(IoC, MR_ADDR(Port, TXA_CTRL), TXA_DIS_FSYNC | TXA_START_RC);
816 }
817
818 return(0);
819 } /* SkGeCfgSync */
820 #endif /* SK_DIAG || SK_CFG_SYNC*/
821
822
823 /******************************************************************************
824 *
825 * DoInitRamQueue() - Initialize the RAM Buffer Address of a single Queue
826 *
827 * Desccription:
828 * If the queue is used, enable and initialize it.
829 * Make sure the queue is still reset, if it is not used.
830 *
831 * Returns:
832 * nothing
833 */
834 static void DoInitRamQueue(
835 SK_AC *pAC, /* adapter context */
836 SK_IOC IoC, /* IO context */
837 int QuIoOffs, /* Queue IO Address Offset */
838 SK_U32 QuStartAddr, /* Queue Start Address */
839 SK_U32 QuEndAddr, /* Queue End Address */
840 int QuType) /* Queue Type (SK_RX_SRAM_Q|SK_RX_BRAM_Q|SK_TX_RAM_Q) */
841 {
842 SK_U32 RxUpThresVal;
843 SK_U32 RxLoThresVal;
844
845 if (QuStartAddr != QuEndAddr) {
846 /* calculate thresholds, assume we have a big Rx queue */
847 RxUpThresVal = (QuEndAddr + 1 - QuStartAddr - SK_RB_ULPP) / 8;
848 RxLoThresVal = (QuEndAddr + 1 - QuStartAddr - SK_RB_LLPP_B)/8;
849
850 /* build HW address format */
851 QuStartAddr = QuStartAddr / 8;
852 QuEndAddr = QuEndAddr / 8;
853
854 /* release local reset */
855 SK_OUT8(IoC, RB_ADDR(QuIoOffs, RB_CTRL), RB_RST_CLR);
856
857 /* configure addresses */
858 SK_OUT32(IoC, RB_ADDR(QuIoOffs, RB_START), QuStartAddr);
859 SK_OUT32(IoC, RB_ADDR(QuIoOffs, RB_END), QuEndAddr);
860 SK_OUT32(IoC, RB_ADDR(QuIoOffs, RB_WP), QuStartAddr);
861 SK_OUT32(IoC, RB_ADDR(QuIoOffs, RB_RP), QuStartAddr);
862
863 switch (QuType) {
864 case SK_RX_SRAM_Q:
865 /* configure threshold for small Rx Queue */
866 RxLoThresVal += (SK_RB_LLPP_B - SK_RB_LLPP_S) / 8;
867
868 /* continue with SK_RX_BRAM_Q */
869 case SK_RX_BRAM_Q:
870 /* write threshold for Rx Queue */
871
872 SK_OUT32(IoC, RB_ADDR(QuIoOffs, RB_RX_UTPP), RxUpThresVal);
873 SK_OUT32(IoC, RB_ADDR(QuIoOffs, RB_RX_LTPP), RxLoThresVal);
874
875 /* the high priority threshold not used */
876 break;
877 case SK_TX_RAM_Q:
878 /*
879 * Do NOT use Store & Forward under normal operation due to
880 * performance optimization (GENESIS only).
881 * But if Jumbo Frames are configured (XMAC Tx FIFO is only 4 kB)
882 * or YUKON is used ((GMAC Tx FIFO is only 1 kB)
883 * we NEED Store & Forward of the RAM buffer.
884 */
885 if (pAC->GIni.GIPortUsage == SK_JUMBO_LINK ||
886 pAC->GIni.GIYukon) {
887 /* enable Store & Forward Mode for the Tx Side */
888 SK_OUT8(IoC, RB_ADDR(QuIoOffs, RB_CTRL), RB_ENA_STFWD);
889 }
890 break;
891 }
892
893 /* set queue operational */
894 SK_OUT8(IoC, RB_ADDR(QuIoOffs, RB_CTRL), RB_ENA_OP_MD);
895 }
896 else {
897 /* ensure the queue is still disabled */
898 SK_OUT8(IoC, RB_ADDR(QuIoOffs, RB_CTRL), RB_RST_SET);
899 }
900 } /* DoInitRamQueue */
901
902
903 /******************************************************************************
904 *
905 * SkGeInitRamBufs() - Initialize the RAM Buffer Queues
906 *
907 * Description:
908 * Initialize all RAM Buffer Queues of the specified port
909 *
910 * Returns:
911 * nothing
912 */
913 static void SkGeInitRamBufs(
914 SK_AC *pAC, /* adapter context */
915 SK_IOC IoC, /* IO context */
916 int Port) /* Port Index (MAC_1 + n) */
917 {
918 SK_GEPORT *pPrt;
919 int RxQType;
920
921 pPrt = &pAC->GIni.GP[Port];
922
923 if (pPrt->PRxQSize == SK_MIN_RXQ_SIZE) {
924 RxQType = SK_RX_SRAM_Q; /* small Rx Queue */
925 }
926 else {
927 RxQType = SK_RX_BRAM_Q; /* big Rx Queue */
928 }
929
930 DoInitRamQueue(pAC, IoC, pPrt->PRxQOff, pPrt->PRxQRamStart,
931 pPrt->PRxQRamEnd, RxQType);
932
933 DoInitRamQueue(pAC, IoC, pPrt->PXsQOff, pPrt->PXsQRamStart,
934 pPrt->PXsQRamEnd, SK_TX_RAM_Q);
935
936 DoInitRamQueue(pAC, IoC, pPrt->PXaQOff, pPrt->PXaQRamStart,
937 pPrt->PXaQRamEnd, SK_TX_RAM_Q);
938
939 } /* SkGeInitRamBufs */
940
941
942 /******************************************************************************
943 *
944 * SkGeInitRamIface() - Initialize the RAM Interface
945 *
946 * Description:
947 * This function initializes the Adapters RAM Interface.
948 *
949 * Note:
950 * This function is used in the diagnostics.
951 *
952 * Returns:
953 * nothing
954 */
955 void SkGeInitRamIface(
956 SK_AC *pAC, /* adapter context */
957 SK_IOC IoC) /* IO context */
958 {
959 /* release local reset */
960 SK_OUT16(IoC, B3_RI_CTRL, RI_RST_CLR);
961
962 /* configure timeout values */
963 SK_OUT8(IoC, B3_RI_WTO_R1, SK_RI_TO_53);
964 SK_OUT8(IoC, B3_RI_WTO_XA1, SK_RI_TO_53);
965 SK_OUT8(IoC, B3_RI_WTO_XS1, SK_RI_TO_53);
966 SK_OUT8(IoC, B3_RI_RTO_R1, SK_RI_TO_53);
967 SK_OUT8(IoC, B3_RI_RTO_XA1, SK_RI_TO_53);
968 SK_OUT8(IoC, B3_RI_RTO_XS1, SK_RI_TO_53);
969 SK_OUT8(IoC, B3_RI_WTO_R2, SK_RI_TO_53);
970 SK_OUT8(IoC, B3_RI_WTO_XA2, SK_RI_TO_53);
971 SK_OUT8(IoC, B3_RI_WTO_XS2, SK_RI_TO_53);
972 SK_OUT8(IoC, B3_RI_RTO_R2, SK_RI_TO_53);
973 SK_OUT8(IoC, B3_RI_RTO_XA2, SK_RI_TO_53);
974 SK_OUT8(IoC, B3_RI_RTO_XS2, SK_RI_TO_53);
975
976 } /* SkGeInitRamIface */
977
978
979 /******************************************************************************
980 *
981 * SkGeInitBmu() - Initialize the BMU state machines
982 *
983 * Description:
984 * Initialize all BMU state machines of the specified port
985 *
986 * Returns:
987 * nothing
988 */
989 static void SkGeInitBmu(
990 SK_AC *pAC, /* adapter context */
991 SK_IOC IoC, /* IO context */
992 int Port) /* Port Index (MAC_1 + n) */
993 {
994 SK_GEPORT *pPrt;
995 SK_U32 RxWm;
996 SK_U32 TxWm;
997
998 pPrt = &pAC->GIni.GP[Port];
999
1000 RxWm = SK_BMU_RX_WM;
1001 TxWm = SK_BMU_TX_WM;
1002
1003 if (!pAC->GIni.GIPciSlot64 && !pAC->GIni.GIPciClock66) {
1004 /* for better performance */
1005 RxWm /= 2;
1006 TxWm /= 2;
1007 }
1008
1009 /* Rx Queue: Release all local resets and set the watermark */
1010 SK_OUT32(IoC, Q_ADDR(pPrt->PRxQOff, Q_CSR), CSR_CLR_RESET);
1011 SK_OUT32(IoC, Q_ADDR(pPrt->PRxQOff, Q_F), RxWm);
1012
1013 /*
1014 * Tx Queue: Release all local resets if the queue is used !
1015 * set watermark
1016 */
1017 if (pPrt->PXSQSize != 0) {
1018 SK_OUT32(IoC, Q_ADDR(pPrt->PXsQOff, Q_CSR), CSR_CLR_RESET);
1019 SK_OUT32(IoC, Q_ADDR(pPrt->PXsQOff, Q_F), TxWm);
1020 }
1021
1022 if (pPrt->PXAQSize != 0) {
1023 SK_OUT32(IoC, Q_ADDR(pPrt->PXaQOff, Q_CSR), CSR_CLR_RESET);
1024 SK_OUT32(IoC, Q_ADDR(pPrt->PXaQOff, Q_F), TxWm);
1025 }
1026 /*
1027 * Do NOT enable the descriptor poll timers here, because
1028 * the descriptor addresses are not specified yet.
1029 */
1030 } /* SkGeInitBmu */
1031
1032
1033 /******************************************************************************
1034 *
1035 * TestStopBit() - Test the stop bit of the queue
1036 *
1037 * Description:
1038 * Stopping a queue is not as simple as it seems to be.
1039 * If descriptor polling is enabled, it may happen
1040 * that RX/TX stop is done and SV idle is NOT set.
1041 * In this case we have to issue another stop command.
1042 *
1043 * Returns:
1044 * The queues control status register
1045 */
1046 static SK_U32 TestStopBit(
1047 SK_AC *pAC, /* Adapter Context */
1048 SK_IOC IoC, /* IO Context */
1049 int QuIoOffs) /* Queue IO Address Offset */
1050 {
1051 SK_U32 QuCsr; /* CSR contents */
1052
1053 SK_IN32(IoC, Q_ADDR(QuIoOffs, Q_CSR), &QuCsr);
1054
1055 if ((QuCsr & (CSR_STOP | CSR_SV_IDLE)) == 0) {
1056 /* Stop Descriptor overridden by start command */
1057 SK_OUT32(IoC, Q_ADDR(QuIoOffs, Q_CSR), CSR_STOP);
1058
1059 SK_IN32(IoC, Q_ADDR(QuIoOffs, Q_CSR), &QuCsr);
1060 }
1061
1062 return(QuCsr);
1063 } /* TestStopBit */
1064
1065
1066 /******************************************************************************
1067 *
1068 * SkGeStopPort() - Stop the Rx/Tx activity of the port 'Port'.
1069 *
1070 * Description:
1071 * After calling this function the descriptor rings and Rx and Tx
1072 * queues of this port may be reconfigured.
1073 *
1074 * It is possible to stop the receive and transmit path separate or
1075 * both together.
1076 *
1077 * Dir = SK_STOP_TX Stops the transmit path only and resets the MAC.
1078 * The receive queue is still active and
1079 * the pending Rx frames may be still transferred
1080 * into the RxD.
1081 * SK_STOP_RX Stop the receive path. The tansmit path
1082 * has to be stopped once before.
1083 * SK_STOP_ALL SK_STOP_TX + SK_STOP_RX
1084 *
1085 * RstMode = SK_SOFT_RST Resets the MAC. The PHY is still alive.
1086 * SK_HARD_RST Resets the MAC and the PHY.
1087 *
1088 * Example:
1089 * 1) A Link Down event was signaled for a port. Therefore the activity
1090 * of this port should be stopped and a hardware reset should be issued
1091 * to enable the workaround of XMAC Errata #2. But the received frames
1092 * should not be discarded.
1093 * ...
1094 * SkGeStopPort(pAC, IoC, Port, SK_STOP_TX, SK_HARD_RST);
1095 * (transfer all pending Rx frames)
1096 * SkGeStopPort(pAC, IoC, Port, SK_STOP_RX, SK_HARD_RST);
1097 * ...
1098 *
1099 * 2) An event was issued which request the driver to switch
1100 * the 'virtual active' link to an other already active port
1101 * as soon as possible. The frames in the receive queue of this
1102 * port may be lost. But the PHY must not be reset during this
1103 * event.
1104 * ...
1105 * SkGeStopPort(pAC, IoC, Port, SK_STOP_ALL, SK_SOFT_RST);
1106 * ...
1107 *
1108 * Extended Description:
1109 * If SK_STOP_TX is set,
1110 * o disable the MAC's receive and transmitter to prevent
1111 * from sending incomplete frames
1112 * o stop the port's transmit queues before terminating the
1113 * BMUs to prevent from performing incomplete PCI cycles
1114 * on the PCI bus
1115 * - The network Rx and Tx activity and PCI Tx transfer is
1116 * disabled now.
1117 * o reset the MAC depending on the RstMode
1118 * o Stop Interval Timer and Limit Counter of Tx Arbiter,
1119 * also disable Force Sync bit and Enable Alloc bit.
1120 * o perform a local reset of the port's Tx path
1121 * - reset the PCI FIFO of the async Tx queue
1122 * - reset the PCI FIFO of the sync Tx queue
1123 * - reset the RAM Buffer async Tx queue
1124 * - reset the RAM Buffer sync Tx queue
1125 * - reset the MAC Tx FIFO
1126 * o switch Link and Tx LED off, stop the LED counters
1127 *
1128 * If SK_STOP_RX is set,
1129 * o stop the port's receive queue
1130 * - The path data transfer activity is fully stopped now.
1131 * o perform a local reset of the port's Rx path
1132 * - reset the PCI FIFO of the Rx queue
1133 * - reset the RAM Buffer receive queue
1134 * - reset the MAC Rx FIFO
1135 * o switch Rx LED off, stop the LED counter
1136 *
1137 * If all ports are stopped,
1138 * o reset the RAM Interface.
1139 *
1140 * Notes:
1141 * o This function may be called during the driver states RESET_PORT and
1142 * SWITCH_PORT.
1143 */
1144 void SkGeStopPort(
1145 SK_AC *pAC, /* adapter context */
1146 SK_IOC IoC, /* I/O context */
1147 int Port, /* port to stop (MAC_1 + n) */
1148 int Dir, /* Direction to Stop (SK_STOP_RX, SK_STOP_TX, SK_STOP_ALL) */
1149 int RstMode)/* Reset Mode (SK_SOFT_RST, SK_HARD_RST) */
1150 {
1151 #ifndef SK_DIAG
1152 SK_EVPARA Para;
1153 #endif /* !SK_DIAG */
1154 SK_GEPORT *pPrt;
1155 SK_U32 DWord;
1156 SK_U32 XsCsr;
1157 SK_U32 XaCsr;
1158 SK_U64 ToutStart;
1159 int i;
1160 int ToutCnt;
1161
1162 pPrt = &pAC->GIni.GP[Port];
1163
1164 if ((Dir & SK_STOP_TX) != 0) {
1165 /* disable receiver and transmitter */
1166 SkMacRxTxDisable(pAC, IoC, Port);
1167
1168 /* stop both transmit queues */
1169 /*
1170 * If the BMU is in the reset state CSR_STOP will terminate
1171 * immediately.
1172 */
1173 SK_OUT32(IoC, Q_ADDR(pPrt->PXsQOff, Q_CSR), CSR_STOP);
1174 SK_OUT32(IoC, Q_ADDR(pPrt->PXaQOff, Q_CSR), CSR_STOP);
1175
1176 ToutStart = SkOsGetTime(pAC);
1177 ToutCnt = 0;
1178 do {
1179 /*
1180 * Clear packet arbiter timeout to make sure
1181 * this loop will terminate.
1182 */
1183 SK_OUT16(IoC, B3_PA_CTRL, (SK_U16)((Port == MAC_1) ?
1184 PA_CLR_TO_TX1 : PA_CLR_TO_TX2));
1185
1186 /*
1187 * If the transfer stucks at the MAC the STOP command will not
1188 * terminate if we don't flush the XMAC's transmit FIFO !
1189 */
1190 SkMacFlushTxFifo(pAC, IoC, Port);
1191
1192 XsCsr = TestStopBit(pAC, IoC, pPrt->PXsQOff);
1193 XaCsr = TestStopBit(pAC, IoC, pPrt->PXaQOff);
1194
1195 if (SkOsGetTime(pAC) - ToutStart > (SK_TICKS_PER_SEC / 18)) {
1196 /*
1197 * Timeout of 1/18 second reached.
1198 * This needs to be checked at 1/18 sec only.
1199 */
1200 ToutCnt++;
1201 if (ToutCnt > 1) {
1202 /* Might be a problem when the driver event handler
1203 * calls StopPort again. XXX.
1204 */
1205
1206 /* Fatal Error, Loop aborted */
1207 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_HWI_E018,
1208 SKERR_HWI_E018MSG);
1209 #ifndef SK_DIAG
1210 Para.Para64 = Port;
1211 SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_FAIL, Para);
1212 #endif /* !SK_DIAG */
1213 return;
1214 }
1215 /*
1216 * Cache incoherency workaround: Assume a start command
1217 * has been lost while sending the frame.
1218 */
1219 ToutStart = SkOsGetTime(pAC);
1220
1221 if ((XsCsr & CSR_STOP) != 0) {
1222 SK_OUT32(IoC, Q_ADDR(pPrt->PXsQOff, Q_CSR), CSR_START);
1223 }
1224 if ((XaCsr & CSR_STOP) != 0) {
1225 SK_OUT32(IoC, Q_ADDR(pPrt->PXaQOff, Q_CSR), CSR_START);
1226 }
1227 }
1228
1229 /*
1230 * Because of the ASIC problem report entry from 21.08.1998 it is
1231 * required to wait until CSR_STOP is reset and CSR_SV_IDLE is set.
1232 */
1233 } while ((XsCsr & (CSR_STOP | CSR_SV_IDLE)) != CSR_SV_IDLE ||
1234 (XaCsr & (CSR_STOP | CSR_SV_IDLE)) != CSR_SV_IDLE);
1235
1236 /* Reset the MAC depending on the RstMode */
1237 if (RstMode == SK_SOFT_RST) {
1238 SkMacSoftRst(pAC, IoC, Port);
1239 }
1240 else {
1241 SkMacHardRst(pAC, IoC, Port);
1242 }
1243
1244 /* Disable Force Sync bit and Enable Alloc bit */
1245 SK_OUT8(IoC, MR_ADDR(Port, TXA_CTRL),
1246 TXA_DIS_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC);
1247
1248 /* Stop Interval Timer and Limit Counter of Tx Arbiter */
1249 SK_OUT32(IoC, MR_ADDR(Port, TXA_ITI_INI), 0L);
1250 SK_OUT32(IoC, MR_ADDR(Port, TXA_LIM_INI), 0L);
1251
1252 /* Perform a local reset of the port's Tx path */
1253
1254 /* Reset the PCI FIFO of the async Tx queue */
1255 SK_OUT32(IoC, Q_ADDR(pPrt->PXaQOff, Q_CSR), CSR_SET_RESET);
1256 /* Reset the PCI FIFO of the sync Tx queue */
1257 SK_OUT32(IoC, Q_ADDR(pPrt->PXsQOff, Q_CSR), CSR_SET_RESET);
1258 /* Reset the RAM Buffer async Tx queue */
1259 SK_OUT8(IoC, RB_ADDR(pPrt->PXaQOff, RB_CTRL), RB_RST_SET);
1260 /* Reset the RAM Buffer sync Tx queue */
1261 SK_OUT8(IoC, RB_ADDR(pPrt->PXsQOff, RB_CTRL), RB_RST_SET);
1262
1263 /* Reset Tx MAC FIFO */
1264 #ifdef GENESIS
1265 if (pAC->GIni.GIGenesis) {
1266 /* Note: MFF_RST_SET does NOT reset the XMAC ! */
1267 SK_OUT8(IoC, MR_ADDR(Port, TX_MFF_CTRL2), MFF_RST_SET);
1268
1269 /* switch Link and Tx LED off, stop the LED counters */
1270 /* Link LED is switched off by the RLMT and the Diag itself */
1271 SkGeXmitLED(pAC, IoC, MR_ADDR(Port, TX_LED_INI), SK_LED_DIS);
1272 }
1273 #endif /* GENESIS */
1274
1275 #ifdef YUKON
1276 if (pAC->GIni.GIYukon) {
1277 /* Reset TX MAC FIFO */
1278 SK_OUT8(IoC, MR_ADDR(Port, TX_GMF_CTRL_T), (SK_U8)GMF_RST_SET);
1279 }
1280 #endif /* YUKON */
1281 }
1282
1283 if ((Dir & SK_STOP_RX) != 0) {
1284 /*
1285 * The RX Stop Command will not terminate if no buffers
1286 * are queued in the RxD ring. But it will always reach
1287 * the Idle state. Therefore we can use this feature to
1288 * stop the transfer of received packets.
1289 */
1290 /* stop the port's receive queue */
1291 SK_OUT32(IoC, Q_ADDR(pPrt->PRxQOff, Q_CSR), CSR_STOP);
1292
1293 i = 100;
1294 do {
1295 /*
1296 * Clear packet arbiter timeout to make sure
1297 * this loop will terminate
1298 */
1299 SK_OUT16(IoC, B3_PA_CTRL, (SK_U16)((Port == MAC_1) ?
1300 PA_CLR_TO_RX1 : PA_CLR_TO_RX2));
1301
1302 DWord = TestStopBit(pAC, IoC, pPrt->PRxQOff);
1303
1304 /* timeout if i==0 (bug fix for #10748) */
1305 if (--i == 0) {
1306 SK_ERR_LOG(pAC, SK_ERRCL_HW, SKERR_HWI_E024,
1307 SKERR_HWI_E024MSG);
1308 break;
1309 }
1310 /*
1311 * because of the ASIC problem report entry from 21.08.98
1312 * it is required to wait until CSR_STOP is reset and
1313 * CSR_SV_IDLE is set.
1314 */
1315 } while ((DWord & (CSR_STOP | CSR_SV_IDLE)) != CSR_SV_IDLE);
1316
1317 /* The path data transfer activity is fully stopped now */
1318
1319 /* Perform a local reset of the port's Rx path */
1320
1321 /* Reset the PCI FIFO of the Rx queue */
1322 SK_OUT32(IoC, Q_ADDR(pPrt->PRxQOff, Q_CSR), CSR_SET_RESET);
1323 /* Reset the RAM Buffer receive queue */
1324 SK_OUT8(IoC, RB_ADDR(pPrt->PRxQOff, RB_CTRL), RB_RST_SET);
1325
1326 /* Reset Rx MAC FIFO */
1327 #ifdef GENESIS
1328 if (pAC->GIni.GIGenesis) {
1329
1330 SK_OUT8(IoC, MR_ADDR(Port, RX_MFF_CTRL2), MFF_RST_SET);
1331
1332 /* switch Rx LED off, stop the LED counter */
1333 SkGeXmitLED(pAC, IoC, MR_ADDR(Port, RX_LED_INI), SK_LED_DIS);
1334 }
1335 #endif /* GENESIS */
1336
1337 #ifdef YUKON
1338 if (pAC->GIni.GIYukon) {
1339 /* Reset Rx MAC FIFO */
1340 SK_OUT8(IoC, MR_ADDR(Port, RX_GMF_CTRL_T), (SK_U8)GMF_RST_SET);
1341 }
1342 #endif /* YUKON */
1343 }
1344 } /* SkGeStopPort */
1345
1346
1347 /******************************************************************************
1348 *
1349 * SkGeInit0() - Level 0 Initialization
1350 *
1351 * Description:
1352 * - Initialize the BMU address offsets
1353 *
1354 * Returns:
1355 * nothing
1356 */
1357 static void SkGeInit0(
1358 SK_AC *pAC, /* adapter context */
1359 SK_IOC IoC) /* IO context */
1360 {
1361 int i;
1362 SK_GEPORT *pPrt;
1363
1364 for (i = 0; i < SK_MAX_MACS; i++) {
1365 pPrt = &pAC->GIni.GP[i];
1366
1367 pPrt->PState = SK_PRT_RESET;
1368 pPrt->PRxQOff = QOffTab[i].RxQOff;
1369 pPrt->PXsQOff = QOffTab[i].XsQOff;
1370 pPrt->PXaQOff = QOffTab[i].XaQOff;
1371 pPrt->PCheckPar = SK_FALSE;
1372 pPrt->PIsave = 0;
1373 pPrt->PPrevShorts = 0;
1374 pPrt->PLinkResCt = 0;
1375 pPrt->PAutoNegTOCt = 0;
1376 pPrt->PPrevRx = 0;
1377 pPrt->PPrevFcs = 0;
1378 pPrt->PRxLim = SK_DEF_RX_WA_LIM;
1379 pPrt->PLinkMode = (SK_U8)SK_LMODE_AUTOFULL;
1380 pPrt->PLinkSpeedCap = (SK_U8)SK_LSPEED_CAP_1000MBPS;
1381 pPrt->PLinkSpeed = (SK_U8)SK_LSPEED_1000MBPS;
1382 pPrt->PLinkSpeedUsed = (SK_U8)SK_LSPEED_STAT_UNKNOWN;
1383 pPrt->PLinkModeConf = (SK_U8)SK_LMODE_AUTOSENSE;
1384 pPrt->PFlowCtrlMode = (SK_U8)SK_FLOW_MODE_SYM_OR_REM;
1385 pPrt->PLinkCap = (SK_U8)(SK_LMODE_CAP_HALF | SK_LMODE_CAP_FULL |
1386 SK_LMODE_CAP_AUTOHALF | SK_LMODE_CAP_AUTOFULL);
1387 pPrt->PLinkModeStatus = (SK_U8)SK_LMODE_STAT_UNKNOWN;
1388 pPrt->PFlowCtrlCap = (SK_U8)SK_FLOW_MODE_SYM_OR_REM;
1389 pPrt->PFlowCtrlStatus = (SK_U8)SK_FLOW_STAT_NONE;
1390 pPrt->PMSCap = 0;
1391 pPrt->PMSMode = (SK_U8)SK_MS_MODE_AUTO;
1392 pPrt->PMSStatus = (SK_U8)SK_MS_STAT_UNSET;
1393 pPrt->PLipaAutoNeg = (SK_U8)SK_LIPA_UNKNOWN;
1394 pPrt->PAutoNegFail = SK_FALSE;
1395 pPrt->PHWLinkUp = SK_FALSE;
1396 pPrt->PLinkBroken = SK_TRUE; /* See WA code */
1397 pPrt->PPhyPowerState = PHY_PM_OPERATIONAL_MODE;
1398 pPrt->PMacColThres = TX_COL_DEF;
1399 pPrt->PMacJamLen = TX_JAM_LEN_DEF;
1400 pPrt->PMacJamIpgVal = TX_JAM_IPG_DEF;
1401 pPrt->PMacJamIpgData = TX_IPG_JAM_DEF;
1402 pPrt->PMacIpgData = IPG_DATA_DEF;
1403 pPrt->PMacLimit4 = SK_FALSE;
1404 }
1405
1406 pAC->GIni.GIPortUsage = SK_RED_LINK;
1407 pAC->GIni.GILedBlinkCtrl = (SK_U16)OemConfig.Value;
1408 pAC->GIni.GIValIrqMask = IS_ALL_MSK;
1409
1410 } /* SkGeInit0*/
1411
1412 #ifdef SK_PCI_RESET
1413
1414 /******************************************************************************
1415 *
1416 * SkGePciReset() - Reset PCI interface
1417 *
1418 * Description:
1419 * o Read PCI configuration.
1420 * o Change power state to 3.
1421 * o Change power state to 0.
1422 * o Restore PCI configuration.
1423 *
1424 * Returns:
1425 * 0: Success.
1426 * 1: Power state could not be changed to 3.
1427 */
1428 static int SkGePciReset(
1429 SK_AC *pAC, /* adapter context */
1430 SK_IOC IoC) /* IO context */
1431 {
1432 int i;
1433 SK_U16 PmCtlSts;
1434 SK_U32 Bp1;
1435 SK_U32 Bp2;
1436 SK_U16 PciCmd;
1437 SK_U8 Cls;
1438 SK_U8 Lat;
1439 SK_U8 ConfigSpace[PCI_CFG_SIZE];
1440
1441 /*
1442 * Note: Switching to D3 state is like a software reset.
1443 * Switching from D3 to D0 is a hardware reset.
1444 * We have to save and restore the configuration space.
1445 */
1446 for (i = 0; i < PCI_CFG_SIZE; i++) {
1447 SkPciReadCfgDWord(pAC, i*4, &ConfigSpace[i]);
1448 }
1449
1450 /* We know the RAM Interface Arbiter is enabled. */
1451 SkPciWriteCfgWord(pAC, PCI_PM_CTL_STS, PCI_PM_STATE_D3);
1452 SkPciReadCfgWord(pAC, PCI_PM_CTL_STS, &PmCtlSts);
1453
1454 if ((PmCtlSts & PCI_PM_STATE_MSK) != PCI_PM_STATE_D3) {
1455 return(1);
1456 }
1457
1458 /* Return to D0 state. */
1459 SkPciWriteCfgWord(pAC, PCI_PM_CTL_STS, PCI_PM_STATE_D0);
1460
1461 /* Check for D0 state. */
1462 SkPciReadCfgWord(pAC, PCI_PM_CTL_STS, &PmCtlSts);
1463
1464 if ((PmCtlSts & PCI_PM_STATE_MSK) != PCI_PM_STATE_D0) {
1465 return(1);
1466 }
1467
1468 /* Check PCI Config Registers. */
1469 SkPciReadCfgWord(pAC, PCI_COMMAND, &PciCmd);
1470 SkPciReadCfgByte(pAC, PCI_CACHE_LSZ, &Cls);
1471 SkPciReadCfgDWord(pAC, PCI_BASE_1ST, &Bp1);
1472 SkPciReadCfgDWord(pAC, PCI_BASE_2ND, &Bp2);
1473 SkPciReadCfgByte(pAC, PCI_LAT_TIM, &Lat);
1474
1475 if (PciCmd != 0 || Cls != (SK_U8)0 || Lat != (SK_U8)0 ||
1476 (Bp1 & 0xfffffff0L) != 0 || Bp2 != 1) {
1477 return(1);
1478 }
1479
1480 /* Restore PCI Config Space. */
1481 for (i = 0; i < PCI_CFG_SIZE; i++) {
1482 SkPciWriteCfgDWord(pAC, i*4, ConfigSpace[i]);
1483 }
1484
1485 return(0);
1486 } /* SkGePciReset */
1487
1488 #endif /* SK_PCI_RESET */
1489
1490 /******************************************************************************
1491 *
1492 * SkGeInit1() - Level 1 Initialization
1493 *
1494 * Description:
1495 * o Do a software reset.
1496 * o Clear all reset bits.
1497 * o Verify that the detected hardware is present.
1498 * Return an error if not.
1499 * o Get the hardware configuration
1500 * + Read the number of MACs/Ports.
1501 * + Read the RAM size.
1502 * + Read the PCI Revision Id.
1503 * + Find out the adapters host clock speed
1504 * + Read and check the PHY type
1505 *
1506 * Returns:
1507 * 0: success
1508 * 5: Unexpected PHY type detected
1509 * 6: HW self test failed
1510 */
1511 static int SkGeInit1(
1512 SK_AC *pAC, /* adapter context */
1513 SK_IOC IoC) /* IO context */
1514 {
1515 SK_U8 Byte;
1516 SK_U16 Word;
1517 SK_U16 CtrlStat;
1518 SK_U32 DWord;
1519 int RetVal;
1520 int i;
1521
1522 RetVal = 0;
1523
1524 /* save CLK_RUN bits (YUKON-Lite) */
1525 SK_IN16(IoC, B0_CTST, &CtrlStat);
1526
1527 #ifdef SK_PCI_RESET
1528 (void)SkGePciReset(pAC, IoC);
1529 #endif /* SK_PCI_RESET */
1530
1531 /* do the SW-reset */
1532 SK_OUT8(IoC, B0_CTST, CS_RST_SET);
1533
1534 /* release the SW-reset */
1535 SK_OUT8(IoC, B0_CTST, CS_RST_CLR);
1536
1537 /* reset all error bits in the PCI STATUS register */
1538 /*
1539 * Note: PCI Cfg cycles cannot be used, because they are not
1540 * available on some platforms after 'boot time'.
1541 */
1542 SK_IN16(IoC, PCI_C(PCI_STATUS), &Word);
1543
1544 SK_OUT8(IoC, B2_TST_CTRL1, TST_CFG_WRITE_ON);
1545 SK_OUT16(IoC, PCI_C(PCI_STATUS), (SK_U16)(Word | PCI_ERRBITS));
1546 SK_OUT8(IoC, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
1547
1548 /* release Master Reset */
1549 SK_OUT8(IoC, B0_CTST, CS_MRST_CLR);
1550
1551 #ifdef CLK_RUN
1552 CtrlStat |= CS_CLK_RUN_ENA;
1553 #endif /* CLK_RUN */
1554
1555 /* restore CLK_RUN bits */
1556 SK_OUT16(IoC, B0_CTST, (SK_U16)(CtrlStat &
1557 (CS_CLK_RUN_HOT | CS_CLK_RUN_RST | CS_CLK_RUN_ENA)));
1558
1559 /* read Chip Identification Number */
1560 SK_IN8(IoC, B2_CHIP_ID, &Byte);
1561 pAC->GIni.GIChipId = Byte;
1562
1563 /* read number of MACs */
1564 SK_IN8(IoC, B2_MAC_CFG, &Byte);
1565 pAC->GIni.GIMacsFound = (Byte & CFG_SNG_MAC) ? 1 : 2;
1566
1567 /* get Chip Revision Number */
1568 pAC->GIni.GIChipRev = (SK_U8)((Byte & CFG_CHIP_R_MSK) >> 4);
1569
1570 /* get diff. PCI parameters */
1571 SK_IN16(IoC, B0_CTST, &CtrlStat);
1572
1573 /* read the adapters RAM size */
1574 SK_IN8(IoC, B2_E_0, &Byte);
1575
1576 pAC->GIni.GIGenesis = SK_FALSE;
1577 pAC->GIni.GIYukon = SK_FALSE;
1578 pAC->GIni.GIYukonLite = SK_FALSE;
1579
1580 #ifdef GENESIS
1581 if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) {
1582
1583 pAC->GIni.GIGenesis = SK_TRUE;
1584
1585 if (Byte == (SK_U8)3) {
1586 /* special case: 4 x 64k x 36, offset = 0x80000 */
1587 pAC->GIni.GIRamSize = 1024;
1588 pAC->GIni.GIRamOffs = (SK_U32)512 * 1024;
1589 }
1590 else {
1591 pAC->GIni.GIRamSize = (int)Byte * 512;
1592 pAC->GIni.GIRamOffs = 0;
1593 }
1594 /* all GE adapters work with 53.125 MHz host clock */
1595 pAC->GIni.GIHstClkFact = SK_FACT_53;
1596
1597 /* set Descr. Poll Timer Init Value to 250 ms */
1598 pAC->GIni.GIPollTimerVal =
1599 SK_DPOLL_DEF * (SK_U32)pAC->GIni.GIHstClkFact / 100;
1600 }
1601 #endif /* GENESIS */
1602
1603 #ifdef YUKON
1604 if (pAC->GIni.GIChipId != CHIP_ID_GENESIS) {
1605
1606 pAC->GIni.GIYukon = SK_TRUE;
1607
1608 pAC->GIni.GIRamSize = (Byte == (SK_U8)0) ? 128 : (int)Byte * 4;
1609
1610 pAC->GIni.GIRamOffs = 0;
1611
1612 /* WA for chip Rev. A */
1613 pAC->GIni.GIWolOffs = (pAC->GIni.GIChipId == CHIP_ID_YUKON &&
1614 pAC->GIni.GIChipRev == 0) ? WOL_REG_OFFS : 0;
1615
1616 /* get PM Capabilities of PCI config space */
1617 SK_IN16(IoC, PCI_C(PCI_PM_CAP_REG), &Word);
1618
1619 /* check if VAUX is available */
1620 if (((CtrlStat & CS_VAUX_AVAIL) != 0) &&
1621 /* check also if PME from D3cold is set */
1622 ((Word & PCI_PME_D3C_SUP) != 0)) {
1623 /* set entry in GE init struct */
1624 pAC->GIni.GIVauxAvail = SK_TRUE;
1625 }
1626
1627 if (pAC->GIni.GIChipId == CHIP_ID_YUKON_LITE) {
1628 /* this is Rev. A1 */
1629 pAC->GIni.GIYukonLite = SK_TRUE;
1630 }
1631 else {
1632 /* save Flash-Address Register */
1633 SK_IN32(IoC, B2_FAR, &DWord);
1634
1635 /* test Flash-Address Register */
1636 SK_OUT8(IoC, B2_FAR + 3, 0xff);
1637 SK_IN8(IoC, B2_FAR + 3, &Byte);
1638
1639 if (Byte != 0) {
1640 /* this is Rev. A0 */
1641 pAC->GIni.GIYukonLite = SK_TRUE;
1642
1643 /* restore Flash-Address Register */
1644 SK_OUT32(IoC, B2_FAR, DWord);
1645 }
1646 }
1647
1648 /* switch power to VCC (WA for VAUX problem) */
1649 SK_OUT8(IoC, B0_POWER_CTRL, (SK_U8)(PC_VAUX_ENA | PC_VCC_ENA |
1650 PC_VAUX_OFF | PC_VCC_ON));
1651
1652 /* read the Interrupt source */
1653 SK_IN32(IoC, B0_ISRC, &DWord);
1654
1655 if ((DWord & IS_HW_ERR) != 0) {
1656 /* read the HW Error Interrupt source */
1657 SK_IN32(IoC, B0_HWE_ISRC, &DWord);
1658
1659 if ((DWord & IS_IRQ_SENSOR) != 0) {
1660 /* disable HW Error IRQ */
1661 pAC->GIni.GIValIrqMask &= ~IS_HW_ERR;
1662 }
1663 }
1664
1665 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
1666 /* set GMAC Link Control reset */
1667 SK_OUT16(IoC, MR_ADDR(i, GMAC_LINK_CTRL), GMLC_RST_SET);
1668
1669 /* clear GMAC Link Control reset */
1670 SK_OUT16(IoC, MR_ADDR(i, GMAC_LINK_CTRL), GMLC_RST_CLR);
1671 }
1672 /* all YU chips work with 78.125 MHz host clock */
1673 pAC->GIni.GIHstClkFact = SK_FACT_78;
1674
1675 pAC->GIni.GIPollTimerVal = SK_DPOLL_MAX; /* 215 ms */
1676 }
1677 #endif /* YUKON */
1678
1679 /* check if 64-bit PCI Slot is present */
1680 pAC->GIni.GIPciSlot64 = (SK_BOOL)((CtrlStat & CS_BUS_SLOT_SZ) != 0);
1681
1682 /* check if 66 MHz PCI Clock is active */
1683 pAC->GIni.GIPciClock66 = (SK_BOOL)((CtrlStat & CS_BUS_CLOCK) != 0);
1684
1685 /* read PCI HW Revision Id. */
1686 SK_IN8(IoC, PCI_C(PCI_REV_ID), &Byte);
1687 pAC->GIni.GIPciHwRev = Byte;
1688
1689 /* read the PMD type */
1690 SK_IN8(IoC, B2_PMD_TYP, &Byte);
1691 pAC->GIni.GICopperType = (SK_U8)(Byte == 'T');
1692
1693 /* read the PHY type */
1694 SK_IN8(IoC, B2_E_1, &Byte);
1695
1696 Byte &= 0x0f; /* the PHY type is stored in the lower nibble */
1697 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
1698
1699 #ifdef GENESIS
1700 if (pAC->GIni.GIGenesis) {
1701 switch (Byte) {
1702 case SK_PHY_XMAC:
1703 pAC->GIni.GP[i].PhyAddr = PHY_ADDR_XMAC;
1704 break;
1705 case SK_PHY_BCOM:
1706 pAC->GIni.GP[i].PhyAddr = PHY_ADDR_BCOM;
1707 pAC->GIni.GP[i].PMSCap = (SK_U8)(SK_MS_CAP_AUTO |
1708 SK_MS_CAP_MASTER | SK_MS_CAP_SLAVE);
1709 break;
1710 #ifdef OTHER_PHY
1711 case SK_PHY_LONE:
1712 pAC->GIni.GP[i].PhyAddr = PHY_ADDR_LONE;
1713 break;
1714 case SK_PHY_NAT:
1715 pAC->GIni.GP[i].PhyAddr = PHY_ADDR_NAT;
1716 break;
1717 #endif /* OTHER_PHY */
1718 default:
1719 /* ERROR: unexpected PHY type detected */
1720 RetVal = 5;
1721 break;
1722 }
1723 }
1724 #endif /* GENESIS */
1725
1726 #ifdef YUKON
1727 if (pAC->GIni.GIYukon) {
1728
1729 if (Byte < (SK_U8)SK_PHY_MARV_COPPER) {
1730 /* if this field is not initialized */
1731 Byte = (SK_U8)SK_PHY_MARV_COPPER;
1732
1733 pAC->GIni.GICopperType = SK_TRUE;
1734 }
1735
1736 pAC->GIni.GP[i].PhyAddr = PHY_ADDR_MARV;
1737
1738 if (pAC->GIni.GICopperType) {
1739
1740 pAC->GIni.GP[i].PLinkSpeedCap = (SK_U8)(SK_LSPEED_CAP_AUTO |
1741 SK_LSPEED_CAP_10MBPS | SK_LSPEED_CAP_100MBPS |
1742 SK_LSPEED_CAP_1000MBPS);
1743
1744 pAC->GIni.GP[i].PLinkSpeed = (SK_U8)SK_LSPEED_AUTO;
1745
1746 pAC->GIni.GP[i].PMSCap = (SK_U8)(SK_MS_CAP_AUTO |
1747 SK_MS_CAP_MASTER | SK_MS_CAP_SLAVE);
1748 }
1749 else {
1750 Byte = (SK_U8)SK_PHY_MARV_FIBER;
1751 }
1752 }
1753 #endif /* YUKON */
1754
1755 pAC->GIni.GP[i].PhyType = (int)Byte;
1756
1757 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_INIT,
1758 ("PHY type: %d PHY addr: %04x\n", Byte,
1759 pAC->GIni.GP[i].PhyAddr));
1760 }
1761
1762 /* get MAC Type & set function pointers dependent on */
1763 #ifdef GENESIS
1764 if (pAC->GIni.GIGenesis) {
1765
1766 pAC->GIni.GIMacType = SK_MAC_XMAC;
1767
1768 pAC->GIni.GIFunc.pFnMacUpdateStats = SkXmUpdateStats;
1769 pAC->GIni.GIFunc.pFnMacStatistic = SkXmMacStatistic;
1770 pAC->GIni.GIFunc.pFnMacResetCounter = SkXmResetCounter;
1771 pAC->GIni.GIFunc.pFnMacOverflow = SkXmOverflowStatus;
1772 }
1773 #endif /* GENESIS */
1774
1775 #ifdef YUKON
1776 if (pAC->GIni.GIYukon) {
1777
1778 pAC->GIni.GIMacType = SK_MAC_GMAC;
1779
1780 pAC->GIni.GIFunc.pFnMacUpdateStats = SkGmUpdateStats;
1781 pAC->GIni.GIFunc.pFnMacStatistic = SkGmMacStatistic;
1782 pAC->GIni.GIFunc.pFnMacResetCounter = SkGmResetCounter;
1783 pAC->GIni.GIFunc.pFnMacOverflow = SkGmOverflowStatus;
1784
1785 #ifdef SPECIAL_HANDLING
1786 if (pAC->GIni.GIChipId == CHIP_ID_YUKON) {
1787 /* check HW self test result */
1788 SK_IN8(IoC, B2_E_3, &Byte);
1789 if (Byte & B2_E3_RES_MASK) {
1790 RetVal = 6;
1791 }
1792 }
1793 #endif
1794 }
1795 #endif /* YUKON */
1796
1797 return(RetVal);
1798 } /* SkGeInit1 */
1799
1800
1801 /******************************************************************************
1802 *
1803 * SkGeInit2() - Level 2 Initialization
1804 *
1805 * Description:
1806 * - start the Blink Source Counter
1807 * - start the Descriptor Poll Timer
1808 * - configure the MAC-Arbiter
1809 * - configure the Packet-Arbiter
1810 * - enable the Tx Arbiters
1811 * - enable the RAM Interface Arbiter
1812 *
1813 * Returns:
1814 * nothing
1815 */
1816 static void SkGeInit2(
1817 SK_AC *pAC, /* adapter context */
1818 SK_IOC IoC) /* IO context */
1819 {
1820 #ifdef GENESIS
1821 SK_U32 DWord;
1822 #endif /* GENESIS */
1823 int i;
1824
1825 /* start the Descriptor Poll Timer */
1826 if (pAC->GIni.GIPollTimerVal != 0) {
1827 if (pAC->GIni.GIPollTimerVal > SK_DPOLL_MAX) {
1828 pAC->GIni.GIPollTimerVal = SK_DPOLL_MAX;
1829
1830 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E017, SKERR_HWI_E017MSG);
1831 }
1832 SK_OUT32(IoC, B28_DPT_INI, pAC->GIni.GIPollTimerVal);
1833 SK_OUT8(IoC, B28_DPT_CTRL, DPT_START);
1834 }
1835
1836 #ifdef GENESIS
1837 if (pAC->GIni.GIGenesis) {
1838 /* start the Blink Source Counter */
1839 DWord = SK_BLK_DUR * (SK_U32)pAC->GIni.GIHstClkFact / 100;
1840
1841 SK_OUT32(IoC, B2_BSC_INI, DWord);
1842 SK_OUT8(IoC, B2_BSC_CTRL, BSC_START);
1843
1844 /*
1845 * Configure the MAC Arbiter and the Packet Arbiter.
1846 * They will be started once and never be stopped.
1847 */
1848 SkGeInitMacArb(pAC, IoC);
1849
1850 SkGeInitPktArb(pAC, IoC);
1851 }
1852 #endif /* GENESIS */
1853
1854 #ifdef YUKON
1855 if (pAC->GIni.GIYukon) {
1856 /* start Time Stamp Timer */
1857 SK_OUT8(IoC, GMAC_TI_ST_CTRL, (SK_U8)GMT_ST_START);
1858 }
1859 #endif /* YUKON */
1860
1861 /* enable the Tx Arbiters */
1862 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
1863 SK_OUT8(IoC, MR_ADDR(i, TXA_CTRL), TXA_ENA_ARB);
1864 }
1865
1866 /* enable the RAM Interface Arbiter */
1867 SkGeInitRamIface(pAC, IoC);
1868
1869 } /* SkGeInit2 */
1870
1871 /******************************************************************************
1872 *
1873 * SkGeInit() - Initialize the GE Adapter with the specified level.
1874 *
1875 * Description:
1876 * Level 0: Initialize the Module structures.
1877 * Level 1: Generic Hardware Initialization. The IOP/MemBase pointer has
1878 * to be set before calling this level.
1879 *
1880 * o Do a software reset.
1881 * o Clear all reset bits.
1882 * o Verify that the detected hardware is present.
1883 * Return an error if not.
1884 * o Get the hardware configuration
1885 * + Set GIMacsFound with the number of MACs.
1886 * + Store the RAM size in GIRamSize.
1887 * + Save the PCI Revision ID in GIPciHwRev.
1888 * o return an error
1889 * if Number of MACs > SK_MAX_MACS
1890 *
1891 * After returning from Level 0 the adapter
1892 * may be accessed with IO operations.
1893 *
1894 * Level 2: start the Blink Source Counter
1895 *
1896 * Returns:
1897 * 0: success
1898 * 1: Number of MACs exceeds SK_MAX_MACS (after level 1)
1899 * 2: Adapter not present or not accessible
1900 * 3: Illegal initialization level
1901 * 4: Initialization Level 1 Call missing
1902 * 5: Unexpected PHY type detected
1903 * 6: HW self test failed
1904 */
1905 int SkGeInit(
1906 SK_AC *pAC, /* adapter context */
1907 SK_IOC IoC, /* IO context */
1908 int Level) /* initialization level */
1909 {
1910 int RetVal; /* return value */
1911 SK_U32 DWord;
1912
1913 RetVal = 0;
1914 SK_DBG_MSG(pAC, SK_DBGMOD_HWM, SK_DBGCAT_INIT,
1915 ("SkGeInit(Level %d)\n", Level));
1916
1917 switch (Level) {
1918 case SK_INIT_DATA:
1919 /* Initialization Level 0 */
1920 SkGeInit0(pAC, IoC);
1921 pAC->GIni.GILevel = SK_INIT_DATA;
1922 break;
1923
1924 case SK_INIT_IO:
1925 /* Initialization Level 1 */
1926 RetVal = SkGeInit1(pAC, IoC);
1927 if (RetVal != 0) {
1928 break;
1929 }
1930
1931 /* check if the adapter seems to be accessible */
1932 SK_OUT32(IoC, B2_IRQM_INI, SK_TEST_VAL);
1933 SK_IN32(IoC, B2_IRQM_INI, &DWord);
1934 SK_OUT32(IoC, B2_IRQM_INI, 0L);
1935
1936 if (DWord != SK_TEST_VAL) {
1937 RetVal = 2;
1938 break;
1939 }
1940
1941 /* check if the number of GIMacsFound matches SK_MAX_MACS */
1942 if (pAC->GIni.GIMacsFound > SK_MAX_MACS) {
1943 RetVal = 1;
1944 break;
1945 }
1946
1947 /* Level 1 successfully passed */
1948 pAC->GIni.GILevel = SK_INIT_IO;
1949 break;
1950
1951 case SK_INIT_RUN:
1952 /* Initialization Level 2 */
1953 if (pAC->GIni.GILevel != SK_INIT_IO) {
1954 #ifndef SK_DIAG
1955 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E002, SKERR_HWI_E002MSG);
1956 #endif /* !SK_DIAG */
1957 RetVal = 4;
1958 break;
1959 }
1960 SkGeInit2(pAC, IoC);
1961
1962 /* Level 2 successfully passed */
1963 pAC->GIni.GILevel = SK_INIT_RUN;
1964 break;
1965
1966 default:
1967 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E003, SKERR_HWI_E003MSG);
1968 RetVal = 3;
1969 break;
1970 }
1971
1972 return(RetVal);
1973 } /* SkGeInit */
1974
1975
1976 /******************************************************************************
1977 *
1978 * SkGeDeInit() - Deinitialize the adapter
1979 *
1980 * Description:
1981 * All ports of the adapter will be stopped if not already done.
1982 * Do a software reset and switch off all LEDs.
1983 *
1984 * Returns:
1985 * nothing
1986 */
1987 void SkGeDeInit(
1988 SK_AC *pAC, /* adapter context */
1989 SK_IOC IoC) /* IO context */
1990 {
1991 int i;
1992 SK_U16 Word;
1993
1994 #ifdef SK_PHY_LP_MODE
1995 SK_U8 Byte;
1996 SK_U16 PmCtlSts;
1997 #endif /* SK_PHY_LP_MODE */
1998
1999 #if (!defined(SK_SLIM) && !defined(VCPU))
2000 /* ensure I2C is ready */
2001 SkI2cWaitIrq(pAC, IoC);
2002 #endif
2003
2004 /* stop all current transfer activity */
2005 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
2006 if (pAC->GIni.GP[i].PState != SK_PRT_STOP &&
2007 pAC->GIni.GP[i].PState != SK_PRT_RESET) {
2008
2009 SkGeStopPort(pAC, IoC, i, SK_STOP_ALL, SK_HARD_RST);
2010 }
2011 }
2012
2013 #ifdef SK_PHY_LP_MODE
2014 /*
2015 * for power saving purposes within mobile environments
2016 * we set the PHY to coma mode and switch to D3 power state.
2017 */
2018 if (pAC->GIni.GIYukonLite &&
2019 pAC->GIni.GIChipRev == CHIP_REV_YU_LITE_A3) {
2020
2021 /* for all ports switch PHY to coma mode */
2022 for (i = 0; i < pAC->GIni.GIMacsFound; i++) {
2023
2024 SkGmEnterLowPowerMode(pAC, IoC, i, PHY_PM_DEEP_SLEEP);
2025 }
2026
2027 if (pAC->GIni.GIVauxAvail) {
2028 /* switch power to VAUX */
2029 Byte = PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_ON | PC_VCC_OFF;
2030
2031 SK_OUT8(IoC, B0_POWER_CTRL, Byte);
2032 }
2033
2034 /* switch to D3 state */
2035 SK_IN16(IoC, PCI_C(PCI_PM_CTL_STS), &PmCtlSts);
2036
2037 PmCtlSts |= PCI_PM_STATE_D3;
2038
2039 SK_OUT8(IoC, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2040
2041 SK_OUT16(IoC, PCI_C(PCI_PM_CTL_STS), PmCtlSts);
2042 }
2043 #endif /* SK_PHY_LP_MODE */
2044
2045 /* Reset all bits in the PCI STATUS register */
2046 /*
2047 * Note: PCI Cfg cycles cannot be used, because they are not
2048 * available on some platforms after 'boot time'.
2049 */
2050 SK_IN16(IoC, PCI_C(PCI_STATUS), &Word);
2051
2052 SK_OUT8(IoC, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2053 SK_OUT16(IoC, PCI_C(PCI_STATUS), (SK_U16)(Word | PCI_ERRBITS));
2054 SK_OUT8(IoC, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2055
2056 /* do the reset, all LEDs are switched off now */
2057 SK_OUT8(IoC, B0_CTST, CS_RST_SET);
2058
2059 pAC->GIni.GILevel = SK_INIT_DATA;
2060 } /* SkGeDeInit */
2061
2062
2063 /******************************************************************************
2064 *
2065 * SkGeInitPort() Initialize the specified port.
2066 *
2067 * Description:
2068 * PRxQSize, PXSQSize, and PXAQSize has to be
2069 * configured for the specified port before calling this function.
2070 * The descriptor rings has to be initialized too.
2071 *
2072 * o (Re)configure queues of the specified port.
2073 * o configure the MAC of the specified port.
2074 * o put ASIC and MAC(s) in operational mode.
2075 * o initialize Rx/Tx and Sync LED
2076 * o initialize RAM Buffers and MAC FIFOs
2077 *
2078 * The port is ready to connect when returning.
2079 *
2080 * Note:
2081 * The MAC's Rx and Tx state machine is still disabled when returning.
2082 *
2083 * Returns:
2084 * 0: success
2085 * 1: Queue size initialization error. The configured values
2086 * for PRxQSize, PXSQSize, or PXAQSize are invalid for one
2087 * or more queues. The specified port was NOT initialized.
2088 * An error log entry was generated.
2089 * 2: The port has to be stopped before it can be initialized again.
2090 */
2091 int SkGeInitPort(
2092 SK_AC *pAC, /* adapter context */
2093 SK_IOC IoC, /* IO context */
2094 int Port) /* Port to configure */
2095 {
2096 SK_GEPORT *pPrt;
2097
2098 pPrt = &pAC->GIni.GP[Port];
2099
2100 if (SkGeCheckQSize(pAC, Port) != 0) {
2101 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E004, SKERR_HWI_E004MSG);
2102 return(1);
2103 }
2104
2105 if (pPrt->PState == SK_PRT_INIT || pPrt->PState == SK_PRT_RUN) {
2106 SK_ERR_LOG(pAC, SK_ERRCL_SW, SKERR_HWI_E005, SKERR_HWI_E005MSG);
2107 return(2);
2108 }
2109
2110 /* configuration ok, initialize the Port now */
2111
2112 #ifdef GENESIS
2113 if (pAC->GIni.GIGenesis) {
2114 /* initialize Rx, Tx and Link LED */
2115 /*
2116 * If 1000BT Phy needs LED initialization than swap
2117 * LED and XMAC initialization order
2118 */
2119 SkGeXmitLED(pAC, IoC, MR_ADDR(Port, TX_LED_INI), SK_LED_ENA);
2120 SkGeXmitLED(pAC, IoC, MR_ADDR(Port, RX_LED_INI), SK_LED_ENA);
2121 /* The Link LED is initialized by RLMT or Diagnostics itself */
2122
2123 SkXmInitMac(pAC, IoC, Port);
2124 }
2125 #endif /* GENESIS */
2126
2127 #ifdef YUKON
2128 if (pAC->GIni.GIYukon) {
2129
2130 SkGmInitMac(pAC, IoC, Port);
2131 }
2132 #endif /* YUKON */
2133
2134 /* do NOT initialize the Link Sync Counter */
2135
2136 SkGeInitMacFifo(pAC, IoC, Port);
2137
2138 SkGeInitRamBufs(pAC, IoC, Port);
2139
2140 if (pPrt->PXSQSize != 0) {
2141 /* enable Force Sync bit if synchronous queue available */
2142 SK_OUT8(IoC, MR_ADDR(Port, TXA_CTRL), TXA_ENA_FSYNC);
2143 }
2144
2145 SkGeInitBmu(pAC, IoC, Port);
2146
2147 /* mark port as initialized */
2148 pPrt->PState = SK_PRT_INIT;
2149
2150 return(0);
2151 } /* SkGeInitPort */
Ubuntu Artful kernel mirror