* Add support for SK98xx driver

[thirdparty/u-boot.git] / drivers / sk98lin / skgepnmi.c

/*****************************************************************************
 *
 * Name:        skgepnmi.c
 * Project:     GEnesis, PCI Gigabit Ethernet Adapter
 * Version:     $Revision: 1.102 $
 * Date:        $Date: 2002/12/16 14:03:24 $
 * Purpose:     Private Network Management Interface
 *
 ****************************************************************************/

/******************************************************************************
 *
 *      (C)Copyright 1998-2002 SysKonnect GmbH.
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      The information in this file is provided "AS IS" without warranty.
 *
 ******************************************************************************/

/*****************************************************************************
 *
 * History:
 *
 *      $Log: skgepnmi.c,v $
 *      Revision 1.102  2002/12/16 14:03:24  tschilli
 *      VCT code in Vct() changed.
 *      
 *      Revision 1.101  2002/12/16 09:04:10  tschilli
 *      Code for VCT handling added.
 *      
 *      Revision 1.100  2002/09/26 14:28:13  tschilli
 *      For XMAC the values in the SK_PNMI_PORT Port struct are copied to
 *      the new SK_PNMI_PORT BufPort struct during a MacUpdate() call.
 *      These values are used when GetPhysStatVal() is called. With this
 *      mechanism you get the best results when software corrections for
 *      counters are needed. Example: RX_LONGFRAMES.
 *      
 *      Revision 1.99  2002/09/17 12:31:19  tschilli
 *      OID_SKGE_TX_HW_ERROR_CTS, OID_SKGE_OUT_ERROR_CTS, OID_GEN_XMIT_ERROR:
 *      Double count of SK_PNMI_HTX_EXCESS_COL in function General() removed.
 *      OID_PNP_CAPABILITIES: sizeof(SK_PM_WAKE_UP_CAPABILITIES) changed to
 *      sizeof(SK_PNP_CAPABILITIES) in function PowerManagement().
 *      
 *      Revision 1.98  2002/09/10 09:00:03  rwahl
 *      Adapted boolean definitions according sktypes.
 *      
 *      Revision 1.97  2002/09/05 15:07:03  rwahl
 *      Editorial changes.
 *      
 *      Revision 1.96  2002/09/05 11:04:14  rwahl
 *      - Rx/Tx packets statistics of virtual port were zero on link down (#10750)
 *      - For GMAC the overflow IRQ for Rx longframe counter was not counted.
 *      - Incorrect calculation for oids OID_SKGE_RX_HW_ERROR_CTS,
 *        OID_SKGE_IN_ERRORS_CTS,  OID_GEN_RCV_ERROR.
 *      - Moved correction for OID_SKGE_STAT_RX_TOO_LONG to GetPhysStatVal().
 *      - Editorial changes.
 *      
 *      Revision 1.95  2002/09/04 08:53:37  rwahl
 *      - Incorrect statistics for Rx_too_long counter with jumbo frame (#10751)
 *      - StatRxFrameTooLong & StatRxPMaccErr counters were not reset.
 *      - Fixed compiler warning for debug msg arg types.
 *      
 *      Revision 1.94  2002/08/09 15:42:14  rwahl
 *      - Fixed StatAddr table for GMAC.
 *      - VirtualConf(): returned indeterminated status for speed oids if no
 *        active port.
 *      
 *      Revision 1.93  2002/08/09 11:04:59  rwahl
 *      Added handler for link speed caps.
 *      
 *      Revision 1.92  2002/08/09 09:43:03  rwahl
 *      - Added handler for NDIS OID_PNP_xxx ids.
 *      
 *      Revision 1.91  2002/07/17 19:53:03  rwahl
 *      - Added StatOvrflwBit table for XMAC & GMAC.
 *      - Extended StatAddr table for GMAC. Added check of number of counters
 *        in enumeration and size of StatAddr table on init level.
 *      - Added use of GIFunc table.
 *      - ChipSet is not static anymore,
 *      - Extended SIRQ event handler for both mac types.
 *      - Fixed rx short counter bug (#10620)
 *      - Added handler for oids SKGE_SPEED_MODE & SKGE_SPEED_STATUS.
 *      - Extendet GetPhysStatVal() for GMAC.
 *      - Editorial changes.
 *      
 *      Revision 1.90  2002/05/22 08:56:25  rwahl
 *      - Moved OID table to separate source file.
 *      - Fix: TX_DEFFERAL counter incremented in full-duplex mode.
 *      - Use string definitions for error msgs.
 *      
 *      Revision 1.89  2001/09/18 10:01:30  mkunz
 *      some OID's fixed for dualnetmode
 *      
 *      Revision 1.88  2001/08/02 07:58:08  rwahl
 *      - Fixed NetIndex to csum module at ResetCounter().
 *      
 *      Revision 1.87  2001/04/06 13:35:09  mkunz
 *      -Bugs fixed in handling of OID_SKGE_MTU and the VPD OID's
 *      
 *      Revision 1.86  2001/03/09 09:18:03  mkunz
 *      Changes in SK_DBG_MSG
 *      
 *      Revision 1.85  2001/03/08 09:37:31  mkunz
 *      Bugfix in ResetCounter for Pnmi.Port structure
 *      
 *      Revision 1.84  2001/03/06 09:04:55  mkunz
 *      Made some changes in instance calculation
 *      
 *      Revision 1.83  2001/02/15 09:15:32  mkunz
 *      Necessary changes for dual net mode added
 *      
 *      Revision 1.82  2001/02/07 08:24:19  mkunz
 *      -Made changes in handling of OID_SKGE_MTU
 *      
 *      Revision 1.81  2001/02/06 09:58:00  mkunz
 *      -Vpd bug fixed
 *      -OID_SKGE_MTU added
 *      -pnmi support for dual net mode. Interface function and macros extended
 *      
 *      Revision 1.80  2001/01/22 13:41:35  rassmann
 *      Supporting two nets on dual-port adapters.
 *      
 *      Revision 1.79  2000/12/05 14:57:40  cgoos
 *      SetStruct failed before first Link Up (link mode of virtual
 *      port "INDETERMINATED").
 *      
 *      Revision 1.78  2000/09/12 10:44:58  cgoos
 *      Fixed SK_PNMI_STORE_U32 calls with typecasted argument.
 *      
 *      Revision 1.77  2000/09/07 08:10:19  rwahl
 *      - Modified algorithm for 64bit NDIS statistic counters;
 *        returns 64bit or 32bit value depending on passed buffer
 *        size. Indicate capability for 64bit NDIS counter, if passed
 *        buffer size is zero. OID_GEN_XMIT_ERROR, OID_GEN_RCV_ERROR,
 *        and OID_GEN_RCV_NO_BUFFER handled as 64bit counter, too.
 *      - corrected OID_SKGE_RLMT_PORT_PREFERRED.
 *      
 *      Revision 1.76  2000/08/03 15:23:39  rwahl
 *      - Correction for FrameTooLong counter has to be moved to OID handling
 *        routines (instead of statistic counter routine).
 *      - Fix in XMAC Reset Event handling: Only offset counter for hardware
 *        statistic registers are updated.
 *      
 *      Revision 1.75  2000/08/01 16:46:05  rwahl
 *      - Added StatRxLongFrames counter and correction of FrameTooLong counter.
 *      - Added directive to control width (default = 32bit) of NDIS statistic
 *        counters (SK_NDIS_64BIT_CTR).
 *      
 *      Revision 1.74  2000/07/04 11:41:53  rwahl
 *      - Added volition connector type.
 *      
 *      Revision 1.73  2000/03/15 16:33:10  rwahl
 *      Fixed bug 10510; wrong reset of virtual port statistic counters.
 *      
 *      Revision 1.72  1999/12/06 16:15:53  rwahl
 *      Fixed problem of instance range for current and factory MAC address.
 *      
 *      Revision 1.71  1999/12/06 10:14:20  rwahl
 *      Fixed bug 10476; set operation for PHY_OPERATION_MODE.
 *      
 *      Revision 1.70  1999/11/22 13:33:34  cgoos
 *      Changed license header to GPL.
 *      
 *      Revision 1.69  1999/10/18 11:42:15  rwahl
 *      Added typecasts for checking event dependent param (debug only).
 *      
 *      Revision 1.68  1999/10/06 09:35:59  cgoos
 *      Added state check to PHY_READ call (hanged if called during startup).
 *      
 *      Revision 1.67  1999/09/22 09:53:20  rwahl
 *      - Read Broadcom register for updating fcs error counter (1000Base-T).
 *
 *      Revision 1.66  1999/08/26 13:47:56  rwahl
 *      Added SK_DRIVER_SENDEVENT when queueing RLMT_CHANGE_THRES trap.
 *      
 *      Revision 1.65  1999/07/26 07:49:35  cgoos
 *      Added two typecasts to avoid compiler warnings.
 *      
 *      Revision 1.64  1999/05/20 09:24:12  cgoos
 *      Changes for 1000Base-T (sensors, Master/Slave).
 *
 *      Revision 1.63  1999/04/13 15:11:58  mhaveman
 *      Moved include of rlmt.h to header skgepnmi.h because some macros
 *      are needed there.
 *      
 *      Revision 1.62  1999/04/13 15:08:07  mhaveman
 *      Replaced again SK_RLMT_CHECK_LINK with SK_PNMI_RLMT_MODE_CHK_LINK
 *      to grant unified interface by only using the PNMI header file.
 *      SK_PNMI_RLMT_MODE_CHK_LINK is defined the same as SK_RLMT_CHECK_LINK.
 *      
 *      Revision 1.61  1999/04/13 15:02:48  mhaveman
 *      Changes caused by review:
 *      -Changed some comments
 *      -Removed redundant check for OID_SKGE_PHYS_FAC_ADDR
 *      -Optimized PRESET check.
 *      -Meaning of error SK_ADDR_DUPLICATE_ADDRESS changed. Set of same
 *       address will now not cause this error. Removed corresponding check.
 *      
 *      Revision 1.60  1999/03/23 10:41:23  mhaveman
 *      Added comments.
 *      
 *      Revision 1.59  1999/02/19 08:01:28  mhaveman
 *      Fixed bug 10372 that after counter reset all ports were displayed
 *      as inactive.
 *      
 *      Revision 1.58  1999/02/16 18:04:47  mhaveman
 *      Fixed problem of twisted OIDs SENSOR_WAR_TIME and SENSOR_ERR_TIME.
 *      
 *      Revision 1.56  1999/01/27 12:29:11  mhaveman
 *      SkTimerStart was called with time value in milli seconds but needs
 *      micro seconds.
 *      
 *      Revision 1.55  1999/01/25 15:00:38  mhaveman
 *      Added support to allow multiple ports to be active. If this feature in
 *      future will be used, the Management Data Base variables PORT_ACTIVE
 *      and PORT_PREFERED should be moved to the port specific part of RLMT.
 *      Currently they return the values of the first active physical port
 *      found. A set to the virtual port will actually change all active
 *      physical ports. A get returns the melted values of all active physical
 *      ports. If the port values differ a return value INDETERMINATED will
 *      be returned. This effects especially the CONF group.
 *      
 *      Revision 1.54  1999/01/19 10:10:22  mhaveman
 *      -Fixed bug 10354: Counter values of virtual port were wrong after port
 *       switches
 *      -Added check if a switch to the same port is notified.
 *      
 *      Revision 1.53  1999/01/07 09:25:21  mhaveman
 *      Forgot to initialize a variable.
 *      
 *      Revision 1.52  1999/01/05 10:34:33  mhaveman
 *      Fixed little error in RlmtChangeEstimate calculation.
 *      
 *      Revision 1.51  1999/01/05 09:59:07  mhaveman
 *      -Moved timer start to init level 2
 *      -Redesigned port switch average calculation to avoid 64bit
 *       arithmetic.
 *      
 *      Revision 1.50  1998/12/10 15:13:59  mhaveman
 *      -Fixed: PHYS_CUR_ADDR returned wrong addresses
 *      -Fixed: RLMT_PORT_PREFERED and RLMT_CHANGE_THRES preset returned
 *              always BAD_VALUE.
 *      -Fixed: TRAP buffer seemed to sometimes suddenly empty
 *      
 *      Revision 1.49  1998/12/09 16:17:07  mhaveman
 *      Fixed: Couldnot delete VPD keys on UNIX.
 *      
 *      Revision 1.48  1998/12/09 14:11:10  mhaveman
 *      -Add: Debugmessage for XMAC_RESET supressed to minimize output.
 *      -Fixed: RlmtChangeThreshold will now be initialized.
 *      -Fixed: VPD_ENTRIES_LIST extended value with unnecessary space char.
 *      -Fixed: On VPD key creation an invalid key name could be created
 *              (e.g. A5)
 *      -Some minor changes in comments and code.
 *      
 *      Revision 1.47  1998/12/08 16:00:31  mhaveman
 *      -Fixed: For RLMT_PORT_ACTIVE will now be returned a 0 if no port
 *              is active.
 *      -Fixed: For the RLMT statistics group only the last value was
 *              returned and the rest of the buffer was filled with 0xff
 *      -Fixed: Mysteriously the preset on RLMT_MODE still returned
 *              BAD_VALUE.
 *      Revision 1.46  1998/12/08 10:04:56  mhaveman
 *      -Fixed: Preset on RLMT_MODE returned always BAD_VALUE error.
 *      -Fixed: Alignment error in GetStruct
 *      -Fixed: If for Get/Preset/SetStruct the buffer size is equal or
 *              larger than SK_PNMI_MIN_STRUCT_SIZE the return value is stored
 *              to the buffer. In this case the caller should always return
 *              ok to its upper routines. Only if the buffer size is less
 *              than SK_PNMI_MIN_STRUCT_SIZE and the return value is unequal
 *              to 0, an error should be returned by the caller.
 *      -Fixed: Wrong number of instances with RLMT statistic.
 *      -Fixed: Return now SK_LMODE_STAT_UNKNOWN if the LinkModeStatus is 0.
 *      
 *      Revision 1.45  1998/12/03 17:17:24  mhaveman
 *      -Removed for VPD create action the buffer size limitation to 4 bytes.
 *      -Pass now physical/active physical port to ADDR for CUR_ADDR set
 *      
 *      Revision 1.44  1998/12/03 15:14:35  mhaveman
 *      Another change to Vpd instance evaluation.
 *
 *      Revision 1.43  1998/12/03 14:18:10  mhaveman
 *      -Fixed problem in PnmiSetStruct. It was impossible to set any value.
 *      -Removed VPD key evaluation for VPD_FREE_BYTES and VPD_ACTION.
 *
 *      Revision 1.42  1998/12/03 11:31:47  mhaveman
 *      Inserted cast to satisfy lint.
 *      
 *      Revision 1.41  1998/12/03 11:28:16  mhaveman
 *      Removed SK_PNMI_CHECKPTR
 *      
 *      Revision 1.40  1998/12/03 11:19:07  mhaveman
 *      Fixed problems
 *      -A set to virtual port will now be ignored. A set with broadcast
 *       address to any port will be ignored.
 *      -GetStruct function made VPD instance calculation wrong.
 *      -Prefered port returned -1 instead of 0.
 *      
 *      Revision 1.39  1998/11/26 15:30:29  mhaveman
 *      Added sense mode to link mode.
 *      
 *      Revision 1.38  1998/11/23 15:34:00  mhaveman
 *      -Fixed bug for RX counters. On an RX overflow interrupt the high
 *       words of all RX counters were incremented.
 *      -SET operations on FLOWCTRL_MODE and LINK_MODE accept now the
 *       value 0, which has no effect. It is usefull for multiple instance
 *       SETs.
 *      
 *      Revision 1.37  1998/11/20 08:02:04  mhaveman
 *      -Fixed: Ports were compared with MAX_SENSORS
 *      -Fixed: Crash in GetTrapEntry with MEMSET macro
 *      -Fixed: Conversions between physical, logical port index and instance
 *      
 *      Revision 1.36  1998/11/16 07:48:53  mhaveman
 *      Casted SK_DRIVER_SENDEVENT with (void) to eleminate compiler warnings
 *      on Solaris.
 *      
 *      Revision 1.35  1998/11/16 07:45:34  mhaveman
 *      SkAddrOverride now returns value and will be checked.
 *
 *      Revision 1.34  1998/11/10 13:40:37  mhaveman
 *      Needed to change interface, because NT driver needs a return value
 *      of needed buffer space on TOO_SHORT errors. Therefore all
 *      SkPnmiGet/Preset/Set functions now have a pointer to the length
 *      parameter, where the needed space on error is returned.
 *      
 *      Revision 1.33  1998/11/03 13:52:46  mhaveman
 *      Made file lint conform.
 *      
 *      Revision 1.32  1998/11/03 13:19:07  mhaveman
 *      The events SK_HWEV_SET_LMODE and SK_HWEV_SET_FLOWMODE pass now in
 *      Para32[0] the physical MAC index and in Para32[1] the new mode.
 *      
 *      Revision 1.31  1998/11/03 12:30:40  gklug
 *      fix: compiler warning memset
 *
 *      Revision 1.30  1998/11/03 12:04:46  mhaveman
 *      Fixed problem in SENSOR_VALUE, which wrote beyond the buffer end
 *      Fixed alignment problem with CHIPSET.
 *
 *      Revision 1.29  1998/11/02 11:23:54  mhaveman
 *      Corrected SK_ERROR_LOG to SK_ERR_LOG. Sorry.
 *      
 *      Revision 1.28  1998/11/02 10:47:16  mhaveman
 *      Added syslog messages for internal errors.
 *      
 *      Revision 1.27  1998/10/30 15:48:06  mhaveman
 *      Fixed problems after simulation of SK_PNMI_EVT_CHG_EST_TIMER and
 *      RlmtChangeThreshold calculation.
 *      
 *      Revision 1.26  1998/10/29 15:36:55  mhaveman
 *      -Fixed bug in trap buffer handling.
 *      -OID_SKGE_DRIVER_DESCR, OID_SKGE_DRIVER_VERSION, OID_SKGE_HW_DESCR,
 *       OID_SKGE_HW_VERSION, OID_SKGE_VPD_ENTRIES_LIST, OID_SKGE_VPD_KEY,
 *       OID_SKGE_VPD_VALUE, and OID_SKGE_SENSOR_DESCR return values with
 *       a leading octet before each string storing the string length.
 *      -Perform a RlmtUpdate during SK_PNMI_EVT_XMAC_RESET to minimize
 *       RlmtUpdate calls in GetStatVal.
 *      -Inserted SK_PNMI_CHECKFLAGS macro increase readability.
 *      
 *      Revision 1.25  1998/10/29 08:50:36  mhaveman
 *      Fixed problems after second event simulation.
 *      
 *      Revision 1.24  1998/10/28 08:44:37  mhaveman
 *      -Fixed alignment problem
 *      -Fixed problems during event simulation
 *      -Fixed sequence of error return code (INSTANCE -> ACCESS -> SHORT)
 *      -Changed type of parameter Instance back to SK_U32 because of VPD
 *      -Updated new VPD function calls
 *
 *      Revision 1.23  1998/10/23 10:16:37  mhaveman
 *      Fixed bugs after buffer test simulation.
 *      
 *      Revision 1.22  1998/10/21 13:23:52  mhaveman
 *      -Call syntax of SkOsGetTime() changed to SkOsGetTime(pAc).
 *      -Changed calculation of hundrets of seconds.
 *
 *      Revision 1.20  1998/10/20 07:30:45  mhaveman
 *      Made type changes to unsigned integer where possible.
 *      
 *      Revision 1.19  1998/10/19 10:51:30  mhaveman
 *      -Made Bug fixes after simulation run
 *      -Renamed RlmtMAC... to RlmtPort...
 *      -Marked workarounds with Errata comments
 *      
 *      Revision 1.18  1998/10/14 07:50:08  mhaveman
 *      -For OID_SKGE_LINK_STATUS the link down detection has moved from RLMT
 *       to HWACCESS.
 *      -Provided all MEMCPY/MEMSET macros with (char *) pointers, because
 *       Solaris throwed warnings when mapping to bcopy/bset.
 *
 *      Revision 1.17  1998/10/13 07:42:01  mhaveman
 *      -Added OIDs OID_SKGE_TRAP_NUMBER and OID_SKGE_ALL_DATA
 *      -Removed old cvs history entries
 *      -Renamed MacNumber to PortNumber
 *
 *      Revision 1.16  1998/10/07 10:52:49  mhaveman
 *      -Inserted handling of some OID_GEN_ Ids for windows
 *      -Fixed problem with 803.2 statistic.
 *      
 *      Revision 1.15  1998/10/01 09:16:29  mhaveman
 *      Added Debug messages for function call and UpdateFlag tracing.
 *      
 *      Revision 1.14  1998/09/30 13:39:09  mhaveman
 *      -Reduced namings of 'MAC' by replacing them with 'PORT'.
 *      -Completed counting of OID_SKGE_RX_HW_ERROR_CTS,
 *       OID_SKGE_TX_HW_ERROR_CTS,
 *       OID_SKGE_IN_ERRORS_CTS, and OID_SKGE_OUT_ERROR_CTS.
 *      -SET check for RlmtMode
 *      
 *      Revision 1.13  1998/09/28 13:13:08  mhaveman
 *      Hide strcmp, strlen, and strncpy behind macros SK_STRCMP, SK_STRLEN,
 *      and SK_STRNCPY. (Same reasons as for mem.. and MEM..)
 *      
 *      Revision 1.12  1998/09/16 08:18:36  cgoos
 *      Fix: XM_INxx and XM_OUTxx called with different parameter order:
 *      sometimes IoC,Mac,...  sometimes Mac,IoC,... Now always first variant.
 *      Fix: inserted "Pnmi." into some pAC->pDriverDescription / Version.
 *      Change: memset, memcpy to makros SK_MEMSET, SK_MEMCPY
 *
 *      Revision 1.11  1998/09/04 17:01:45  mhaveman
 *      Added SyncCounter as macro and OID_SKGE_.._NO_DESCR_CTS to
 *      OID_SKGE_RX_NO_BUF_CTS.
 *      
 *      Revision 1.10  1998/09/04 14:35:35  mhaveman
 *      Added macro counters, that are counted by driver.
 *      
 ****************************************************************************/


static const char SysKonnectFileId[] =
        "@(#) $Id: skgepnmi.c,v 1.102 2002/12/16 14:03:24 tschilli Exp $"
        " (C) SysKonnect.";

#include "h/skdrv1st.h"
#include "h/sktypes.h"
#include "h/xmac_ii.h"
#include "h/skdebug.h"
#include "h/skqueue.h"
#include "h/skgepnmi.h"
#include "h/skgesirq.h"
#include "h/skcsum.h"
#include "h/skvpd.h"
#include "h/skgehw.h"
#include "h/skgeinit.h"
#include "h/skdrv2nd.h"
#include "h/skgepnm2.h"
#ifdef SK_POWER_MGMT
#include "h/skgepmgt.h"
#endif
/* defines *******************************************************************/

#ifndef DEBUG
#define PNMI_STATIC     static
#else   /* DEBUG */
#define PNMI_STATIC
#endif /* DEBUG */

/*
 * Public Function prototypes
 */
int SkPnmiInit(SK_AC *pAC, SK_IOC IoC, int level);
int SkPnmiGetVar(SK_AC *pAC, SK_IOC IoC, SK_U32 Id, void *pBuf,
        unsigned int *pLen, SK_U32 Instance, SK_U32 NetIndex);
int SkPnmiPreSetVar(SK_AC *pAC, SK_IOC IoC, SK_U32 Id, void *pBuf,
        unsigned int *pLen, SK_U32 Instance, SK_U32 NetIndex);
int SkPnmiSetVar(SK_AC *pAC, SK_IOC IoC, SK_U32 Id, void *pBuf,
        unsigned int *pLen, SK_U32 Instance, SK_U32 NetIndex);
int SkPnmiGetStruct(SK_AC *pAC, SK_IOC IoC, void *pBuf,
        unsigned int *pLen, SK_U32 NetIndex);
int SkPnmiPreSetStruct(SK_AC *pAC, SK_IOC IoC, void *pBuf, 
        unsigned int *pLen, SK_U32 NetIndex);
int SkPnmiSetStruct(SK_AC *pAC, SK_IOC IoC, void *pBuf, 
        unsigned int *pLen, SK_U32 NetIndex);
int SkPnmiEvent(SK_AC *pAC, SK_IOC IoC, SK_U32 Event, SK_EVPARA Param);


/*
 * Private Function prototypes
 */

PNMI_STATIC SK_U8 CalculateLinkModeStatus(SK_AC *pAC, SK_IOC IoC, unsigned int
        PhysPortIndex);
PNMI_STATIC SK_U8 CalculateLinkStatus(SK_AC *pAC, SK_IOC IoC, unsigned int
        PhysPortIndex);
PNMI_STATIC void CopyMac(char *pDst, SK_MAC_ADDR *pMac);
PNMI_STATIC void CopyTrapQueue(SK_AC *pAC, char *pDstBuf);
PNMI_STATIC SK_U64 GetPhysStatVal(SK_AC *pAC, SK_IOC IoC,
        unsigned int PhysPortIndex, unsigned int StatIndex);
PNMI_STATIC SK_U64 GetStatVal(SK_AC *pAC, SK_IOC IoC, unsigned int LogPortIndex,
        unsigned int StatIndex, SK_U32 NetIndex);
PNMI_STATIC char* GetTrapEntry(SK_AC *pAC, SK_U32 TrapId, unsigned int Size);
PNMI_STATIC void GetTrapQueueLen(SK_AC *pAC, unsigned int *pLen,
        unsigned int *pEntries);
PNMI_STATIC int GetVpdKeyArr(SK_AC *pAC, SK_IOC IoC, char *pKeyArr,
        unsigned int KeyArrLen, unsigned int *pKeyNo);
PNMI_STATIC int LookupId(SK_U32 Id);
PNMI_STATIC int MacUpdate(SK_AC *pAC, SK_IOC IoC, unsigned int FirstMac,
        unsigned int LastMac);
PNMI_STATIC int PnmiStruct(SK_AC *pAC, SK_IOC IoC, int Action, char *pBuf,
        unsigned int *pLen, SK_U32 NetIndex);
PNMI_STATIC int PnmiVar(SK_AC *pAC, SK_IOC IoC, int Action, SK_U32 Id,
        char *pBuf, unsigned int *pLen, SK_U32 Instance, SK_U32 NetIndex);
PNMI_STATIC void QueueRlmtNewMacTrap(SK_AC *pAC, unsigned int ActiveMac);
PNMI_STATIC void QueueRlmtPortTrap(SK_AC *pAC, SK_U32 TrapId,
        unsigned int PortIndex);
PNMI_STATIC void QueueSensorTrap(SK_AC *pAC, SK_U32 TrapId,
        unsigned int SensorIndex);
PNMI_STATIC void QueueSimpleTrap(SK_AC *pAC, SK_U32 TrapId);
PNMI_STATIC void ResetCounter(SK_AC *pAC, SK_IOC IoC, SK_U32 NetIndex);
PNMI_STATIC int RlmtUpdate(SK_AC *pAC, SK_IOC IoC, SK_U32 NetIndex);
PNMI_STATIC int SirqUpdate(SK_AC *pAC, SK_IOC IoC);
PNMI_STATIC void VirtualConf(SK_AC *pAC, SK_IOC IoC, SK_U32 Id, char *pBuf);
PNMI_STATIC int Vct(SK_AC *pAC, SK_IOC IoC, int Action, SK_U32 Id, char *pBuf,
        unsigned int *pLen, SK_U32 Instance, unsigned int TableIndex, SK_U32 NetIndex);
PNMI_STATIC void CheckVctStatus(SK_AC *, SK_IOC, char *, SK_U32, SK_U32);

/*
 * Table to correlate OID with handler function and index to
 * hardware register stored in StatAddress if applicable.
 */
#include "skgemib.c"

/* global variables **********************************************************/

/*
 * Overflow status register bit table and corresponding counter
 * dependent on MAC type - the number relates to the size of overflow
 * mask returned by the pFnMacOverflow function 
 */
