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