git.oblomov.eu Git - linux-2.6/blob - 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 */