PNMI_STATIC const SK_U16 StatOvrflwBit[][SK_PNMI_MAC_TYPES] = {
/* Bit0  */     { SK_PNMI_HTX,                          SK_PNMI_HTX_UNICAST},
/* Bit1  */     { SK_PNMI_HTX_OCTETHIGH,        SK_PNMI_HTX_BROADCAST},
/* Bit2  */     { SK_PNMI_HTX_OCTETLOW,         SK_PNMI_HTX_PMACC},
/* Bit3  */     { SK_PNMI_HTX_BROADCAST,        SK_PNMI_HTX_MULTICAST},
/* Bit4  */     { SK_PNMI_HTX_MULTICAST,        SK_PNMI_HTX_OCTETLOW},
/* Bit5  */     { SK_PNMI_HTX_UNICAST,          SK_PNMI_HTX_OCTETHIGH},
/* Bit6  */     { SK_PNMI_HTX_LONGFRAMES,       SK_PNMI_HTX_64},
/* Bit7  */     { SK_PNMI_HTX_BURST,            SK_PNMI_HTX_127},
/* Bit8  */     { SK_PNMI_HTX_PMACC,            SK_PNMI_HTX_255},
/* Bit9  */     { SK_PNMI_HTX_MACC,             SK_PNMI_HTX_511},
/* Bit10 */     { SK_PNMI_HTX_SINGLE_COL,       SK_PNMI_HTX_1023},
/* Bit11 */     { SK_PNMI_HTX_MULTI_COL,        SK_PNMI_HTX_MAX},
/* Bit12 */     { SK_PNMI_HTX_EXCESS_COL,       SK_PNMI_HTX_LONGFRAMES},
/* Bit13 */     { SK_PNMI_HTX_LATE_COL,         SK_PNMI_HTX_RESERVED},
/* Bit14 */     { SK_PNMI_HTX_DEFFERAL,         SK_PNMI_HTX_COL},
/* Bit15 */     { SK_PNMI_HTX_EXCESS_DEF,       SK_PNMI_HTX_LATE_COL},
/* Bit16 */     { SK_PNMI_HTX_UNDERRUN,         SK_PNMI_HTX_EXCESS_COL},
/* Bit17 */     { SK_PNMI_HTX_CARRIER,          SK_PNMI_HTX_MULTI_COL},
/* Bit18 */     { SK_PNMI_HTX_UTILUNDER,        SK_PNMI_HTX_SINGLE_COL},
/* Bit19 */     { SK_PNMI_HTX_UTILOVER,         SK_PNMI_HTX_UNDERRUN},
/* Bit20 */     { SK_PNMI_HTX_64,                       SK_PNMI_HTX_RESERVED},
/* Bit21 */     { SK_PNMI_HTX_127,                      SK_PNMI_HTX_RESERVED},
/* Bit22 */     { SK_PNMI_HTX_255,                      SK_PNMI_HTX_RESERVED},
/* Bit23 */     { SK_PNMI_HTX_511,                      SK_PNMI_HTX_RESERVED},
/* Bit24 */     { SK_PNMI_HTX_1023,             SK_PNMI_HTX_RESERVED},
/* Bit25 */     { SK_PNMI_HTX_MAX,                      SK_PNMI_HTX_RESERVED},
/* Bit26 */     { SK_PNMI_HTX_RESERVED,         SK_PNMI_HTX_RESERVED},
/* Bit27 */     { SK_PNMI_HTX_RESERVED,         SK_PNMI_HTX_RESERVED},
/* Bit28 */     { SK_PNMI_HTX_RESERVED,         SK_PNMI_HTX_RESERVED},
/* Bit29 */     { SK_PNMI_HTX_RESERVED,         SK_PNMI_HTX_RESERVED},
/* Bit30 */     { SK_PNMI_HTX_RESERVED,         SK_PNMI_HTX_RESERVED},
/* Bit31 */     { SK_PNMI_HTX_RESERVED,         SK_PNMI_HTX_RESERVED},
/* Bit32 */     { SK_PNMI_HRX,                          SK_PNMI_HRX_UNICAST},
/* Bit33 */     { SK_PNMI_HRX_OCTETHIGH,        SK_PNMI_HRX_BROADCAST},
/* Bit34 */     { SK_PNMI_HRX_OCTETLOW,         SK_PNMI_HRX_PMACC},
/* Bit35 */     { SK_PNMI_HRX_BROADCAST,        SK_PNMI_HRX_MULTICAST},
/* Bit36 */     { SK_PNMI_HRX_MULTICAST,        SK_PNMI_HRX_FCS},
/* Bit37 */     { SK_PNMI_HRX_UNICAST,          SK_PNMI_HRX_RESERVED},
/* Bit38 */     { SK_PNMI_HRX_PMACC,            SK_PNMI_HRX_OCTETLOW},
/* Bit39 */     { SK_PNMI_HRX_MACC,             SK_PNMI_HRX_OCTETHIGH},
/* Bit40 */     { SK_PNMI_HRX_PMACC_ERR,        SK_PNMI_HRX_BADOCTETLOW},
/* Bit41 */     { SK_PNMI_HRX_MACC_UNKWN,       SK_PNMI_HRX_BADOCTETHIGH},
/* Bit42 */     { SK_PNMI_HRX_BURST,            SK_PNMI_HRX_UNDERSIZE},
/* Bit43 */     { SK_PNMI_HRX_MISSED,           SK_PNMI_HRX_RUNT},
/* Bit44 */     { SK_PNMI_HRX_FRAMING,          SK_PNMI_HRX_64},
/* Bit45 */     { SK_PNMI_HRX_OVERFLOW,         SK_PNMI_HRX_127},
/* Bit46 */     { SK_PNMI_HRX_JABBER,           SK_PNMI_HRX_255},
/* Bit47 */     { SK_PNMI_HRX_CARRIER,          SK_PNMI_HRX_511},
/* Bit48 */     { SK_PNMI_HRX_IRLENGTH,         SK_PNMI_HRX_1023},
/* Bit49 */     { SK_PNMI_HRX_SYMBOL,           SK_PNMI_HRX_MAX},
/* Bit50 */     { SK_PNMI_HRX_SHORTS,           SK_PNMI_HRX_LONGFRAMES},
/* Bit51 */     { SK_PNMI_HRX_RUNT,             SK_PNMI_HRX_TOO_LONG},
/* Bit52 */     { SK_PNMI_HRX_TOO_LONG,         SK_PNMI_HRX_JABBER},
/* Bit53 */     { SK_PNMI_HRX_FCS,                      SK_PNMI_HRX_RESERVED},
/* Bit54 */     { SK_PNMI_HRX_RESERVED,         SK_PNMI_HRX_OVERFLOW},
/* Bit55 */     { SK_PNMI_HRX_CEXT,             SK_PNMI_HRX_RESERVED},
/* Bit56 */     { SK_PNMI_HRX_UTILUNDER,        SK_PNMI_HRX_RESERVED},
/* Bit57 */     { SK_PNMI_HRX_UTILOVER,         SK_PNMI_HRX_RESERVED},
/* Bit58 */     { SK_PNMI_HRX_64,                       SK_PNMI_HRX_RESERVED},
/* Bit59 */     { SK_PNMI_HRX_127,                      SK_PNMI_HRX_RESERVED},
/* Bit60 */     { SK_PNMI_HRX_255,                      SK_PNMI_HRX_RESERVED},
/* Bit61 */     { SK_PNMI_HRX_511,                      SK_PNMI_HRX_RESERVED},
/* Bit62 */     { SK_PNMI_HRX_1023,             SK_PNMI_HRX_RESERVED},
/* Bit63 */     { SK_PNMI_HRX_MAX,                      SK_PNMI_HRX_RESERVED}
};

/*
 * Table for hardware register saving on resets and port switches
 */
PNMI_STATIC const SK_PNMI_STATADDR StatAddr[SK_PNMI_MAX_IDX][SK_PNMI_MAC_TYPES] = {
        /* SK_PNMI_HTX */
        {{XM_TXF_OK, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_OCTETHIGH */
        {{XM_TXO_OK_HI, SK_TRUE}, {GM_TXO_OK_HI, SK_TRUE}},
        /* SK_PNMI_HTX_OCTETLOW */
        {{XM_TXO_OK_LO, SK_FALSE}, {GM_TXO_OK_LO, SK_FALSE}},
        /* SK_PNMI_HTX_BROADCAST */
        {{XM_TXF_BC_OK, SK_TRUE}, {GM_TXF_BC_OK, SK_TRUE}},
        /* SK_PNMI_HTX_MULTICAST */
        {{XM_TXF_MC_OK, SK_TRUE}, {GM_TXF_MC_OK, SK_TRUE}},
        /* SK_PNMI_HTX_UNICAST */
        {{XM_TXF_UC_OK, SK_TRUE}, {GM_TXF_UC_OK, SK_TRUE}},
        /* SK_PNMI_HTX_BURST */
        {{XM_TXE_BURST, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_PMACC */
        {{XM_TXF_MPAUSE, SK_TRUE}, {GM_TXF_MPAUSE, SK_TRUE}},
        /* SK_PNMI_HTX_MACC */
        {{XM_TXF_MCTRL, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_COL */
        {{0, SK_FALSE}, {GM_TXF_COL, SK_TRUE}},
        /* SK_PNMI_HTX_SINGLE_COL */
        {{XM_TXF_SNG_COL, SK_TRUE}, {GM_TXF_SNG_COL, SK_TRUE}},
        /* SK_PNMI_HTX_MULTI_COL */
        {{XM_TXF_MUL_COL, SK_TRUE}, {GM_TXF_MUL_COL, SK_TRUE}},
        /* SK_PNMI_HTX_EXCESS_COL */
        {{XM_TXF_ABO_COL, SK_TRUE}, {GM_TXF_ABO_COL, SK_TRUE}},
        /* SK_PNMI_HTX_LATE_COL */
        {{XM_TXF_LAT_COL, SK_TRUE}, {GM_TXF_LAT_COL, SK_TRUE}},
        /* SK_PNMI_HTX_DEFFERAL */
        {{XM_TXF_DEF, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_EXCESS_DEF */
        {{XM_TXF_EX_DEF, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_UNDERRUN */
        {{XM_TXE_FIFO_UR, SK_TRUE}, {GM_TXE_FIFO_UR, SK_TRUE}},
        /* SK_PNMI_HTX_CARRIER */
        {{XM_TXE_CS_ERR, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_UTILUNDER */
        {{0, SK_FALSE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_UTILOVER */
        {{0, SK_FALSE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_64 */
        {{XM_TXF_64B, SK_TRUE}, {GM_TXF_64B, SK_TRUE}},
        /* SK_PNMI_HTX_127 */
        {{XM_TXF_127B, SK_TRUE}, {GM_TXF_127B, SK_TRUE}},
        /* SK_PNMI_HTX_255 */
        {{XM_TXF_255B, SK_TRUE}, {GM_TXF_255B, SK_TRUE}},
        /* SK_PNMI_HTX_511 */
        {{XM_TXF_511B, SK_TRUE}, {GM_TXF_511B, SK_TRUE}},
        /* SK_PNMI_HTX_1023 */
        {{XM_TXF_1023B, SK_TRUE}, {GM_TXF_1023B, SK_TRUE}},
        /* SK_PNMI_HTX_MAX */
        {{XM_TXF_MAX_SZ, SK_TRUE}, {GM_TXF_1518B, SK_TRUE}},
        /* SK_PNMI_HTX_LONGFRAMES  */
        {{XM_TXF_LONG, SK_TRUE}, {GM_TXF_MAX_SZ, SK_TRUE}},
        /* SK_PNMI_HTX_SYNC */
        {{0, SK_FALSE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_SYNC_OCTET */
        {{0, SK_FALSE}, {0, SK_FALSE}},
        /* SK_PNMI_HTX_RESERVED */
        {{0, SK_FALSE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX */
        {{XM_RXF_OK, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_OCTETHIGH */
        {{XM_RXO_OK_HI, SK_TRUE}, {GM_RXO_OK_HI, SK_TRUE}},
        /* SK_PNMI_HRX_OCTETLOW */
        {{XM_RXO_OK_LO, SK_FALSE}, {GM_RXO_OK_LO, SK_FALSE}},
        /* SK_PNMI_HRX_BADOCTETHIGH */
        {{0, SK_FALSE}, {GM_RXO_ERR_HI, SK_TRUE}},
        /* SK_PNMI_HRX_BADOCTETLOW */
        {{0, SK_FALSE}, {GM_RXO_ERR_LO, SK_TRUE}},
        /* SK_PNMI_HRX_BROADCAST */
        {{XM_RXF_BC_OK, SK_TRUE}, {GM_RXF_BC_OK, SK_TRUE}},
        /* SK_PNMI_HRX_MULTICAST */
        {{XM_RXF_MC_OK, SK_TRUE}, {GM_RXF_MC_OK, SK_TRUE}},
        /* SK_PNMI_HRX_UNICAST */
        {{XM_RXF_UC_OK, SK_TRUE}, {GM_RXF_UC_OK, SK_TRUE}},
        /* SK_PNMI_HRX_PMACC */
        {{XM_RXF_MPAUSE, SK_TRUE}, {GM_RXF_MPAUSE, SK_TRUE}},
        /* SK_PNMI_HRX_MACC */
        {{XM_RXF_MCTRL, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_PMACC_ERR */
        {{XM_RXF_INV_MP, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_MACC_UNKWN */
        {{XM_RXF_INV_MOC, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_BURST */
        {{XM_RXE_BURST, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_MISSED */
        {{XM_RXE_FMISS, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_FRAMING */
        {{XM_RXF_FRA_ERR, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_UNDERSIZE */
        {{0, SK_FALSE},{GM_RXF_SHT, SK_TRUE}},
        /* SK_PNMI_HRX_OVERFLOW */
        {{XM_RXE_FIFO_OV, SK_TRUE}, {GM_RXE_FIFO_OV, SK_TRUE}},
        /* SK_PNMI_HRX_JABBER */
        {{XM_RXF_JAB_PKT, SK_TRUE}, {GM_RXF_JAB_PKT, SK_TRUE}},
        /* SK_PNMI_HRX_CARRIER */
        {{XM_RXE_CAR_ERR, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_IRLENGTH */
        {{XM_RXF_LEN_ERR, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_SYMBOL */
        {{XM_RXE_SYM_ERR, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_SHORTS */
        {{XM_RXE_SHT_ERR, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_RUNT */
        {{XM_RXE_RUNT, SK_TRUE}, {GM_RXE_FRAG, SK_TRUE}},
        /* SK_PNMI_HRX_TOO_LONG */
        {{XM_RXF_LNG_ERR, SK_TRUE}, {GM_RXF_LNG_ERR, SK_TRUE}},
        /* SK_PNMI_HRX_FCS */
        {{XM_RXF_FCS_ERR, SK_TRUE}, {GM_RXF_FCS_ERR, SK_TRUE}},
        /* SK_PNMI_HRX_CEXT */
        {{XM_RXF_CEX_ERR, SK_TRUE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_UTILUNDER */
        {{0, SK_FALSE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_UTILOVER */
        {{0, SK_FALSE}, {0, SK_FALSE}},
        /* SK_PNMI_HRX_64 */
        {{XM_RXF_64B, SK_TRUE}, {GM_RXF_64B, SK_TRUE}},
        /* SK_PNMI_HRX_127 */
        {{XM_RXF_127B, SK_TRUE}, {GM_RXF_127B, SK_TRUE}},
        /* SK_PNMI_HRX_255 */
        {{XM_RXF_255B, SK_TRUE}, {GM_RXF_255B, SK_TRUE}},
        /* SK_PNMI_HRX_511 */
        {{XM_RXF_511B, SK_TRUE}, {GM_RXF_511B, SK_TRUE}},
        /* SK_PNMI_HRX_1023 */
        {{XM_RXF_1023B, SK_TRUE}, {GM_RXF_1023B, SK_TRUE}},
        /* SK_PNMI_HRX_MAX */
        {{XM_RXF_MAX_SZ, SK_TRUE}, {GM_RXF_1518B, SK_TRUE}},
        /* SK_PNMI_HRX_LONGFRAMES */
        {{0, SK_FALSE}, {GM_RXF_MAX_SZ, SK_TRUE}},
        /* SK_PNMI_HRX_RESERVED */
        {{0, SK_FALSE}, {0, SK_FALSE}}
};


/*****************************************************************************
 *
 * Public functions
 *
 */

/*****************************************************************************
 *
 * SkPnmiInit - Init function of PNMI
 *
 * Description:
 *      SK_INIT_DATA: Initialises the data structures
 *      SK_INIT_IO:   Resets the XMAC statistics, determines the device and
 *                    connector type.
 *      SK_INIT_RUN:  Starts a timer event for port switch per hour
 *                    calculation.
 *
 * Returns:
 *      Always 0
 */
int SkPnmiInit(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Level)              /* Initialization level */
{
        unsigned int    PortMax;        /* Number of ports */
        unsigned int    PortIndex;      /* Current port index in loop */
        SK_U16          Val16;          /* Multiple purpose 16 bit variable */
        SK_U8           Val8;           /* Mulitple purpose 8 bit variable */
        SK_EVPARA       EventParam;     /* Event struct for timer event */
        SK_GEPORT       *pPrt;
        SK_PNMI_VCT     *pVctBackupData;


        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                ("PNMI: SkPnmiInit: Called, level=%d\n", Level));

        switch (Level) {

        case SK_INIT_DATA:
                SK_MEMSET((char *)&pAC->Pnmi, 0, sizeof(pAC->Pnmi));
                pAC->Pnmi.TrapBufFree = SK_PNMI_TRAP_QUEUE_LEN;
                pAC->Pnmi.StartUpTime = SK_PNMI_HUNDREDS_SEC(SkOsGetTime(pAC));
                pAC->Pnmi.RlmtChangeThreshold = SK_PNMI_DEF_RLMT_CHG_THRES;
                for (PortIndex = 0; PortIndex < SK_MAX_MACS; PortIndex ++) {

                        pAC->Pnmi.Port[PortIndex].ActiveFlag = SK_FALSE;
                        pAC->Pnmi.DualNetActiveFlag = SK_FALSE;
                }

#ifdef SK_PNMI_CHECK
                if (SK_PNMI_MAX_IDX != SK_PNMI_CNT_NO) {
                        
                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR049, SK_PNMI_ERR049MSG);

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_INIT | SK_DBGCAT_FATAL,
                                           ("CounterOffset struct size (%d) differs from"
                                                "SK_PNMI_MAX_IDX (%d)\n",
                                                SK_PNMI_CNT_NO, SK_PNMI_MAX_IDX));
                        BRK;
                }

                if (SK_PNMI_MAX_IDX !=
                        (sizeof(StatAddr) / (sizeof(SK_PNMI_STATADDR) * SK_PNMI_MAC_TYPES))) {
                        
                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR050, SK_PNMI_ERR050MSG);

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_INIT | SK_DBGCAT_FATAL,
                                           ("StatAddr table size (%d) differs from "
                                                "SK_PNMI_MAX_IDX (%d)\n",
                                                (sizeof(StatAddr) / 
                                                 (sizeof(SK_PNMI_STATADDR) * SK_PNMI_MAC_TYPES)),
                                                 SK_PNMI_MAX_IDX));
                        BRK;
                }
#endif /* SK_PNMI_CHECK */
                break;

        case SK_INIT_IO:
                /*
                 * Reset MAC counters
                 */
                PortMax = pAC->GIni.GIMacsFound;

                for (PortIndex = 0; PortIndex < PortMax; PortIndex ++) {

                        pAC->GIni.GIFunc.pFnMacResetCounter(pAC, IoC, PortIndex);
                }
                
                /* Initialize DSP variables for Vct() to 0xff => Never written! */              
                for (PortIndex = 0; PortIndex < PortMax; PortIndex ++) {
                        pPrt = &pAC->GIni.GP[PortIndex];
                        pPrt->PCableLen =0xff;
                        pVctBackupData = &pAC->Pnmi.VctBackup[PortIndex];
                        pVctBackupData->PCableLen = 0xff;
                }
                
                /*
                 * Get pci bus speed
                 */
                SK_IN16(IoC, B0_CTST, &Val16);
                if ((Val16 & CS_BUS_CLOCK) == 0) {

                        pAC->Pnmi.PciBusSpeed = 33;
                }
                else {
                        pAC->Pnmi.PciBusSpeed = 66;
                }

                /*
                 * Get pci bus width
                 */
                SK_IN16(IoC, B0_CTST, &Val16);
                if ((Val16 & CS_BUS_SLOT_SZ) == 0) {

                        pAC->Pnmi.PciBusWidth = 32;
                }
                else {
                        pAC->Pnmi.PciBusWidth = 64;
                }

                /*
                 * Get chipset
                 */
                switch (pAC->GIni.GIChipId) {
                case CHIP_ID_GENESIS:
                        pAC->Pnmi.Chipset = SK_PNMI_CHIPSET_XMAC;
                        break;

                case CHIP_ID_YUKON:
                        pAC->Pnmi.Chipset = SK_PNMI_CHIPSET_YUKON;
                        break;

                default:
                        break;
                }

                /*
                 * Get PMD and DeviceType
                 */
                SK_IN8(IoC, B2_PMD_TYP, &Val8);
                switch (Val8) {
                case 'S':
                        pAC->Pnmi.PMD = 3;
                        if (pAC->GIni.GIMacsFound > 1) {

                                pAC->Pnmi.DeviceType = 0x00020002;
                        }
                        else {
                                pAC->Pnmi.DeviceType = 0x00020001;
                        }
                        break;

                case 'L':
                        pAC->Pnmi.PMD = 2;
                        if (pAC->GIni.GIMacsFound > 1) {

                                pAC->Pnmi.DeviceType = 0x00020004;
                        }
                        else {
                                pAC->Pnmi.DeviceType = 0x00020003;
                        }
                        break;

                case 'C':
                        pAC->Pnmi.PMD = 4;
                        if (pAC->GIni.GIMacsFound > 1) {

                                pAC->Pnmi.DeviceType = 0x00020006;
                        }
                        else {
                                pAC->Pnmi.DeviceType = 0x00020005;
                        }
                        break;

                case 'T':
                        pAC->Pnmi.PMD = 5;
                        if (pAC->GIni.GIMacsFound > 1) {

                                pAC->Pnmi.DeviceType = 0x00020008;
                        }
                        else {
                                pAC->Pnmi.DeviceType = 0x00020007;
                        }
                        break;

                default :
                        pAC->Pnmi.PMD = 1;
                        pAC->Pnmi.DeviceType = 0;
                        break;
                }

                /*
                 * Get connector
                 */
                SK_IN8(IoC, B2_CONN_TYP, &Val8);
                switch (Val8) {
                case 'C':
                        pAC->Pnmi.Connector = 2;
                        break;

                case 'D':
                        pAC->Pnmi.Connector = 3;
                        break;

                case 'F':
                        pAC->Pnmi.Connector = 4;
                        break;

                case 'J':
                        pAC->Pnmi.Connector = 5;
                        break;

                case 'V':
                        pAC->Pnmi.Connector = 6;
                        break;

                default:
                        pAC->Pnmi.Connector = 1;
                        break;
                }               
                break;
                
        case SK_INIT_RUN:
                /*
                 * Start timer for RLMT change counter
                 */
                SK_MEMSET((char *) &EventParam, 0, sizeof(EventParam));
                SkTimerStart(pAC, IoC, &pAC->Pnmi.RlmtChangeEstimate.EstTimer,
                        28125000, SKGE_PNMI, SK_PNMI_EVT_CHG_EST_TIMER,
                        EventParam);
                break;

        default:
                break; /* Nothing todo */
        }

        return (0);
}

/*****************************************************************************
 *
 * SkPnmiGetVar - Retrieves the value of a single OID
 *
 * Description:
 *      Calls a general sub-function for all this stuff. If the instance
 *      -1 is passed, the values of all instances are returned in an
 *      array of values.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to take
 *                               the data.
 *      SK_PNMI_ERR_UNKNOWN_OID  The requested OID is unknown
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
int SkPnmiGetVar(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
SK_U32 Id,              /* Object ID that is to be processed */
void *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                ("PNMI: SkPnmiGetVar: Called, Id=0x%x, BufLen=%d, Instance=%d, NetIndex=%d\n",
                        Id, *pLen, Instance, NetIndex));

        return (PnmiVar(pAC, IoC, SK_PNMI_GET, Id, (char *)pBuf, pLen,
                Instance, NetIndex));
}

/*****************************************************************************
 *
 * SkPnmiPreSetVar - Presets the value of a single OID
 *
 * Description:
 *      Calls a general sub-function for all this stuff. The preset does
 *      the same as a set, but returns just before finally setting the
 *      new value. This is usefull to check if a set might be successfull.
 *      If as instance a -1 is passed, an array of values is supposed and
 *      all instance of the OID will be set.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_OID  The requested OID is unknown.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
int SkPnmiPreSetVar(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
SK_U32 Id,              /* Object ID that is to be processed */
void *pBuf,             /* Buffer which stores the mgmt data to be set */
unsigned int *pLen,     /* Total length of mgmt data */
SK_U32 Instance,        /* Instance (1..n) that is to be set or -1 */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                ("PNMI: SkPnmiPreSetVar: Called, Id=0x%x, BufLen=%d, Instance=%d, NetIndex=%d\n",
                        Id, *pLen, Instance, NetIndex));


        return (PnmiVar(pAC, IoC, SK_PNMI_PRESET, Id, (char *)pBuf, pLen,
                Instance, NetIndex));
}

/*****************************************************************************
 *
 * SkPnmiSetVar - Sets the value of a single OID
 *
 * Description:
 *      Calls a general sub-function for all this stuff. The preset does
 *      the same as a set, but returns just before finally setting the
 *      new value. This is usefull to check if a set might be successfull.
 *      If as instance a -1 is passed, an array of values is supposed and
 *      all instance of the OID will be set.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_OID  The requested OID is unknown.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
int SkPnmiSetVar(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
SK_U32 Id,              /* Object ID that is to be processed */
void *pBuf,             /* Buffer which stores the mgmt data to be set */
unsigned int *pLen,     /* Total length of mgmt data */
SK_U32 Instance,        /* Instance (1..n) that is to be set or -1 */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                ("PNMI: SkPnmiSetVar: Called, Id=0x%x, BufLen=%d, Instance=%d, NetIndex=%d\n",
                        Id, *pLen, Instance, NetIndex));

        return (PnmiVar(pAC, IoC, SK_PNMI_SET, Id, (char *)pBuf, pLen,
                Instance, NetIndex));
}

/*****************************************************************************
 *
 * SkPnmiGetStruct - Retrieves the management database in SK_PNMI_STRUCT_DATA
 *
 * Description:
 *      Runs through the IdTable, queries the single OIDs and stores the
 *      returned data into the management database structure
 *      SK_PNMI_STRUCT_DATA. The offset of the OID in the structure
 *      is stored in the IdTable. The return value of the function will also
 *      be stored in SK_PNMI_STRUCT_DATA if the passed buffer has the
 *      minimum size of SK_PNMI_MIN_STRUCT_SIZE.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to take
 *                               the data.
 *      SK_PNMI_ERR_UNKNOWN_NET  The requested NetIndex doesn't exist 
 */
int SkPnmiGetStruct(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
void *pBuf,             /* Buffer which will store the retrieved data */
unsigned int *pLen,     /* Length of buffer */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        int             Ret;
        unsigned int    TableIndex;
        unsigned int    DstOffset;
        unsigned int    InstanceNo;
        unsigned int    InstanceCnt;
        SK_U32          Instance;
        unsigned int    TmpLen;
        char            KeyArr[SK_PNMI_VPD_ENTRIES][SK_PNMI_VPD_KEY_SIZE];


        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                ("PNMI: SkPnmiGetStruct: Called, BufLen=%d, NetIndex=%d\n",
                        *pLen, NetIndex));

        if (*pLen < SK_PNMI_STRUCT_SIZE) {

                if (*pLen >= SK_PNMI_MIN_STRUCT_SIZE) {

                        SK_PNMI_SET_STAT(pBuf, SK_PNMI_ERR_TOO_SHORT,
                                (SK_U32)(-1));
                }

                *pLen = SK_PNMI_STRUCT_SIZE;
                return (SK_PNMI_ERR_TOO_SHORT);
        }

    /*
     * Check NetIndex
     */
        if (NetIndex >= pAC->Rlmt.NumNets) {
                return (SK_PNMI_ERR_UNKNOWN_NET);
        }

        /* Update statistic */
        SK_PNMI_CHECKFLAGS("SkPnmiGetStruct: On call");

        if ((Ret = MacUpdate(pAC, IoC, 0, pAC->GIni.GIMacsFound - 1)) !=
                SK_PNMI_ERR_OK) {

                SK_PNMI_SET_STAT(pBuf, Ret, (SK_U32)(-1));
                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                return (Ret);
        }

        if ((Ret = RlmtUpdate(pAC, IoC, NetIndex)) != SK_PNMI_ERR_OK) {

                SK_PNMI_SET_STAT(pBuf, Ret, (SK_U32)(-1));
                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                return (Ret);
        }

        if ((Ret = SirqUpdate(pAC, IoC)) != SK_PNMI_ERR_OK) {

                SK_PNMI_SET_STAT(pBuf, Ret, (SK_U32)(-1));
                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                return (Ret);
        }

        /*
         * Increment semaphores to indicate that an update was
         * already done
         */
        pAC->Pnmi.MacUpdatedFlag ++;
        pAC->Pnmi.RlmtUpdatedFlag ++;
        pAC->Pnmi.SirqUpdatedFlag ++;

        /* Get vpd keys for instance calculation */
        Ret = GetVpdKeyArr(pAC, IoC, &KeyArr[0][0], sizeof(KeyArr), &TmpLen);
        if (Ret != SK_PNMI_ERR_OK) {

                pAC->Pnmi.MacUpdatedFlag --;
                pAC->Pnmi.RlmtUpdatedFlag --;
                pAC->Pnmi.SirqUpdatedFlag --;

                SK_PNMI_CHECKFLAGS("SkPnmiGetStruct: On return");
                SK_PNMI_SET_STAT(pBuf, Ret, (SK_U32)(-1));
                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                return (SK_PNMI_ERR_GENERAL);
        }

        /* Retrieve values */
        SK_MEMSET((char *)pBuf, 0, SK_PNMI_STRUCT_SIZE);
        for (TableIndex = 0; TableIndex < ID_TABLE_SIZE; TableIndex ++) {

                InstanceNo = IdTable[TableIndex].InstanceNo;
                for (InstanceCnt = 1; InstanceCnt <= InstanceNo;
                        InstanceCnt ++) {

                        DstOffset = IdTable[TableIndex].Offset +
                                (InstanceCnt - 1) *
                                IdTable[TableIndex].StructSize;

                        /*
                         * For the VPD the instance is not an index number
                         * but the key itself. Determin with the instance
                         * counter the VPD key to be used.
                         */
                        if (IdTable[TableIndex].Id == OID_SKGE_VPD_KEY ||
                                IdTable[TableIndex].Id == OID_SKGE_VPD_VALUE ||
                                IdTable[TableIndex].Id == OID_SKGE_VPD_ACCESS ||
                                IdTable[TableIndex].Id == OID_SKGE_VPD_ACTION) {

                                SK_STRNCPY((char *)&Instance, KeyArr[InstanceCnt - 1], 4);
                        }
                        else {
                                Instance = (SK_U32)InstanceCnt;
                        }

                        TmpLen = *pLen - DstOffset;
                        Ret = IdTable[TableIndex].Func(pAC, IoC, SK_PNMI_GET,
                                IdTable[TableIndex].Id, (char *)pBuf +
                                DstOffset, &TmpLen, Instance, TableIndex, NetIndex);

                        /*
                         * An unknown instance error means that we reached
                         * the last instance of that variable. Proceed with
                         * the next OID in the table and ignore the return
                         * code.
                         */
                        if (Ret == SK_PNMI_ERR_UNKNOWN_INST) {

                break;
                        }

                        if (Ret != SK_PNMI_ERR_OK) {

                                pAC->Pnmi.MacUpdatedFlag --;
                                pAC->Pnmi.RlmtUpdatedFlag --;
                                pAC->Pnmi.SirqUpdatedFlag --;

                                SK_PNMI_CHECKFLAGS("SkPnmiGetStruct: On return");
                                SK_PNMI_SET_STAT(pBuf, Ret, DstOffset);
                                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                                return (Ret);
                        }
                }
        }

        pAC->Pnmi.MacUpdatedFlag --;
        pAC->Pnmi.RlmtUpdatedFlag --;
        pAC->Pnmi.SirqUpdatedFlag --;

        *pLen = SK_PNMI_STRUCT_SIZE;
        SK_PNMI_CHECKFLAGS("SkPnmiGetStruct: On return");
        SK_PNMI_SET_STAT(pBuf, SK_PNMI_ERR_OK, (SK_U32)(-1));
        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * SkPnmiPreSetStruct - Presets the management database in SK_PNMI_STRUCT_DATA
 *
 * Description:
 *      Calls a general sub-function for all this set stuff. The preset does
 *      the same as a set, but returns just before finally setting the
 *      new value. This is usefull to check if a set might be successfull.
 *      The sub-function runs through the IdTable, checks which OIDs are able
 *      to set, and calls the handler function of the OID to perform the
 *      preset. The return value of the function will also be stored in
 *      SK_PNMI_STRUCT_DATA if the passed buffer has the minimum size of
 *      SK_PNMI_MIN_STRUCT_SIZE.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 */
int SkPnmiPreSetStruct(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
void *pBuf,             /* Buffer which contains the data to be set */
unsigned int *pLen,     /* Length of buffer */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                ("PNMI: SkPnmiPreSetStruct: Called, BufLen=%d, NetIndex=%d\n",
                        *pLen, NetIndex));

        return (PnmiStruct(pAC, IoC, SK_PNMI_PRESET, (char *)pBuf, 
                                        pLen, NetIndex));
}

/*****************************************************************************
 *
 * SkPnmiSetStruct - Sets the management database in SK_PNMI_STRUCT_DATA
 *
 * Description:
 *      Calls a general sub-function for all this set stuff. The return value
 *      of the function will also be stored in SK_PNMI_STRUCT_DATA if the
 *      passed buffer has the minimum size of SK_PNMI_MIN_STRUCT_SIZE.
 *      The sub-function runs through the IdTable, checks which OIDs are able
 *      to set, and calls the handler function of the OID to perform the
 *      set. The return value of the function will also be stored in
 *      SK_PNMI_STRUCT_DATA if the passed buffer has the minimum size of
 *      SK_PNMI_MIN_STRUCT_SIZE.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 */
int SkPnmiSetStruct(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
void *pBuf,             /* Buffer which contains the data to be set */
unsigned int *pLen,     /* Length of buffer */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                ("PNMI: SkPnmiSetStruct: Called, BufLen=%d, NetIndex=%d\n",
                        *pLen, NetIndex));

        return (PnmiStruct(pAC, IoC, SK_PNMI_SET, (char *)pBuf, 
                                        pLen, NetIndex));
}

/*****************************************************************************
 *
 * SkPnmiEvent - Event handler
 *
 * Description:
 *      Handles the following events:
 *      SK_PNMI_EVT_SIRQ_OVERFLOW     When a hardware counter overflows an
 *                                    interrupt will be generated which is
 *                                    first handled by SIRQ which generates a
 *                                    this event. The event increments the
 *                                    upper 32 bit of the 64 bit counter.
 *      SK_PNMI_EVT_SEN_XXX           The event is generated by the I2C module
 *                                    when a sensor reports a warning or
 *                                    error. The event will store a trap
 *                                    message in the trap buffer.
 *      SK_PNMI_EVT_CHG_EST_TIMER     The timer event was initiated by this
 *                                    module and is used to calculate the
 *                                    port switches per hour.
 *      SK_PNMI_EVT_CLEAR_COUNTER     The event clears all counters and
 *                                    timestamps.
 *      SK_PNMI_EVT_XMAC_RESET        The event is generated by the driver
 *                                    before a hard reset of the XMAC is
 *                                    performed. All counters will be saved
 *                                    and added to the hardware counter
 *                                    values after reset to grant continuous
 *                                    counter values.
 *      SK_PNMI_EVT_RLMT_PORT_UP      Generated by RLMT to notify that a port
 *                                    went logically up. A trap message will
 *                                    be stored to the trap buffer.
 *      SK_PNMI_EVT_RLMT_PORT_DOWN    Generated by RLMT to notify that a port
 *                                    went logically down. A trap message will
 *                                    be stored to the trap buffer.
 *      SK_PNMI_EVT_RLMT_SEGMENTATION Generated by RLMT to notify that two
 *                                    spanning tree root bridges were
 *                                    detected. A trap message will be stored
 *                                    to the trap buffer.
 *      SK_PNMI_EVT_RLMT_ACTIVE_DOWN  Notifies PNMI that an active port went
 *                                    down. PNMI will not further add the
 *                                    statistic values to the virtual port.
 *      SK_PNMI_EVT_RLMT_ACTIVE_UP    Notifies PNMI that a port went up and
 *                                    is now an active port. PNMI will now
 *                                    add the statistic data of this port to
 *                                    the virtual port.
 *      SK_PNMI_EVT_RLMT_SET_NETS     Notifies PNMI about the net mode. The first Parameter
 *                                    contains the number of nets. 1 means single net, 2 means
 *                                    dual net. The second Parameter is -1
 *
 * Returns:
 *      Always 0
 */
int SkPnmiEvent(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
SK_U32 Event,           /* Event-Id */
SK_EVPARA Param)        /* Event dependent parameter */
{
        unsigned int    PhysPortIndex;
        unsigned int    MaxNetNumber;
        int                     CounterIndex;
        int                     Ret;
        SK_U16          MacStatus;
        SK_U64          OverflowStatus;
        SK_U64          Mask;
        int                     MacType;
        SK_U64          Value;
        SK_U32          Val32;
        SK_U16          Register;
        SK_EVPARA       EventParam;
        SK_U64          NewestValue;
        SK_U64          OldestValue;
        SK_U64          Delta;
        SK_PNMI_ESTIMATE *pEst;
        SK_U32          NetIndex;
        SK_GEPORT       *pPrt;
        SK_PNMI_VCT     *pVctBackupData;
        SK_U32          RetCode;
        int             i;
        SK_U32          CableLength;


#ifdef DEBUG
        if (Event != SK_PNMI_EVT_XMAC_RESET) {

                SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                        ("PNMI: SkPnmiEvent: Called, Event=0x%x, Param=0x%x\n",
                        (unsigned int)Event, (unsigned int)Param.Para64));
        }
#endif
        SK_PNMI_CHECKFLAGS("SkPnmiEvent: On call");

        MacType = pAC->GIni.GIMacType;
        
        switch (Event) {

        case SK_PNMI_EVT_SIRQ_OVERFLOW:
                PhysPortIndex = (int)Param.Para32[0];
                MacStatus = (SK_U16)Param.Para32[1];
#ifdef DEBUG
                if (PhysPortIndex >= SK_MAX_MACS) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_SIRQ_OVERFLOW parameter"
                                 " wrong, PhysPortIndex=0x%x\n",
                                PhysPortIndex));
                        return (0);
                }
#endif
                OverflowStatus = 0;

                /*
                 * Check which source caused an overflow interrupt.
                 */
                if ((pAC->GIni.GIFunc.pFnMacOverflow(
                         pAC, IoC, PhysPortIndex, MacStatus, &OverflowStatus) != 0) ||
                        (OverflowStatus == 0)) {

                        SK_PNMI_CHECKFLAGS("SkPnmiEvent: On return");
                        return (0); 
                }

                /*
                 * Check the overflow status register and increment
                 * the upper dword of corresponding counter.
                 */
                for (CounterIndex = 0; CounterIndex < sizeof(Mask) * 8;
                        CounterIndex ++) {

                        Mask = (SK_U64)1 << CounterIndex;
                        if ((OverflowStatus & Mask) == 0) {

                                continue;
                        }

                        switch (StatOvrflwBit[CounterIndex][MacType]) {

                        case SK_PNMI_HTX_UTILUNDER:
                        case SK_PNMI_HTX_UTILOVER:
                                XM_IN16(IoC, PhysPortIndex, XM_TX_CMD,
                                        &Register);
                                Register |= XM_TX_SAM_LINE;
                                XM_OUT16(IoC, PhysPortIndex, XM_TX_CMD,
                                        Register);
                                break;

                        case SK_PNMI_HRX_UTILUNDER:
                        case SK_PNMI_HRX_UTILOVER:
                                XM_IN16(IoC, PhysPortIndex, XM_RX_CMD,
                                        &Register);
                                Register |= XM_RX_SAM_LINE;
                                XM_OUT16(IoC, PhysPortIndex, XM_RX_CMD,
                                        Register);
                                break;

                        case SK_PNMI_HTX_OCTETHIGH:
                        case SK_PNMI_HTX_OCTETLOW:
                        case SK_PNMI_HTX_RESERVED:
                        case SK_PNMI_HRX_OCTETHIGH:
                        case SK_PNMI_HRX_OCTETLOW:
                        case SK_PNMI_HRX_IRLENGTH:
                        case SK_PNMI_HRX_RESERVED:
                        
                        /*
                         * the following counters aren't be handled (id > 63)
                         */
                        case SK_PNMI_HTX_SYNC:
                        case SK_PNMI_HTX_SYNC_OCTET:
                                break;

                        case SK_PNMI_HRX_LONGFRAMES:
                                if (MacType == SK_MAC_GMAC) {
                                        pAC->Pnmi.Port[PhysPortIndex].
                                                CounterHigh[CounterIndex] ++;
                                }
                                break;

                        default:
                                pAC->Pnmi.Port[PhysPortIndex].
                                        CounterHigh[CounterIndex] ++;
                        }
                }
                break;

        case SK_PNMI_EVT_SEN_WAR_LOW:
#ifdef DEBUG
                if ((unsigned int)Param.Para64 >= (unsigned int)pAC->I2c.MaxSens) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_SEN_WAR_LOW parameter wrong, SensorIndex=%d\n",
                                (unsigned int)Param.Para64));
                        return (0);
                }
#endif
                /*
                 * Store a trap message in the trap buffer and generate
                 * an event for user space applications with the
                 * SK_DRIVER_SENDEVENT macro.
                 */
                QueueSensorTrap(pAC, OID_SKGE_TRAP_SEN_WAR_LOW,
                        (unsigned int)Param.Para64);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);
                break;

        case SK_PNMI_EVT_SEN_WAR_UPP:
#ifdef DEBUG
                if ((unsigned int)Param.Para64 >= (unsigned int)pAC->I2c.MaxSens) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR:SkPnmiEvent: SK_PNMI_EVT_SEN_WAR_UPP parameter wrong, SensorIndex=%d\n",
                                (unsigned int)Param.Para64));
                        return (0);
                }
#endif
                /*
                 * Store a trap message in the trap buffer and generate
                 * an event for user space applications with the
                 * SK_DRIVER_SENDEVENT macro.
                 */
                QueueSensorTrap(pAC, OID_SKGE_TRAP_SEN_WAR_UPP,
                        (unsigned int)Param.Para64);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);
                break;

        case SK_PNMI_EVT_SEN_ERR_LOW:
#ifdef DEBUG
                if ((unsigned int)Param.Para64 >= (unsigned int)pAC->I2c.MaxSens) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_SEN_ERR_LOW parameter wrong, SensorIndex=%d\n",
                                (unsigned int)Param.Para64));
                        return (0);
                }
#endif
                /*
                 * Store a trap message in the trap buffer and generate
                 * an event for user space applications with the
                 * SK_DRIVER_SENDEVENT macro.
                 */
                QueueSensorTrap(pAC, OID_SKGE_TRAP_SEN_ERR_LOW,
                        (unsigned int)Param.Para64);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);
                break;
        
        case SK_PNMI_EVT_SEN_ERR_UPP:
#ifdef DEBUG
                if ((unsigned int)Param.Para64 >= (unsigned int)pAC->I2c.MaxSens) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_SEN_ERR_UPP parameter wrong, SensorIndex=%d\n",
                                (unsigned int)Param.Para64));
                        return (0);
                }
#endif
                /*
                 * Store a trap message in the trap buffer and generate
                 * an event for user space applications with the
                 * SK_DRIVER_SENDEVENT macro.
                 */
                QueueSensorTrap(pAC, OID_SKGE_TRAP_SEN_ERR_UPP,
                        (unsigned int)Param.Para64);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);
                break;

        case SK_PNMI_EVT_CHG_EST_TIMER:
                /*
                 * Calculate port switch average on a per hour basis
                 *   Time interval for check       : 28125 ms
                 *   Number of values for average  : 8
                 *
                 * Be careful in changing these values, on change check
                 *   - typedef of SK_PNMI_ESTIMATE (Size of EstValue
                 *     array one less than value number)
                 *   - Timer initilization SkTimerStart() in SkPnmiInit
                 *   - Delta value below must be multiplicated with
                 *     power of 2
                 *
                 */
                pEst = &pAC->Pnmi.RlmtChangeEstimate;
                CounterIndex = pEst->EstValueIndex + 1;
                if (CounterIndex == 7) {

                        CounterIndex = 0;
                }
                pEst->EstValueIndex = CounterIndex;

                NewestValue = pAC->Pnmi.RlmtChangeCts;
                OldestValue = pEst->EstValue[CounterIndex];
                pEst->EstValue[CounterIndex] = NewestValue;

                /*
                 * Calculate average. Delta stores the number of
                 * port switches per 28125 * 8 = 225000 ms
                 */
                if (NewestValue >= OldestValue) {

                        Delta = NewestValue - OldestValue;
                }
                else {
                        /* Overflow situation */
                        Delta = (SK_U64)(0 - OldestValue) + NewestValue;
                }

                /*
                 * Extrapolate delta to port switches per hour.
                 *     Estimate = Delta * (3600000 / 225000)
                 *              = Delta * 16
                 *              = Delta << 4
                 */
                pAC->Pnmi.RlmtChangeEstimate.Estimate = Delta << 4;

                /*
                 * Check if threshold is exceeded. If the threshold is
                 * permanently exceeded every 28125 ms an event will be
                 * generated to remind the user of this condition.
                 */
                if ((pAC->Pnmi.RlmtChangeThreshold != 0) &&
                        (pAC->Pnmi.RlmtChangeEstimate.Estimate >=
                        pAC->Pnmi.RlmtChangeThreshold)) {

                        QueueSimpleTrap(pAC, OID_SKGE_TRAP_RLMT_CHANGE_THRES);
                        (void)SK_DRIVER_SENDEVENT(pAC, IoC);
                }

                SK_MEMSET((char *) &EventParam, 0, sizeof(EventParam));
                SkTimerStart(pAC, IoC, &pAC->Pnmi.RlmtChangeEstimate.EstTimer,
                        28125000, SKGE_PNMI, SK_PNMI_EVT_CHG_EST_TIMER,
                        EventParam);
                break;

        case SK_PNMI_EVT_CLEAR_COUNTER:
                /*
                 *  Param.Para32[0] contains the NetIndex (0 ..1).
                 *  Param.Para32[1] is reserved, contains -1.
                 */
                NetIndex = (SK_U32)Param.Para32[0];

#ifdef DEBUG
                if (NetIndex >= pAC->Rlmt.NumNets) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_CLEAR_COUNTER parameter wrong, NetIndex=%d\n",
                                NetIndex));

                        return (0);
                }
#endif

                /*
                 * Set all counters and timestamps to zero
                 */
                ResetCounter(pAC, IoC, NetIndex); /* the according NetIndex is required
                                                                                                as a Parameter of the Event */ 
                break;

        case SK_PNMI_EVT_XMAC_RESET:
                /*
                 * To grant continuous counter values store the current
                 * XMAC statistic values to the entries 1..n of the
                 * CounterOffset array. XMAC Errata #2 
                 */
#ifdef DEBUG
                if ((unsigned int)Param.Para64 >= SK_MAX_MACS) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_XMAC_RESET parameter wrong, PhysPortIndex=%d\n",
                                (unsigned int)Param.Para64));
                        return (0);
                }
#endif
                PhysPortIndex = (unsigned int)Param.Para64;

                /*
                 * Update XMAC statistic to get fresh values
                 */
                Ret = MacUpdate(pAC, IoC, 0, pAC->GIni.GIMacsFound - 1);
                if (Ret != SK_PNMI_ERR_OK) {

                        SK_PNMI_CHECKFLAGS("SkPnmiEvent: On return");
                        return (0);
                }
                /*
                 * Increment semaphore to indicate that an update was
                 * already done
                 */
                pAC->Pnmi.MacUpdatedFlag ++;

                for (CounterIndex = 0; CounterIndex < SK_PNMI_MAX_IDX;
                        CounterIndex ++) {

                        if (!StatAddr[CounterIndex][MacType].GetOffset) {

                                continue;
                        }

                        pAC->Pnmi.Port[PhysPortIndex].
                                CounterOffset[CounterIndex] = GetPhysStatVal(
                                pAC, IoC, PhysPortIndex, CounterIndex);
                        pAC->Pnmi.Port[PhysPortIndex].
                                CounterHigh[CounterIndex] = 0;
                }

                pAC->Pnmi.MacUpdatedFlag --;
                break;

        case SK_PNMI_EVT_RLMT_PORT_UP:
                PhysPortIndex = (unsigned int)Param.Para32[0];
#ifdef DEBUG
                if (PhysPortIndex >= SK_MAX_MACS) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_RLMT_PORT_UP parameter"
                 " wrong, PhysPortIndex=%d\n", PhysPortIndex));

                        return (0);
                }
#endif
                /*
                 * Store a trap message in the trap buffer and generate an event for
                 * user space applications with the SK_DRIVER_SENDEVENT macro.
                 */
                QueueRlmtPortTrap(pAC, OID_SKGE_TRAP_RLMT_PORT_UP, PhysPortIndex);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);

                /* Bugfix for XMAC errata (#10620)*/
                if (pAC->GIni.GIMacType == SK_MAC_XMAC){

                        /* Add incremental difference to offset (#10620)*/
                        (void)pAC->GIni.GIFunc.pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                XM_RXE_SHT_ERR, &Val32);
                        
                        Value = (((SK_U64)pAC->Pnmi.Port[PhysPortIndex].
                                 CounterHigh[SK_PNMI_HRX_SHORTS] << 32) | (SK_U64)Val32);
                        pAC->Pnmi.Port[PhysPortIndex].CounterOffset[SK_PNMI_HRX_SHORTS] +=
                                Value - pAC->Pnmi.Port[PhysPortIndex].RxShortZeroMark;
                }
                
                /* Tell VctStatus() that a link was up meanwhile. */
                pAC->Pnmi.VctStatus[PhysPortIndex] |= SK_PNMI_VCT_LINK;         
                break;

    case SK_PNMI_EVT_RLMT_PORT_DOWN:
                PhysPortIndex = (unsigned int)Param.Para32[0];

#ifdef DEBUG
                if (PhysPortIndex >= SK_MAX_MACS) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_RLMT_PORT_DOWN parameter"
                 " wrong, PhysPortIndex=%d\n", PhysPortIndex));

                        return (0);
                }
#endif
                /*
                 * Store a trap message in the trap buffer and generate an event for
                 * user space applications with the SK_DRIVER_SENDEVENT macro.
                 */
                QueueRlmtPortTrap(pAC, OID_SKGE_TRAP_RLMT_PORT_DOWN, PhysPortIndex);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);
        
                /* Bugfix #10620 - get zero level for incremental difference */
                if ((pAC->GIni.GIMacType == SK_MAC_XMAC)) {

                        (void)pAC->GIni.GIFunc.pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                XM_RXE_SHT_ERR, &Val32);
                        pAC->Pnmi.Port[PhysPortIndex].RxShortZeroMark = 
                                (((SK_U64)pAC->Pnmi.Port[PhysPortIndex].
                                 CounterHigh[SK_PNMI_HRX_SHORTS] << 32) | (SK_U64)Val32);
                }
                break;

        case SK_PNMI_EVT_RLMT_ACTIVE_DOWN:
                PhysPortIndex = (unsigned int)Param.Para32[0];
                NetIndex = (SK_U32)Param.Para32[1];

