drivers/net/sk98lin/skgesirq.c

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