drivers/net/sk98lin/skgeinit.c

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