#ifdef DEBUG
                if (PhysPortIndex >= SK_MAX_MACS) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_RLMT_ACTIVE_DOWN parameter too high, PhysPort=%d\n",
                                PhysPortIndex));
                }

                if (NetIndex >= pAC->Rlmt.NumNets) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_RLMT_ACTIVE_DOWN parameter too high, NetIndex=%d\n",
                                NetIndex));
                }
#endif
                /*
                 * For now, ignore event if NetIndex != 0.
                 */
                if (Param.Para32[1] != 0) {

                        return (0);
                }

                /*
                 * Nothing to do if port is already inactive
                 */
                if (!pAC->Pnmi.Port[PhysPortIndex].ActiveFlag) {

                        return (0);
                }

                /*
                 * Update statistic counters to calculate new offset for the virtual
                 * port and increment semaphore to indicate that an update was already
                 * done.
                 */
                if (MacUpdate(pAC, IoC, 0, pAC->GIni.GIMacsFound - 1) !=
                        SK_PNMI_ERR_OK) {

                        SK_PNMI_CHECKFLAGS("SkPnmiEvent: On return");
                        return (0);
                }
                pAC->Pnmi.MacUpdatedFlag ++;

                /*
                 * Calculate new counter offset for virtual port to grant continous
                 * counting on port switches. The virtual port consists of all currently
                 * active ports. The port down event indicates that a port is removed
                 * from the virtual port. Therefore add the counter value of the removed
                 * port to the CounterOffset for the virtual port to grant the same
                 * counter value.
                 */
                for (CounterIndex = 0; CounterIndex < SK_PNMI_MAX_IDX;
                        CounterIndex ++) {

                        if (!StatAddr[CounterIndex][MacType].GetOffset) {

                                continue;
                        }

                        Value = GetPhysStatVal(pAC, IoC, PhysPortIndex, CounterIndex);

                        pAC->Pnmi.VirtualCounterOffset[CounterIndex] += Value;
                }

                /*
                 * Set port to inactive
                 */
                pAC->Pnmi.Port[PhysPortIndex].ActiveFlag = SK_FALSE;

                pAC->Pnmi.MacUpdatedFlag --;
                break;

        case SK_PNMI_EVT_RLMT_ACTIVE_UP:
                PhysPortIndex = (unsigned int)Param.Para32[0];
                NetIndex = (SK_U32)Param.Para32[1];

#ifdef DEBUG
                if (PhysPortIndex >= SK_MAX_MACS) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_RLMT_ACTIVE_UP parameter too high, PhysPort=%d\n",
                                PhysPortIndex));
                }

                if (NetIndex >= pAC->Rlmt.NumNets) {

                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_CTRL,
                                ("PNMI: ERR: SkPnmiEvent: SK_PNMI_EVT_RLMT_ACTIVE_UP parameter too high, NetIndex=%d\n",
                                NetIndex));
                }
#endif
                /*
                 * For now, ignore event if NetIndex != 0.
                 */
                if (Param.Para32[1] != 0) {

                        return (0);
                }

                /*
                 * Nothing to do if port is already active
                 */
                if (pAC->Pnmi.Port[PhysPortIndex].ActiveFlag) {

                        return (0);
                }

                /*
                 * Statistic maintenance
                 */
                pAC->Pnmi.RlmtChangeCts ++;
                pAC->Pnmi.RlmtChangeTime = SK_PNMI_HUNDREDS_SEC(SkOsGetTime(pAC));

                /*
                 * Store a trap message in the trap buffer and generate an event for
                 * user space applications with the SK_DRIVER_SENDEVENT macro.
                 */
                QueueRlmtNewMacTrap(pAC, PhysPortIndex);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);

                /*
                 * Update statistic counters to calculate new offset for the virtual
                 * port and increment semaphore to indicate that an update was
                 * already done.
                 */
                if (MacUpdate(pAC, IoC, 0, pAC->GIni.GIMacsFound - 1) !=
                        SK_PNMI_ERR_OK) {

                        SK_PNMI_CHECKFLAGS("SkPnmiEvent: On return");
                        return (0);
                }
                pAC->Pnmi.MacUpdatedFlag ++;

                /*
                 * Calculate new counter offset for virtual port to grant continous
                 * counting on port switches. A new port is added to the virtual port.
                 * Therefore substract the counter value of the new port from the
                 * CounterOffset for the virtual port to grant the same value.
                 */
                for (CounterIndex = 0; CounterIndex < SK_PNMI_MAX_IDX;
                        CounterIndex ++) {

                        if (!StatAddr[CounterIndex][MacType].GetOffset) {

                                continue;
                        }

                        Value = GetPhysStatVal(pAC, IoC, PhysPortIndex, CounterIndex);

                        pAC->Pnmi.VirtualCounterOffset[CounterIndex] -= Value;
                }

                /*
                 * Set port to active
                 */
                pAC->Pnmi.Port[PhysPortIndex].ActiveFlag = SK_TRUE;

                pAC->Pnmi.MacUpdatedFlag --;
                break;

        case SK_PNMI_EVT_RLMT_SEGMENTATION:
                /*
                 * Para.Para32[0] contains the NetIndex.
                 */

                /*
                 * Store a trap message in the trap buffer and generate an event for
                 * user space applications with the SK_DRIVER_SENDEVENT macro.
                 */
                QueueSimpleTrap(pAC, OID_SKGE_TRAP_RLMT_SEGMENTATION);
                (void)SK_DRIVER_SENDEVENT(pAC, IoC);
                break;

    case SK_PNMI_EVT_RLMT_SET_NETS:
                /*
                 *  Param.Para32[0] contains the number of Nets.
                 *  Param.Para32[1] is reserved, contains -1.
                 */
            /*
         * Check number of nets
                 */
                MaxNetNumber = pAC->GIni.GIMacsFound;
                if (((unsigned int)Param.Para32[0] < 1)
                        || ((unsigned int)Param.Para32[0] > MaxNetNumber)) {
                        return (SK_PNMI_ERR_UNKNOWN_NET);
                }

        if ((unsigned int)Param.Para32[0] == 1) { /* single net mode */
                pAC->Pnmi.DualNetActiveFlag = SK_FALSE;
        }
        else { /* dual net mode */
                pAC->Pnmi.DualNetActiveFlag = SK_TRUE;
        }
        break;

    case SK_PNMI_EVT_VCT_RESET:
        PhysPortIndex = Param.Para32[0];
        pPrt = &pAC->GIni.GP[PhysPortIndex];
        pVctBackupData = &pAC->Pnmi.VctBackup[PhysPortIndex];
        
        if (pAC->Pnmi.VctStatus[PhysPortIndex] & SK_PNMI_VCT_PENDING) {
                RetCode = SkGmCableDiagStatus(pAC, IoC, PhysPortIndex, SK_FALSE);
                if (RetCode == 2) {
                        /*
                         * VCT test is still running.
                         * Start VCT timer counter again.
                         */
                        SK_MEMSET((char *) &Param, 0, sizeof(Param));
                        Param.Para32[0] = PhysPortIndex;
                        Param.Para32[1] = -1;
                        SkTimerStart(pAC, IoC, &pAC->Pnmi.VctTimeout[PhysPortIndex].VctTimer,
                                4000000, SKGE_PNMI, SK_PNMI_EVT_VCT_RESET, Param);
                        break;
                }
                pAC->Pnmi.VctStatus[PhysPortIndex] &= ~SK_PNMI_VCT_PENDING;
                pAC->Pnmi.VctStatus[PhysPortIndex] |=
                        (SK_PNMI_VCT_NEW_VCT_DATA | SK_PNMI_VCT_TEST_DONE);
                
                /* Copy results for later use to PNMI struct. */
                for (i = 0; i < 4; i++)  {
                        if (pPrt->PMdiPairLen[i] > 35) {
                                CableLength = 1000 * (((175 * pPrt->PMdiPairLen[i]) / 210) - 28);
                        }
                        else {
                                CableLength = 0;
                        }
                        pVctBackupData->PMdiPairLen[i] = CableLength;
                        pVctBackupData->PMdiPairSts[i] = pPrt->PMdiPairSts[i];
                }
                
                Param.Para32[0] = PhysPortIndex;
                Param.Para32[1] = -1;
                SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_RESET, Param);
                SkEventDispatcher(pAC, IoC);
        }
        
        break;

        default:
                break;
        }

        SK_PNMI_CHECKFLAGS("SkPnmiEvent: On return");
        return (0);
}


/******************************************************************************
 *
 * Private functions
 *
 */

/*****************************************************************************
 *
 * PnmiVar - Gets, presets, and sets single OIDs
 *
 * Description:
 *      Looks up the requested OID, calls the corresponding handler
 *      function, and passes the parameters with the get, preset, or
 *      set command. The function is called by SkGePnmiGetVar,
 *      SkGePnmiPreSetVar, or SkGePnmiSetVar.
 *
 * Returns:
 *      SK_PNMI_ERR_XXX. For details have a look to the description of the
 *      calling functions.
 *      SK_PNMI_ERR_UNKNOWN_NET  The requested NetIndex doesn't exist 
 */
PNMI_STATIC int PnmiVar(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer which stores the mgmt data to be set */
unsigned int *pLen,     /* Total length of mgmt data */
SK_U32 Instance,        /* Instance (1..n) that is to be set or -1 */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    TableIndex;
        int             Ret;


        if ((TableIndex = LookupId(Id)) == (unsigned int)(-1)) {

                *pLen = 0;
                return (SK_PNMI_ERR_UNKNOWN_OID);
        }
        
    /* 
     * Check NetIndex 
     */
        if (NetIndex >= pAC->Rlmt.NumNets) {
                return (SK_PNMI_ERR_UNKNOWN_NET);
        }

        SK_PNMI_CHECKFLAGS("PnmiVar: On call");

        Ret = IdTable[TableIndex].Func(pAC, IoC, Action, Id, pBuf, pLen,
                Instance, TableIndex, NetIndex);

        SK_PNMI_CHECKFLAGS("PnmiVar: On return");

        return (Ret);
}

/*****************************************************************************
 *
 * PnmiStruct - Presets and Sets data in structure SK_PNMI_STRUCT_DATA
 *
 * Description:
 *      The return value of the function will also be stored in
 *      SK_PNMI_STRUCT_DATA if the passed buffer has the minimum size of
 *      SK_PNMI_MIN_STRUCT_SIZE. The sub-function runs through the IdTable,
 *      checks which OIDs are able to set, and calls the handler function of
 *      the OID to perform the set. The return value of the function will
 *      also be stored in SK_PNMI_STRUCT_DATA if the passed buffer has the
 *      minimum size of SK_PNMI_MIN_STRUCT_SIZE. The function is called
 *      by SkGePnmiPreSetStruct and SkGePnmiSetStruct.
 *
 * Returns:
 *      SK_PNMI_ERR_XXX. The codes are described in the calling functions.
 *      SK_PNMI_ERR_UNKNOWN_NET  The requested NetIndex doesn't exist 
 */
PNMI_STATIC int PnmiStruct(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int  Action,            /* Set action to be performed */
char *pBuf,             /* Buffer which contains the data to be set */
unsigned int *pLen,     /* Length of buffer */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        int             Ret;
        unsigned int    TableIndex;
        unsigned int    DstOffset;
        unsigned int    Len;
        unsigned int    InstanceNo;
        unsigned int    InstanceCnt;
        SK_U32          Instance;
        SK_U32          Id;


        /* Check if the passed buffer has the right size */
        if (*pLen < SK_PNMI_STRUCT_SIZE) {

                /* Check if we can return the error within the buffer */
                if (*pLen >= SK_PNMI_MIN_STRUCT_SIZE) {

                        SK_PNMI_SET_STAT(pBuf, SK_PNMI_ERR_TOO_SHORT,
                                (SK_U32)(-1));
                }

                *pLen = SK_PNMI_STRUCT_SIZE;
                return (SK_PNMI_ERR_TOO_SHORT);
        }
        
    /* 
     * Check NetIndex 
     */
        if (NetIndex >= pAC->Rlmt.NumNets) {
                return (SK_PNMI_ERR_UNKNOWN_NET);
        }
        
        SK_PNMI_CHECKFLAGS("PnmiStruct: On call");

        /*
         * Update the values of RLMT and SIRQ and increment semaphores to
         * indicate that an update was already done.
         */
        if ((Ret = RlmtUpdate(pAC, IoC, NetIndex)) != SK_PNMI_ERR_OK) {

                SK_PNMI_SET_STAT(pBuf, Ret, (SK_U32)(-1));
                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                return (Ret);
        }

        if ((Ret = SirqUpdate(pAC, IoC)) != SK_PNMI_ERR_OK) {

                SK_PNMI_SET_STAT(pBuf, Ret, (SK_U32)(-1));
                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                return (Ret);
        }

        pAC->Pnmi.RlmtUpdatedFlag ++;
        pAC->Pnmi.SirqUpdatedFlag ++;

        /* Preset/Set values */
        for (TableIndex = 0; TableIndex < ID_TABLE_SIZE; TableIndex ++) {

                if ((IdTable[TableIndex].Access != SK_PNMI_RW) &&
                        (IdTable[TableIndex].Access != SK_PNMI_WO)) {

                        continue;
                }

                InstanceNo = IdTable[TableIndex].InstanceNo;
                Id = IdTable[TableIndex].Id;

                for (InstanceCnt = 1; InstanceCnt <= InstanceNo;
                        InstanceCnt ++) {

                        DstOffset = IdTable[TableIndex].Offset +
                                (InstanceCnt - 1) *
                                IdTable[TableIndex].StructSize;

                        /*
                         * Because VPD multiple instance variables are
                         * not setable we do not need to evaluate VPD
                         * instances. Have a look to VPD instance
                         * calculation in SkPnmiGetStruct().
                         */
                        Instance = (SK_U32)InstanceCnt;

                        /*
                         * Evaluate needed buffer length
                         */
                        Len = 0;
                        Ret = IdTable[TableIndex].Func(pAC, IoC,
                                SK_PNMI_GET, IdTable[TableIndex].Id,
                                NULL, &Len, Instance, TableIndex, NetIndex);

                        if (Ret == SK_PNMI_ERR_UNKNOWN_INST) {

                                break;
                        }
                        if (Ret != SK_PNMI_ERR_TOO_SHORT) {

                                pAC->Pnmi.RlmtUpdatedFlag --;
                                pAC->Pnmi.SirqUpdatedFlag --;

                                SK_PNMI_CHECKFLAGS("PnmiStruct: On return");
                                SK_PNMI_SET_STAT(pBuf,
                                        SK_PNMI_ERR_GENERAL, DstOffset);
                                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        if (Id == OID_SKGE_VPD_ACTION) {

                                switch (*(pBuf + DstOffset)) {

                                case SK_PNMI_VPD_CREATE:
                                        Len = 3 + *(pBuf + DstOffset + 3);
                                        break;

                                case SK_PNMI_VPD_DELETE:
                                        Len = 3;
                                        break;

                                default:
                                        Len = 1;
                                        break;
                                }
                        }

                        /* Call the OID handler function */
                        Ret = IdTable[TableIndex].Func(pAC, IoC, Action,
                                IdTable[TableIndex].Id, pBuf + DstOffset,
                                &Len, Instance, TableIndex, NetIndex);

                        if (Ret != SK_PNMI_ERR_OK) {

                                pAC->Pnmi.RlmtUpdatedFlag --;
                                pAC->Pnmi.SirqUpdatedFlag --;

                                SK_PNMI_CHECKFLAGS("PnmiStruct: On return");
                                SK_PNMI_SET_STAT(pBuf, SK_PNMI_ERR_BAD_VALUE,
                                        DstOffset);
                                *pLen = SK_PNMI_MIN_STRUCT_SIZE;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }
                }
        }

        pAC->Pnmi.RlmtUpdatedFlag --;
        pAC->Pnmi.SirqUpdatedFlag --;

        SK_PNMI_CHECKFLAGS("PnmiStruct: On return");
        SK_PNMI_SET_STAT(pBuf, SK_PNMI_ERR_OK, (SK_U32)(-1));
        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * LookupId - Lookup an OID in the IdTable
 *
 * Description:
 *      Scans the IdTable to find the table entry of an OID.
 *
 * Returns:
 *      The table index or -1 if not found.
 */
PNMI_STATIC int LookupId(
SK_U32 Id)              /* Object identifier to be searched */
{
        int i;

        for (i = 0; i < ID_TABLE_SIZE; i++) {

                if (IdTable[i].Id == Id) {

                        return i;
                }
        }

        return (-1);
}

/*****************************************************************************
 *
 * OidStruct - Handler of OID_SKGE_ALL_DATA
 *
 * Description:
 *      This OID performs a Get/Preset/SetStruct call and returns all data
 *      in a SK_PNMI_STRUCT_DATA structure.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int OidStruct(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        if (Id != OID_SKGE_ALL_DATA) {

                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR003,
                        SK_PNMI_ERR003MSG);

                *pLen = 0;
                return (SK_PNMI_ERR_GENERAL);
        }

        /*
         * Check instance. We only handle single instance variables
         */
        if (Instance != (SK_U32)(-1) && Instance != 1) {

                *pLen = 0;
                return (SK_PNMI_ERR_UNKNOWN_INST);
        }

        switch (Action) {

        case SK_PNMI_GET:
                return (SkPnmiGetStruct(pAC, IoC, pBuf, pLen, NetIndex));

        case SK_PNMI_PRESET:
                return (SkPnmiPreSetStruct(pAC, IoC, pBuf, pLen, NetIndex));

        case SK_PNMI_SET:
                return (SkPnmiSetStruct(pAC, IoC, pBuf, pLen, NetIndex));
        }

        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR004, SK_PNMI_ERR004MSG);

        *pLen = 0;
        return (SK_PNMI_ERR_GENERAL);
}

/*****************************************************************************
 *
 * Perform - OID handler of OID_SKGE_ACTION
 *
 * Description:
 *      None.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int Perform(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        int     Ret;
        SK_U32  ActionOp;


        /*
         * Check instance. We only handle single instance variables
         */
        if (Instance != (SK_U32)(-1) && Instance != 1) {

                *pLen = 0;
                return (SK_PNMI_ERR_UNKNOWN_INST);
        }

        if (*pLen < sizeof(SK_U32)) {

                *pLen = sizeof(SK_U32);
                return (SK_PNMI_ERR_TOO_SHORT);
        }

        /* Check if a get should be performed */
        if (Action == SK_PNMI_GET) {

                /* A get is easy. We always return the same value */
                ActionOp = (SK_U32)SK_PNMI_ACT_IDLE;
                SK_PNMI_STORE_U32(pBuf, ActionOp);
                *pLen = sizeof(SK_U32);

                return (SK_PNMI_ERR_OK);
        }

        /* Continue with PRESET/SET action */
        if (*pLen > sizeof(SK_U32)) {

                return (SK_PNMI_ERR_BAD_VALUE);
        }

        /* Check if the command is a known one */
        SK_PNMI_READ_U32(pBuf, ActionOp);
        if (*pLen > sizeof(SK_U32) ||
                (ActionOp != SK_PNMI_ACT_IDLE &&
                ActionOp != SK_PNMI_ACT_RESET &&
                ActionOp != SK_PNMI_ACT_SELFTEST &&
                ActionOp != SK_PNMI_ACT_RESETCNT)) {

                *pLen = 0;
                return (SK_PNMI_ERR_BAD_VALUE);
        }

        /* A preset ends here */
        if (Action == SK_PNMI_PRESET) {

                return (SK_PNMI_ERR_OK);
        }

        switch (ActionOp) {

        case SK_PNMI_ACT_IDLE:
                /* Nothing to do */
                break;

        case SK_PNMI_ACT_RESET:
                /*
                 * Perform a driver reset or something that comes near
                 * to this.
                 */
                Ret = SK_DRIVER_RESET(pAC, IoC);
                if (Ret != 0) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR005,
                                SK_PNMI_ERR005MSG);

                        return (SK_PNMI_ERR_GENERAL);
                }
                break;

        case SK_PNMI_ACT_SELFTEST:
                /*
                 * Perform a driver selftest or something similar to this.
                 * Currently this feature is not used and will probably
                 * implemented in another way.
                 */
                Ret = SK_DRIVER_SELFTEST(pAC, IoC);
                pAC->Pnmi.TestResult = Ret;
                break;

        case SK_PNMI_ACT_RESETCNT:
                /* Set all counters and timestamps to zero */
                ResetCounter(pAC, IoC, NetIndex);
                break;

        default:
                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR006,
                        SK_PNMI_ERR006MSG);

                return (SK_PNMI_ERR_GENERAL);
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * Mac8023Stat - OID handler of OID_GEN_XXX and OID_802_3_XXX
 *
 * Description:
 *      Retrieves the statistic values of the virtual port (logical
 *      index 0). Only special OIDs of NDIS are handled which consist
 *      of a 32 bit instead of a 64 bit value. The OIDs are public
 *      because perhaps some other platform can use them too.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int Mac8023Stat(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex,        /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        int     Ret;
        SK_U64  StatVal;
        SK_U32  StatVal32;
        SK_BOOL Is64BitReq = SK_FALSE;

        /*
         * Only the active Mac is returned
         */
        if (Instance != (SK_U32)(-1) && Instance != 1) {

                *pLen = 0;
                return (SK_PNMI_ERR_UNKNOWN_INST);
        }

        /*
         * Check action type
         */
        if (Action != SK_PNMI_GET) {

                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }

        /*
         * Check length
         */
        switch (Id) {

        case OID_802_3_PERMANENT_ADDRESS:
        case OID_802_3_CURRENT_ADDRESS:
                if (*pLen < sizeof(SK_MAC_ADDR)) {

                        *pLen = sizeof(SK_MAC_ADDR);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        default:
#ifndef SK_NDIS_64BIT_CTR
                if (*pLen < sizeof(SK_U32)) {
                        *pLen = sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }

#else /* SK_NDIS_64BIT_CTR */

                /*
                 * for compatibility, at least 32bit are required for oid
                 */
                if (*pLen < sizeof(SK_U32)) {
                        /*
                        * but indicate handling for 64bit values,
                        * if insufficient space is provided
                        */
                        *pLen = sizeof(SK_U64);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }

                Is64BitReq = (*pLen < sizeof(SK_U64)) ? SK_FALSE : SK_TRUE;
#endif /* SK_NDIS_64BIT_CTR */
                break;
        }

        /*
         * Update all statistics, because we retrieve virtual MAC, which
         * consists of multiple physical statistics and increment semaphore
         * to indicate that an update was already done.
         */
        Ret = MacUpdate(pAC, IoC, 0, pAC->GIni.GIMacsFound - 1);
        if ( Ret != SK_PNMI_ERR_OK) {

                *pLen = 0;
                return (Ret);
        }
        pAC->Pnmi.MacUpdatedFlag ++;

        /*
         * Get value (MAC Index 0 identifies the virtual MAC)
         */
        switch (Id) {

        case OID_802_3_PERMANENT_ADDRESS:
                CopyMac(pBuf, &pAC->Addr.Net[NetIndex].PermanentMacAddress);
                *pLen = sizeof(SK_MAC_ADDR);
                break;

        case OID_802_3_CURRENT_ADDRESS:
                CopyMac(pBuf, &pAC->Addr.Net[NetIndex].CurrentMacAddress);
                *pLen = sizeof(SK_MAC_ADDR);
                break;

        default:
                StatVal = GetStatVal(pAC, IoC, 0, IdTable[TableIndex].Param, NetIndex);

                /*
                 * by default 32bit values are evaluated
                 */
                if (!Is64BitReq) {
                        StatVal32 = (SK_U32)StatVal;
                        SK_PNMI_STORE_U32(pBuf, StatVal32);
                        *pLen = sizeof(SK_U32);
                }
                else {
                        SK_PNMI_STORE_U64(pBuf, StatVal);
                        *pLen = sizeof(SK_U64);
                }
                break;
        }

        pAC->Pnmi.MacUpdatedFlag --;

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * MacPrivateStat - OID handler function of OID_SKGE_STAT_XXX
 *
 * Description:
 *      Retrieves the XMAC statistic data.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int MacPrivateStat(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    LogPortMax;
        unsigned int    LogPortIndex;
        unsigned int    PhysPortMax;
        unsigned int    Limit;
        unsigned int    Offset;
        int                             Ret;
        SK_U64                  StatVal;


        /*
         * Calculate instance if wished. MAC index 0 is the virtual
         * MAC.
         */
        PhysPortMax = pAC->GIni.GIMacsFound;
        LogPortMax = SK_PNMI_PORT_PHYS2LOG(PhysPortMax);

        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) { /* Dual net mode */
                LogPortMax--;
        }

        if ((Instance != (SK_U32)(-1))) { /* Only one specific instance is queried */
                /* Check instance range */
                if ((Instance < 1) || (Instance > LogPortMax)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }
                LogPortIndex = SK_PNMI_PORT_INST2LOG(Instance);
                Limit = LogPortIndex + 1;
        }

        else { /* Instance == (SK_U32)(-1), get all Instances of that OID */

                LogPortIndex = 0;
                Limit = LogPortMax;
        }


        /*
         * Check action
         */
        if (Action != SK_PNMI_GET) {

                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }

        /*
         * Check length
         */
        if (*pLen < (Limit - LogPortIndex) * sizeof(SK_U64)) {

                *pLen = (Limit - LogPortIndex) * sizeof(SK_U64);
                return (SK_PNMI_ERR_TOO_SHORT);
        }

        /*
         * Update XMAC statistic and increment semaphore to indicate that
         * an update was already done.
         */
        Ret = MacUpdate(pAC, IoC, 0, pAC->GIni.GIMacsFound - 1);
        if (Ret != SK_PNMI_ERR_OK) {

                *pLen = 0;
                return (Ret);
        }
        pAC->Pnmi.MacUpdatedFlag ++;

        /*
         * Get value
         */
        Offset = 0;
        for (; LogPortIndex < Limit; LogPortIndex ++) {

                switch (Id) {

/* XXX not yet implemented due to XMAC problems
                case OID_SKGE_STAT_TX_UTIL:
                        return (SK_PNMI_ERR_GENERAL);
*/
/* XXX not yet implemented due to XMAC problems
                case OID_SKGE_STAT_RX_UTIL:
                        return (SK_PNMI_ERR_GENERAL);
*/
                case OID_SKGE_STAT_RX:
                case OID_SKGE_STAT_TX:
                        switch (pAC->GIni.GIMacType) {
                        case SK_MAC_XMAC:
                                StatVal = GetStatVal(pAC, IoC, LogPortIndex,
                                        IdTable[TableIndex].Param, NetIndex);
                                break;

                        case SK_MAC_GMAC:
                                if (Id == OID_SKGE_STAT_TX) {

                                        StatVal =
                                                GetStatVal(pAC, IoC, LogPortIndex,
                                                                   SK_PNMI_HTX_BROADCAST, NetIndex) +
                                                GetStatVal(pAC, IoC, LogPortIndex,
                                                                   SK_PNMI_HTX_MULTICAST, NetIndex) +
                                                GetStatVal(pAC, IoC, LogPortIndex,
                                                                   SK_PNMI_HTX_UNICAST, NetIndex);
                                }
                                else {
                                        StatVal =
                                                GetStatVal(pAC, IoC, LogPortIndex,
                                                                   SK_PNMI_HRX_BROADCAST, NetIndex) +
                                                GetStatVal(pAC, IoC, LogPortIndex,
                                                                   SK_PNMI_HRX_MULTICAST, NetIndex) +
                                                GetStatVal(pAC, IoC, LogPortIndex,
                                                                   SK_PNMI_HRX_UNICAST, NetIndex) +
                                                GetStatVal(pAC, IoC, LogPortIndex,
                                                                   SK_PNMI_HRX_UNDERSIZE, NetIndex);
                                }
                                break;

                        default:
                                StatVal = 0;
                                break;
                        }

                        SK_PNMI_STORE_U64(pBuf + Offset, StatVal);
                        break;

                default:
                        StatVal = GetStatVal(pAC, IoC, LogPortIndex,
                                IdTable[TableIndex].Param, NetIndex);
                        SK_PNMI_STORE_U64(pBuf + Offset, StatVal);
                        break;
                }

                Offset += sizeof(SK_U64);
        }
        *pLen = Offset;

        pAC->Pnmi.MacUpdatedFlag --;

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * Addr - OID handler function of OID_SKGE_PHYS_CUR_ADDR and _FAC_ADDR
 *
 * Description:
 *      Get/Presets/Sets the current and factory MAC address. The MAC
 *      address of the virtual port, which is reported to the OS, may
 *      not be changed, but the physical ones. A set to the virtual port
 *      will be ignored. No error should be reported because otherwise
 *      a multiple instance set (-1) would always fail.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int Addr(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        int             Ret;
        unsigned int    LogPortMax;
        unsigned int    PhysPortMax;
        unsigned int    LogPortIndex;
        unsigned int    PhysPortIndex;
        unsigned int    Limit;
        unsigned int    Offset = 0;

        /*
         * Calculate instance if wished. MAC index 0 is the virtual
         * MAC.
         */
        PhysPortMax = pAC->GIni.GIMacsFound;
        LogPortMax = SK_PNMI_PORT_PHYS2LOG(PhysPortMax);

        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) { /* Dual net mode */
                LogPortMax--;
        }

        if ((Instance != (SK_U32)(-1))) { /* Only one specific instance is queried */
                /* Check instance range */
                if ((Instance < 1) || (Instance > LogPortMax)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }
                LogPortIndex = SK_PNMI_PORT_INST2LOG(Instance);
                Limit = LogPortIndex + 1;
        }

        else { /* Instance == (SK_U32)(-1), get all Instances of that OID */

                LogPortIndex = 0;
                Limit = LogPortMax;
        }

        /*
         * Perform Action
         */
        if (Action == SK_PNMI_GET) {

                /*
                 * Check length
                */
                if (*pLen < (Limit - LogPortIndex) * 6) {

                        *pLen = (Limit - LogPortIndex) * 6;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }

                /*
                 * Get value
                 */
                for (; LogPortIndex < Limit; LogPortIndex ++) {

                        switch (Id) {

                        case OID_SKGE_PHYS_CUR_ADDR:
                                if (LogPortIndex == 0) {
                                        CopyMac(pBuf + Offset, &pAC->Addr.Net[NetIndex].CurrentMacAddress);
                                }
                                else {
                                        PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(pAC, LogPortIndex);

                                        CopyMac(pBuf + Offset,
                                                &pAC->Addr.Port[PhysPortIndex].CurrentMacAddress);
                                }
                                Offset += 6;
                                break;

                        case OID_SKGE_PHYS_FAC_ADDR:
                                if (LogPortIndex == 0) {
                                        CopyMac(pBuf + Offset,
                                                &pAC->Addr.Net[NetIndex].PermanentMacAddress);
                                }
                                else {
                                        PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                pAC, LogPortIndex);

                                        CopyMac(pBuf + Offset,
                                                &pAC->Addr.Port[PhysPortIndex].PermanentMacAddress);
                                }
                                Offset += 6;
                                break;

                        default:
                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR008,
                                        SK_PNMI_ERR008MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                }

                *pLen = Offset;
        }
        else {
                /*
                 * The logical MAC address may not be changed only
                 * the physical ones
                 */
                if (Id == OID_SKGE_PHYS_FAC_ADDR) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_READ_ONLY);
                }

                /*
                 * Only the current address may be changed
                 */
                if (Id != OID_SKGE_PHYS_CUR_ADDR) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR009,
                                SK_PNMI_ERR009MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                /*
                 * Check length
                */
                if (*pLen < (Limit - LogPortIndex) * 6) {

                        *pLen = (Limit - LogPortIndex) * 6;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                if (*pLen > (Limit - LogPortIndex) * 6) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_BAD_VALUE);
                }

                /*
                 * Check Action
                 */
                if (Action == SK_PNMI_PRESET) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_OK);
                }

                /*
                 * Set OID_SKGE_MAC_CUR_ADDR
                 */
                for (; LogPortIndex < Limit; LogPortIndex ++, Offset += 6) {

                        /*
                         * A set to virtual port and set of broadcast
                         * address will be ignored
                         */
                        if (LogPortIndex == 0 || SK_MEMCMP(pBuf + Offset,
                                "\xff\xff\xff\xff\xff\xff", 6) == 0) {

                                continue;
                        }

                        PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(pAC,
                                LogPortIndex);

                        Ret = SkAddrOverride(pAC, IoC, PhysPortIndex,
                                (SK_MAC_ADDR *)(pBuf + Offset),
                                (LogPortIndex == 0 ? SK_ADDR_VIRTUAL_ADDRESS :
                                SK_ADDR_PHYSICAL_ADDRESS));
                        if (Ret != SK_ADDR_OVERRIDE_SUCCESS) {

                                return (SK_PNMI_ERR_GENERAL);
                        }
                }
                *pLen = Offset;
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * CsumStat - OID handler function of OID_SKGE_CHKSM_XXX
 *
 * Description:
 *      Retrieves the statistic values of the CSUM module. The CSUM data
 *      structure must be available in the SK_AC even if the CSUM module
 *      is not included, because PNMI reads the statistic data from the
 *      CSUM part of SK_AC directly.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int CsumStat(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    Index;
        unsigned int    Limit;
        unsigned int    Offset = 0;
        SK_U64          StatVal;


        /*
         * Calculate instance if wished
         */
        if (Instance != (SK_U32)(-1)) {

                if ((Instance < 1) || (Instance > SKCS_NUM_PROTOCOLS)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }
                Index = (unsigned int)Instance - 1;
                Limit = Index + 1;
        }
        else {
                Index = 0;
                Limit = SKCS_NUM_PROTOCOLS;
        }

        /*
         * Check action
         */
        if (Action != SK_PNMI_GET) {

                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }

        /*
         * Check length
         */
        if (*pLen < (Limit - Index) * sizeof(SK_U64)) {

                *pLen = (Limit - Index) * sizeof(SK_U64);
                return (SK_PNMI_ERR_TOO_SHORT);
        }

        /*
         * Get value
         */
        for (; Index < Limit; Index ++) {

                switch (Id) {

                case OID_SKGE_CHKSM_RX_OK_CTS:
                        StatVal = pAC->Csum.ProtoStats[NetIndex][Index].RxOkCts;
                        break;

                case OID_SKGE_CHKSM_RX_UNABLE_CTS:
                        StatVal = pAC->Csum.ProtoStats[NetIndex][Index].RxUnableCts;
                        break;

                case OID_SKGE_CHKSM_RX_ERR_CTS:
                        StatVal = pAC->Csum.ProtoStats[NetIndex][Index].RxErrCts;
                        break;

                case OID_SKGE_CHKSM_TX_OK_CTS:
                        StatVal = pAC->Csum.ProtoStats[NetIndex][Index].TxOkCts;
                        break;

                case OID_SKGE_CHKSM_TX_UNABLE_CTS:
                        StatVal = pAC->Csum.ProtoStats[NetIndex][Index].TxUnableCts;
                        break;

                default:
                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR010,
                                SK_PNMI_ERR010MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                SK_PNMI_STORE_U64(pBuf + Offset, StatVal);
                Offset += sizeof(SK_U64);
        }

        /*
         * Store used buffer space
         */
        *pLen = Offset;

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * SensorStat - OID handler function of OID_SKGE_SENSOR_XXX
 *
 * Description:
 *      Retrieves the statistic values of the I2C module, which handles
 *      the temperature and voltage sensors.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int SensorStat(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    i;
        unsigned int    Index;
        unsigned int    Limit;
        unsigned int    Offset;
        unsigned int    Len;
        SK_U32          Val32;
        SK_U64          Val64;


        /*
         * Calculate instance if wished
         */
        if ((Instance != (SK_U32)(-1))) {

                if ((Instance < 1) || (Instance > (SK_U32)pAC->I2c.MaxSens)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }

                Index = (unsigned int)Instance -1;
                Limit = (unsigned int)Instance;
        }
        else {
                Index = 0;
                Limit = (unsigned int) pAC->I2c.MaxSens;
        }

        /*
         * Check action
         */
        if (Action != SK_PNMI_GET) {

                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }

        /*
         * Check length
         */
        switch (Id) {

        case OID_SKGE_SENSOR_VALUE:
        case OID_SKGE_SENSOR_WAR_THRES_LOW:
        case OID_SKGE_SENSOR_WAR_THRES_UPP:
        case OID_SKGE_SENSOR_ERR_THRES_LOW:
        case OID_SKGE_SENSOR_ERR_THRES_UPP:
                if (*pLen < (Limit - Index) * sizeof(SK_U32)) {

                        *pLen = (Limit - Index) * sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        case OID_SKGE_SENSOR_DESCR:
                for (Offset = 0, i = Index; i < Limit; i ++) {

                        Len = (unsigned int)
                                SK_STRLEN(pAC->I2c.SenTable[i].SenDesc) + 1;
                        if (Len >= SK_PNMI_STRINGLEN2) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR011,
                                        SK_PNMI_ERR011MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        Offset += Len;
                }
                if (*pLen < Offset) {

                        *pLen = Offset;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        case OID_SKGE_SENSOR_INDEX:
        case OID_SKGE_SENSOR_TYPE:
        case OID_SKGE_SENSOR_STATUS:
                if (*pLen < Limit - Index) {

                        *pLen = Limit - Index;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        case OID_SKGE_SENSOR_WAR_CTS:
        case OID_SKGE_SENSOR_WAR_TIME:
        case OID_SKGE_SENSOR_ERR_CTS:
        case OID_SKGE_SENSOR_ERR_TIME:
                if (*pLen < (Limit - Index) * sizeof(SK_U64)) {

                        *pLen = (Limit - Index) * sizeof(SK_U64);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        default:
                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR012,
                        SK_PNMI_ERR012MSG);

                *pLen = 0;
                return (SK_PNMI_ERR_GENERAL);

        }

        /*
         * Get value
         */
        for (Offset = 0; Index < Limit; Index ++) {

                switch (Id) {

                case OID_SKGE_SENSOR_INDEX:
                        *(pBuf + Offset) = (char)Index;
                        Offset += sizeof(char);
                        break;

                case OID_SKGE_SENSOR_DESCR:
                        Len = SK_STRLEN(pAC->I2c.SenTable[Index].SenDesc);
                        SK_MEMCPY(pBuf + Offset + 1,
                                pAC->I2c.SenTable[Index].SenDesc, Len);
                        *(pBuf + Offset) = (char)Len;
                        Offset += Len + 1;
                        break;

                case OID_SKGE_SENSOR_TYPE:
                        *(pBuf + Offset) =
                                (char)pAC->I2c.SenTable[Index].SenType;
                        Offset += sizeof(char);
                        break;

                case OID_SKGE_SENSOR_VALUE:
                        Val32 = (SK_U32)pAC->I2c.SenTable[Index].SenValue;
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                        Offset += sizeof(SK_U32);
                        break;

                case OID_SKGE_SENSOR_WAR_THRES_LOW:
                        Val32 = (SK_U32)pAC->I2c.SenTable[Index].
                                SenThreWarnLow;
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                        Offset += sizeof(SK_U32);
                        break;

                case OID_SKGE_SENSOR_WAR_THRES_UPP:
                        Val32 = (SK_U32)pAC->I2c.SenTable[Index].
                                SenThreWarnHigh;
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                        Offset += sizeof(SK_U32);
                        break;

                case OID_SKGE_SENSOR_ERR_THRES_LOW:
                        Val32 = (SK_U32)pAC->I2c.SenTable[Index].
                                SenThreErrLow;
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                        Offset += sizeof(SK_U32);
                        break;

                case OID_SKGE_SENSOR_ERR_THRES_UPP:
                        Val32 = pAC->I2c.SenTable[Index].SenThreErrHigh;
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                        Offset += sizeof(SK_U32);
                        break;

                case OID_SKGE_SENSOR_STATUS:
                        *(pBuf + Offset) =
                                (char)pAC->I2c.SenTable[Index].SenErrFlag;
                        Offset += sizeof(char);
                        break;

                case OID_SKGE_SENSOR_WAR_CTS:
                        Val64 = pAC->I2c.SenTable[Index].SenWarnCts;
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                case OID_SKGE_SENSOR_ERR_CTS:
                        Val64 = pAC->I2c.SenTable[Index].SenErrCts;
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                case OID_SKGE_SENSOR_WAR_TIME:
                        Val64 = SK_PNMI_HUNDREDS_SEC(pAC->I2c.SenTable[Index].
                                SenBegWarnTS);
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                case OID_SKGE_SENSOR_ERR_TIME:
                        Val64 = SK_PNMI_HUNDREDS_SEC(pAC->I2c.SenTable[Index].
                                SenBegErrTS);
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                default:
                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_ERR,
                                ("SensorStat: Unknown OID should be handled before"));

                        return (SK_PNMI_ERR_GENERAL);
                }
        }

        /*
         * Store used buffer space
         */
        *pLen = Offset;

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * Vpd - OID handler function of OID_SKGE_VPD_XXX
 *
 * Description:
 *      Get/preset/set of VPD data. As instance the name of a VPD key
 *      can be passed. The Instance parameter is a SK_U32 and can be
 *      used as a string buffer for the VPD key, because their maximum
 *      length is 4 byte.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int Vpd(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        SK_VPD_STATUS   *pVpdStatus;
        unsigned int    BufLen;
        char            Buf[256];
        char            KeyArr[SK_PNMI_VPD_ENTRIES][SK_PNMI_VPD_KEY_SIZE];
        char            KeyStr[SK_PNMI_VPD_KEY_SIZE];
        unsigned int    KeyNo;
        unsigned int    Offset;
        unsigned int    Index;
        unsigned int    FirstIndex;
        unsigned int    LastIndex;
        unsigned int    Len;
        int             Ret;
        SK_U32          Val32;

        /*
         * Get array of all currently stored VPD keys
         */
        Ret = GetVpdKeyArr(pAC, IoC, &KeyArr[0][0], sizeof(KeyArr),
                &KeyNo);
        if (Ret != SK_PNMI_ERR_OK) {
                *pLen = 0;
                return (Ret);
        }

        /*
         * If instance is not -1, try to find the requested VPD key for
         * the multiple instance variables. The other OIDs as for example
         * OID VPD_ACTION are single instance variables and must be
         * handled separatly.
         */
        FirstIndex = 0;
        LastIndex = KeyNo;

        if ((Instance != (SK_U32)(-1))) {

                if (Id == OID_SKGE_VPD_KEY || Id == OID_SKGE_VPD_VALUE ||
                        Id == OID_SKGE_VPD_ACCESS) {

                        SK_STRNCPY(KeyStr, (char *)&Instance, 4);
                        KeyStr[4] = 0;

                        for (Index = 0; Index < KeyNo; Index ++) {

                                if (SK_STRCMP(KeyStr, KeyArr[Index]) == 0) {
                                        FirstIndex = Index;
                                        LastIndex = Index+1;
                                        break;
                                }
                        }
                        if (Index == KeyNo) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_UNKNOWN_INST);
                        }
                }
                else if (Instance != 1) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }
        }

        /*
         * Get value, if a query should be performed
         */
        if (Action == SK_PNMI_GET) {

                switch (Id) {

                case OID_SKGE_VPD_FREE_BYTES:
                        /* Check length of buffer */
                        if (*pLen < sizeof(SK_U32)) {

                                *pLen = sizeof(SK_U32);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        /* Get number of free bytes */
                        pVpdStatus = VpdStat(pAC, IoC);
                        if (pVpdStatus == NULL) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR017,
                                        SK_PNMI_ERR017MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        if ((pVpdStatus->vpd_status & VPD_VALID) == 0) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR018,
                                        SK_PNMI_ERR018MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        
                        Val32 = (SK_U32)pVpdStatus->vpd_free_rw;
                        SK_PNMI_STORE_U32(pBuf, Val32);
                        *pLen = sizeof(SK_U32);
                        break;

                case OID_SKGE_VPD_ENTRIES_LIST:
                        /* Check length */
                        for (Len = 0, Index = 0; Index < KeyNo; Index ++) {

                                Len += SK_STRLEN(KeyArr[Index]) + 1;
                        }
                        if (*pLen < Len) {

                                *pLen = Len;
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }

                        /* Get value */
                        *(pBuf) = (char)Len - 1;
                        for (Offset = 1, Index = 0; Index < KeyNo; Index ++) {

                                Len = SK_STRLEN(KeyArr[Index]);
                                SK_MEMCPY(pBuf + Offset, KeyArr[Index], Len);

                                Offset += Len;

                                if (Index < KeyNo - 1) {

                                        *(pBuf + Offset) = ' ';
                                        Offset ++;
                                }
                        }
                        *pLen = Offset;
                        break;

                case OID_SKGE_VPD_ENTRIES_NUMBER:
                        /* Check length */
                        if (*pLen < sizeof(SK_U32)) {

                                *pLen = sizeof(SK_U32);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }

                        Val32 = (SK_U32)KeyNo;
                        SK_PNMI_STORE_U32(pBuf, Val32);
                        *pLen = sizeof(SK_U32);
                        break;

                case OID_SKGE_VPD_KEY:
                        /* Check buffer length, if it is large enough */
                        for (Len = 0, Index = FirstIndex;
                                Index < LastIndex; Index ++) {

                                Len += SK_STRLEN(KeyArr[Index]) + 1;
                        }
                        if (*pLen < Len) {

                                *pLen = Len;
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }

                        /*
                         * Get the key to an intermediate buffer, because
                         * we have to prepend a length byte.
                         */
                        for (Offset = 0, Index = FirstIndex;
                                Index < LastIndex; Index ++) {

                                Len = SK_STRLEN(KeyArr[Index]);

                                *(pBuf + Offset) = (char)Len;
                                SK_MEMCPY(pBuf + Offset + 1, KeyArr[Index],
                                        Len);
                                Offset += Len + 1;
                        }
                        *pLen = Offset;
                        break;

                case OID_SKGE_VPD_VALUE:
                        /* Check the buffer length if it is large enough */
                        for (Offset = 0, Index = FirstIndex;
                                Index < LastIndex; Index ++) {

                                BufLen = 256;
                                if (VpdRead(pAC, IoC, KeyArr[Index], Buf,
                                        (int *)&BufLen) > 0 ||
                                        BufLen >= SK_PNMI_VPD_DATALEN) {

                                        SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                SK_PNMI_ERR021,
                                                SK_PNMI_ERR021MSG);

                                        return (SK_PNMI_ERR_GENERAL);
                                }
                                Offset += BufLen + 1;
                        }
                        if (*pLen < Offset) {

                                *pLen = Offset;
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }

                        /*
                         * Get the value to an intermediate buffer, because
                         * we have to prepend a length byte.
                         */
                        for (Offset = 0, Index = FirstIndex;
                                Index < LastIndex; Index ++) {

                                BufLen = 256;
                                if (VpdRead(pAC, IoC, KeyArr[Index], Buf,
                                        (int *)&BufLen) > 0 ||
                                        BufLen >= SK_PNMI_VPD_DATALEN) {

                                        SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                SK_PNMI_ERR022,
                                                SK_PNMI_ERR022MSG);

                                        *pLen = 0;
                                        return (SK_PNMI_ERR_GENERAL);
                                }

                                *(pBuf + Offset) = (char)BufLen;
                                SK_MEMCPY(pBuf + Offset + 1, Buf, BufLen);
                                Offset += BufLen + 1;
                        }
                        *pLen = Offset;
                        break;

                case OID_SKGE_VPD_ACCESS:
                        if (*pLen < LastIndex - FirstIndex) {

                                *pLen = LastIndex - FirstIndex;
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }

                        for (Offset = 0, Index = FirstIndex;
                                Index < LastIndex; Index ++) {

                                if (VpdMayWrite(KeyArr[Index])) {

                                        *(pBuf + Offset) = SK_PNMI_VPD_RW;
                                }
                                else {
                                        *(pBuf + Offset) = SK_PNMI_VPD_RO;
                                }
                                Offset ++;
                        }
                        *pLen = Offset;
                        break;

                case OID_SKGE_VPD_ACTION:
                        Offset = LastIndex - FirstIndex;
                        if (*pLen < Offset) {

                                *pLen = Offset;
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        SK_MEMSET(pBuf, 0, Offset);
                        *pLen = Offset;
                        break;

                default:
                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR023,
                                SK_PNMI_ERR023MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }
        } 
        else {
                /* The only OID which can be set is VPD_ACTION */
                if (Id != OID_SKGE_VPD_ACTION) {

                        if (Id == OID_SKGE_VPD_FREE_BYTES ||
                                Id == OID_SKGE_VPD_ENTRIES_LIST ||
                                Id == OID_SKGE_VPD_ENTRIES_NUMBER ||
                                Id == OID_SKGE_VPD_KEY ||
                                Id == OID_SKGE_VPD_VALUE ||
                                Id == OID_SKGE_VPD_ACCESS) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_READ_ONLY);
                        }

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR024,
                                SK_PNMI_ERR024MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                /*
                 * From this point we handle VPD_ACTION. Check the buffer
                 * length. It should at least have the size of one byte.
                 */
                if (*pLen < 1) {

                        *pLen = 1;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }

                /*
                 * The first byte contains the VPD action type we should
                 * perform.
                 */
                switch (*pBuf) {

                case SK_PNMI_VPD_IGNORE:
                        /* Nothing to do */
                        break;

                case SK_PNMI_VPD_CREATE:
                        /*
                         * We have to create a new VPD entry or we modify
                         * an existing one. Check first the buffer length.
                         */
                        if (*pLen < 4) {

                                *pLen = 4;
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        KeyStr[0] = pBuf[1];
                        KeyStr[1] = pBuf[2];
                        KeyStr[2] = 0;

                        /*
                         * Is the entry writable or does it belong to the
                         * read-only area?
                         */
                        if (!VpdMayWrite(KeyStr)) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }

                        Offset = (int)pBuf[3] & 0xFF;

                        SK_MEMCPY(Buf, pBuf + 4, Offset);
                        Buf[Offset] = 0;

                        /* A preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                return (SK_PNMI_ERR_OK);
                        }

                        /* Write the new entry or modify an existing one */
                        Ret = VpdWrite(pAC, IoC, KeyStr, Buf);
                        if (Ret == SK_PNMI_VPD_NOWRITE ) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }
                        else if (Ret != SK_PNMI_VPD_OK) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR025,
                                        SK_PNMI_ERR025MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }

                        /*
                         * Perform an update of the VPD data. This is
                         * not mandantory, but just to be sure.
                         */
                        Ret = VpdUpdate(pAC, IoC);
                        if (Ret != SK_PNMI_VPD_OK) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR026,
                                        SK_PNMI_ERR026MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        break;

                case SK_PNMI_VPD_DELETE:
                        /* Check if the buffer size is plausible */
                        if (*pLen < 3) {

                                *pLen = 3;
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        if (*pLen > 3) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }
                        KeyStr[0] = pBuf[1];
                        KeyStr[1] = pBuf[2];
                        KeyStr[2] = 0;

                        /* Find the passed key in the array */
                        for (Index = 0; Index < KeyNo; Index ++) {

                                if (SK_STRCMP(KeyStr, KeyArr[Index]) == 0) {

                                        break;
                                }
                        }
                        /*
                         * If we cannot find the key it is wrong, so we
                         * return an appropriate error value.
                         */
                        if (Index == KeyNo) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }

                        if (Action == SK_PNMI_PRESET) {

                                return (SK_PNMI_ERR_OK);
                        }

                        /* Ok, you wanted it and you will get it */
                        Ret = VpdDelete(pAC, IoC, KeyStr);
                        if (Ret != SK_PNMI_VPD_OK) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR027,
                                        SK_PNMI_ERR027MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }

                        /*
                         * Perform an update of the VPD data. This is
                         * not mandantory, but just to be sure.
                         */
                        Ret = VpdUpdate(pAC, IoC);
                        if (Ret != SK_PNMI_VPD_OK) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR028,
                                        SK_PNMI_ERR028MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        break;

                default:
                        *pLen = 0;
                        return (SK_PNMI_ERR_BAD_VALUE);
                }
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * General - OID handler function of various single instance OIDs
 *
 * Description:
 *      The code is simple. No description necessary.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int General(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        int             Ret;
        unsigned int    Index;
        unsigned int    Len;
        unsigned int    Offset;
        unsigned int    Val;
        SK_U8           Val8;
        SK_U16          Val16;
        SK_U32          Val32;
        SK_U64          Val64;
        SK_U64          Val64RxHwErrs = 0;
        SK_U64          Val64TxHwErrs = 0;
        SK_BOOL         Is64BitReq = SK_FALSE;
        char            Buf[256];
        int                     MacType;

        /*
         * Check instance. We only handle single instance variables
         */
        if (Instance != (SK_U32)(-1) && Instance != 1) {

                *pLen = 0;
                return (SK_PNMI_ERR_UNKNOWN_INST);
        }

        /*
         * Check action. We only allow get requests.
         */
        if (Action != SK_PNMI_GET) {

                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }
        
        MacType = pAC->GIni.GIMacType;
        
        /*
         * Check length for the various supported OIDs
         */
        switch (Id) {

        case OID_GEN_XMIT_ERROR:
        case OID_GEN_RCV_ERROR:
        case OID_GEN_RCV_NO_BUFFER:
#ifndef SK_NDIS_64BIT_CTR
                if (*pLen < sizeof(SK_U32)) {
                        *pLen = sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }

#else /* SK_NDIS_64BIT_CTR */

                /*
                 * for compatibility, at least 32bit are required for oid
                 */
                if (*pLen < sizeof(SK_U32)) {
                        /*
                        * but indicate handling for 64bit values,
                        * if insufficient space is provided
                        */
                        *pLen = sizeof(SK_U64);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }

                Is64BitReq = (*pLen < sizeof(SK_U64)) ? SK_FALSE : SK_TRUE;
#endif /* SK_NDIS_64BIT_CTR */
                break;

        case OID_SKGE_PORT_NUMBER:
        case OID_SKGE_DEVICE_TYPE:
        case OID_SKGE_RESULT:
        case OID_SKGE_RLMT_MONITOR_NUMBER:
        case OID_GEN_TRANSMIT_QUEUE_LENGTH:
        case OID_SKGE_TRAP_NUMBER:
        case OID_SKGE_MDB_VERSION:
                if (*pLen < sizeof(SK_U32)) {

                        *pLen = sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        case OID_SKGE_CHIPSET:
                if (*pLen < sizeof(SK_U16)) {

                        *pLen = sizeof(SK_U16);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        case OID_SKGE_BUS_TYPE:
        case OID_SKGE_BUS_SPEED:
        case OID_SKGE_BUS_WIDTH:
        case OID_SKGE_SENSOR_NUMBER:
        case OID_SKGE_CHKSM_NUMBER:
                if (*pLen < sizeof(SK_U8)) {

                        *pLen = sizeof(SK_U8);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        case OID_SKGE_TX_SW_QUEUE_LEN:
        case OID_SKGE_TX_SW_QUEUE_MAX:
        case OID_SKGE_TX_RETRY:
        case OID_SKGE_RX_INTR_CTS:
        case OID_SKGE_TX_INTR_CTS:
        case OID_SKGE_RX_NO_BUF_CTS:
        case OID_SKGE_TX_NO_BUF_CTS:
        case OID_SKGE_TX_USED_DESCR_NO:
        case OID_SKGE_RX_DELIVERED_CTS:
        case OID_SKGE_RX_OCTETS_DELIV_CTS:
        case OID_SKGE_RX_HW_ERROR_CTS:
        case OID_SKGE_TX_HW_ERROR_CTS:
        case OID_SKGE_IN_ERRORS_CTS:
        case OID_SKGE_OUT_ERROR_CTS:
        case OID_SKGE_ERR_RECOVERY_CTS:
        case OID_SKGE_SYSUPTIME:
                if (*pLen < sizeof(SK_U64)) {

                        *pLen = sizeof(SK_U64);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        default:
                /* Checked later */
                break;
        }

        /* Update statistic */
        if (Id == OID_SKGE_RX_HW_ERROR_CTS ||
                Id == OID_SKGE_TX_HW_ERROR_CTS ||
                Id == OID_SKGE_IN_ERRORS_CTS ||
                Id == OID_SKGE_OUT_ERROR_CTS ||
                Id == OID_GEN_XMIT_ERROR ||
                Id == OID_GEN_RCV_ERROR) {

                /* Force the XMAC to update its statistic counters and
                 * Increment semaphore to indicate that an update was
                 * already done.
                 */
                Ret = MacUpdate(pAC, IoC, 0, pAC->GIni.GIMacsFound - 1);
                if (Ret != SK_PNMI_ERR_OK) {

                        *pLen = 0;
                        return (Ret);
                }
                pAC->Pnmi.MacUpdatedFlag ++;

                /*
                 * Some OIDs consist of multiple hardware counters. Those
                 * values which are contained in all of them will be added
                 * now.
                 */
                switch (Id) {

                case OID_SKGE_RX_HW_ERROR_CTS:
                case OID_SKGE_IN_ERRORS_CTS:
                case OID_GEN_RCV_ERROR:
                        Val64RxHwErrs =
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_MISSED, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_FRAMING, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_OVERFLOW, NetIndex)+
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_JABBER, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_CARRIER, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_IRLENGTH, NetIndex)+
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_SYMBOL, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_SHORTS, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_RUNT, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_TOO_LONG, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_FCS, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HRX_CEXT, NetIndex);
                break;

                case OID_SKGE_TX_HW_ERROR_CTS:
                case OID_SKGE_OUT_ERROR_CTS:
                case OID_GEN_XMIT_ERROR:
                        Val64TxHwErrs =
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HTX_EXCESS_COL, NetIndex) +
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HTX_LATE_COL, NetIndex)+
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HTX_UNDERRUN, NetIndex)+
                                GetStatVal(pAC, IoC, 0, SK_PNMI_HTX_CARRIER, NetIndex);
                        break;
                }
        }

        /*
         * Retrieve value
         */
        switch (Id) {

        case OID_SKGE_SUPPORTED_LIST:
                Len = ID_TABLE_SIZE * sizeof(SK_U32);
                if (*pLen < Len) {

                        *pLen = Len;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                for (Offset = 0, Index = 0; Offset < Len;
                        Offset += sizeof(SK_U32), Index ++) {

                        Val32 = (SK_U32)IdTable[Index].Id;
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                }
                *pLen = Len;
                break;

        case OID_SKGE_PORT_NUMBER:
                Val32 = (SK_U32)pAC->GIni.GIMacsFound;
                SK_PNMI_STORE_U32(pBuf, Val32);
                *pLen = sizeof(SK_U32);
                break;

        case OID_SKGE_DEVICE_TYPE:
                Val32 = (SK_U32)pAC->Pnmi.DeviceType;
                SK_PNMI_STORE_U32(pBuf, Val32);
                *pLen = sizeof(SK_U32);
                break;

        case OID_SKGE_DRIVER_DESCR:
                if (pAC->Pnmi.pDriverDescription == NULL) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR007,
                                SK_PNMI_ERR007MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                Len = SK_STRLEN(pAC->Pnmi.pDriverDescription) + 1;
                if (Len > SK_PNMI_STRINGLEN1) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR029,
                                SK_PNMI_ERR029MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                if (*pLen < Len) {

                        *pLen = Len;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                *pBuf = (char)(Len - 1);
                SK_MEMCPY(pBuf + 1, pAC->Pnmi.pDriverDescription, Len - 1);
                *pLen = Len;
                break;

        case OID_SKGE_DRIVER_VERSION:
                if (pAC->Pnmi.pDriverVersion == NULL) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR030,
                                SK_PNMI_ERR030MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                Len = SK_STRLEN(pAC->Pnmi.pDriverVersion) + 1;
                if (Len > SK_PNMI_STRINGLEN1) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR031,
                                SK_PNMI_ERR031MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                if (*pLen < Len) {

                        *pLen = Len;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                *pBuf = (char)(Len - 1);
                SK_MEMCPY(pBuf + 1, pAC->Pnmi.pDriverVersion, Len - 1);
                *pLen = Len;
                break;

        case OID_SKGE_HW_DESCR:
                /*
                 * The hardware description is located in the VPD. This
                 * query may move to the initialisation routine. But
                 * the VPD data is cached and therefore a call here
                 * will not make much difference.
                 */
                Len = 256;
                if (VpdRead(pAC, IoC, VPD_NAME, Buf, (int *)&Len) > 0) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR032,
                                SK_PNMI_ERR032MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }
                Len ++;
                if (Len > SK_PNMI_STRINGLEN1) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR033,
                                SK_PNMI_ERR033MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }
                if (*pLen < Len) {

                        *pLen = Len;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                *pBuf = (char)(Len - 1);
                SK_MEMCPY(pBuf + 1, Buf, Len - 1);
                *pLen = Len;
                break;

        case OID_SKGE_HW_VERSION:
                /* Oh, I love to do some string manipulation */
                if (*pLen < 5) {

                        *pLen = 5;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                Val8 = (SK_U8)pAC->GIni.GIPciHwRev;
                pBuf[0] = 4;
                pBuf[1] = 'v';
                pBuf[2] = (char)(0x30 | ((Val8 >> 4) & 0x0F));
                pBuf[3] = '.';
                pBuf[4] = (char)(0x30 | (Val8 & 0x0F));
                *pLen = 5;
                break;

        case OID_SKGE_CHIPSET:
                Val16 = pAC->Pnmi.Chipset;
                SK_PNMI_STORE_U16(pBuf, Val16);
                *pLen = sizeof(SK_U16);
                break;

        case OID_SKGE_BUS_TYPE:
                *pBuf = (char)SK_PNMI_BUS_PCI;
                *pLen = sizeof(char);
                break;

        case OID_SKGE_BUS_SPEED:
                *pBuf = pAC->Pnmi.PciBusSpeed;
                *pLen = sizeof(char);
                break;

        case OID_SKGE_BUS_WIDTH:
                *pBuf = pAC->Pnmi.PciBusWidth;
                *pLen = sizeof(char);
                break;

        case OID_SKGE_RESULT:
                Val32 = pAC->Pnmi.TestResult;
                SK_PNMI_STORE_U32(pBuf, Val32);
                *pLen = sizeof(SK_U32);
                break;

        case OID_SKGE_SENSOR_NUMBER:
                *pBuf = (char)pAC->I2c.MaxSens;
                *pLen = sizeof(char);
                break;

        case OID_SKGE_CHKSM_NUMBER:
                *pBuf = SKCS_NUM_PROTOCOLS;
                *pLen = sizeof(char);
                break;

        case OID_SKGE_TRAP_NUMBER:
                GetTrapQueueLen(pAC, &Len, &Val);
                Val32 = (SK_U32)Val;
                SK_PNMI_STORE_U32(pBuf, Val32);
                *pLen = sizeof(SK_U32);
                break;

        case OID_SKGE_TRAP:
                GetTrapQueueLen(pAC, &Len, &Val);
                if (*pLen < Len) {

                        *pLen = Len;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                CopyTrapQueue(pAC, pBuf);
                *pLen = Len;
                break;

        case OID_SKGE_RLMT_MONITOR_NUMBER:
/* XXX Not yet implemented by RLMT therefore we return zero elements */
                Val32 = 0;
                SK_PNMI_STORE_U32(pBuf, Val32);
                *pLen = sizeof(SK_U32);
                break;

        case OID_SKGE_TX_SW_QUEUE_LEN:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].TxSwQueueLen;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].TxSwQueueLen +
                                        pAC->Pnmi.BufPort[1].TxSwQueueLen;
                        }                       
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].TxSwQueueLen;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].TxSwQueueLen +
                                        pAC->Pnmi.Port[1].TxSwQueueLen;
                        }                       
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;


        case OID_SKGE_TX_SW_QUEUE_MAX:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].TxSwQueueMax;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].TxSwQueueMax +
                                        pAC->Pnmi.BufPort[1].TxSwQueueMax;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].TxSwQueueMax;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].TxSwQueueMax +
                                        pAC->Pnmi.Port[1].TxSwQueueMax;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_TX_RETRY:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].TxRetryCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].TxRetryCts +
                                        pAC->Pnmi.BufPort[1].TxRetryCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].TxRetryCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].TxRetryCts +
                                        pAC->Pnmi.Port[1].TxRetryCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_RX_INTR_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].RxIntrCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].RxIntrCts +
                                        pAC->Pnmi.BufPort[1].RxIntrCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].RxIntrCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].RxIntrCts +
                                        pAC->Pnmi.Port[1].RxIntrCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_TX_INTR_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].TxIntrCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].TxIntrCts +
                                        pAC->Pnmi.BufPort[1].TxIntrCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].TxIntrCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].TxIntrCts +
                                        pAC->Pnmi.Port[1].TxIntrCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_RX_NO_BUF_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].RxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].RxNoBufCts +
                                        pAC->Pnmi.BufPort[1].RxNoBufCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].RxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].RxNoBufCts +
                                        pAC->Pnmi.Port[1].RxNoBufCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_TX_NO_BUF_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].TxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].TxNoBufCts +
                                        pAC->Pnmi.BufPort[1].TxNoBufCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].TxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].TxNoBufCts +
                                        pAC->Pnmi.Port[1].TxNoBufCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_TX_USED_DESCR_NO:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].TxUsedDescrNo;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].TxUsedDescrNo +
                                        pAC->Pnmi.BufPort[1].TxUsedDescrNo;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].TxUsedDescrNo;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].TxUsedDescrNo +
                                        pAC->Pnmi.Port[1].TxUsedDescrNo;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_RX_DELIVERED_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].RxDeliveredCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].RxDeliveredCts +
                                        pAC->Pnmi.BufPort[1].RxDeliveredCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].RxDeliveredCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].RxDeliveredCts +
                                        pAC->Pnmi.Port[1].RxDeliveredCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_RX_OCTETS_DELIV_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].RxOctetsDeliveredCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].RxOctetsDeliveredCts +
                                        pAC->Pnmi.BufPort[1].RxOctetsDeliveredCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].RxOctetsDeliveredCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].RxOctetsDeliveredCts +
                                        pAC->Pnmi.Port[1].RxOctetsDeliveredCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_RX_HW_ERROR_CTS:
                SK_PNMI_STORE_U64(pBuf, Val64RxHwErrs);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_TX_HW_ERROR_CTS:
                SK_PNMI_STORE_U64(pBuf, Val64TxHwErrs);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_IN_ERRORS_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = Val64RxHwErrs + pAC->Pnmi.BufPort[NetIndex].RxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = Val64RxHwErrs + 
                                        pAC->Pnmi.BufPort[0].RxNoBufCts +
                                        pAC->Pnmi.BufPort[1].RxNoBufCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = Val64RxHwErrs + pAC->Pnmi.Port[NetIndex].RxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = Val64RxHwErrs + 
                                        pAC->Pnmi.Port[0].RxNoBufCts +
                                        pAC->Pnmi.Port[1].RxNoBufCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_OUT_ERROR_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = Val64TxHwErrs + pAC->Pnmi.BufPort[NetIndex].TxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = Val64TxHwErrs + 
                                        pAC->Pnmi.BufPort[0].TxNoBufCts +
                                        pAC->Pnmi.BufPort[1].TxNoBufCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = Val64TxHwErrs + pAC->Pnmi.Port[NetIndex].TxNoBufCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = Val64TxHwErrs + 
                                        pAC->Pnmi.Port[0].TxNoBufCts +
                                        pAC->Pnmi.Port[1].TxNoBufCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_ERR_RECOVERY_CTS:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.BufPort[NetIndex].ErrRecoveryCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.BufPort[0].ErrRecoveryCts +
                                        pAC->Pnmi.BufPort[1].ErrRecoveryCts;
                        }
                }
                else {
                        /* Dual net mode */
                        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                                Val64 = pAC->Pnmi.Port[NetIndex].ErrRecoveryCts;
                        }
                        /* Single net mode */
                        else {
                                Val64 = pAC->Pnmi.Port[0].ErrRecoveryCts +
                                        pAC->Pnmi.Port[1].ErrRecoveryCts;
                        }
                }
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_SYSUPTIME:
                Val64 = SK_PNMI_HUNDREDS_SEC(SkOsGetTime(pAC));
                Val64 -= pAC->Pnmi.StartUpTime;
                SK_PNMI_STORE_U64(pBuf, Val64);
                *pLen = sizeof(SK_U64);
                break;

        case OID_SKGE_MDB_VERSION:
                Val32 = SK_PNMI_MDB_VERSION;
                SK_PNMI_STORE_U32(pBuf, Val32);
                *pLen = sizeof(SK_U32);
                break;

        case OID_GEN_RCV_ERROR:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        Val64 = Val64RxHwErrs + pAC->Pnmi.BufPort[NetIndex].RxNoBufCts;
                }
                else {
                        Val64 = Val64RxHwErrs + pAC->Pnmi.Port[NetIndex].RxNoBufCts;
                }

                /*
                 * by default 32bit values are evaluated
                 */
                if (!Is64BitReq) {
                        Val32 = (SK_U32)Val64;
                        SK_PNMI_STORE_U32(pBuf, Val32);
                        *pLen = sizeof(SK_U32);
                }
                else {
                        SK_PNMI_STORE_U64(pBuf, Val64);
                        *pLen = sizeof(SK_U64);
                }
                break;

        case OID_GEN_XMIT_ERROR:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        Val64 = Val64TxHwErrs + pAC->Pnmi.BufPort[NetIndex].TxNoBufCts;
                }
                else {
                        Val64 = Val64TxHwErrs + pAC->Pnmi.Port[NetIndex].TxNoBufCts;
                }

                /*
                 * by default 32bit values are evaluated
                 */
                if (!Is64BitReq) {
                        Val32 = (SK_U32)Val64;
                        SK_PNMI_STORE_U32(pBuf, Val32);
                        *pLen = sizeof(SK_U32);
                }
                else {
                        SK_PNMI_STORE_U64(pBuf, Val64);
                        *pLen = sizeof(SK_U64);
                }
                break;

        case OID_GEN_RCV_NO_BUFFER:
                /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
                if (MacType == SK_MAC_XMAC) {
                        Val64 = pAC->Pnmi.BufPort[NetIndex].RxNoBufCts;
                }
                else {
                        Val64 = pAC->Pnmi.Port[NetIndex].RxNoBufCts;
                }

                /*
                 * by default 32bit values are evaluated
                 */
                if (!Is64BitReq) {
                        Val32 = (SK_U32)Val64;
                        SK_PNMI_STORE_U32(pBuf, Val32);
                        *pLen = sizeof(SK_U32);
                }
                else {
                        SK_PNMI_STORE_U64(pBuf, Val64);
                        *pLen = sizeof(SK_U64);
                }
                break;

        case OID_GEN_TRANSMIT_QUEUE_LENGTH:
                Val32 = (SK_U32)pAC->Pnmi.Port[NetIndex].TxSwQueueLen;
                SK_PNMI_STORE_U32(pBuf, Val32);
                *pLen = sizeof(SK_U32);
                break;

        default:
                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR034,
                        SK_PNMI_ERR034MSG);

                *pLen = 0;
                return (SK_PNMI_ERR_GENERAL);
        }

        if (Id == OID_SKGE_RX_HW_ERROR_CTS ||
                Id == OID_SKGE_TX_HW_ERROR_CTS ||
                Id == OID_SKGE_IN_ERRORS_CTS ||
                Id == OID_SKGE_OUT_ERROR_CTS ||
                Id == OID_GEN_XMIT_ERROR ||
                Id == OID_GEN_RCV_ERROR) {

                pAC->Pnmi.MacUpdatedFlag --;
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * Rlmt - OID handler function of OID_SKGE_RLMT_XXX single instance.
 *
 * Description:
 *      Get/Presets/Sets the RLMT OIDs.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int Rlmt(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        int             Ret;
        unsigned int    PhysPortIndex;
        unsigned int    PhysPortMax;
        SK_EVPARA       EventParam;
        SK_U32          Val32;
        SK_U64          Val64;


        /*
         * Check instance. Only single instance OIDs are allowed here.
         */
        if (Instance != (SK_U32)(-1) && Instance != 1) {

                *pLen = 0;
                return (SK_PNMI_ERR_UNKNOWN_INST);
        }

        /*
         * Perform the requested action
         */
        if (Action == SK_PNMI_GET) {

                /*
                 * Check if the buffer length is large enough.
                 */

                switch (Id) {

                case OID_SKGE_RLMT_MODE:
                case OID_SKGE_RLMT_PORT_ACTIVE:
                case OID_SKGE_RLMT_PORT_PREFERRED:
                        if (*pLen < sizeof(SK_U8)) {

                                *pLen = sizeof(SK_U8);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;

                case OID_SKGE_RLMT_PORT_NUMBER:
                        if (*pLen < sizeof(SK_U32)) {

                                *pLen = sizeof(SK_U32);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;

                case OID_SKGE_RLMT_CHANGE_CTS:
                case OID_SKGE_RLMT_CHANGE_TIME:
                case OID_SKGE_RLMT_CHANGE_ESTIM:
                case OID_SKGE_RLMT_CHANGE_THRES:
                        if (*pLen < sizeof(SK_U64)) {

                                *pLen = sizeof(SK_U64);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;

                default:
                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR035,
                                SK_PNMI_ERR035MSG);

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                /*
                 * Update RLMT statistic and increment semaphores to indicate
                 * that an update was already done. Maybe RLMT will hold its
                 * statistic always up to date some time. Then we can
                 * remove this type of call.
                 */
                if ((Ret = RlmtUpdate(pAC, IoC, NetIndex)) != SK_PNMI_ERR_OK) {

                        *pLen = 0;
                        return (Ret);
                }
                pAC->Pnmi.RlmtUpdatedFlag ++;

                /*
                 * Retrieve Value
                */
                switch (Id) {

                case OID_SKGE_RLMT_MODE:
                        *pBuf = (char)pAC->Rlmt.Net[0].RlmtMode;
                        *pLen = sizeof(char);
                        break;

                case OID_SKGE_RLMT_PORT_NUMBER:
                        Val32 = (SK_U32)pAC->GIni.GIMacsFound;
                        SK_PNMI_STORE_U32(pBuf, Val32);
                        *pLen = sizeof(SK_U32);
                        break;

                case OID_SKGE_RLMT_PORT_ACTIVE:
                        *pBuf = 0;
                        /*
                         * If multiple ports may become active this OID
                         * doesn't make sense any more. A new variable in
                         * the port structure should be created. However,
                         * for this variable the first active port is
                         * returned.
                         */
                        PhysPortMax = pAC->GIni.GIMacsFound;

                        for (PhysPortIndex = 0; PhysPortIndex < PhysPortMax;
                                PhysPortIndex ++) {

                                if (pAC->Pnmi.Port[PhysPortIndex].ActiveFlag) {

                                        *pBuf = (char)SK_PNMI_PORT_PHYS2LOG(PhysPortIndex);
                                        break;
                                }
                        }
                        *pLen = sizeof(char);
                        break;

                case OID_SKGE_RLMT_PORT_PREFERRED:
                        *pBuf = (char)SK_PNMI_PORT_PHYS2LOG(pAC->Rlmt.Net[NetIndex].Preference);
                        *pLen = sizeof(char);
                        break;

                case OID_SKGE_RLMT_CHANGE_CTS:
                        Val64 = pAC->Pnmi.RlmtChangeCts;
                        SK_PNMI_STORE_U64(pBuf, Val64);
                        *pLen = sizeof(SK_U64);
                        break;

                case OID_SKGE_RLMT_CHANGE_TIME:
                        Val64 = pAC->Pnmi.RlmtChangeTime;
                        SK_PNMI_STORE_U64(pBuf, Val64);
                        *pLen = sizeof(SK_U64);
                        break;

                case OID_SKGE_RLMT_CHANGE_ESTIM:
                        Val64 = pAC->Pnmi.RlmtChangeEstimate.Estimate;
                        SK_PNMI_STORE_U64(pBuf, Val64);
                        *pLen = sizeof(SK_U64);
                        break;

                case OID_SKGE_RLMT_CHANGE_THRES:
                        Val64 = pAC->Pnmi.RlmtChangeThreshold;
                        SK_PNMI_STORE_U64(pBuf, Val64);
                        *pLen = sizeof(SK_U64);
                        break;

                default:
                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_ERR,
                                ("Rlmt: Unknown OID should be handled before"));

                        pAC->Pnmi.RlmtUpdatedFlag --;
                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                pAC->Pnmi.RlmtUpdatedFlag --;
        }
        else {
                /* Perform a preset or set */
                switch (Id) {

                case OID_SKGE_RLMT_MODE:
                        /* Check if the buffer length is plausible */
                        if (*pLen < sizeof(char)) {

                                *pLen = sizeof(char);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        /* Check if the value range is correct */
                        if (*pLen != sizeof(char) ||
                                (*pBuf & SK_PNMI_RLMT_MODE_CHK_LINK) == 0 ||
                                *(SK_U8 *)pBuf > 15) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }
                        /* The preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_OK);
                        }
                        /* Send an event to RLMT to change the mode */
                        SK_MEMSET((char *)&EventParam, 0, sizeof(EventParam));
                        EventParam.Para32[0] |= (SK_U32)(*pBuf);
                        EventParam.Para32[1] = 0;
                        if (SkRlmtEvent(pAC, IoC, SK_RLMT_MODE_CHANGE,
                                EventParam) > 0) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR037,
                                        SK_PNMI_ERR037MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        break;

                case OID_SKGE_RLMT_PORT_PREFERRED:
                        /* Check if the buffer length is plausible */
                        if (*pLen < sizeof(char)) {

                                *pLen = sizeof(char);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        /* Check if the value range is correct */
                        if (*pLen != sizeof(char) || *(SK_U8 *)pBuf >
                                (SK_U8)pAC->GIni.GIMacsFound) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }
                        /* The preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_OK);
                        }

                        /*
                         * Send an event to RLMT change the preferred port.
                         * A param of -1 means automatic mode. RLMT will
                         * make the decision which is the preferred port.
                         */
                        SK_MEMSET((char *)&EventParam, 0, sizeof(EventParam));
                        EventParam.Para32[0] = (SK_U32)(*pBuf) - 1;
                        EventParam.Para32[1] = NetIndex;
                        if (SkRlmtEvent(pAC, IoC, SK_RLMT_PREFPORT_CHANGE,
                                EventParam) > 0) {

                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR038,
                                        SK_PNMI_ERR038MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                        break;

                case OID_SKGE_RLMT_CHANGE_THRES:
                        /* Check if the buffer length is plausible */
                        if (*pLen < sizeof(SK_U64)) {

                                *pLen = sizeof(SK_U64);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        /*
                         * There are not many restrictions to the
                         * value range.
                         */
                        if (*pLen != sizeof(SK_U64)) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }
                        /* A preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_OK);
                        }
                        /*
                         * Store the new threshold, which will be taken
                         * on the next timer event.
                         */
                        SK_PNMI_READ_U64(pBuf, Val64);
                        pAC->Pnmi.RlmtChangeThreshold = Val64;
                        break;

                default:
                        /* The other OIDs are not be able for set */
                        *pLen = 0;
                        return (SK_PNMI_ERR_READ_ONLY);
                }
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * RlmtStat - OID handler function of OID_SKGE_RLMT_XXX multiple instance.
 *
 * Description:
 *      Performs get requests on multiple instance variables.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int RlmtStat(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    PhysPortMax;
        unsigned int    PhysPortIndex;
        unsigned int    Limit;
        unsigned int    Offset;
        int             Ret;
        SK_U32          Val32;
        SK_U64          Val64;

        /*
         * Calculate the port indexes from the instance
         */
        PhysPortMax = pAC->GIni.GIMacsFound;

        if ((Instance != (SK_U32)(-1))) {
                /* Check instance range */
                if ((Instance < 1) || (Instance > PhysPortMax)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }

                /* Single net mode */
                PhysPortIndex = Instance - 1;

                /* Dual net mode */
                if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                        PhysPortIndex = NetIndex;
                }

                /* Both net modes */
                Limit = PhysPortIndex + 1;
        }
        else {
                /* Single net mode */
                PhysPortIndex = 0;
                Limit = PhysPortMax;

                /* Dual net mode */
                if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                        PhysPortIndex = NetIndex;
                        Limit = PhysPortIndex + 1;
                }
        }

        /*
         * Currently only get requests are allowed.
         */
        if (Action != SK_PNMI_GET) {

                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }

        /*
         * Check if the buffer length is large enough.
         */
        switch (Id) {

        case OID_SKGE_RLMT_PORT_INDEX:
        case OID_SKGE_RLMT_STATUS:
                if (*pLen < (Limit - PhysPortIndex) * sizeof(SK_U32)) {

                        *pLen = (Limit - PhysPortIndex) * sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        case OID_SKGE_RLMT_TX_HELLO_CTS:
        case OID_SKGE_RLMT_RX_HELLO_CTS:
        case OID_SKGE_RLMT_TX_SP_REQ_CTS:
        case OID_SKGE_RLMT_RX_SP_CTS:
                if (*pLen < (Limit - PhysPortIndex) * sizeof(SK_U64)) {

                        *pLen = (Limit - PhysPortIndex) * sizeof(SK_U64);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;

        default:
                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR039,
                        SK_PNMI_ERR039MSG);

                *pLen = 0;
                return (SK_PNMI_ERR_GENERAL);

        }

        /*
         * Update statistic and increment semaphores to indicate that
         * an update was already done.
         */
        if ((Ret = RlmtUpdate(pAC, IoC, NetIndex)) != SK_PNMI_ERR_OK) {

                *pLen = 0;
                return (Ret);
        }
        pAC->Pnmi.RlmtUpdatedFlag ++;

        /*
         * Get value
         */
        Offset = 0;
        for (; PhysPortIndex < Limit; PhysPortIndex ++) {

                switch (Id) {

                case OID_SKGE_RLMT_PORT_INDEX:
                        Val32 = PhysPortIndex;
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                        Offset += sizeof(SK_U32);
                        break;

                case OID_SKGE_RLMT_STATUS:
                        if (pAC->Rlmt.Port[PhysPortIndex].PortState ==
                                SK_RLMT_PS_INIT ||
                                pAC->Rlmt.Port[PhysPortIndex].PortState ==
                                SK_RLMT_PS_DOWN) {

                                Val32 = SK_PNMI_RLMT_STATUS_ERROR;
                        }
                        else if (pAC->Pnmi.Port[PhysPortIndex].ActiveFlag) {

                                Val32 = SK_PNMI_RLMT_STATUS_ACTIVE;
                        }
                        else {
                                Val32 = SK_PNMI_RLMT_STATUS_STANDBY;
                        }
                        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                        Offset += sizeof(SK_U32);
                        break;

                case OID_SKGE_RLMT_TX_HELLO_CTS:
                        Val64 = pAC->Rlmt.Port[PhysPortIndex].TxHelloCts;
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                case OID_SKGE_RLMT_RX_HELLO_CTS:
                        Val64 = pAC->Rlmt.Port[PhysPortIndex].RxHelloCts;
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                case OID_SKGE_RLMT_TX_SP_REQ_CTS:
                        Val64 = pAC->Rlmt.Port[PhysPortIndex].TxSpHelloReqCts;
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                case OID_SKGE_RLMT_RX_SP_CTS:
                        Val64 = pAC->Rlmt.Port[PhysPortIndex].RxSpHelloCts;
                        SK_PNMI_STORE_U64(pBuf + Offset, Val64);
                        Offset += sizeof(SK_U64);
                        break;

                default:
                        SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_ERR,
                                ("RlmtStat: Unknown OID should be errored before"));

                        pAC->Pnmi.RlmtUpdatedFlag --;
                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }
        }
        *pLen = Offset;

        pAC->Pnmi.RlmtUpdatedFlag --;

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * MacPrivateConf - OID handler function of OIDs concerning the configuration
 *
 * Description:
 *      Get/Presets/Sets the OIDs concerning the configuration.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int MacPrivateConf(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    PhysPortMax;
        unsigned int    PhysPortIndex;
        unsigned int    LogPortMax;
        unsigned int    LogPortIndex;
        unsigned int    Limit;
        unsigned int    Offset;
        char            Val8;
        int             Ret;
        SK_EVPARA       EventParam;
        SK_U32          Val32;


        /*
         * Calculate instance if wished. MAC index 0 is the virtual
         * MAC.
         */
        PhysPortMax = pAC->GIni.GIMacsFound;
        LogPortMax = SK_PNMI_PORT_PHYS2LOG(PhysPortMax);

        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) { /* Dual net mode */
                LogPortMax--;
        }

        if ((Instance != (SK_U32)(-1))) { /* Only one specific instance is queried */
                /* Check instance range */
                if ((Instance < 1) || (Instance > LogPortMax)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }
                LogPortIndex = SK_PNMI_PORT_INST2LOG(Instance);
                Limit = LogPortIndex + 1;
        }

        else { /* Instance == (SK_U32)(-1), get all Instances of that OID */

                LogPortIndex = 0;
                Limit = LogPortMax;
        }

        /*
         * Perform action
         */
        if (Action == SK_PNMI_GET) {

                /*
                 * Check length
                 */
                switch (Id) {

                case OID_SKGE_PMD:
                case OID_SKGE_CONNECTOR:
                case OID_SKGE_LINK_CAP:
                case OID_SKGE_LINK_MODE:
                case OID_SKGE_LINK_MODE_STATUS:
                case OID_SKGE_LINK_STATUS:
                case OID_SKGE_FLOWCTRL_CAP:
                case OID_SKGE_FLOWCTRL_MODE:
                case OID_SKGE_FLOWCTRL_STATUS:
                case OID_SKGE_PHY_OPERATION_CAP:
                case OID_SKGE_PHY_OPERATION_MODE:
                case OID_SKGE_PHY_OPERATION_STATUS:
                case OID_SKGE_SPEED_CAP:
                case OID_SKGE_SPEED_MODE:
                case OID_SKGE_SPEED_STATUS:
                        if (*pLen < (Limit - LogPortIndex) * sizeof(SK_U8)) {

                                *pLen = (Limit - LogPortIndex) *
                                        sizeof(SK_U8);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;

        case OID_SKGE_MTU:
                        if (*pLen < sizeof(SK_U32)) {

                                *pLen = sizeof(SK_U32);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;

                default:
                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR041,
                                SK_PNMI_ERR041MSG);
                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                /*
                 * Update statistic and increment semaphore to indicate
                 * that an update was already done.
                 */
                if ((Ret = SirqUpdate(pAC, IoC)) != SK_PNMI_ERR_OK) {

                        *pLen = 0;
                        return (Ret);
                }
                pAC->Pnmi.SirqUpdatedFlag ++;

                /*
                 * Get value
                 */
                Offset = 0;
                for (; LogPortIndex < Limit; LogPortIndex ++) {

                        switch (Id) {

                        case OID_SKGE_PMD:
                                *(pBuf + Offset) = pAC->Pnmi.PMD;
                                Offset += sizeof(char);
                                break;

                        case OID_SKGE_CONNECTOR:
                                *(pBuf + Offset) = pAC->Pnmi.Connector;
                                Offset += sizeof(char);
                                break;

                        case OID_SKGE_LINK_CAP:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical ports */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);

                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PLinkCap;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */
                                        
                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PLinkCap;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_LINK_MODE:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                Offset);
                                        }
                                        else {
                                                /* Get value for physical ports */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);

                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PLinkModeConf;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */ 
                                
                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PLinkModeConf;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_LINK_MODE_STATUS:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical port */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);

                                                *(pBuf + Offset) =
                                                        CalculateLinkModeStatus(pAC,
                                                                IoC, PhysPortIndex);
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */
                                        *(pBuf + Offset) = CalculateLinkModeStatus(pAC, IoC, NetIndex);
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_LINK_STATUS:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical ports */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) =
                                                        CalculateLinkStatus(pAC,
                                                                IoC, PhysPortIndex);
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */

                                        *(pBuf + Offset) = CalculateLinkStatus(pAC, IoC, NetIndex);
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_FLOWCTRL_CAP:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical ports */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PFlowCtrlCap;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */
                                
                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PFlowCtrlCap;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_FLOWCTRL_MODE:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical port */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PFlowCtrlMode;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */

                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PFlowCtrlMode;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_FLOWCTRL_STATUS:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical port */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PFlowCtrlStatus;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */

                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PFlowCtrlStatus;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_PHY_OPERATION_CAP:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical ports */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PMSCap;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */
                                
                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PMSCap;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_PHY_OPERATION_MODE:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {

                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf + Offset);
                                        }
                                        else {
                                                /* Get value for physical port */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);

                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PMSMode;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */
                                
                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PMSMode;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_PHY_OPERATION_STATUS:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {

                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf + Offset);
                                        }
                                        else {
                                                /* Get value for physical port */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PMSStatus;
                                        }
                                        Offset += sizeof(char);
                                }
                                else {
                                
                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PMSStatus;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_SPEED_CAP:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf +
                                                        Offset);
                                        }
                                        else {
                                                /* Get value for physical ports */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PLinkSpeedCap;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */
                                
                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PLinkSpeedCap;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_SPEED_MODE:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf + Offset);
                                        }
                                        else {
                                                /* Get value for physical port */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PLinkSpeed;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */

                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PLinkSpeed;
                                        Offset += sizeof(char);
                                }
                                break;

                        case OID_SKGE_SPEED_STATUS:
                                if (!pAC->Pnmi.DualNetActiveFlag) { /* SingleNetMode */
                                        if (LogPortIndex == 0) {
        
                                                /* Get value for virtual port */
                                                VirtualConf(pAC, IoC, Id, pBuf + Offset);
                                        }
                                        else {
                                                /* Get value for physical port */
                                                PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(
                                                        pAC, LogPortIndex);
        
                                                *(pBuf + Offset) = pAC->GIni.GP[
                                                        PhysPortIndex].PLinkSpeedUsed;
                                        }
                                        Offset += sizeof(char);
                                }
                                else { /* DualNetMode */

                                        *(pBuf + Offset) = pAC->GIni.GP[NetIndex].PLinkSpeedUsed;
                                        Offset += sizeof(char);
                                }
                                break;
                        
                        case OID_SKGE_MTU:
                                Val32 = SK_DRIVER_GET_MTU(pAC, IoC, NetIndex);
                                SK_PNMI_STORE_U32(pBuf + Offset, Val32);
                                Offset += sizeof(SK_U32);
                                break;

                        default:
                                SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_ERR,
                                        ("MacPrivateConf: Unknown OID should be handled before"));

                                pAC->Pnmi.SirqUpdatedFlag --;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                }
                *pLen = Offset;
                pAC->Pnmi.SirqUpdatedFlag --;

                return (SK_PNMI_ERR_OK);
        }

        /*
         * From here SET or PRESET action. Check if the passed
         * buffer length is plausible.
         */
        switch (Id) {

        case OID_SKGE_LINK_MODE:
        case OID_SKGE_FLOWCTRL_MODE:
        case OID_SKGE_PHY_OPERATION_MODE:
        case OID_SKGE_SPEED_MODE:
                if (*pLen < Limit - LogPortIndex) {

                        *pLen = Limit - LogPortIndex;
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                if (*pLen != Limit - LogPortIndex) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_BAD_VALUE);
                }
                break;

        case OID_SKGE_MTU:
                if (*pLen < sizeof(SK_U32)) {

                        *pLen = sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                if (*pLen != sizeof(SK_U32)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_BAD_VALUE);
                }
                break;

    default:
                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }

        /*
         * Perform preset or set
         */
        Offset = 0;
        for (; LogPortIndex < Limit; LogPortIndex ++) {

                switch (Id) {

                case OID_SKGE_LINK_MODE:
                        /* Check the value range */
                        Val8 = *(pBuf + Offset);
                        if (Val8 == 0) {

                                Offset += sizeof(char);
                                break;
                        }
                        if (Val8 < SK_LMODE_HALF ||
                                (LogPortIndex != 0 && Val8 > SK_LMODE_AUTOSENSE) ||
                                (LogPortIndex == 0 && Val8 > SK_LMODE_INDETERMINATED)) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }

                        /* The preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                return (SK_PNMI_ERR_OK);
                        }

                        if (LogPortIndex == 0) {

                                /*
                                 * The virtual port consists of all currently
                                 * active ports. Find them and send an event
                                 * with the new link mode to SIRQ.
                                 */
                                for (PhysPortIndex = 0;
                                        PhysPortIndex < PhysPortMax;
                                        PhysPortIndex ++) {

                                        if (!pAC->Pnmi.Port[PhysPortIndex].
                                                ActiveFlag) {

                                                continue;
                                        }

                                        EventParam.Para32[0] = PhysPortIndex;
                                        EventParam.Para32[1] = (SK_U32)Val8;
                                        if (SkGeSirqEvent(pAC, IoC,
                                                SK_HWEV_SET_LMODE,
                                                EventParam) > 0) {

                                                SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                        SK_PNMI_ERR043,
                                                        SK_PNMI_ERR043MSG);

                                                *pLen = 0;
                                                return (SK_PNMI_ERR_GENERAL);
                                        }
                                }
                        }
                        else {
                                /*
                                 * Send an event with the new link mode to
                                 * the SIRQ module.
                                 */
                                EventParam.Para32[0] = SK_PNMI_PORT_LOG2PHYS(
                                        pAC, LogPortIndex);
                                EventParam.Para32[1] = (SK_U32)Val8;
                                if (SkGeSirqEvent(pAC, IoC, SK_HWEV_SET_LMODE,
                                        EventParam) > 0) {

                                        SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                SK_PNMI_ERR043,
                                                SK_PNMI_ERR043MSG);

                                        *pLen = 0;
                                        return (SK_PNMI_ERR_GENERAL);
                                }
                        }
                        Offset += sizeof(char);
                        break;

                case OID_SKGE_FLOWCTRL_MODE:
                        /* Check the value range */
                        Val8 = *(pBuf + Offset);
                        if (Val8 == 0) {

                                Offset += sizeof(char);
                                break;
                        }
                        if (Val8 < SK_FLOW_MODE_NONE ||
                                (LogPortIndex != 0 && Val8 > SK_FLOW_MODE_SYM_OR_REM) ||
                                (LogPortIndex == 0 && Val8 > SK_FLOW_MODE_INDETERMINATED)) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }

                        /* The preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                return (SK_PNMI_ERR_OK);
                        }

                        if (LogPortIndex == 0) {

                                /*
                                 * The virtual port consists of all currently
                                 * active ports. Find them and send an event
                                 * with the new flow control mode to SIRQ.
                                 */
                                for (PhysPortIndex = 0;
                                        PhysPortIndex < PhysPortMax;
                                        PhysPortIndex ++) {

                                        if (!pAC->Pnmi.Port[PhysPortIndex].
                                                ActiveFlag) {

                                                continue;
                                        }

                                        EventParam.Para32[0] = PhysPortIndex;
                                        EventParam.Para32[1] = (SK_U32)Val8;
                                        if (SkGeSirqEvent(pAC, IoC,
                                                SK_HWEV_SET_FLOWMODE,
                                                EventParam) > 0) {

                                                SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                        SK_PNMI_ERR044,
                                                        SK_PNMI_ERR044MSG);

                                                *pLen = 0;
                                                return (SK_PNMI_ERR_GENERAL);
                                        }
                                }
                        }
                        else {
                                /*
                                 * Send an event with the new flow control
                                 * mode to the SIRQ module.
                                 */
                                EventParam.Para32[0] = SK_PNMI_PORT_LOG2PHYS(
                                        pAC, LogPortIndex);
                                EventParam.Para32[1] = (SK_U32)Val8;
                                if (SkGeSirqEvent(pAC, IoC,
                                        SK_HWEV_SET_FLOWMODE, EventParam)
                                        > 0) {

                                        SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                SK_PNMI_ERR044,
                                                SK_PNMI_ERR044MSG);

                                        *pLen = 0;
                                        return (SK_PNMI_ERR_GENERAL);
                                }
                        }
                        Offset += sizeof(char);
                        break;

                case OID_SKGE_PHY_OPERATION_MODE :
                        /* Check the value range */
                        Val8 = *(pBuf + Offset);
                        if (Val8 == 0) {
                                /* mode of this port remains unchanged */
                                Offset += sizeof(char);
                                break;
                        }
                        if (Val8 < SK_MS_MODE_AUTO ||
                                (LogPortIndex != 0 && Val8 > SK_MS_MODE_SLAVE) ||
                                (LogPortIndex == 0 && Val8 > SK_MS_MODE_INDETERMINATED)) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }

                        /* The preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                return (SK_PNMI_ERR_OK);
                        }

                        if (LogPortIndex == 0) {

                                /*
                                 * The virtual port consists of all currently
                                 * active ports. Find them and send an event
                                 * with new master/slave (role) mode to SIRQ.
                                 */
                                for (PhysPortIndex = 0;
                                        PhysPortIndex < PhysPortMax;
                                        PhysPortIndex ++) {

                                        if (!pAC->Pnmi.Port[PhysPortIndex].
                                                ActiveFlag) {

                                                continue;
                                        }

                                        EventParam.Para32[0] = PhysPortIndex;
                                        EventParam.Para32[1] = (SK_U32)Val8;
                                        if (SkGeSirqEvent(pAC, IoC,
                                                SK_HWEV_SET_ROLE,
                                                EventParam) > 0) {

                                                SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                        SK_PNMI_ERR042,
                                                        SK_PNMI_ERR042MSG);

                                                *pLen = 0;
                                                return (SK_PNMI_ERR_GENERAL);
                                        }
                                }
                        }
                        else {
                                /*
                                 * Send an event with the new master/slave
                                 * (role) mode to the SIRQ module.
                                 */
                                EventParam.Para32[0] = SK_PNMI_PORT_LOG2PHYS(
                                        pAC, LogPortIndex);
                                EventParam.Para32[1] = (SK_U32)Val8;
                                if (SkGeSirqEvent(pAC, IoC,
                                        SK_HWEV_SET_ROLE, EventParam) > 0) {

                                        SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                SK_PNMI_ERR042,
                                                SK_PNMI_ERR042MSG);

                                        *pLen = 0;
                                        return (SK_PNMI_ERR_GENERAL);
                                }
                        }

                        Offset += sizeof(char);
                        break;

                case OID_SKGE_SPEED_MODE:
                        /* Check the value range */
                        Val8 = *(pBuf + Offset);
                        if (Val8 == 0) {

                                Offset += sizeof(char);
                                break;
                        }
                        if (Val8 < (SK_LSPEED_AUTO) ||
                                (LogPortIndex != 0 && Val8 > (SK_LSPEED_1000MBPS)) ||
                                (LogPortIndex == 0 && Val8 > (SK_LSPEED_INDETERMINATED))) {

                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }

                        /* The preset ends here */
                        if (Action == SK_PNMI_PRESET) {

                                return (SK_PNMI_ERR_OK);
                        }

                        if (LogPortIndex == 0) {

                                /*
                                 * The virtual port consists of all currently
                                 * active ports. Find them and send an event
                                 * with the new flow control mode to SIRQ.
                                 */
                                for (PhysPortIndex = 0;
                                        PhysPortIndex < PhysPortMax;
                                        PhysPortIndex ++) {

                                        if (!pAC->Pnmi.Port[PhysPortIndex].ActiveFlag) {

                                                continue;
                                        }

                                        EventParam.Para32[0] = PhysPortIndex;
                                        EventParam.Para32[1] = (SK_U32)Val8;
                                        if (SkGeSirqEvent(pAC, IoC,
                                                SK_HWEV_SET_SPEED,
                                                EventParam) > 0) {

                                                SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                        SK_PNMI_ERR045,
                                                        SK_PNMI_ERR045MSG);

                                                *pLen = 0;
                                                return (SK_PNMI_ERR_GENERAL);
                                        }
                                }
                        }
                        else {
                                /*
                                 * Send an event with the new flow control
                                 * mode to the SIRQ module.
                                 */
                                EventParam.Para32[0] = SK_PNMI_PORT_LOG2PHYS(
                                        pAC, LogPortIndex);
                                EventParam.Para32[1] = (SK_U32)Val8;
                                if (SkGeSirqEvent(pAC, IoC,
                                        SK_HWEV_SET_SPEED,
                                        EventParam) > 0) {

                                        SK_ERR_LOG(pAC, SK_ERRCL_SW,
                                                SK_PNMI_ERR045,
                                                SK_PNMI_ERR045MSG);

                                        *pLen = 0;
                                        return (SK_PNMI_ERR_GENERAL);
                                }
                        }
                        Offset += sizeof(char);
                        break;

                case OID_SKGE_MTU :
                        /* Check the value range */
                        Val32 = *(SK_U32*)(pBuf + Offset);
                        if (Val32 == 0) {
                                /* mtu of this port remains unchanged */
                                Offset += sizeof(SK_U32);
                                break;
                        }
                        if (SK_DRIVER_PRESET_MTU(pAC, IoC, NetIndex, Val32) != 0) {
                                *pLen = 0;
                                return (SK_PNMI_ERR_BAD_VALUE);
                        }

                        /* The preset ends here */
                        if (Action == SK_PNMI_PRESET) {
                                return (SK_PNMI_ERR_OK);
                        }

                        if (SK_DRIVER_SET_MTU(pAC, IoC, NetIndex, Val32) != 0) {
                                return (SK_PNMI_ERR_GENERAL);
                        }

                        Offset += sizeof(SK_U32);
                        break;

                default:
            SK_DBG_MSG(pAC, SK_DBGMOD_PNMI, SK_DBGCAT_ERR,
                ("MacPrivateConf: Unknown OID should be handled before set"));

                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * Monitor - OID handler function for RLMT_MONITOR_XXX
 *
 * Description:
 *      Because RLMT currently does not support the monitoring of
 *      remote adapter cards, we return always an empty table.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_BAD_VALUE    The passed value is not in the valid
 *                               value range.
 *      SK_PNMI_ERR_READ_ONLY    The OID is read-only and cannot be set.
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */
PNMI_STATIC int Monitor(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    Index;
        unsigned int    Limit;
        unsigned int    Offset;
        unsigned int    Entries;

        
        /*
         * Calculate instance if wished.
         */
/* XXX Not yet implemented. Return always an empty table. */
        Entries = 0;

        if ((Instance != (SK_U32)(-1))) {

                if ((Instance < 1) || (Instance > Entries)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }

                Index = (unsigned int)Instance - 1;
                Limit = (unsigned int)Instance;
        }
        else {
                Index = 0;
                Limit = Entries;
        }

        /*
         * Get/Set value
        */
        if (Action == SK_PNMI_GET) {

                for (Offset=0; Index < Limit; Index ++) {

                        switch (Id) {

                        case OID_SKGE_RLMT_MONITOR_INDEX:
                        case OID_SKGE_RLMT_MONITOR_ADDR:
                        case OID_SKGE_RLMT_MONITOR_ERRS:
                        case OID_SKGE_RLMT_MONITOR_TIMESTAMP:
                        case OID_SKGE_RLMT_MONITOR_ADMIN:
                                break;

                        default:
                                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR046,
                                        SK_PNMI_ERR046MSG);

                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                }
                *pLen = Offset;
        }
        else {
                /* Only MONITOR_ADMIN can be set */
                if (Id != OID_SKGE_RLMT_MONITOR_ADMIN) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_READ_ONLY);
                }

                /* Check if the length is plausible */
                if (*pLen < (Limit - Index)) {

                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                /* Okay, we have a wide value range */
                if (*pLen != (Limit - Index)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_BAD_VALUE);
                }
/*
                for (Offset=0; Index < Limit; Index ++) {
                }
*/
/*
 * XXX Not yet implemented. Return always BAD_VALUE, because the table
 * is empty.
 */
                *pLen = 0;
                return (SK_PNMI_ERR_BAD_VALUE);
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * VirtualConf - Calculates the values of configuration OIDs for virtual port
 *
 * Description:
 *      We handle here the get of the configuration group OIDs, which are
 *      a little bit complicated. The virtual port consists of all currently
 *      active physical ports. If multiple ports are active and configured
 *      differently we get in some trouble to return a single value. So we
 *      get the value of the first active port and compare it with that of
 *      the other active ports. If they are not the same, we return a value
 *      that indicates that the state is indeterminated.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void VirtualConf(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf)             /* Buffer to which to mgmt data will be retrieved */
{
        unsigned int    PhysPortMax;
        unsigned int    PhysPortIndex;
        SK_U8           Val8;
        SK_BOOL         PortActiveFlag;


        *pBuf = 0;
        PortActiveFlag = SK_FALSE;
        PhysPortMax = pAC->GIni.GIMacsFound;

        for (PhysPortIndex = 0; PhysPortIndex < PhysPortMax;
                PhysPortIndex ++) {

                /* Check if the physical port is active */
                if (!pAC->Pnmi.Port[PhysPortIndex].ActiveFlag) {

                        continue;
                }

                PortActiveFlag = SK_TRUE;

                switch (Id) {

                case OID_SKGE_LINK_CAP:

                        /*
                         * Different capabilities should not happen, but
                         * in the case of the cases OR them all together.
                         * From a curious point of view the virtual port
                         * is capable of all found capabilities.
                         */
                        *pBuf |= pAC->GIni.GP[PhysPortIndex].PLinkCap;
                        break;

                case OID_SKGE_LINK_MODE:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PLinkModeConf;
                                continue;
                        }

                        /*
                         * If we find an active port with a different link
                         * mode than the first one we return a value that
                         * indicates that the link mode is indeterminated.
                         */
                        if (*pBuf != pAC->GIni.GP[PhysPortIndex].PLinkModeConf
                                ) {

                                *pBuf = SK_LMODE_INDETERMINATED;
                        }
                        break;

                case OID_SKGE_LINK_MODE_STATUS:
                        /* Get the link mode of the physical port */
                        Val8 = CalculateLinkModeStatus(pAC, IoC, PhysPortIndex);

                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = Val8;
                                continue;
                        }

                        /*
                         * If we find an active port with a different link
                         * mode status than the first one we return a value
                         * that indicates that the link mode status is
                         * indeterminated.
                         */
                        if (*pBuf != Val8) {

                                *pBuf = SK_LMODE_STAT_INDETERMINATED;
                        }
                        break;

                case OID_SKGE_LINK_STATUS:
                        /* Get the link status of the physical port */
                        Val8 = CalculateLinkStatus(pAC, IoC, PhysPortIndex);

                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = Val8;
                                continue;
                        }

                        /*
                         * If we find an active port with a different link
                         * status than the first one, we return a value
                         * that indicates that the link status is
                         * indeterminated.
                         */
                        if (*pBuf != Val8) {

                                *pBuf = SK_PNMI_RLMT_LSTAT_INDETERMINATED;
                        }
                        break;

                case OID_SKGE_FLOWCTRL_CAP:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PFlowCtrlCap;
                                continue;
                        }

                        /*
                         * From a curious point of view the virtual port
                         * is capable of all found capabilities.
                         */
                        *pBuf |= pAC->GIni.GP[PhysPortIndex].PFlowCtrlCap;
                        break;

                case OID_SKGE_FLOWCTRL_MODE:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PFlowCtrlMode;
                                continue;
                        }

                        /*
                         * If we find an active port with a different flow
                         * control mode than the first one, we return a value
                         * that indicates that the mode is indeterminated.
                         */
                        if (*pBuf != pAC->GIni.GP[PhysPortIndex].PFlowCtrlMode) {

                                *pBuf = SK_FLOW_MODE_INDETERMINATED;
                        }
                        break;

                case OID_SKGE_FLOWCTRL_STATUS:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PFlowCtrlStatus;
                                continue;
                        }

                        /*
                         * If we find an active port with a different flow
                         * control status than the first one, we return a
                         * value that indicates that the status is
                         * indeterminated.
                         */
                        if (*pBuf != pAC->GIni.GP[PhysPortIndex].PFlowCtrlStatus) {

                                *pBuf = SK_FLOW_STAT_INDETERMINATED;
                        }
                        break;
                
                case OID_SKGE_PHY_OPERATION_CAP:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PMSCap;
                                continue;
                        }

                        /*
                         * From a curious point of view the virtual port
                         * is capable of all found capabilities.
                         */
                        *pBuf |= pAC->GIni.GP[PhysPortIndex].PMSCap;
                        break;

                case OID_SKGE_PHY_OPERATION_MODE:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PMSMode;
                                continue;
                        }

                        /*
                         * If we find an active port with a different master/
                         * slave mode than the first one, we return a value
                         * that indicates that the mode is indeterminated.
                         */
                        if (*pBuf != pAC->GIni.GP[PhysPortIndex].PMSMode) {

                                *pBuf = SK_MS_MODE_INDETERMINATED;
                        }
                        break;

                case OID_SKGE_PHY_OPERATION_STATUS:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PMSStatus;
                                continue;
                        }

                        /*
                         * If we find an active port with a different master/
                         * slave status than the first one, we return a
                         * value that indicates that the status is
                         * indeterminated.
                         */
                        if (*pBuf != pAC->GIni.GP[PhysPortIndex].PMSStatus) {

                                *pBuf = SK_MS_STAT_INDETERMINATED;
                        }
                        break;
                
                case OID_SKGE_SPEED_MODE:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PLinkSpeed;
                                continue;
                        }

                        /*
                         * If we find an active port with a different flow
                         * control mode than the first one, we return a value
                         * that indicates that the mode is indeterminated.
                         */
                        if (*pBuf != pAC->GIni.GP[PhysPortIndex].PLinkSpeed) {

                                *pBuf = SK_LSPEED_INDETERMINATED;
                        }
                        break;
                
                case OID_SKGE_SPEED_STATUS:
                        /* Check if it is the first active port */
                        if (*pBuf == 0) {

                                *pBuf = pAC->GIni.GP[PhysPortIndex].PLinkSpeedUsed;
                                continue;
                        }

                        /*
                         * If we find an active port with a different flow
                         * control status than the first one, we return a
                         * value that indicates that the status is
                         * indeterminated.
                         */
                        if (*pBuf != pAC->GIni.GP[PhysPortIndex].PLinkSpeedUsed) {

                                *pBuf = SK_LSPEED_STAT_INDETERMINATED;
                        }
                        break;
                }
        }

        /*
         * If no port is active return an indeterminated answer
         */
        if (!PortActiveFlag) {

                switch (Id) {

                case OID_SKGE_LINK_CAP:
                        *pBuf = SK_LMODE_CAP_INDETERMINATED;
                        break;

                case OID_SKGE_LINK_MODE:
                        *pBuf = SK_LMODE_INDETERMINATED;
                        break;

                case OID_SKGE_LINK_MODE_STATUS:
                        *pBuf = SK_LMODE_STAT_INDETERMINATED;
                        break;

                case OID_SKGE_LINK_STATUS:
                        *pBuf = SK_PNMI_RLMT_LSTAT_INDETERMINATED;
                        break;

                case OID_SKGE_FLOWCTRL_CAP:
                case OID_SKGE_FLOWCTRL_MODE:
                        *pBuf = SK_FLOW_MODE_INDETERMINATED;
                        break;

                case OID_SKGE_FLOWCTRL_STATUS:
                        *pBuf = SK_FLOW_STAT_INDETERMINATED;
                        break;
                        
                case OID_SKGE_PHY_OPERATION_CAP:
                        *pBuf = SK_MS_CAP_INDETERMINATED;
                        break;

                case OID_SKGE_PHY_OPERATION_MODE:
                        *pBuf = SK_MS_MODE_INDETERMINATED;
                        break;

                case OID_SKGE_PHY_OPERATION_STATUS:
                        *pBuf = SK_MS_STAT_INDETERMINATED;
                        break;
                case OID_SKGE_SPEED_CAP:
                        *pBuf = SK_LSPEED_CAP_INDETERMINATED;
                        break;

                case OID_SKGE_SPEED_MODE:
                        *pBuf = SK_LSPEED_INDETERMINATED;
                        break;

                case OID_SKGE_SPEED_STATUS:
                        *pBuf = SK_LSPEED_STAT_INDETERMINATED;
                        break;
                }
        }
}

/*****************************************************************************
 *
 * CalculateLinkStatus - Determins the link status of a physical port
 *
 * Description:
 *      Determins the link status the following way:
 *        LSTAT_PHY_DOWN:  Link is down
 *        LSTAT_AUTONEG:   Auto-negotiation failed
 *        LSTAT_LOG_DOWN:  Link is up but RLMT did not yet put the port
 *                         logically up.
 *        LSTAT_LOG_UP:    RLMT marked the port as up
 *
 * Returns:
 *      Link status of physical port
 */
PNMI_STATIC SK_U8 CalculateLinkStatus(
SK_AC *pAC,                     /* Pointer to adapter context */
SK_IOC IoC,                     /* IO context handle */
unsigned int PhysPortIndex)     /* Physical port index */
{
        SK_U8   Result;


        if (!pAC->GIni.GP[PhysPortIndex].PHWLinkUp) {

                Result = SK_PNMI_RLMT_LSTAT_PHY_DOWN;
        }
        else if (pAC->GIni.GP[PhysPortIndex].PAutoNegFail > 0) {

                Result = SK_PNMI_RLMT_LSTAT_AUTONEG;
                                }
        else if (!pAC->Rlmt.Port[PhysPortIndex].PortDown) {

                Result = SK_PNMI_RLMT_LSTAT_LOG_UP;
        }
        else {
                Result = SK_PNMI_RLMT_LSTAT_LOG_DOWN;
        }

        return (Result);
}

/*****************************************************************************
 *
 * CalculateLinkModeStatus - Determins the link mode status of a phys. port
 *
 * Description:
 *      The COMMON module only tells us if the mode is half or full duplex.
 *      But in the decade of auto sensing it is usefull for the user to
 *      know if the mode was negotiated or forced. Therefore we have a
 *      look to the mode, which was last used by the negotiation process.
 *
 * Returns:
 *      The link mode status
 */
PNMI_STATIC SK_U8 CalculateLinkModeStatus(
SK_AC *pAC,                     /* Pointer to adapter context */
SK_IOC IoC,                     /* IO context handle */
unsigned int PhysPortIndex)     /* Physical port index */
{
        SK_U8   Result;


        /* Get the current mode, which can be full or half duplex */
        Result = pAC->GIni.GP[PhysPortIndex].PLinkModeStatus;

        /* Check if no valid mode could be found (link is down) */
        if (Result < SK_LMODE_STAT_HALF) {

                Result = SK_LMODE_STAT_UNKNOWN;
        } 
        else if (pAC->GIni.GP[PhysPortIndex].PLinkMode >= SK_LMODE_AUTOHALF) {

                /*
                 * Auto-negotiation was used to bring up the link. Change
                 * the already found duplex status that it indicates
                 * auto-negotiation was involved.
                 */
                if (Result == SK_LMODE_STAT_HALF) {

                        Result = SK_LMODE_STAT_AUTOHALF;
                }
                else if (Result == SK_LMODE_STAT_FULL) {

                        Result = SK_LMODE_STAT_AUTOFULL;
                }
        }

        return (Result);
}

/*****************************************************************************
 *
 * GetVpdKeyArr - Obtain an array of VPD keys
 *
 * Description:
 *      Read the VPD keys and build an array of VPD keys, which are
 *      easy to access.
 *
 * Returns:
 *      SK_PNMI_ERR_OK       Task successfully performed.
 *      SK_PNMI_ERR_GENERAL  Something went wrong.
 */
PNMI_STATIC int GetVpdKeyArr(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
char *pKeyArr,          /* Ptr KeyArray */
unsigned int KeyArrLen, /* Length of array in bytes */
unsigned int *pKeyNo)   /* Number of keys */
{
        unsigned int            BufKeysLen = SK_PNMI_VPD_BUFSIZE;
        char                    BufKeys[SK_PNMI_VPD_BUFSIZE];
        unsigned int            StartOffset;
        unsigned int            Offset;
        int                     Index;
        int                     Ret;


        SK_MEMSET(pKeyArr, 0, KeyArrLen);

        /*
         * Get VPD key list
         */
        Ret = VpdKeys(pAC, IoC, (char *)&BufKeys, (int *)&BufKeysLen,
                (int *)pKeyNo);
        if (Ret > 0) {

                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR014,
                        SK_PNMI_ERR014MSG);

                return (SK_PNMI_ERR_GENERAL);
        }
        /* If no keys are available return now */
        if (*pKeyNo == 0 || BufKeysLen == 0) {

                return (SK_PNMI_ERR_OK);
        }
        /*
         * If the key list is too long for us trunc it and give a
         * errorlog notification. This case should not happen because
         * the maximum number of keys is limited due to RAM limitations
         */
        if (*pKeyNo > SK_PNMI_VPD_ENTRIES) {

                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR015,
                        SK_PNMI_ERR015MSG);

                *pKeyNo = SK_PNMI_VPD_ENTRIES;
        }

        /*
         * Now build an array of fixed string length size and copy
         * the keys together.
         */
        for (Index = 0, StartOffset = 0, Offset = 0; Offset < BufKeysLen;
                Offset ++) {

                if (BufKeys[Offset] != 0) {

                        continue;
                }

                if (Offset - StartOffset > SK_PNMI_VPD_KEY_SIZE) {

                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR016,
                                SK_PNMI_ERR016MSG);
                        return (SK_PNMI_ERR_GENERAL);
                }

                SK_STRNCPY(pKeyArr + Index * SK_PNMI_VPD_KEY_SIZE,
                        &BufKeys[StartOffset], SK_PNMI_VPD_KEY_SIZE);

                Index ++;
                StartOffset = Offset + 1;
        }

        /* Last key not zero terminated? Get it anyway */
        if (StartOffset < Offset) {

                SK_STRNCPY(pKeyArr + Index * SK_PNMI_VPD_KEY_SIZE,
                        &BufKeys[StartOffset], SK_PNMI_VPD_KEY_SIZE);
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * SirqUpdate - Let the SIRQ update its internal values
 *
 * Description:
 *      Just to be sure that the SIRQ module holds its internal data
 *      structures up to date, we send an update event before we make
 *      any access.
 *
 * Returns:
 *      SK_PNMI_ERR_OK       Task successfully performed.
 *      SK_PNMI_ERR_GENERAL  Something went wrong.
 */
PNMI_STATIC int SirqUpdate(
SK_AC *pAC,     /* Pointer to adapter context */
SK_IOC IoC)     /* IO context handle */
{
        SK_EVPARA       EventParam;


        /* Was the module already updated during the current PNMI call? */
        if (pAC->Pnmi.SirqUpdatedFlag > 0) {

                return (SK_PNMI_ERR_OK);
        }

        /* Send an synchronuous update event to the module */
        SK_MEMSET((char *)&EventParam, 0, sizeof(EventParam));
        if (SkGeSirqEvent(pAC, IoC, SK_HWEV_UPDATE_STAT, EventParam) > 0) {

                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR047,
                        SK_PNMI_ERR047MSG);

                return (SK_PNMI_ERR_GENERAL);
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * RlmtUpdate - Let the RLMT update its internal values
 *
 * Description:
 *      Just to be sure that the RLMT module holds its internal data
 *      structures up to date, we send an update event before we make
 *      any access.
 *
 * Returns:
 *      SK_PNMI_ERR_OK       Task successfully performed.
 *      SK_PNMI_ERR_GENERAL  Something went wrong.
 */
PNMI_STATIC int RlmtUpdate(
SK_AC *pAC,     /* Pointer to adapter context */
SK_IOC IoC,     /* IO context handle */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        SK_EVPARA       EventParam;


        /* Was the module already updated during the current PNMI call? */
        if (pAC->Pnmi.RlmtUpdatedFlag > 0) {

                return (SK_PNMI_ERR_OK);
        }

        /* Send an synchronuous update event to the module */
        SK_MEMSET((char *)&EventParam, 0, sizeof(EventParam));
        EventParam.Para32[0] = NetIndex;
        EventParam.Para32[1] = (SK_U32)-1;
        if (SkRlmtEvent(pAC, IoC, SK_RLMT_STATS_UPDATE, EventParam) > 0) {

                SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR048,
                        SK_PNMI_ERR048MSG);

                return (SK_PNMI_ERR_GENERAL);
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * MacUpdate - Force the XMAC to output the current statistic
 *
 * Description:
 *      The XMAC holds its statistic internally. To obtain the current
 *      values we send a command so that the statistic data will
 *      be written to apredefined memory area on the adapter. 
 *
 * Returns:
 *      SK_PNMI_ERR_OK       Task successfully performed.
 *      SK_PNMI_ERR_GENERAL  Something went wrong.
 */
PNMI_STATIC int MacUpdate(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
unsigned int FirstMac,  /* Index of the first Mac to be updated */
unsigned int LastMac)   /* Index of the last Mac to be updated */
{
        unsigned int    MacIndex;

        /*
         * Were the statistics already updated during the
         * current PNMI call?
         */
        if (pAC->Pnmi.MacUpdatedFlag > 0) {

                return (SK_PNMI_ERR_OK);
        }

        /* Send an update command to all MACs specified */
        for (MacIndex = FirstMac; MacIndex <= LastMac; MacIndex ++) {

                /*
                 * 2002-09-13 pweber:   Freeze the current sw counters. 
                 *                      (That should be done as close as 
                 *                      possible to the update of the 
                 *                      hw counters)
                 */
                if (pAC->GIni.GIMacType == SK_MAC_XMAC) {
                        pAC->Pnmi.BufPort[MacIndex] = pAC->Pnmi.Port[MacIndex];
                }
                        
                /* 2002-09-13 pweber:  Update the hw counter  */
                if (pAC->GIni.GIFunc.pFnMacUpdateStats(pAC, IoC, MacIndex) != 0) {

                        return (SK_PNMI_ERR_GENERAL);
                }
        }

        return (SK_PNMI_ERR_OK);
}

/*****************************************************************************
 *
 * GetStatVal - Retrieve an XMAC statistic counter
 *
 * Description:
 *      Retrieves the statistic counter of a virtual or physical port. The
 *      virtual port is identified by the index 0. It consists of all
 *      currently active ports. To obtain the counter value for this port
 *      we must add the statistic counter of all active ports. To grant
 *      continuous counter values for the virtual port even when port
 *      switches occur we must additionally add a delta value, which was
 *      calculated during a SK_PNMI_EVT_RLMT_ACTIVE_UP event.
 *
 * Returns:
 *      Requested statistic value
 */
PNMI_STATIC SK_U64 GetStatVal(
SK_AC *pAC,                                     /* Pointer to adapter context */
SK_IOC IoC,                                     /* IO context handle */
unsigned int LogPortIndex,      /* Index of the logical Port to be processed */
unsigned int StatIndex,         /* Index to statistic value */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        unsigned int    PhysPortIndex;
        unsigned int    PhysPortMax;
        SK_U64                  Val = 0;


        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {   /* Dual net mode */

                PhysPortIndex = NetIndex;
                Val = GetPhysStatVal(pAC, IoC, PhysPortIndex, StatIndex);
        }
        else {  /* Single Net mode */

                if (LogPortIndex == 0) {

                        PhysPortMax = pAC->GIni.GIMacsFound;

                        /* Add counter of all active ports */
                        for (PhysPortIndex = 0; PhysPortIndex < PhysPortMax;
                                PhysPortIndex ++) {

                                if (pAC->Pnmi.Port[PhysPortIndex].ActiveFlag) {

                                        Val += GetPhysStatVal(pAC, IoC, PhysPortIndex,
                                                StatIndex);
                                }
                        }

                        /* Correct value because of port switches */
                        Val += pAC->Pnmi.VirtualCounterOffset[StatIndex];
                }
                else {
                        /* Get counter value of physical port */
                        PhysPortIndex = SK_PNMI_PORT_LOG2PHYS(pAC, LogPortIndex);
                        Val = GetPhysStatVal(pAC, IoC, PhysPortIndex, StatIndex);
                }
        }
        return (Val);
}

/*****************************************************************************
 *
 * GetPhysStatVal - Get counter value for physical port
 *
 * Description:
 *      Builds a 64bit counter value. Except for the octet counters
 *      the lower 32bit are counted in hardware and the upper 32bit
 *      in software by monitoring counter overflow interrupts in the
 *      event handler. To grant continous counter values during XMAC
 *      resets (caused by a workaround) we must add a delta value.
 *      The delta was calculated in the event handler when a
 *      SK_PNMI_EVT_XMAC_RESET was received.
 *
 * Returns:
 *      Counter value
 */
PNMI_STATIC SK_U64 GetPhysStatVal(
SK_AC *pAC,                                     /* Pointer to adapter context */
SK_IOC IoC,                                     /* IO context handle */
unsigned int PhysPortIndex,     /* Index of the logical Port to be processed */
unsigned int StatIndex)         /* Index to statistic value */
{
        SK_U64  Val = 0;
        SK_U32  LowVal = 0;
        SK_U32  HighVal = 0;
        SK_U16  Word;
        int             MacType;
        
        SK_PNMI_PORT    *pPnmiPrt;
        SK_GEMACFUNC    *pFnMac;
        
        MacType = pAC->GIni.GIMacType;
        
        /* 2002-09-17 pweber: For XMAC, use the frozen sw counters (BufPort) */
        if (pAC->GIni.GIMacType == SK_MAC_XMAC) {
                pPnmiPrt = &pAC->Pnmi.BufPort[PhysPortIndex];
        }
        else {
                pPnmiPrt = &pAC->Pnmi.Port[PhysPortIndex];
        }
        
        pFnMac   = &pAC->GIni.GIFunc;

        switch (StatIndex) {
        case SK_PNMI_HTX:
        case SK_PNMI_HRX:
                /* Not supported by GMAC */
                if (MacType == SK_MAC_GMAC) {
                        return (Val); 
                }
                        
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;

        case SK_PNMI_HTX_OCTET:
        case SK_PNMI_HRX_OCTET:
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &HighVal);
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex + 1][MacType].Reg,
                                                                          &LowVal);
                break;

        case SK_PNMI_HTX_BURST:
        case SK_PNMI_HTX_EXCESS_DEF:
        case SK_PNMI_HTX_CARRIER:
                /* Not supported by GMAC */
                if (MacType == SK_MAC_GMAC) {
                        return (Val);
                }

                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;

        case SK_PNMI_HTX_MACC:
                /* GMAC only supports PAUSE MAC control frames */
                if (MacType == SK_MAC_GMAC) {
                        Val = GetPhysStatVal(pAC, IoC, PhysPortIndex, SK_PNMI_HTX_PMACC);

                        return (Val); 
                }

                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;

        case SK_PNMI_HTX_COL:
        case SK_PNMI_HRX_UNDERSIZE:
                /* Not supported by XMAC */
                if (MacType == SK_MAC_XMAC) {
                        return (Val);
                }

                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;



        case SK_PNMI_HTX_DEFFERAL:
                /* Not supported by GMAC */
                if (MacType == SK_MAC_GMAC) {
                        return (Val); 
                }
                
                /*
                 * XMAC counts frames with deferred transmission
                 * even in full-duplex mode.
                 *
                 * In full-duplex mode the counter remains constant!
                 */
                if ((pAC->GIni.GP[PhysPortIndex].PLinkModeStatus == SK_LMODE_STAT_AUTOFULL) ||
                        (pAC->GIni.GP[PhysPortIndex].PLinkModeStatus == SK_LMODE_STAT_FULL)) {

                        LowVal = 0;
                        HighVal = 0;
                }
                else {
                        /* Otherwise get contents of hardware register. */
                        (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                                  StatAddr[SK_PNMI_HTX_DEFFERAL][MacType].Reg,
                                                                                  &LowVal);
                        HighVal = pPnmiPrt->CounterHigh[StatIndex];
                }
                break;

        case SK_PNMI_HRX_BADOCTET:
                /* Not supported by XMAC */
                if (MacType == SK_MAC_XMAC) {
                        return (Val);
                }

                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &HighVal);
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex + 1][MacType].Reg,
                                      &LowVal);
                break;

        case SK_PNMI_HTX_OCTETLOW:
        case SK_PNMI_HRX_OCTETLOW:
        case SK_PNMI_HRX_BADOCTETLOW:
                return (Val);

        case SK_PNMI_HRX_LONGFRAMES:
                /* For XMAC the SW counter is managed by PNMI */
                if (MacType == SK_MAC_XMAC) {
                        return (pPnmiPrt->StatRxLongFrameCts); 
                }
                
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;
                
        case SK_PNMI_HRX_TOO_LONG:
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                StatAddr[StatIndex][MacType].Reg,
                                                                &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                
                Val = (((SK_U64)HighVal << 32) | (SK_U64)LowVal);

                switch (MacType) {
                case SK_MAC_GMAC:
                        /* For GMAC the SW counter is additionally managed by PNMI */
                        Val += pPnmiPrt->StatRxFrameTooLongCts;
                        break;

                case SK_MAC_XMAC:
                        /*
                         * Frames longer than IEEE 802.3 frame max size are counted
                         * by XMAC in frame_too_long counter even reception of long
                         * frames was enabled and the frame was correct.
                         * So correct the value by subtracting RxLongFrame counter.
                         */
                        Val -= pPnmiPrt->StatRxLongFrameCts;
                        break;

                default:
                        break;
                }

                LowVal = (SK_U32)Val;
                HighVal = (SK_U32)(Val >> 32);
                break;
                
        case SK_PNMI_HRX_SHORTS:
                /* Not supported by GMAC */
                if (MacType == SK_MAC_GMAC) {
                        /* GM_RXE_FRAG?? */
                        return (Val); 
                }
                
                /*
                 * XMAC counts short frame errors even if link down (#10620)
                 *
                 * If link-down the counter remains constant
                 */
                if (pAC->GIni.GP[PhysPortIndex].PLinkModeStatus != SK_LMODE_STAT_UNKNOWN) {

                        /* Otherwise get incremental difference */
                        (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                                  StatAddr[StatIndex][MacType].Reg,
                                                                                  &LowVal);
                        HighVal = pPnmiPrt->CounterHigh[StatIndex];

                        Val = (((SK_U64)HighVal << 32) | (SK_U64)LowVal);
                        Val -= pPnmiPrt->RxShortZeroMark;

                        LowVal = (SK_U32)Val;
                        HighVal = (SK_U32)(Val >> 32);
                }
                break;

        case SK_PNMI_HRX_MACC:
        case SK_PNMI_HRX_MACC_UNKWN:
        case SK_PNMI_HRX_BURST:
        case SK_PNMI_HRX_MISSED:
        case SK_PNMI_HRX_FRAMING:
        case SK_PNMI_HRX_CARRIER:
        case SK_PNMI_HRX_IRLENGTH:
        case SK_PNMI_HRX_SYMBOL:
        case SK_PNMI_HRX_CEXT:
                /* Not supported by GMAC */
                if (MacType == SK_MAC_GMAC) {
                        /* GM_RXE_FRAG?? */
                        return (Val); 
                }

                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;

        case SK_PNMI_HRX_PMACC_ERR:
                /* For GMAC the SW counter is managed by PNMI */
                if (MacType == SK_MAC_GMAC) {
                        return (pPnmiPrt->StatRxPMaccErr); 
                }
                
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;

        /* SW counter managed by PNMI */
        case SK_PNMI_HTX_SYNC:
                LowVal = (SK_U32)pPnmiPrt->StatSyncCts;
                HighVal = (SK_U32)(pPnmiPrt->StatSyncCts >> 32);
                break;

        /* SW counter managed by PNMI */
        case SK_PNMI_HTX_SYNC_OCTET:
                LowVal = (SK_U32)pPnmiPrt->StatSyncOctetsCts;
                HighVal = (SK_U32)(pPnmiPrt->StatSyncOctetsCts >> 32);
                break;

        case SK_PNMI_HRX_FCS:
                /* 
                 * Broadcom filters fcs errors and counts it in 
                 * Receive Error Counter register
                 */
                if (pAC->GIni.GP[PhysPortIndex].PhyType == SK_PHY_BCOM) {
                        /* do not read while not initialized (PHY_READ hangs!)*/
                        if (pAC->GIni.GP[PhysPortIndex].PState) {
                                PHY_READ(IoC, &pAC->GIni.GP[PhysPortIndex],
                                                 PhysPortIndex, PHY_BCOM_RE_CTR,
                                                 &Word);
                                
                                LowVal = Word;
                        }
                        HighVal = pPnmiPrt->CounterHigh[StatIndex];
                }
                else {
                        (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                                  StatAddr[StatIndex][MacType].Reg,
                                                                                  &LowVal);
                        HighVal = pPnmiPrt->CounterHigh[StatIndex];
                }
                break;

        default:
                (void)pFnMac->pFnMacStatistic(pAC, IoC, PhysPortIndex,
                                                                          StatAddr[StatIndex][MacType].Reg,
                                                                          &LowVal);
                HighVal = pPnmiPrt->CounterHigh[StatIndex];
                break;
        }

        Val = (((SK_U64)HighVal << 32) | (SK_U64)LowVal);

        /* Correct value because of possible XMAC reset. XMAC Errata #2 */
        Val += pPnmiPrt->CounterOffset[StatIndex];

        return (Val);
}

/*****************************************************************************
 *
 * ResetCounter - Set all counters and timestamps to zero
 *
 * Description:
 *      Notifies other common modules which store statistic data to
 *      reset their counters and finally reset our own counters.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void ResetCounter(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
SK_U32 NetIndex)
{
        unsigned int    PhysPortIndex;
        SK_EVPARA       EventParam;


        SK_MEMSET((char *)&EventParam, 0, sizeof(EventParam));

        /* Notify sensor module */
        SkEventQueue(pAC, SKGE_I2C, SK_I2CEV_CLEAR, EventParam);

        /* Notify RLMT module */
        EventParam.Para32[0] = NetIndex;
        EventParam.Para32[1] = (SK_U32)-1;
        SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_STATS_CLEAR, EventParam);
        EventParam.Para32[1] = 0;

        /* Notify SIRQ module */
        SkEventQueue(pAC, SKGE_HWAC, SK_HWEV_CLEAR_STAT, EventParam);

        /* Notify CSUM module */
#ifdef SK_USE_CSUM
        EventParam.Para32[0] = NetIndex;
        EventParam.Para32[1] = (SK_U32)-1;
        SkEventQueue(pAC, SKGE_CSUM, SK_CSUM_EVENT_CLEAR_PROTO_STATS,
                EventParam);
#endif

        /* Clear XMAC statistic */
        for (PhysPortIndex = 0; PhysPortIndex <
                (unsigned int)pAC->GIni.GIMacsFound; PhysPortIndex ++) {

                (void)pAC->GIni.GIFunc.pFnMacResetCounter(pAC, IoC, PhysPortIndex);

                SK_MEMSET((char *)&pAC->Pnmi.Port[PhysPortIndex].CounterHigh,
                        0, sizeof(pAC->Pnmi.Port[PhysPortIndex].CounterHigh));
                SK_MEMSET((char *)&pAC->Pnmi.Port[PhysPortIndex].
                        CounterOffset, 0, sizeof(pAC->Pnmi.Port[
                        PhysPortIndex].CounterOffset));
                SK_MEMSET((char *)&pAC->Pnmi.Port[PhysPortIndex].StatSyncCts,
                        0, sizeof(pAC->Pnmi.Port[PhysPortIndex].StatSyncCts));
                SK_MEMSET((char *)&pAC->Pnmi.Port[PhysPortIndex].
                        StatSyncOctetsCts, 0, sizeof(pAC->Pnmi.Port[
                        PhysPortIndex].StatSyncOctetsCts));
                SK_MEMSET((char *)&pAC->Pnmi.Port[PhysPortIndex].
                        StatRxLongFrameCts, 0, sizeof(pAC->Pnmi.Port[
                        PhysPortIndex].StatRxLongFrameCts));
                SK_MEMSET((char *)&pAC->Pnmi.Port[PhysPortIndex].
                                  StatRxFrameTooLongCts, 0, sizeof(pAC->Pnmi.Port[
                        PhysPortIndex].StatRxFrameTooLongCts));
                SK_MEMSET((char *)&pAC->Pnmi.Port[PhysPortIndex].
                                  StatRxPMaccErr, 0, sizeof(pAC->Pnmi.Port[
                        PhysPortIndex].StatRxPMaccErr));
        }

        /*
         * Clear local statistics
         */
        SK_MEMSET((char *)&pAC->Pnmi.VirtualCounterOffset, 0,
                  sizeof(pAC->Pnmi.VirtualCounterOffset));
        pAC->Pnmi.RlmtChangeCts = 0;
        pAC->Pnmi.RlmtChangeTime = 0;
        SK_MEMSET((char *)&pAC->Pnmi.RlmtChangeEstimate.EstValue[0], 0,
                sizeof(pAC->Pnmi.RlmtChangeEstimate.EstValue));
        pAC->Pnmi.RlmtChangeEstimate.EstValueIndex = 0;
        pAC->Pnmi.RlmtChangeEstimate.Estimate = 0;
        pAC->Pnmi.Port[NetIndex].TxSwQueueMax = 0;
        pAC->Pnmi.Port[NetIndex].TxRetryCts = 0;
        pAC->Pnmi.Port[NetIndex].RxIntrCts = 0;
        pAC->Pnmi.Port[NetIndex].TxIntrCts = 0;
        pAC->Pnmi.Port[NetIndex].RxNoBufCts = 0;
        pAC->Pnmi.Port[NetIndex].TxNoBufCts = 0;
        pAC->Pnmi.Port[NetIndex].TxUsedDescrNo = 0;
        pAC->Pnmi.Port[NetIndex].RxDeliveredCts = 0;
        pAC->Pnmi.Port[NetIndex].RxOctetsDeliveredCts = 0;
        pAC->Pnmi.Port[NetIndex].ErrRecoveryCts = 0;
}

/*****************************************************************************
 *
 * GetTrapEntry - Get an entry in the trap buffer
 *
 * Description:
 *      The trap buffer stores various events. A user application somehow
 *      gets notified that an event occured and retrieves the trap buffer
 *      contens (or simply polls the buffer). The buffer is organized as
 *      a ring which stores the newest traps at the beginning. The oldest
 *      traps are overwritten by the newest ones. Each trap entry has a
 *      unique number, so that applications may detect new trap entries.
 *
 * Returns:
 *      A pointer to the trap entry
 */
PNMI_STATIC char* GetTrapEntry(
SK_AC *pAC,             /* Pointer to adapter context */
SK_U32 TrapId,          /* SNMP ID of the trap */
unsigned int Size)      /* Space needed for trap entry */
{
        unsigned int            BufPad = pAC->Pnmi.TrapBufPad;
        unsigned int            BufFree = pAC->Pnmi.TrapBufFree;
        unsigned int            Beg = pAC->Pnmi.TrapQueueBeg;
        unsigned int            End = pAC->Pnmi.TrapQueueEnd;
        char                    *pBuf = &pAC->Pnmi.TrapBuf[0];
        int                     Wrap;
        unsigned int            NeededSpace;
        unsigned int            EntrySize;
        SK_U32                  Val32;
        SK_U64                  Val64;


        /* Last byte of entry will get a copy of the entry length */
        Size ++;

        /*
         * Calculate needed buffer space */
        if (Beg >= Size) {

                NeededSpace = Size;
                Wrap = SK_FALSE;
        }
        else {
                NeededSpace = Beg + Size;
                Wrap = SK_TRUE;
        }

        /*
         * Check if enough buffer space is provided. Otherwise
         * free some entries. Leave one byte space between begin
         * and end of buffer to make it possible to detect whether
         * the buffer is full or empty
         */
        while (BufFree < NeededSpace + 1) {

                if (End == 0) {

                        End = SK_PNMI_TRAP_QUEUE_LEN;
                }

                EntrySize = (unsigned int)*((unsigned char *)pBuf + End - 1);
                BufFree += EntrySize;
                End -= EntrySize;
#ifdef DEBUG
                SK_MEMSET(pBuf + End, (char)(-1), EntrySize);
#endif
                if (End == BufPad) {
#ifdef DEBUG
                        SK_MEMSET(pBuf, (char)(-1), End);
#endif
                        BufFree += End;
                        End = 0;
                        BufPad = 0;
                }
        }

        /* 
         * Insert new entry as first entry. Newest entries are
         * stored at the beginning of the queue.
         */
        if (Wrap) {

                BufPad = Beg;
                Beg = SK_PNMI_TRAP_QUEUE_LEN - Size;
        }
        else {
                Beg = Beg - Size;
        }
        BufFree -= NeededSpace;

        /* Save the current offsets */
        pAC->Pnmi.TrapQueueBeg = Beg;
        pAC->Pnmi.TrapQueueEnd = End;
        pAC->Pnmi.TrapBufPad = BufPad;
        pAC->Pnmi.TrapBufFree = BufFree;

        /* Initialize the trap entry */
        *(pBuf + Beg + Size - 1) = (char)Size;
        *(pBuf + Beg) = (char)Size;
        Val32 = (pAC->Pnmi.TrapUnique) ++;
        SK_PNMI_STORE_U32(pBuf + Beg + 1, Val32);
        SK_PNMI_STORE_U32(pBuf + Beg + 1 + sizeof(SK_U32), TrapId);
        Val64 = SK_PNMI_HUNDREDS_SEC(SkOsGetTime(pAC));
        SK_PNMI_STORE_U64(pBuf + Beg + 1 + 2 * sizeof(SK_U32), Val64);

        return (pBuf + Beg);
}

/*****************************************************************************
 *
 * CopyTrapQueue - Copies the trap buffer for the TRAP OID
 *
 * Description:
 *      On a query of the TRAP OID the trap buffer contents will be
 *      copied continuously to the request buffer, which must be large
 *      enough. No length check is performed.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void CopyTrapQueue(
SK_AC *pAC,             /* Pointer to adapter context */
char *pDstBuf)          /* Buffer to which the queued traps will be copied */
{
        unsigned int    BufPad = pAC->Pnmi.TrapBufPad;
        unsigned int    Trap = pAC->Pnmi.TrapQueueBeg;
        unsigned int    End = pAC->Pnmi.TrapQueueEnd;
        char            *pBuf = &pAC->Pnmi.TrapBuf[0];
        unsigned int    Len;
        unsigned int    DstOff = 0;


        while (Trap != End) {

                Len = (unsigned int)*(pBuf + Trap);

                /*
                 * Last byte containing a copy of the length will
                 * not be copied.
                 */
                *(pDstBuf + DstOff) = (char)(Len - 1);
                SK_MEMCPY(pDstBuf + DstOff + 1, pBuf + Trap + 1, Len - 2);
                DstOff += Len - 1;

                Trap += Len;
                if (Trap == SK_PNMI_TRAP_QUEUE_LEN) {

                        Trap = BufPad;
                }
        }
}

/*****************************************************************************
 *
 * GetTrapQueueLen - Get the length of the trap buffer
 *
 * Description:
 *      Evaluates the number of currently stored traps and the needed
 *      buffer size to retrieve them.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void GetTrapQueueLen(
SK_AC *pAC,             /* Pointer to adapter context */
unsigned int *pLen,     /* Length in Bytes of all queued traps */
unsigned int *pEntries) /* Returns number of trapes stored in queue */
{
        unsigned int    BufPad = pAC->Pnmi.TrapBufPad;
        unsigned int    Trap = pAC->Pnmi.TrapQueueBeg;
        unsigned int    End = pAC->Pnmi.TrapQueueEnd;
        char            *pBuf = &pAC->Pnmi.TrapBuf[0];
        unsigned int    Len;
        unsigned int    Entries = 0;
        unsigned int    TotalLen = 0;


        while (Trap != End) {

                Len = (unsigned int)*(pBuf + Trap);
                TotalLen += Len - 1;
                Entries ++;

                Trap += Len;
                if (Trap == SK_PNMI_TRAP_QUEUE_LEN) {

                        Trap = BufPad;
                }
        }

        *pEntries = Entries;
        *pLen = TotalLen;
}

/*****************************************************************************
 *
 * QueueSimpleTrap - Store a simple trap to the trap buffer
 *
 * Description:
 *      A simple trap is a trap with now additional data. It consists
 *      simply of a trap code.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void QueueSimpleTrap(
SK_AC *pAC,             /* Pointer to adapter context */
SK_U32 TrapId)          /* Type of sensor trap */
{
        GetTrapEntry(pAC, TrapId, SK_PNMI_TRAP_SIMPLE_LEN);
}

/*****************************************************************************
 *
 * QueueSensorTrap - Stores a sensor trap in the trap buffer
 *
 * Description:
 *      Gets an entry in the trap buffer and fills it with sensor related
 *      data.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void QueueSensorTrap(
SK_AC *pAC,                     /* Pointer to adapter context */
SK_U32 TrapId,                  /* Type of sensor trap */
unsigned int SensorIndex)       /* Index of sensor which caused the trap */
{
        char            *pBuf;
        unsigned int    Offset;
        unsigned int    DescrLen;
        SK_U32          Val32;


        /* Get trap buffer entry */
        DescrLen = SK_STRLEN(pAC->I2c.SenTable[SensorIndex].SenDesc);
        pBuf = GetTrapEntry(pAC, TrapId,
                SK_PNMI_TRAP_SENSOR_LEN_BASE + DescrLen);
        Offset = SK_PNMI_TRAP_SIMPLE_LEN;

        /* Store additionally sensor trap related data */
        Val32 = OID_SKGE_SENSOR_INDEX;
        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
        *(pBuf + Offset + 4) = 4;
        Val32 = (SK_U32)SensorIndex;
        SK_PNMI_STORE_U32(pBuf + Offset + 5, Val32);
        Offset += 9;
        
        Val32 = (SK_U32)OID_SKGE_SENSOR_DESCR;
        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
        *(pBuf + Offset + 4) = (char)DescrLen;
        SK_MEMCPY(pBuf + Offset + 5, pAC->I2c.SenTable[SensorIndex].SenDesc,
                DescrLen);
        Offset += DescrLen + 5;

        Val32 = OID_SKGE_SENSOR_TYPE;
        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
        *(pBuf + Offset + 4) = 1;
        *(pBuf + Offset + 5) = (char)pAC->I2c.SenTable[SensorIndex].SenType;
        Offset += 6;

        Val32 = OID_SKGE_SENSOR_VALUE;
        SK_PNMI_STORE_U32(pBuf + Offset, Val32);
        *(pBuf + Offset + 4) = 4;
        Val32 = (SK_U32)pAC->I2c.SenTable[SensorIndex].SenValue;
        SK_PNMI_STORE_U32(pBuf + Offset + 5, Val32);
}

/*****************************************************************************
 *
 * QueueRlmtNewMacTrap - Store a port switch trap in the trap buffer
 *
 * Description:
 *      Nothing further to explain.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void QueueRlmtNewMacTrap(
SK_AC *pAC,             /* Pointer to adapter context */
unsigned int ActiveMac) /* Index (0..n) of the currently active port */
{
        char    *pBuf;
        SK_U32  Val32;


        pBuf = GetTrapEntry(pAC, OID_SKGE_TRAP_RLMT_CHANGE_PORT,
                SK_PNMI_TRAP_RLMT_CHANGE_LEN);

        Val32 = OID_SKGE_RLMT_PORT_ACTIVE;
        SK_PNMI_STORE_U32(pBuf + SK_PNMI_TRAP_SIMPLE_LEN, Val32);
        *(pBuf + SK_PNMI_TRAP_SIMPLE_LEN + 4) = 1;
        *(pBuf + SK_PNMI_TRAP_SIMPLE_LEN + 5) = (char)ActiveMac;
}

/*****************************************************************************
 *
 * QueueRlmtPortTrap - Store port related RLMT trap to trap buffer
 *
 * Description:
 *      Nothing further to explain.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void QueueRlmtPortTrap(
SK_AC *pAC,             /* Pointer to adapter context */
SK_U32 TrapId,          /* Type of RLMT port trap */
unsigned int PortIndex) /* Index of the port, which changed its state */
{
        char    *pBuf;
        SK_U32  Val32;


        pBuf = GetTrapEntry(pAC, TrapId, SK_PNMI_TRAP_RLMT_PORT_LEN);

        Val32 = OID_SKGE_RLMT_PORT_INDEX;
        SK_PNMI_STORE_U32(pBuf + SK_PNMI_TRAP_SIMPLE_LEN, Val32);
        *(pBuf + SK_PNMI_TRAP_SIMPLE_LEN + 4) = 1;
        *(pBuf + SK_PNMI_TRAP_SIMPLE_LEN + 5) = (char)PortIndex;
}

/*****************************************************************************
 *
 * CopyMac - Copies a MAC address
 *
 * Description:
 *      Nothing further to explain.
 *
 * Returns:
 *      Nothing
 */
PNMI_STATIC void CopyMac(
char *pDst,             /* Pointer to destination buffer */
SK_MAC_ADDR *pMac)      /* Pointer of Source */
{
        int     i;


        for (i = 0; i < sizeof(SK_MAC_ADDR); i ++) {

                *(pDst + i) = pMac->a[i];
        }
}


#ifdef SK_POWER_MGMT
/*****************************************************************************
 *
 * PowerManagement - OID handler function of PowerManagement OIDs
 *
 * Description:
 *      The code is simple. No description necessary.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was successfully performed.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter.
 */

PNMI_STATIC int PowerManagement(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which to mgmt data will be retrieved */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (1..n) that is to be queried or -1 */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode allways zero */
{
        
        SK_U32  RetCode = SK_PNMI_ERR_GENERAL;

        /*
         * Check instance. We only handle single instance variables
         */
        if (Instance != (SK_U32)(-1) && Instance != 1) {

                *pLen = 0;
                return (SK_PNMI_ERR_UNKNOWN_INST);
        }

        /*
         * Perform action
         */
        if (Action == SK_PNMI_GET) {

                /*
                 * Check length
                 */
                switch (Id) {

                case OID_PNP_CAPABILITIES:
                        if (*pLen < sizeof(SK_PNP_CAPABILITIES)) {

                                *pLen = sizeof(SK_PNP_CAPABILITIES);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;

                case OID_PNP_QUERY_POWER:
                case OID_PNP_ENABLE_WAKE_UP:
                        if (*pLen < sizeof(SK_U32)) {

                                *pLen = sizeof(SK_U32);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;

                case OID_PNP_SET_POWER:
                case OID_PNP_ADD_WAKE_UP_PATTERN:
                case OID_PNP_REMOVE_WAKE_UP_PATTERN:
                        break;
                
                default:
                        SK_ERR_LOG(pAC, SK_ERRCL_SW, SK_PNMI_ERR040,
                                SK_PNMI_ERR040MSG);
                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }

                /*
                 * Get value
                 */
                switch (Id) {

                case OID_PNP_CAPABILITIES:
                        RetCode = SkPowerQueryPnPCapabilities(pAC, IoC, pBuf, pLen);
                        break;

                case OID_PNP_QUERY_POWER:
                        /* The Windows DDK describes: An OID_PNP_QUERY_POWER requests
                         the miniport to indicate whether it can transition its NIC 
                         to the low-power state. 
                         A miniport driver must always return NDIS_STATUS_SUCCESS
                         to a query of OID_PNP_QUERY_POWER. */
                        RetCode = SK_PNMI_ERR_OK;
                        break;

                        /* NDIS handles these OIDs as write-only.
                         * So in case of get action the buffer with written length = 0
                         * is returned
                         */
                case OID_PNP_SET_POWER:
                case OID_PNP_ADD_WAKE_UP_PATTERN:
                case OID_PNP_REMOVE_WAKE_UP_PATTERN:
                        *pLen = 0;      
                        RetCode = SK_PNMI_ERR_OK;
                        break;

                case OID_PNP_ENABLE_WAKE_UP:
                        RetCode = SkPowerGetEnableWakeUp(pAC, IoC, pBuf, pLen);
                        break;

                default:
                        RetCode = SK_PNMI_ERR_GENERAL;
                        break;
                }

                return (RetCode); 
        }
        
        /*
         * From here SET or PRESET action. Check if the passed
         * buffer length is plausible.
         */
        switch (Id) {
        case OID_PNP_SET_POWER:
        case OID_PNP_ENABLE_WAKE_UP:
                if (*pLen < sizeof(SK_U32)) {

                        *pLen = sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                if (*pLen != sizeof(SK_U32)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_BAD_VALUE);
                }
                break;

        case OID_PNP_ADD_WAKE_UP_PATTERN:
        case OID_PNP_REMOVE_WAKE_UP_PATTERN:
                if (*pLen < sizeof(SK_PM_PACKET_PATTERN)) {

                        *pLen = 0;
                        return (SK_PNMI_ERR_BAD_VALUE); 
                }
                break;

    default:
                *pLen = 0;
                return (SK_PNMI_ERR_READ_ONLY);
        }

        /*
         * Perform preset or set
         */
        
        /* POWER module does not support PRESET action */
        if (Action == SK_PNMI_PRESET) {
                return (SK_PNMI_ERR_OK); 
        }

        switch (Id) {
        case OID_PNP_SET_POWER:
                RetCode = SkPowerSetPower(pAC, IoC, pBuf, pLen);        
                break;

        case OID_PNP_ADD_WAKE_UP_PATTERN:
                RetCode = SkPowerAddWakeUpPattern(pAC, IoC, pBuf, pLen);        
                break;
                
        case OID_PNP_REMOVE_WAKE_UP_PATTERN:
                RetCode = SkPowerRemoveWakeUpPattern(pAC, IoC, pBuf, pLen);     
                break;
                
        case OID_PNP_ENABLE_WAKE_UP:
                RetCode = SkPowerSetEnableWakeUp(pAC, IoC, pBuf, pLen);
                break;
                
        default:
                RetCode = SK_PNMI_ERR_GENERAL;
        }
        
        return (RetCode);
}
#endif /* SK_POWER_MGMT */


/*****************************************************************************
 *
 * Vct - OID handler function of  OIDs
 *
 * Description:
 *      The code is simple. No description necessary.
 *
 * Returns:
 *      SK_PNMI_ERR_OK           The request was performed successfully.
 *      SK_PNMI_ERR_GENERAL      A general severe internal error occured.
 *      SK_PNMI_ERR_TOO_SHORT    The passed buffer is too short to contain
 *                               the correct data (e.g. a 32bit value is
 *                               needed, but a 16 bit value was passed).
 *      SK_PNMI_ERR_UNKNOWN_INST The requested instance of the OID doesn't
 *                               exist (e.g. port instance 3 on a two port
 *                               adapter).
 *      SK_PNMI_ERR_READ_ONLY    Only the Get action is allowed.
 *
 */

PNMI_STATIC int Vct(
SK_AC *pAC,             /* Pointer to adapter context */
SK_IOC IoC,             /* IO context handle */
int Action,             /* Get/PreSet/Set action */
SK_U32 Id,              /* Object ID that is to be processed */
char *pBuf,             /* Buffer to which the mgmt data will be copied */
unsigned int *pLen,     /* On call: buffer length. On return: used buffer */
SK_U32 Instance,        /* Instance (-1,2..n) that is to be queried */
unsigned int TableIndex, /* Index to the Id table */
SK_U32 NetIndex)        /* NetIndex (0..n), in single net mode always zero */
{
        SK_GEPORT       *pPrt;
        SK_PNMI_VCT     *pVctBackupData;
        SK_U32          LogPortMax;
        SK_U32          PhysPortMax;
        SK_U32          PhysPortIndex;
        SK_U32          Limit;
        SK_U32          Offset;
        SK_BOOL         Link;
        SK_U32          RetCode = SK_PNMI_ERR_GENERAL;
        int             i;
        SK_EVPARA       Para;
        SK_U32          CableLength;
        
        /*
         * Calculate the port indexes from the instance.
         */
        PhysPortMax = pAC->GIni.GIMacsFound;
        LogPortMax = SK_PNMI_PORT_PHYS2LOG(PhysPortMax);
        
        /* Dual net mode? */
        if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                LogPortMax--;
        }
        
        if ((Instance != (SK_U32) (-1))) {
                /* Check instance range. */
                if ((Instance < 2) || (Instance > LogPortMax)) {
                        *pLen = 0;
                        return (SK_PNMI_ERR_UNKNOWN_INST);
                }
                
                if (pAC->Pnmi.DualNetActiveFlag == SK_TRUE) {
                        PhysPortIndex = NetIndex;
                }
                else {
                        PhysPortIndex = Instance - 2;
                }
                Limit = PhysPortIndex + 1;
        }
        else {  /*
                 * Instance == (SK_U32) (-1), get all Instances of that OID.
                 *
                 * Not implemented yet. May be used in future releases.
                 */
                PhysPortIndex = 0;
                Limit = PhysPortMax;
        }
        
        pPrt = &pAC->GIni.GP[PhysPortIndex];
        if (pPrt->PHWLinkUp) {
                Link = SK_TRUE;
        }
        else {
                Link = SK_FALSE;
        }
        
        /*
         * Check MAC type.
         */
        if (pPrt->PhyType != SK_PHY_MARV_COPPER) {
                *pLen = 0;
                return (SK_PNMI_ERR_GENERAL);
        }
        
        /* Initialize backup data pointer. */
        pVctBackupData = &pAC->Pnmi.VctBackup[PhysPortIndex];
        
        /*
         * Check action type.
         */
        if (Action == SK_PNMI_GET) {
                /*
                 * Check length.
                 */
                switch (Id) {
                
                case OID_SKGE_VCT_GET:
                        if (*pLen < (Limit - PhysPortIndex) * sizeof(SK_PNMI_VCT)) {
                                *pLen = (Limit - PhysPortIndex) * sizeof(SK_PNMI_VCT);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;
                
                case OID_SKGE_VCT_STATUS:
                        if (*pLen < (Limit - PhysPortIndex) * sizeof(SK_U8)) {
                                *pLen = (Limit - PhysPortIndex) * sizeof(SK_U8);
                                return (SK_PNMI_ERR_TOO_SHORT);
                        }
                        break;
                
                default:
                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }       
                
                /*
                 * Get value.
                 */
                Offset = 0;
                for (; PhysPortIndex < Limit; PhysPortIndex++) {
                        switch (Id) {
                        
                        case OID_SKGE_VCT_GET:          
                                if ((Link == SK_FALSE) &&
                                        (pAC->Pnmi.VctStatus[PhysPortIndex] & SK_PNMI_VCT_PENDING)) {
                                        RetCode = SkGmCableDiagStatus(pAC, IoC, PhysPortIndex, SK_FALSE);
                                        if (RetCode == 0) {
                                                pAC->Pnmi.VctStatus[PhysPortIndex] &= ~SK_PNMI_VCT_PENDING;
                                                pAC->Pnmi.VctStatus[PhysPortIndex] |=
                                                        (SK_PNMI_VCT_NEW_VCT_DATA | SK_PNMI_VCT_TEST_DONE);
                                                
                                                /* Copy results for later use to PNMI struct. */
                                                for (i = 0; i < 4; i++)  {
                                                        if (pPrt->PMdiPairSts[i] == SK_PNMI_VCT_NORMAL_CABLE) {
                                                                if ((pPrt->PMdiPairLen[i] > 35) && (pPrt->PMdiPairLen[i] < 0xff)) {
                                                                        pPrt->PMdiPairSts[i] = SK_PNMI_VCT_IMPEDANCE_MISMATCH;
                                                                }
                                                        }
                                                        if ((pPrt->PMdiPairLen[i] > 35) && (pPrt->PMdiPairLen[i] != 0xff)) {
                                                                CableLength = 1000 * (((175 * pPrt->PMdiPairLen[i]) / 210) - 28);
                                                        }
                                                        else {
                                                                CableLength = 0;
                                                        }
                                                        pVctBackupData->PMdiPairLen[i] = CableLength;
                                                        pVctBackupData->PMdiPairSts[i] = pPrt->PMdiPairSts[i];
                                                }

                                                Para.Para32[0] = PhysPortIndex;
                                                Para.Para32[1] = -1;
                                                SkEventQueue(pAC, SKGE_DRV, SK_DRV_PORT_RESET, Para);
                                                SkEventDispatcher(pAC, IoC);
                                        }
                                        else {
                                                ; /* VCT test is running. */
                                        }
                                }
                                
                                /* Get all results. */
                                CheckVctStatus(pAC, IoC, pBuf, Offset, PhysPortIndex);
                                Offset += sizeof(SK_U8);
                                *(pBuf + Offset) = pPrt->PCableLen;
                                Offset += sizeof(SK_U8);
                                for (i = 0; i < 4; i++)  {
                                        SK_PNMI_STORE_U32((pBuf + Offset), pVctBackupData->PMdiPairLen[i]);
                                        Offset += sizeof(SK_U32);
                                }
                                for (i = 0; i < 4; i++)  {
                                        *(pBuf + Offset) = pVctBackupData->PMdiPairSts[i];
                                        Offset += sizeof(SK_U8);
                                }
                                
                                RetCode = SK_PNMI_ERR_OK;
                                break;
                
                        case OID_SKGE_VCT_STATUS:
                                CheckVctStatus(pAC, IoC, pBuf, Offset, PhysPortIndex);
                                Offset += sizeof(SK_U8);
                                RetCode = SK_PNMI_ERR_OK;
                                break;
                        
                        default:
                                *pLen = 0;
                                return (SK_PNMI_ERR_GENERAL);
                        }
                } /* for */
                *pLen = Offset;
                return (RetCode);
        
        } /* if SK_PNMI_GET */
        
        /*
         * From here SET or PRESET action. Check if the passed
         * buffer length is plausible.
         */
        
        /*
         * Check length.
         */
        switch (Id) {
        case OID_SKGE_VCT_SET:
                if (*pLen < (Limit - PhysPortIndex) * sizeof(SK_U32)) {
                        *pLen = (Limit - PhysPortIndex) * sizeof(SK_U32);
                        return (SK_PNMI_ERR_TOO_SHORT);
                }
                break;
        
        default:
                *pLen = 0;
                return (SK_PNMI_ERR_GENERAL);
        }
        
        /*
         * Perform preset or set.
         */
        
        /* VCT does not support PRESET action. */
        if (Action == SK_PNMI_PRESET) {
                return (SK_PNMI_ERR_OK);
        }
        
        Offset = 0;
        for (; PhysPortIndex < Limit; PhysPortIndex++) {
                switch (Id) {
                case OID_SKGE_VCT_SET: /* Start VCT test. */
                        if (Link == SK_FALSE) {
                                SkGeStopPort(pAC, IoC, PhysPortIndex, SK_STOP_ALL, SK_SOFT_RST);
                                
                                RetCode = SkGmCableDiagStatus(pAC, IoC, PhysPortIndex, SK_TRUE);
                                if (RetCode == 0) { /* RetCode: 0 => Start! */
                                        pAC->Pnmi.VctStatus[PhysPortIndex] |= SK_PNMI_VCT_PENDING;
                                        pAC->Pnmi.VctStatus[PhysPortIndex] &= ~SK_PNMI_VCT_NEW_VCT_DATA;
                                        pAC->Pnmi.VctStatus[PhysPortIndex] &= ~SK_PNMI_VCT_LINK;
                                        
                                        /*
                                         * Start VCT timer counter.
                                         */
                                        SK_MEMSET((char *) &Para, 0, sizeof(Para));
                                        Para.Para32[0] = PhysPortIndex;
                                        Para.Para32[1] = -1;
                                        SkTimerStart(pAC, IoC, &pAC->Pnmi.VctTimeout[PhysPortIndex].VctTimer,
                                                4000000, SKGE_PNMI, SK_PNMI_EVT_VCT_RESET, Para);
                                        SK_PNMI_STORE_U32((pBuf + Offset), RetCode);
                                        RetCode = SK_PNMI_ERR_OK;
                                }
                                else { /* RetCode: 2 => Running! */
                                        SK_PNMI_STORE_U32((pBuf + Offset), RetCode);
                                        RetCode = SK_PNMI_ERR_OK;
                                }
                        }
                        else { /* RetCode: 4 => Link! */
                                RetCode = 4;
                                SK_PNMI_STORE_U32((pBuf + Offset), RetCode);
                                RetCode = SK_PNMI_ERR_OK;
                        }
                        Offset += sizeof(SK_U32);
                        break;
        
                default:
                        *pLen = 0;
                        return (SK_PNMI_ERR_GENERAL);
                }
        } /* for */
        *pLen = Offset;
        return (RetCode);

} /* Vct */


PNMI_STATIC void CheckVctStatus(
SK_AC           *pAC,
SK_IOC          IoC,
char            *pBuf,
SK_U32          Offset,
SK_U32          PhysPortIndex)
{
        SK_GEPORT       *pPrt;
        SK_PNMI_VCT     *pVctData;
        SK_U32          RetCode;
        SK_U8           LinkSpeedUsed;
        
        pPrt = &pAC->GIni.GP[PhysPortIndex];
        
        pVctData = (SK_PNMI_VCT *) (pBuf + Offset);
        pVctData->VctStatus = SK_PNMI_VCT_NONE;
        
        if (!pPrt->PHWLinkUp) {
                
                /* Was a VCT test ever made before? */
                if (pAC->Pnmi.VctStatus[PhysPortIndex] & SK_PNMI_VCT_TEST_DONE) {
                        if ((pAC->Pnmi.VctStatus[PhysPortIndex] & SK_PNMI_VCT_LINK)) {
                                pVctData->VctStatus |= SK_PNMI_VCT_OLD_VCT_DATA;
                        }
                        else {
                                pVctData->VctStatus |= SK_PNMI_VCT_NEW_VCT_DATA;
                        }
                }
                
                /* Check VCT test status. */
                RetCode = SkGmCableDiagStatus(pAC,IoC, PhysPortIndex, SK_FALSE);
                if (RetCode == 2) { /* VCT test is running. */
                        pVctData->VctStatus |= SK_PNMI_VCT_RUNNING;
                }
                else { /* VCT data was copied to pAC here. Check PENDING state. */
                        if (pAC->Pnmi.VctStatus[PhysPortIndex] & SK_PNMI_VCT_PENDING) {
                                pVctData->VctStatus |= SK_PNMI_VCT_NEW_VCT_DATA;
                        }
                }
                
                if (pPrt->PCableLen != 0xff) { /* Old DSP value. */
                        pVctData->VctStatus |= SK_PNMI_VCT_OLD_DSP_DATA;
                }
        }
        else {
                
                /* Was a VCT test ever made before? */
                if (pAC->Pnmi.VctStatus[PhysPortIndex] & SK_PNMI_VCT_TEST_DONE) {
                        pVctData->VctStatus &= ~SK_PNMI_VCT_NEW_VCT_DATA;
                        pVctData->VctStatus |= SK_PNMI_VCT_OLD_VCT_DATA;
                }
                
                /* DSP only valid in 100/1000 modes. */
                LinkSpeedUsed = pAC->GIni.GP[PhysPortIndex].PLinkSpeedUsed;
                if (LinkSpeedUsed != SK_LSPEED_STAT_10MBPS) {   
                        pVctData->VctStatus |= SK_PNMI_VCT_NEW_DSP_DATA;
                }
        }

} /* CheckVctStatus */