diff options
| -rw-r--r-- | sys/contrib/dev/nve/adapter.h | 579 | ||||
| -rw-r--r-- | sys/contrib/dev/nve/amd64/nvenetlib.o.bz2.uu | 317 | ||||
| -rw-r--r-- | sys/contrib/dev/nve/basetype.h | 281 | ||||
| -rw-r--r-- | sys/contrib/dev/nve/drvinfo.h | 190 | ||||
| -rw-r--r-- | sys/contrib/dev/nve/i386/nvenetlib.o.bz2.uu | 316 | ||||
| -rw-r--r-- | sys/contrib/dev/nve/os.h | 128 | ||||
| -rw-r--r-- | sys/contrib/dev/nve/phy.h | 164 |
7 files changed, 1975 insertions, 0 deletions
diff --git a/sys/contrib/dev/nve/adapter.h b/sys/contrib/dev/nve/adapter.h new file mode 100644 index 0000000..82ef8ef --- /dev/null +++ b/sys/contrib/dev/nve/adapter.h @@ -0,0 +1,579 @@ +/***************************************************************************\ +|* *| +|* Copyright 2001-2004 NVIDIA Corporation. All Rights Reserved. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL *| +|* TO NVIDIA, CORPORATION. USE, REPRODUCTION OR DISCLOSURE TO ANY *| +|* THIRD PARTY IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORP. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROVIDED "AS IS" WITHOUT *| +|* EXPRESS OR IMPLIED WARRANTY OF ANY KIND, INCLUDING ALL IMPLIED *| +|* WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A *| +|* PARTICULAR PURPOSE. *| +|* *| +\***************************************************************************/ + +/* + FILE: adapter.h + DATE: 2/7/00 + + This file contains the hardware interface to the ethernet adapter. +*/ + +#ifndef _ADAPTER_H_ +#define _ADAPTER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#define HDA_VERSION_STRING "HDR A: $Revision: #46 $" + +#ifdef MODS_NETWORK_BUILD +#ifndef _DRVAPP_H_ +#include "drvapp.h" +#endif +#endif + +////////////////////////////////////////////////////////////////// +// For the set and get configuration calls. +typedef struct _ADAPTER_CONFIG +{ + NV_UINT32 ulFlags; +} ADAPTER_CONFIG, *PADAPTER_CONFIG; +////////////////////////////////////////////////////////////////// + +typedef struct _ADAPTER_WRITE_OFFLOAD +{ + NV_UINT32 usBitmask; + NV_UINT32 ulMss; + +} ADAPTER_WRITE_OFFLOAD; + +////////////////////////////////////////////////////////////////// +// For the ADAPTER_Write1 call. +/* This scatter gather list should be same as defined in ndis.h by MS. + For ULONG_PTR MS header file says that it will be of same size as + pointer. It has been defined to take care of casting between differenet + sizes. +*/ +typedef struct _NVSCATTER_GATHER_ELEMENT { + NV_UINT32 PhysLow; + NV_UINT32 PhysHigh; + NV_UINT32 Length; + NV_VOID *Reserved; +} NVSCATTER_GATHER_ELEMENT, *PNVSCATTER_GATHER_ELEMENT; + +#ifndef linux +#pragma warning(disable:4200) +#endif +typedef struct _NVSCATTER_GATHER_LIST { + NV_UINT32 NumberOfElements; + NV_VOID *Reserved; + NVSCATTER_GATHER_ELEMENT Elements[0]; // Made 0 sized element to remove MODS compilation error + // Elements[0] and Elements[] have the same effect. + // sizeof(NVSCATTER_GATHER_LIST) is the same (value of 8) in both cases + // And both lead to Warning 4200 in MSVC +} NVSCATTER_GATHER_LIST, *PNVSCATTER_GATHER_LIST; +#ifndef linux +#pragma warning(default:4200) +#endif + +typedef struct _ADAPTER_WRITE_DATA1 +{ + NV_UINT32 ulTotalLength; + PNV_VOID pvID; + NV_UINT8 uc8021pPriority; + ADAPTER_WRITE_OFFLOAD *psOffload; + PNVSCATTER_GATHER_LIST pNVSGL; +} ADAPTER_WRITE_DATA1, *PADAPTER_WRITE_DATA1; + + +////////////////////////////////////////////////////////////////// +// For the ADAPTER_Write call. +typedef struct _ADAPTER_WRITE_ELEMENT +{ + PNV_VOID pPhysical; + NV_UINT32 ulLength; +} ADAPTER_WRITE_ELEMENT, *PADAPTER_WRITE_ELEMENT; + + +#define ADAPTER_WRITE_OFFLOAD_BP_SEGOFFLOAD 0 +#define ADAPTER_WRITE_OFFLOAD_BP_IPV4CHECKSUM 1 +#define ADAPTER_WRITE_OFFLOAD_BP_IPV6CHECKSUM 2 +#define ADAPTER_WRITE_OFFLOAD_BP_TCPCHECKSUM 3 +#define ADAPTER_WRITE_OFFLOAD_BP_UDPCHECKSUM 4 +#define ADAPTER_WRITE_OFFLOAD_BP_IPCHECKSUM 5 + + +// pvID is a value that will be passed back into OSAPI.pfnPacketWasSent +// when the transmission completes. if pvID is NULL, the ADAPTER code +// assumes the caller does not want the pfnPacketWasSent callback. +typedef struct _ADAPTER_WRITE_DATA +{ + NV_UINT32 ulNumberOfElements; + NV_UINT32 ulTotalLength; + PNV_VOID pvID; + NV_UINT8 uc8021pPriority; + ADAPTER_WRITE_OFFLOAD *psOffload; + ADAPTER_WRITE_ELEMENT sElement[100]; +} ADAPTER_WRITE_DATA, *PADAPTER_WRITE_DATA; +////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////// +// For the ADAPTER_Read call. +typedef struct _ADAPTER_READ_ELEMENT +{ + PNV_VOID pPhysical; + NV_UINT32 ulLength; +} ADAPTER_READ_ELEMENT, *PADAPTER_READ_ELEMENT; + +typedef struct _ADAPTER_READ_OFFLOAD +{ + NV_UINT8 ucChecksumStatus; + +} ADAPTER_READ_OFFLOAD; + +typedef struct _ADAPTER_READ_DATA +{ + NV_UINT32 ulNumberOfElements; + NV_UINT32 ulTotalLength; + PNV_VOID pvID; + NV_UINT32 ulFilterMatch; + ADAPTER_READ_OFFLOAD sOffload; + ADAPTER_READ_ELEMENT sElement[10]; +} ADAPTER_READ_DATA, *PADAPTER_READ_DATA; + + +#define RDFLAG_CHK_NOCHECKSUM 0 +#define RDFLAG_CHK_IPPASSTCPFAIL 1 +#define RDFLAG_CHK_IPPASSUDPFAIL 2 +#define RDFLAG_CHK_IPFAIL 3 +#define RDFLAG_CHK_IPPASSNOTCPUDP 4 +#define RDFLAG_CHK_IPPASSTCPPASS 5 +#define RDFLAG_CHK_IPPASSUDPPASS 6 +#define RDFLAG_CHK_RESERVED 7 + + +// The ulFilterMatch flag can be a logical OR of the following +#define ADREADFL_UNICAST_MATCH 0x00000001 +#define ADREADFL_MULTICAST_MATCH 0x00000002 +#define ADREADFL_BROADCAST_MATCH 0x00000004 +////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////// +// For the ADAPTER_GetPowerCapabilities call. +typedef struct _ADAPTER_POWERCAPS +{ + NV_UINT32 ulPowerFlags; + NV_UINT32 ulMagicPacketWakeUpFlags; + NV_UINT32 ulPatternWakeUpFlags; + NV_UINT32 ulLinkChangeWakeUpFlags; + NV_SINT32 iMaxWakeUpPatterns; +} ADAPTER_POWERCAPS, *PADAPTER_POWERCAPS; + +// For the ADAPTER_GetPowerState and ADAPTER_SetPowerState call. +typedef struct _ADAPTER_POWERSTATE +{ + NV_UINT32 ulPowerFlags; + NV_UINT32 ulMagicPacketWakeUpFlags; + NV_UINT32 ulPatternWakeUpFlags; + NV_UINT32 ulLinkChangeWakeUpFlags; +} ADAPTER_POWERSTATE, *PADAPTER_POWERSTATE; + +// Each of the flag fields in the POWERCAPS structure above can have +// any of the following bitflags set giving the capabilites of the +// adapter. In the case of the wake up fields, these flags mean that +// wake up can happen from the specified power state. + +// For the POWERSTATE structure, the ulPowerFlags field should just +// have one of these bits set to go to that particular power state. +// The WakeUp fields can have one or more of these bits set to indicate +// what states should be woken up from. +#define POWER_STATE_D0 0x00000001 +#define POWER_STATE_D1 0x00000002 +#define POWER_STATE_D2 0x00000004 +#define POWER_STATE_D3 0x00000008 + +#define POWER_STATE_ALL (POWER_STATE_D0 | \ + POWER_STATE_D1 | \ + POWER_STATE_D2 | \ + POWER_STATE_D3) +////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////// +// The ADAPTER_GetPacketFilterCaps call returns a NV_UINT32 that can +// have the following capability bits set. +#define ACCEPT_UNICAST_PACKETS 0x00000001 +#define ACCEPT_MULTICAST_PACKETS 0x00000002 +#define ACCEPT_BROADCAST_PACKETS 0x00000004 +#define ACCEPT_ALL_PACKETS 0x00000008 + +#define ETH_LENGTH_OF_ADDRESS 6 + +// The ADAPTER_SetPacketFilter call uses this structure to know what +// packet filter to set. The ulPacketFilter field can contain some +// union of the bit flags above. The acMulticastMask array holds a +// 48 bit MAC address mask with a 0 in every bit position that should +// be ignored on compare and a 1 in every bit position that should +// be taken into account when comparing to see if the destination +// address of a packet should be accepted for multicast. +typedef struct _PACKET_FILTER +{ + NV_UINT32 ulFilterFlags; + NV_UINT8 acMulticastAddress[ETH_LENGTH_OF_ADDRESS]; + NV_UINT8 acMulticastMask[ETH_LENGTH_OF_ADDRESS]; +} PACKET_FILTER, *PPACKET_FILTER; +////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////// +// A WAKE_UP_PATTERN is a 128-byte pattern that the adapter can +// look for in incoming packets to decide when to wake up. Higher- +// level protocols can use this to, for example, wake up the +// adapter whenever it sees an IP packet that is addressed to it. +// A pattern consists of 128 bits of byte masks that indicate +// which bytes in the packet are relevant to the pattern, plus +// values for each byte. +#define WAKE_UP_PATTERN_SIZE 128 + +typedef struct _WAKE_UP_PATTERN +{ + NV_UINT32 aulByteMask[WAKE_UP_PATTERN_SIZE/32]; + NV_UINT8 acData[WAKE_UP_PATTERN_SIZE]; +} WAKE_UP_PATTERN, *PWAKE_UP_PATTERN; + + + +// +// +// Adapter offload +// +typedef struct _ADAPTER_OFFLOAD { + + NV_UINT32 Type; + NV_UINT32 Value0; + +} ADAPTER_OFFLOAD, *PADAPTER_OFFLOAD; + +#define ADAPTER_OFFLOAD_VLAN 0x00000001 +#define ADAPTER_OFFLOAD_IEEE802_1P 0x00000002 +#define ADAPTER_OFFLOAD_IEEE802_1PQ_PAD 0x00000004 + +////////////////////////////////////////////////////////////////// + +// CMNDATA_OS_ADAPTER +// Structure common to OS and Adapter layers +// Used for moving data from the OS layer to the adapter layer through SetCommonData +// function call from OS layer to Adapter layer +// + +typedef struct _CMNDATA_OS_ADAPTER +{ +#ifndef linux + ASF_SEC0_BASE sRegSec0Base; +#endif + NV_UINT32 bFPGA; + NV_UINT32 ulFPGAEepromSize; + NV_UINT32 bChecksumOffloadEnable; + NV_UINT32 ulChecksumOffloadBM; + NV_UINT32 ulChecksumOffloadOS; + NV_UINT32 ulMediaIF; + NV_UINT32 bOemCustomEventRead; + + // Debug only right now + //!!! Beware mods is relying on the fields blow. + NV_UINT32 ulWatermarkTFBW; + NV_UINT32 ulBackoffRseed; + NV_UINT32 ulBackoffSlotTime; + NV_UINT32 ulModeRegTxReadCompleteEnable; + NV_UINT32 ulFatalErrorRegister; + +} CMNDATA_OS_ADAPTER; + + +////////////////////////////////////////////////////////////////// +// The functional typedefs for the ADAPTER Api +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_CLOSE) (PNV_VOID pvContext, NV_UINT8 ucIsPowerDown); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_INIT) (PNV_VOID pvContext, NV_UINT16 usForcedSpeed, NV_UINT8 ucForceDpx, NV_UINT8 ucForceMode, NV_UINT8 ucAsyncMode, NV_UINT32 *puiLinkState); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_DEINIT) (PNV_VOID pvContext, NV_UINT8 ucIsPowerDown); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_START) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_STOP) (PNV_VOID pvContext, NV_UINT8 ucIsPowerDown); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_QUERY_WRITE_SLOTS) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_WRITE) (PNV_VOID pvContext, ADAPTER_WRITE_DATA *pADWriteData); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_WRITE1) (PNV_VOID pvContext, ADAPTER_WRITE_DATA1 *pADWriteData1); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_QUERY_INTERRUPT) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_HANDLE_INTERRUPT) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_DISABLE_INTERRUPTS) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_ENABLE_INTERRUPTS) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_CLEAR_INTERRUPTS) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_CLEAR_TX_DESC) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_LINK_SPEED) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_LINK_MODE) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_LINK_STATE) (PNV_VOID pvContext, NV_UINT32 *pulLinkState); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_IS_LINK_INITIALIZING) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_RESET_PHY_INIT_STATE) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_TRANSMIT_QUEUE_SIZE) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_RECEIVE_QUEUE_SIZE) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_STATISTICS) (PNV_VOID pvContext, PADAPTER_STATS pADStats); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_POWER_CAPS) (PNV_VOID pvContext, PADAPTER_POWERCAPS pADPowerCaps); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_POWER_STATE) (PNV_VOID pvContext, PADAPTER_POWERSTATE pADPowerState); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_SET_POWER_STATE) (PNV_VOID pvContext, PADAPTER_POWERSTATE pADPowerState); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_SET_LOW_SPEED_FOR_PM) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_GET_PACKET_FILTER_CAPS) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_SET_PACKET_FILTER) (PNV_VOID pvContext, PPACKET_FILTER pPacketFilter); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_SET_WAKE_UP_PATTERN) (PNV_VOID pvContext, NV_SINT32 iPattern, PWAKE_UP_PATTERN pPattern); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_ENABLE_WAKE_UP_PATTERN) (PNV_VOID pvContext, NV_SINT32 iPattern, NV_SINT32 iEnable); +typedef NV_API_CALL NV_SINT32 (* PFN_SET_NODE_ADDRESS) (PNV_VOID pvContext, NV_UINT8 *pNodeAddress); +typedef NV_API_CALL NV_SINT32 (* PFN_GET_NODE_ADDRESS) (PNV_VOID pvContext, NV_UINT8 *pNodeAddress); +typedef NV_API_CALL NV_SINT32 (* PFN_GET_ADAPTER_INFO) (PNV_VOID pvContext, PNV_VOID pVoidPtr, NV_SINT32 iType, NV_SINT32 *piLength); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_READ_PHY) (PNV_VOID pvContext, NV_UINT32 ulPhyAddr, NV_UINT32 ulPhyReg, NV_UINT32 *pulValue); +typedef NV_API_CALL NV_SINT32 (* PFN_ADAPTER_WRITE_PHY) (PNV_VOID pvContext, NV_UINT32 ulPhyAddr, NV_UINT32 ulPhyReg, NV_UINT32 ulValue); +typedef NV_API_CALL NV_VOID(* PFN_ADAPTER_SET_SPPED_DUPLEX) (PNV_VOID pvContext); +typedef NV_API_CALL NV_SINT32 (*PFN_REGISTER_OFFLOAD) (PNV_VOID pvContext, PADAPTER_OFFLOAD pOffload); +typedef NV_API_CALL NV_SINT32 (*PFN_DEREGISTER_OFFLOAD) (PNV_VOID pvContext, PADAPTER_OFFLOAD pOffload); +typedef NV_API_CALL NV_SINT32 (*PFN_RX_BUFF_READY) (PNV_VOID pvContext, PMEMORY_BLOCK pMemBlock, PNV_VOID pvID); + +#ifndef linux +typedef NV_SINT32 (*PFN_ADAPTER_ASF_SETUPREGISTERS) (PNV_VOID pvContext, NV_SINT32 bInitTime); +typedef NV_SINT32 (*PFN_ADAPTER_ASF_GETSEC0BASEADDRESS) (PNV_VOID pvContext, ASF_SEC0_BASE **ppsSec0Base); +typedef NV_SINT32 (*PFN_ADAPTER_ASF_SETSOURCEIPADDRESS) (PNV_VOID pvContext, NV_UINT8 *pucSrcIPAddress); +typedef NV_SINT32 (*PFN_ADAPTER_ASF_GETDESTIPADDRESS) (PNV_VOID pvContext, NV_UINT8 *pucDestIPAddress); +typedef NV_SINT32 (*PFN_ADAPTER_ASF_SETDESTIPADDRESS) (PNV_VOID pvContext, NV_UINT8 *pucDestIPAddress); +typedef NV_SINT32 (*PFN_ADAPTER_ASF_WRITEEEPROMANDSETUPREGISTERS) (PNV_VOID pvContext, NV_BOOLEAN bCompare, PNV_VOID pucValue, PNV_VOID pszSec0BaseMember, + NV_UINT16 usCount, NV_UINT32 ulAddressOffset); + +typedef NV_SINT32 (*PFN_ADAPTER_ASF_ISASFREADY) (PNV_VOID pvContext, ASF_ASFREADY *psASFReady); + +typedef NV_SINT32 (*PFN_ADAPTER_ASF_SETDESTMACADDRESS) (PNV_VOID pvContext, NV_UINT8 *pucDestMACAddress); +typedef NV_SINT32 (*PFN_ADAPTER_ASF_GETSOURCEMACADDRESS) (PNV_VOID pvContext, NV_UINT8 *pucSrcMACAddress); + +typedef NV_SINT32 (*PFN_ADAPTER_ASF_CHECK_FOR_EEPROM_PRESENCE) (PNV_VOID pvContext); +#endif + +typedef NV_API_CALL NV_VOID (*PFN_ADAPTER_SET_COMMONDATA) (PNV_VOID pvContext, CMNDATA_OS_ADAPTER *psOSAdpater); +typedef NV_API_CALL NV_VOID (*PFN_ADAPTER_SET_CHECKSUMOFFLOAD) (PNV_VOID pvContext, NV_UINT32 bSet); + + + +typedef struct _ADAPTER_API +{ + // The adapter context + PNV_VOID pADCX; + + // The adapter interface + PFN_ADAPTER_CLOSE pfnClose; + PFN_ADAPTER_INIT pfnInit; + PFN_ADAPTER_DEINIT pfnDeinit; + PFN_ADAPTER_START pfnStart; + PFN_ADAPTER_STOP pfnStop; + PFN_ADAPTER_QUERY_WRITE_SLOTS pfnQueryWriteSlots; + PFN_ADAPTER_WRITE pfnWrite; + PFN_ADAPTER_WRITE1 pfnWrite1; + PFN_ADAPTER_QUERY_INTERRUPT pfnQueryInterrupt; + PFN_ADAPTER_HANDLE_INTERRUPT pfnHandleInterrupt; + PFN_ADAPTER_DISABLE_INTERRUPTS pfnDisableInterrupts; + PFN_ADAPTER_ENABLE_INTERRUPTS pfnEnableInterrupts; + PFN_ADAPTER_CLEAR_INTERRUPTS pfnClearInterrupts; + PFN_ADAPTER_CLEAR_TX_DESC pfnClearTxDesc; + PFN_ADAPTER_GET_LINK_SPEED pfnGetLinkSpeed; + PFN_ADAPTER_GET_LINK_MODE pfnGetLinkMode; + PFN_ADAPTER_GET_LINK_STATE pfnGetLinkState; + PFN_ADAPTER_IS_LINK_INITIALIZING pfnIsLinkInitializing; + PFN_ADAPTER_RESET_PHY_INIT_STATE pfnResetPhyInitState; + PFN_ADAPTER_GET_TRANSMIT_QUEUE_SIZE pfnGetTransmitQueueSize; + PFN_ADAPTER_GET_RECEIVE_QUEUE_SIZE pfnGetReceiveQueueSize; + PFN_ADAPTER_GET_STATISTICS pfnGetStatistics; + PFN_ADAPTER_GET_POWER_CAPS pfnGetPowerCaps; + PFN_ADAPTER_GET_POWER_STATE pfnGetPowerState; + PFN_ADAPTER_SET_POWER_STATE pfnSetPowerState; + PFN_ADAPTER_SET_LOW_SPEED_FOR_PM pfnSetLowSpeedForPM; + PFN_ADAPTER_GET_PACKET_FILTER_CAPS pfnGetPacketFilterCaps; + PFN_ADAPTER_SET_PACKET_FILTER pfnSetPacketFilter; + PFN_ADAPTER_SET_WAKE_UP_PATTERN pfnSetWakeUpPattern; + PFN_ADAPTER_ENABLE_WAKE_UP_PATTERN pfnEnableWakeUpPattern; + PFN_SET_NODE_ADDRESS pfnSetNodeAddress; + PFN_GET_NODE_ADDRESS pfnGetNodeAddress; + PFN_GET_ADAPTER_INFO pfnGetAdapterInfo; + PFN_ADAPTER_SET_SPPED_DUPLEX pfnSetSpeedDuplex; + PFN_ADAPTER_READ_PHY pfnReadPhy; + PFN_ADAPTER_WRITE_PHY pfnWritePhy; + PFN_REGISTER_OFFLOAD pfnRegisterOffload; + PFN_DEREGISTER_OFFLOAD pfnDeRegisterOffload; + PFN_RX_BUFF_READY pfnRxBuffReady; +#ifndef linux + PFN_ADAPTER_ASF_SETUPREGISTERS pfnASFSetupRegisters; + PFN_ADAPTER_ASF_GETSEC0BASEADDRESS pfnASFGetSec0BaseAddress; + PFN_ADAPTER_ASF_SETSOURCEIPADDRESS pfnASFSetSourceIPAddress; + PFN_ADAPTER_ASF_GETDESTIPADDRESS pfnASFGetDestIPAddress; + PFN_ADAPTER_ASF_SETDESTIPADDRESS pfnASFSetDestIPAddress; + PFN_ADAPTER_ASF_WRITEEEPROMANDSETUPREGISTERS pfnASFWriteEEPROMAndSetupRegisters; + PFN_ADAPTER_ASF_SETDESTMACADDRESS pfnASFSetDestMACAddress; + PFN_ADAPTER_ASF_GETSOURCEMACADDRESS pfnASFGetSourceMACAddress; + PFN_ADAPTER_ASF_ISASFREADY pfnASFIsASFReady; + PFN_ADAPTER_ASF_CHECK_FOR_EEPROM_PRESENCE pfnASFCheckForEepromPresence; +#endif + PFN_ADAPTER_SET_COMMONDATA pfnSetCommonData; + + PFN_ADAPTER_SET_CHECKSUMOFFLOAD pfnSetChecksumOffload; + +} ADAPTER_API, *PADAPTER_API; +////////////////////////////////////////////////////////////////// + +#define MAX_PACKET_TO_ACCUMULATE 16 + +typedef struct _ADAPTER_OPEN_PARAMS +{ + PNV_VOID pOSApi; //pointer to OSAPI structure passed from higher layer + PNV_VOID pvHardwareBaseAddress; //memory mapped address passed from higher layer + NV_UINT32 ulPollInterval; //poll interval in micro seconds. Used in polling mode + NV_UINT32 MaxDpcLoop; //Maximum number of times we loop to in function ADAPTER_HandleInterrupt + NV_UINT32 MaxRxPkt; //Maximum number of packet we process each time in function UpdateReceiveDescRingData + NV_UINT32 MaxTxPkt; //Maximum number of packet we process each time in function UpdateTransmitDescRingData + NV_UINT32 MaxRxPktToAccumulate; //maximum number of rx packet we accumulate in UpdateReceiveDescRingData before + //indicating packets to OS. + NV_UINT32 SentPacketStatusSuccess; //Status returned from adapter layer to higher layer when packet was sent successfully + NV_UINT32 SentPacketStatusFailure; ////Status returned from adapter layer to higher layer when packet send was unsuccessful + NV_UINT32 SetForcedModeEveryNthRxPacket; //NOT USED: For experiment with descriptor based interrupt + NV_UINT32 SetForcedModeEveryNthTxPacket; //NOT USED: For experiment with descriptor based interrupt + NV_UINT32 RxForcedInterrupt; //NOT USED: For experiment with descriptor based interrupt + NV_UINT32 TxForcedInterrupt; //NOT USED: For experiment with descriptor based interrupt + NV_UINT32 DeviceId; //Of MAC + NV_UINT32 DeviceType; + NV_UINT32 PollIntervalInusForThroughputMode; //Of MAC + NV_UINT32 bASFEnabled; + NV_UINT32 ulDescriptorVersion; + NV_UINT32 ulMaxPacketSize; + + +#define MEDIA_IF_AUTO 0 +#define MEDIA_IF_RGMII 1 +#define MEDIA_IF_MII 2 + NV_UINT32 ulMediaIF; + + NV_UINT32 PhyPowerIsolationTimeoutInms; + NV_UINT32 PhyResetTimeoutInms; + NV_UINT32 PhyAutonegotiateTimeoutInms; + NV_UINT32 PhyLinkupTimeoutInms; + NV_UINT32 PhyRdWrTimeoutInus; + NV_UINT32 PhyPowerdownOnClose; + + // Added for Bug 100715 + NV_UINT32 bDisableMIIInterruptAndReadPhyStatus; + +}ADAPTER_OPEN_PARAMS, *PADAPTER_OPEN_PARAMS; + +////////////////////////////////////////////////////////////////// +// This is the one function in the adapter interface that is publicly +// available. The rest of the interface is returned in the pAdapterApi. +// The first argument needs to be cast to a OSAPI structure pointer. +// The second argument should be cast to a ADPATER_API structure pointer. +NV_API_CALL NV_SINT32 ADAPTER_Open (PADAPTER_OPEN_PARAMS pAdapterOpenParams, PNV_VOID *pvpAdapterApi, NV_UINT32 *pulPhyAddr); + +////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////// +// Here are the error codes the adapter function calls return. +#define ADAPTERERR_NONE 0x0000 +#define ADAPTERERR_COULD_NOT_ALLOC_CONTEXT 0x0001 +#define ADAPTERERR_COULD_NOT_CREATE_CONTEXT 0x0002 +#define ADAPTERERR_COULD_NOT_OPEN_PHY 0x0003 +#define ADAPTERERR_TRANSMIT_QUEUE_FULL 0x0004 +#define ADAPTERERR_COULD_NOT_INIT_PHY 0x0005 +#define ADAPTERERR_PHYS_SIZE_SMALL 0x0006 +#define ADAPTERERR_ERROR 0x0007 // Generic error +////////////////////////////////////////////////////////////////// + +// This block moved from myadap.h +// nFlag for Stop/Start ReceiverAndOrTransmitter can be an OR of +// the following two flags +#define AFFECT_RECEIVER 0x01 +#define AFFECT_TRANSMITTER 0x02 + +#define REDUCE_LENGTH_BY 48 + +#define EXTRA_WRITE_SLOT_TO_REDUCE_PER_SEND 4 +#define MAX_TX_DESCS 256 +#define MAX_TX_DESCS_VER2 (256 * 4) + +typedef struct _TX_INFO_ADAP +{ + NV_UINT32 NoOfDesc; + PNV_VOID pvVar2; +}TX_INFO_ADAP, *PTX_INFO_ADAP; + +#define WORKAROUND_FOR_MCP3_TX_STALL + +#ifdef WORKAROUND_FOR_MCP3_TX_STALL +NV_SINT32 ADAPTER_WorkaroundTXHang(PNV_VOID pvContext); +#endif + +//#define TRACK_INIT_TIME + +#ifdef TRACK_INIT_TIME +//This routine is defined in entry.c adapter doesn't link int64.lib +//We defined here so that its easy to use it in phy as well as mswin + +#define MAX_PRINT_INDEX 32 +extern NV_VOID PrintTime(NV_UINT32 ulIndex); +#define PRINT_INIT_TIME(_a) PrintTime((_a)) +#else +#define PRINT_INIT_TIME(_a) +#endif + +// Segmentation offload info +#define DEVCAPS_SEGOL_BP_ENABLE 0 +#define DEVCAPS_SEGOL_BP_IPOPTIONS 1 +#define DEVCAPS_SEGOL_BP_TCPOPTIONS 2 +#define DEVCAPS_SEGOL_BP_SEGSIZE_LO 8 +#define DEVCAPS_SEGOL_BP_SEGSIZE_HI 31 + + +// Checksum offload info +// Byte 0 : V4 TX +#define DEVCAPS_V4_TX_BP_IPOPTIONS 0 +#define DEVCAPS_V4_TX_BP_TCPOPTIONS 1 +#define DEVCAPS_V4_TX_BP_TCPCHECKSUM 2 +#define DEVCAPS_V4_TX_BP_UDPCHECKSUM 3 +#define DEVCAPS_V4_TX_BP_IPCHECKSUM 4 + +// Byte 0 : V4 RX +#define DEVCAPS_V4_RX_BP_IPOPTIONS 8 +#define DEVCAPS_V4_RX_BP_TCPOPTIONS 9 +#define DEVCAPS_V4_RX_BP_TCPCHECKSUM 10 +#define DEVCAPS_V4_RX_BP_UDPCHECKSUM 11 +#define DEVCAPS_V4_RX_BP_IPCHECKSUM 12 + +// Byte 1 : V6 TX +#define DEVCAPS_V6_TX_BP_IPOPTIONS 16 +#define DEVCAPS_V6_TX_BP_TCPOPTIONS 17 +#define DEVCAPS_V6_TX_BP_TCPCHECKSUM 18 +#define DEVCAPS_V6_TX_BP_UDPCHECKSUM 19 + +// Byte 2 : V6 RX +#define DEVCAPS_V6_RX_BP_IPOPTIONS 24 +#define DEVCAPS_V6_RX_BP_TCPOPTIONS 25 +#define DEVCAPS_V6_RX_BP_TCPCHECKSUM 26 +#define DEVCAPS_V6_RX_BP_UDPCHECKSUM 27 + + +#define DESCR_VER_1 1 // MCP1, MCP2 and CK8 descriptor version +#define DESCR_VER_2 2 // The decsriptor structure for CK8G + +// Get device and vendor IDs from 32 bit DeviceVendorID +#define GET_DEVICEID(x) (((x) >> 16) & 0xFFFF) +#define GET_VENDORID(x) ((x) & 0xFFFF) + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _ADAPTER_H_ diff --git a/sys/contrib/dev/nve/amd64/nvenetlib.o.bz2.uu b/sys/contrib/dev/nve/amd64/nvenetlib.o.bz2.uu new file mode 100644 index 0000000..c546f97 --- /dev/null +++ b/sys/contrib/dev/nve/amd64/nvenetlib.o.bz2.uu @@ -0,0 +1,317 @@ +begin-base64 644 nvenetlib.o.bz2 +QlpoOTFBWSZTWUBpjdcAPKd/////////////////////////////////////////////4EQ9vr29 +1e2gT7XjfPPtu9XYzj63x8EUopASoTa1bM0yAX3u93162+757e3eN7x1efWvPe3uTay266i7u7tq +nvXdxGenrevXO1uPOiPPRPOim6bbTvc9va9A68vp3Y9zfV6pX257bNpavtxbNTWTdj6DeojG0wHP +UIrXvdz3ueet3kWetctmys9wd61eJTbHue6h7Qt2GmdvPVbdDeu7XuMHWnntlRkPawDvYNCIIACM +gNTGgExNlM0NA0KbTEMgJmqbyNDUYAJ6JoYEmyT0NqNA0Mmk9Gminsp6Eeo9Gpk00zU9TKemjTJ6 +ps0J6ECYCZommjZQaEJoAEyCZMmTQGgE0BNNGo3qTxMRTzKeJMZDRPIjFPNIngJP0k/RGZNU9Mo8 +pp6ntTSNPJNihtTygPUNinkh6mTRpshGnqHpD0EZA0ZHqCU0IIQQmKeTTUwT0ETUPKfpqm2lP1Mo +9T0hpspp+lA8E9KeSaZAaaG1P1TQ0NHlGgyaPKPUxNAyB6TT9UPU0APU09QB6gNBoPSaeoNAeoGg +AEmlERBT1Mg1PJppTNPRT0Gp7VHgUGyeqPRGanij1GanpHlPJqAD0aIMho0zSGmTaIekAaPUZBoD +TQeoADEGIAADQxNA0AAA0SmqeKaZPSNPUyMmhppoMIaZAAaBpmoGj01HppAAYRpoNqaNGjEAHqNB +6jIyaA0NBoZANGjRoDCaZAaAAAAaABIkQIAgBpMTIAAEYTBGTJqZkT0U9kIZT9Gk00yngj0g0aZT +aGJk0aUxlNjVPaj0piep7U1NonqPUxMRk2gNI9T0T0ekNR6h6TJ6nqA0NHuQzodFdmOXubjsDKGV +fWDPCP6rD1qKdj8vzGJOG+tHooUM6dxfTDTfDTztiOaFIm9Dqm9OKJgtUZWjBmNA6cWr5QsVtEPN +rRgu/o1zSMTP2TFp3yd96YVQNiGwjE7NGaCkA8yAFZvgcbKhwGcuTmSWnKmW1aCTMW+/Zqh1+FsA +zFRRuuozVnLCc161pd8LWe2Nsnz3M+NssZrCzVw0TfG81nNhnimyp2PruWzXwdfAynp8fpo2pu+c +s7scmwszGMb5FrmWct3HaqWq93GFCzpmM9NqiRFKWsHi4w63sNeoddrtVkGoa0I2aXZqbNHlI3Zd +t21IRDA4bbmUC5vfBze4tyvkUaMUBaZEQUQLKMzBWQC1jGWq3AkdntcrD1jnc9zBeCdaFXQLSJi+ +cyxj7fedjLYpxYyoMZkM4D+J3fzaD/YG5RBewIvL2MnW+70VvQbLr/fVYoKdA5+xu9q1oLt3gEjM +zKucYOlyWChykzgvW65x8INMUkaAzjY6/VFXVYrY0E3lmptk7ylEWNBiWUuS5i3VTrl150bXW39B +EuptqBKc9blZvTLhQNKBeiehal4m0y3Zuxiks+51va5oFqYs6jDw52DXU36iRsvYuw169TcNoy50 +bfY21gq2pI7NBAnX76TQ3NUp+vKULaWsrBvYlVIl1mVdtw5TV3BupM3Cf93e3uVYFNTVKp0p4Dw7 +uhhzj+P47kWtreZhdtmYKtL7+F/jwvM2Nb7NF+mn1fzp3tfyKWvxV0olaeuzdu3deBP6UaibYsWu +pmwHqq+ulhW83kK2eo6mp5tcB/V+0z63WtbzGc5tIYYSEpChGuho7bPUh+n6v8up7mXhs9LKwokG +fenEsBs+ZQfa/85Emi8+w/10aOl9C3/2uJa7jtaG5f9p06T9nafNb0kK1R3Jq48FtcaPVsx6W2rL +G7p5djFy8p7c1FtKr2bvLLdXUqemCRYxZEa7mXPx2kejYTfa4tAblZpscJMwSuzHFfr6Lr47ZT/O +LZ0oVE++7EyGAKN/TdM44uI+tq5EW16B84QyJ1iOvPBcL0cb6oGwwG4kL8DIJIQ+pSvLf/fb3+2+ +H0nce9+N2Eu+z+M6V7Ya+ysrRd8bX2K9bkdbUQrPMvMdDNcVCC5ykRKx1+yUW+LNmqk1jtLZRbG5 +/ZLl8pgYGcv9/3+ArA72t7aYtk9JIVNYKMZypNd8sNLR735C+Jf0MJeZ3Cz7Ze8oQABMGREAQ3D0 +zfla12YPy69uqlm1EVLlZMSoSINgIiDSYEDYIhCBB4zSSBUDSEBLT7XNxq1SIGwEkbPk/JmjUBNZ +Jbq4vV9jupTVbWAqgG0JIusBBmy1mpytlu7Vr2H9BbEHPw4edKugvs7f3UBsWYx+tCPkRUAaOiED ++VGr4hkBrNNkEf6r9vN9jO+B8/kb7ku3bs0S7slKKgqUJkfrodNCelXgUO+8Pv97eo23SiLJThkd +RSe/dvbw9ky5HItQKMU7FN4C9UlxxM7fndbovVFMNKIQhJksRCoGItI3Y40RhMOJEAGRU+KoLHGk +IRgx3976sC+549j5411hyS/Jhdd/dD9n8rJ6x2mXouoUPdMocohep5vkypwofVu1s5fQv+6EWCVd +GbjYx5S+p/oyE4w9DudIcrQydt7LyW3sBEtUpYiaWzHHeITkosWTsSiUDiCHFKB4Z/Kz+72t6m5s +v0IScEP8rrk5liZyBtJIFBGKFRhnNrOlasyIRG0a72FT8jFBB+144SOy0RfBlWngek5A/zI/f/n5 +8L+8vQvqrOvhJMV8Qjnh0279kQjuml/Y0tYw17EH3rOL31Nk1voBHh3IXxv4OmlwDS9HrsIHbQAV +nMFJK5c0JS8vs98/ZB8Fl4GhWadpazTGiorqkHvz0AAuAue+jIyed66VANrHeZmzkwFVJwjsKQ+V +wfUkY3CfdyyZOjADkIM2nOQw3vbG97v3nafv0bj1fh4OuphT/o9GKGbfk8EUUEadHKEg1xD9KLqw +5HG+JMQ5N9UEiQOjUxWKSwb9uajDKFCD0PLZIayra1WNSPLtoXLidMBDAFCt5nPwuM18X0qgw240 +GBqPh0XzM1sAigGFCSMOqW7O4iTuHZKYOgdPM1dXQYjq3y1QGGGFNKZbAi4E+QsJHP9pV1WFbF31 +1FwhNram1eaSJkmc1RTSZNFfs91dJtmRXVYcK1SiY1sn18JXNrlSSk0aqd6WZ/V9yhZA1fuWiAPh +HU4Gcr6F3Kz216wh3DwiFQyG9m/Cooh6cLuYN4HKYJXJg6hYcyEkswWsCdSIpA2A7OQ+Id01tFau +vUvvKagiGVz6wz5iDJbWmcUAYYkJuGoHFs1Ddn27EmrWK6QidEev6/UgZ7WFMGxIVQ3XmUGpnaPR +mmpuolFt8ebtoZ6t32io5HoorDx2UUfPbatSK6HUdtR2Ep1Rx4KmF60dSPCj/npq+g7Ydsyz/Fs8 +rwN2qnF5XnwxeviQUY2UuirjXcqrkYtTGs67Fd3yNz7bvEew7Pj0pU8Ttus4sTojqgf1JItLw3Wp +JDaanAoUYENWQExZIFSbc2ECBhzMNhICySCiyBBI4KWAEhtGENngeiwQ1Emy3ZssgEsYSBXvklZC +MGIhlgUoDxX1HZ83altOJNnJLibUomaJKQ4PSYHTEzpz6WcKMNkgMNC89cpTAxMmFNKVu7zcVLlY +h3l6CKVpNVS9qxVIq8Tcpab2iZpe6Hh7qC96u9rkFrKxcayGwQwSmaBMZJhxMzUJgIZoHcZvFTDs +IFLk5OMTLmcphQItzEZoyTRMoZYT1jIZzuY1ZAy6spoWFWDtTRxEs0s/kpSZ0HHs7mDsyXZc/QN3 +btBNRzscGBEFQYJigpS02Myw18yq7q0swkTbSwDjigQQCALIgio7HZ7mmIaoSCyGxIRwUaxLDX0O +3GgbmlhnU0QshpC2EzIc3bNOI6s3Ad1wDhAoIO9Q6MBMecQYphvRWMyhjC94d7ZVMxV2EQYmGHMo +FTgztwZpTQYOSzKFJWoiLtZXZmhXGqmS0ppoOTEmS3cpNMF7ylNaSURgTVhDYixuLgUypqWDXQyo ++VbSTCKIIZJCKiLPSZiz0SkogTBVEZBUmSowmE4LQKwrNroa27U0wQhowrCZxSGVZuppiVW0bapV +aXkZySAhr0ZVeZUCGZq2KITUVhD1HaMLM6CtoHi60owb1iclDiWLg61cYGaEXHScY8hamceS71I1 +U+M4YuWDwvEYukaUwIRtpu3TGF3Y1h3VYSh1okcgQJJImkQY5h4E7OmpUhhIKOSQUQrOBKzjUWhy +xBYN9GFq1vDqkvMjkCDAkHKXswwqrEpwEFYtSUIWD0uwxWGrg9kEOOFYmktSCHHlpQa4LCzFZm64 +2LMsstmuNEyM1pdkww0w4KGwQxdTE01lBmaZwFR+4ZMGLm3BrEQQMolNIw2shpQRdwaMl0lpaBAz +VSTTWyyRu3e0NNEhcW4pRkUihVX2totajmZ3Z0XQWvtmxJdBRx8xt4kM2CbDK8MzZ0zpqIfAYpDO +xaIDfVeqGoUiBhsqSQeW7jSxVyqKpx3GaMSu/qUASZoRNHlGdMZIOSsKjl8HYHjzsGAiVUcdo6SC +BJkjBMwE1EKGtprIpd22TOdcKwliH2fwWTsNlCHis+i93ntzGcAyAxhJ3TCpJFJGEm6wgl7D4VXx +okyPKoSQgR+WwusBCV2+Z0oL0AFxAWVl/QVoEDTBKaGGZiEMDH+y8vDdgumKjR9ViWgMU2I0GgW3 +abQvRYkrd/0K7VCQgOjeVlsm8qpMWkFhOYfEphVSGxUh4rQeSTgRW1DG2NcXk8b835/WfzsqV9pA +dsDQf7hIbypBYTfSSsDnWVIbZ5feL5Zx2nBjsEdq056g7t7+6j9tTsRWuD975WR32NMcOk4mqwcx +MbI7gdLtwkl8lpJb51NFSTTTY0g/hzMVvBepAyceDOTRpNFxgLIpgVbSQqWuVrIKmI3jEIR9waSh +hAnvzJIekAYEMJITm2QqQkL42iwgYkjJyWEww24bCBvMk0SEO4Yczw/r4Yqul4Jta+yRxaTvT/Ll +TNVcTjYZ86VIHN5Q+EAURxr6XgzNEBQnyyVVFZsSdohOcZ0rCHh0hOWwFA2CpBRUd/29n8vO73OY +vN6BtRQFsRrlaHWbTraEYGchrbOgem8l0MQXGKpoCbCBoCliJUxH/bfkilr9ro7eSRUw2YvaWuBJ +xMV1jHwUlTRDDhe0pmMPOKaWQx1x1qYhN52vKGEJVZICirAhwnm3CHQuBBQkwgBqhCHToQrCB75b +IEUMqk6hnAmHDAUqpWiHY8ekwyLFUIqKiiizfZU4rWQ6hJuMCG6mUDUZOeTD2UST89JMIskDYwhV +V9X0vxPThmaKowUVGdHboaaVMTIkmwUQKwOBDiMIdAw80kwh0TANEA1HvN+wwwJbVPweFTFsUJAL +HAYGPAQAoaENNH2jr/l7X3+X6UfNx/I2nT/19DOT6zrtsk3byqKRwIX5nX6thmqt5ke0unlwtFDn +J6BD7jvKKRF11Za6N5ebvt/odnrO1qWr9+2q1dt4rnsh26cGLzjt+9ki9jcDtN1Dqa3G95ysux+9 +4kI4joHY73MY0xJhkFkkUIKiSGP0uXTqDQvYzso+h9lMeMhqMoLO0I8krQ2SX7XIgZcvexrfFsYl +DYKIcDPUxRaGVTEKUOTsuFx+Hxb627TZ7/72bkcyG+DsQ4JQWCDGlugKplpHlv+kAmsAg1KdR5zD +g1AYZMQTAD4oHqx0UxoY9lMzjXJP0zOTlEsvkt2qWaiZ7HQ5VOIAWbMaj5XkNVapgHv9ZSuPWJtk +3gvvrKH8Omg9HLyQHTxVTlNkjjFJi67P7Pk8ry3dc/ZUOb9zuRCJ+TjTex3zMFNWIn5P+fXZtus6 +1Xm0Dx0Du43g1v9dBBzP6JGvbiWVldTI1nZ3Nzc3FfcQgMSlIiF8YAIUxkCIW9muT0AGgEvZoCOa +AJBoQCMrijSsQXXHEKWUMKkAE6hOYeDlfwH76++bIifImCcufrUD/ys4663mTD5sM/JsKQwUd8fT +jQw5aWr70l7jRyg8ubLUYl9mM8w4NAGHnn2rhI6JhxpfnhD1U50XO/t85+3uK7w8Lm5z0uNk5PPw +/GwH/ze351f6l1WzfvzMtEzdv4/I5/jdDJUyytpnXZt8L2vpfiv+/qPJ/KdNOzCMTwmUK0ZbYVLG +2QqAP0wFgVgMRjAYIQQYgyIGQME5GRJGZgiESDDIyIkyQQd5QSYy10u+qbdAfuD2NZy03/tDevbd +W4usw5mNes4Twvjz7pYYHkITBq9jcv9RkW8fIseLbZSsxPWtOPne4xOscegggdjikknnnqVJ5556 +KKcT6vT8X1LI+V8J0D5PuOVd2HSYXZqwPAAAqSfQQIgSAZECIZCFhwExQ5hI0TYQQBTxgiKnuHOM +HmMhNEh4iMkDojHu69iZ9QiVgMbjGNMDSZOFB+YciOzYcvqISSqdQxIOSwW9Gdq+lZ4tEiMozKV0 +nQ++xHZ58TUOmsgS8E3ebLLTzUMWVlQq/bVS8BhiMyEkjfMS0GkgvZ285WuoA9qeOcTl8bg9z8Hh +2+Nzv1/7XiR/GY8eStcSvZ010oad6eP0+xp3Jt4OCYOStY4rndzgoG0qbEqc1Rv5SLvBN0OwhJXY +2DYKD9cteqDE5q2TkBkNCVzixTJ4HivwTojDtry0/n1VsNp73w/d/BUfp/S830e5yBX+/UsDZzWR +p6Q2hWSx1aK/BgtrHIgBgND11+5iYnCkA1ZFFKHwSrW3UMV5+Ch/Zm8A+YLAM3XVoih+U7LIymyW +6jAaVekVgsbGYgJw8Jff1HYipmeVExw3guEpQShFGHYGtVJKvda6rOI0rRcVQQbaHctYHADHou6U +pN2Vm7pIMwT0CFBhARpJEp1pDDa9bseJDVeF6EDvcyme2yqZht+kVmpsMrN1WnoORl15lmcSsJZB +BeJ+NzVxGbb2Bq96BIZ2vsSPwjiVUViKeJ/9MGEh86MhUikUQSIMRgp3nj8Ygr5BpDRCjJu2gLAP +lRZ13ZAxBTvJmhU3HcY8PSTIBIjBOSQOQ8FB7xsYiLyHFwY+PRbyOJDtiyB5M7umm/hDCSuzXyLZ +O7cqCeHGSYFsqTJw32RAoGm2wRBN6J4/7AuYZLKkGIxFFFXzhvU2qVkRlVMyzy9Rma6Zaz4HgnhJ +P1TDt3GaoRTmYO4l1X5tVvKjedu5ogOqGiGiUEBoDQjBwoUxS+xaUFECNEvHTSs3Nfciit3N/I77 +w7f8/t+d9jd155rFIxxODpoyFhVXMCsgGOoMmOwbdcZi0kjgCy1TWMUEk6EQgzxJlOFTOS0xQjq2 +6lDskkjJNFefUz7MoJ0gowYQ1CU41oH1uD6TuPmXOfwMBkqW7u20MNMAbG7f/oZk/f1KL//cogYI ++GNBAdS4GJ7zjx726cqqqunKP3c60sEU5gMEAsDLfjEhlbCTsAN0doZenFCSu77rUClWIld3zgyi +eC2ur37D4NQiyMOnNvXHN6QD7MsGFhq8Kqnl54ctMCD7lPWGr2D+/Oo7Y3MsYNiFtBZ57RGViqQS +FjGQU07YoDPzSNsmUHwn7lyJbO4dDhX9JKZQ+iGquBfDFocLh9px+LfyQKrJ0HZ8Kt0bI0BDAAdK +PMh9gRIGslU1fsov597Mi8z7/5bzgb7SSLWA/fQMf8jcbzd63Kt4WDsOFmE/HmyMa3eytqUPbWC7 +RfpxatetTWr18iwJIccLWNIiVDDD2JFUGP2NKaZaqX0Chf9J04sMZ+C2tlidasZyiF7ekZj3gtBs ++weSHSneCiPWssAooBWqSqvIr0ZH4xYdOLY7bKzcWltczkyB/HkGSeazOlz/e8bQ41rEbrqgA2x2 +jWADZMyQ2XqWXs/k3+a/Xyv/c1VdpV0i5qjA7yzOVTQ7JnFUAwBpqmXOvRamKB+ggA2Jd5e3QoDr +2WAx26MZDecDOYEj4fXO2QGUYEZPPAJDGBYTtXGar4KOd5269gHTGsHxbgoaO1Gkl3rVC7bLXQJ7 +45FXOuQWOwlu7sB6lM3HyLEBni9ycWbz0sWbOlmEUouMJUf+JcdqSYHavBerQ0SR9rWZfG2HGMZH +GOJs/1ZjsTCABlcj49143Tj9p6n8P439a7BVEpCHwGQqzXEQqMxlAiUVSa5Qpo+06pIKUjb6yEuB +x/nSXjvbOxJbfoyv0EIVx3yMLD0kIlmEtLoxiVfBtcG+9PM/J4oeAb+7kbXg6PJ2tn8GG6EqyTte +P77TLuas7+d7r2PJyHoemVFVUiD7A2m9iLsL1TZMd98oUQ6neMqAL7YMIGnuXCrn80D2GjlQOE5G +CALzQsFkjN4Y1G64rQuWwHLNwvxHTSGl8S0OF3Ba7hm8H0O9g1gv6sAS4oyoihYPwJhQhpm1ANUP +hbW5+64IRKg6w7cIEhWD1rgQ5e0fH3ifdKo+atxew3fscp17atn5PbmEnFXBJkg07w/TkGaThGrr +ZLpyC/AsYyUGlvs71zJAMm9IU7wQp+naZz77RsR8efd7Ly8nn08ADT39jqvp8iPqc+QLkWw4mq1x +qBoR5J+t+xI+8bC6R8jX+GqBWrdrsaTwj90+cOClo246cjsdu/fuq8PNu9L3fIu/E8MsUKGLetqF +JnSY8HbJWIgbnXi8rTy1MBT5DgMtGYQGgAQJEGpvp+PYWDzo+vgf33OhdonKlSruls6IAFrWhayi +3qQ0aTDE6XxXkZ+fTCRPVSJvWDicFD1eU33Dyme4H/3m7ryerphwRQPMjbb6dnjod7FFchgzDghq +jisN7B/oVsgJULhRNVxu/m1B3WthZXqEajDTGLUYoZcHDUHdy5wa3QO/BgNNoQRaU4UJtVqa1o84 +OitL25EYZMSxsM/R40425tNscrk/K0QPNaLSwXUQmsxr6xXMjgUAjgMMtXAYFqxnc9Apc9hZ38ku +DYDb6c8oTldYAKHxFwzEgenXBa5tStO8yafF4z7m33pZ6JgvVDg5N2ggEwi8s0tBBIOyEMHeobM5 +1yCODVMybA601k1IgbbJYxtMHJpGbQlbZVSlR5+hncIgC1XUJnUQX+9KS6GYU2FHg4NnGw6K88ej +xcCzrOrpo9U1fhQMaGVWyJLJDEAxh7dYKvmX9oiP6cDJS2Zo0/ks6mVZoqqJ+HkUOTDSEro9geh/ +3tDGCGpqOx3PCfQVcd/YTq5iaguO7Qs6JyzwwtmIKiKr0qZsZ4+pjSlHXxenwXgtqUzC6jo4QrdH +zq8/BPZ+xbhdiJVpYllFGbDyDLd0YxepiJ6RhYPu7ds2+vBoLvko8BiVRRbDMB19DobPCG1y7pgi +qbJwphASEB1/epPHq6xBjdvMV+wyErTIHc4XGVAxglZCsp6af+0fsobcmrklXVouQd40BXsA9C8y +oJgXpkRaOOG3tNxOJB6P7/O/+/HoFSdB1n3TBcw4oT4mHwwpobkIbS5EH8TQd+NeZ5fbEl5URiZW +1aGvL8wPjBeLxQZLrJEfOr4iqvJRMlENK3gY4fIf2c6n40NWCaHUyyFbhs+YMG+g3gEZEBFmZBom +S7so/YieBbjHMPlTPmM6TRyaa6m9JEg+DObMhkGGD/1ZtemIEgTjg3LtgZF6VrtlcptnvL8+2o98 +66PyqZG7TTUyY5Bzm9whHm0vXtkUFUVVZzz8Bxb1YnaTJBQEH4cIMq3tb80qGik6Pn8Unxc/kXL1 +pUoymfahetrxA5YeMzQP8XV1uJ13KxhAYMpHSaYRCeMWxxEffgUKzI5+N36HsCfOLIBFbl3oTV2r +raNHNXQNXruLxDlw1nDPL+/w9L6fRmcokFqO0MzenxWtcknOVMTygZj0VAfuX2NRpHf7P8XzbqZw +UR8/MQESbwuIQBgjMiMXut3jjvR9QVw1J7YkrzwuhgA7/bpF1cHnxVvh6/b+eueU7x0GpVWmLq6z +tVzoEQTzjTYuvRZgFfW6HaR9uJSX12vy2KTWEOoO2tm77QW3zYQpG2piPi+5gUmt2zZ0nO1VilzI +pLc92HsfCuFSQMqTKURf9jvdZtDlGTtnK1C3hcaCEq79nza/2/cTXn3ayWrJv+5EaREHYiiHkug3 +N8LE2VjC9tziKToZVDPxmVjXuECZwtCkS1QPz9eHQ6DaWLWPqkwPor5uH4Dhijck7nhHP8xJhQw5 +2UbRWztL6uhd9XztqeF0KG1pZGSSkh/D/l/Uchsuns7aRfwdXJCpKUUGJJiGYOGn4dgLM+W5DAsj +a/ssB5VumSkOtS9o9YnZHr1toWhmg+fF09i1Fr4TOx+05h3l5x5x2HBEHKC4LH2MIO5J1KPQ2DAr +zJQhKVbdzAPQBckRgoB3dBhxOILHdiXLbEHhQe516XWO7mswkS0Jy7ebtjalDmJsnYnPHdGzJvh2 +iTYMkLIY7bFxALI61pCnax62G1AoeZE11bS+WTG4ZSWFgqQOQnHTqiZlQhrqO1MiBiEmGsgdrRos +VLvWbN/jbZne1abtqb0wzemM6YMZhbM3eqU1swMzaLIkGKJpialsprnelusRGa6TUW2uMYqzmkzo +U2jVhtrSg6esWEPUfABPAkPljUWViuIq6QDqk5QYexngPPsu4Iq7uV32c2EUsx5mwZQzPcdmODps +0BsIDOIdMCEGjtKQSvQIxY37kq69nSmNyKeyPzkNdnj6ITvDGgP0acnFsy1cl4e4UnfIgHxw88rm +vap52F49AZgVoYjGKTxacIzi6QFuw5soDM0CbkZYqUPTGWksLQvM6hO7ZCOBSfXiP5aCg9fsdN8h +AbrC6FNn9t59c12WOMgkk369d9bAyvqwooUd2+0ayFoBRQEIQvldlkcvsUxuGDccY5RWkxaclE4w +2pE0HzRhnJWWPc2whoAw8+INa60Wt+fDNUx76VT6FtgjX4AcBm8DJMGUeBECyLVGHq9VSu6lRhhm +8FQfBEkb/khLGnOeN6LOi3/JsbXnP6phgUMcY3D8k6cprQaympvgm4O4KuE94H1dXvgMrNJB9PWR +wRzw8J6+Zhz7V1JS1nAGF5hk0ECgv5bdCUKsGhB4htEGuMthZAGYKRXu2r7I23x64T8Kfpzw8a7Y +64qzqTwgOWC6upmhj98/+ObS55/GXUB05Clyy+kbgAzMGN9x+100TtCr6bZt6byKvcedN51KTGmm +94G/tcwLrvfpCnmDd1/aeupp3fRSYT180f6TNIZj6/o+0odOQ+UBrcCocqeawvU5zZO/6AQxL2ve +O2nRjyufcOHtcRF1htfrxEAUBszHNCpyCgD+Ihd6uobIrtj0AoejogsKBDWBBigAGM5eniikl7fO +E5rLzP/v44w+KZvnwzdwkNyHgHXau77D0/wsREZtiq61EJHyJA+JEfsx92dx3QKxzkYU3Edh7fIw +g1sjEgP37qbiDdz3yX3uerug8Fic8IgeaEnn+o/9tJ/HXB0JqiIf7nsBYW86//VV9OhdO8ugVUY8 +rYBQHxAMO9+F2boT8PpDYEBgbLfjPjPrjU52VTOwF01r4No7G8CDQ5cevMa/eOgQS7T8Ug9X6nYy +8lIM14hA3tnAuEXcd/GH7fVO2XRTSHfgeRyMf7jovNGzJYPsPHsEAtoXlnTHBRX3Pc0kRCStJY4M +NPpyrqJUhkl1UbtNgNmeMzKJTxzPI9Ayzdj/6hvSJjIUz8EpR2BRO7jCnIEDisCxiUN5QDGeAdD6 +Ynb2K4eP9pu/2o6btdqBsAFiammVFYQ9lXkUizgLPGl6vjBZKMsKnOV5ul3UpFhmGHU+vvvSgyCY +ZFlAQfro+EZJIKZ3xlJsKRGL7F4rB+DaLM/jHvTrd0Nk93Ng+BgOz+sm/AgD0GyHL77i57MuOU32 +mr1+zDI2+jMY/pifoqXZoSBSoJDD6Vh1oSOIjW+XgF0kjmAHhJL6nN/r6a7YGSVTO3f7PHI7O7Fi +AT7NAL9U6ArZRBJ5LJetD/jJkiU4kmopqcOvRB/Bl/WpdRSGElU+StRUp5Z6TAwXZusRfQzvZx7r +yGMaw12Ommbghliix9QEDoh9cEBkhfF4RAhbjwRM4g5PCXzWX8vErYX9eIz/D2pvKDLVYcBrpn33 +mJX5Pi4wWIky088egJlhY4KNc9jzb/UyR1erf24YGXUXa60HghGhHxPdCqIBsCpXKRkfMuEg9KYR +PBihj1HhHiOGabJNmmx8wlQMtmLBgQmOhp4GIVFP+QQ9V7D1xwg42h/Azzp3ZertREh/gkNVQXN0 +eL7uYdEKOxNGeSnmYiRLsu5K7szUPj+V9WU+ld2WrNYzuD7P8xtZbBlLMj8oYoz/AZCAy6UHgMBw +3dr1ku69ScZDADTLEj9vhBBOmIzNZj/Q7dhzKkZF6jH39BUZUQNltjNEOzP23RIZTzafM/UbFkhd +o7sKsPYxW5i8shNa/5uT5w5KWX+YbPM8/v/A8BJpZZ1tiCVGfOsIGNtptJsbSG8cDVIXFBUbAXwN +e4PN1x6B8Uov8BpfqaW97/6W6975h8z7trI5mTnPVKKCX9MQLF58HLYbINGBe1GcfR/6A2z+7Ui8 +J0ohiHHVaGMbQ+o1882UMbkQSlD8idfPOf7+OcZCWWbVtwJhnrpgbiQeQ5PdUUOJHD2wRRKSP573 +pEcGXPPd+Z8M8rs6dI4g2w4W0hgjUDQggJzVDj4E6Fdy3LoUCmGIjZaKYqyVOnuc5FxIlElDJFMT +aZYd3M775zM/ID4pV/NB5qAXpffDcLqq/dGZOF0Z+gFbsi0fz5m+6HldeG9Mdli6k1Bs+2EVCkiM +g/LYK0Vj6JyGtHnkHAWnCzm7U5MDu9og4cvjGrR6iozRDP2SWIlIign/AdOQyikGqQ6vG66SoXbu +lhILZKW4rWg0ENNI0lDTAJ04MGYMwDPADGVWYVzU/miLyNL2HvCAOD5lyDpDKg75siXrcvLHo+H2 +ZObNV48Q8pAJ9UNaa4zRvLpdw4e7ZnNNslR7ORP7ocHhC+VqUfR87cgl6P6ZQj8LHDOyty5A5S3M +1lmWX1vVfJs7N7I6DgXTJumCb51K9Uop0NU5/gcNDBg3hmmh9J4HJkRQiBCANcPZDA0+CQIPY2m5 +PSp+SYeOPiUPX9dDvG7yC8wXoDMq1iGrYb56lkYMXC4NvRmHf+pM5Mv0sYzu+vK94R4Ydqci4jLG +rtv1vyfxPeKgM0qSaE9//M3JSQMZtPT+ofJ5ikJG3D9yoweaRbPcl+S0b7a7Ae47fEUkpj4sdT6d ++ccQdtSI+U8WkKTFOqv3UUJ3MrQW9QxHakZHmj7THb80Pz/GY5dwzYZpTDMOCnmXGMzCVxGYcX/f +ZwuTubPY36E9VwdfwzmDX2CHWdDQrAUgpF7VlcMPLYptZzKGGg0EuYYpEnTJQi+Gb3dqa1pkQskG +Oeuw58jah/eZpvD8vJmHH6hgbkIDlQimzcnktG0ccOw48NCli2ssqLO6tW63YqrU4wWyRRHo1wKh ++e15SYZDFsmJLiie7mGshKB2oMIBSYe/XSViFlzoXwPIR+JCti5JJrMWWQYcSdgzzAQmyv3sOeR8 +ZF5lXxlEFwjSCf+OegBcRaDWfV1YwN1D4oaESHkr+Wxis09MxjOpif7INRb3JC99YtD26WMaiYRF +iHrWBC6hrBsMijMEB9x3WCHvWB+O/+QecKjO7i5GDuOrdQj3Hn5iSsPgCBpk2VQ2OmasYmX5VuUA +Hnfh6kHJ6kkEfnIUOb+LOHGPY/P3Ig1Gc8cBHWQKVbVqGO4rB4MnMz4CLpxcJ7v2Eg0MlLy9JO+W +BEZEDN2YaMBk6REseM+9+ahMgBah1XUW/ktcteO3wt0tWHMhiucrdhpFud+q4a69TSFdxkeC2ouu +jRQYl81oMe/NIXTm4U8sWDD4UTDIiWQWTgQoHiTkkZApC1IIRB4ioQXCmkP53h5NFaNugyaA4hIh +OiQJImbdjWG+2wCd0YgncW6OqxBF8jsXIqnFLNlFA8LukEN3oxEF9v2xPdZVFpnL+lKqfHYbVrQY +fj7sqW/H7cpp3TVLC8hhPBH4RKApa4O/jWs8DwIqdp9+mfKKapUGjudpNB4ozeHB5KnXDCcsEkTl +CWTF8NiYcCBnHfb149ZApDA0mirmliGeCfG4yFPm7bQA8P9x6VLu/ofxtvg52O3M6DzdXts/lGd7 +o2Ia0+3fR7H42tkCbSexgLuJQ0rjUDcvVZWL8OgcXGnCoaIYwjiqHT99phVdGHo0+k2+B1B5jx1L +dSlVezO28dnK5na7MJ3Adqflf37dVX4M6S+1YuNOd7AuaiPNRhMbuNYM35eLoKMC1oj04SRTPuOl +F4bInrGByr322r3i9z6CqPvj6SJuY7hayRgYxie/7uI3sVeIen64/LsnSv0qQyImKbhYWA1Ob0OA +BleyNC5hh9vhTeB8PKZIdcZC2q6g1AsLEQIZoLTXTmQycjsOZTfB6H3uTmvZ+fpf2mPg1LNXkSBO +DxAuy8WQKPTuxl4fB5vvig67AUU9T53nfWKww/kKAfk6oP/mxQQkF0bQOGuMUwklYKMpSCP5H4+c +TKVCldp49MFGwj6I0uQygMvr3pG0Wq3Lhe8lbr9w+3H1bOzch+zGrh9Kd/6bPd8wUNU5b4vwFs86 ++Riu6+bc+loU1r7Ch6Y38yUWdzFTvqR677UsWNz57gW+l37+buDzPanB4Pzp2jlkVRblc6+tXYx5 +SuhBXS5Iok4vdxDA9rit+S92O8/KcM8nyWKYlhOwSDVpYVn3/c9zzNQGgMwNaL8eZPh+N62xoazW +a0OyjZnDsxEHXPRE+EQnzoadSvMvyF6ZGV6hIOgIQdDKYOvQwFY8u91Wp5lkZpDEGEbnA2JGeoMU +Y+kg5wgiFaePuBzhf9+/N/RwaG3PTmWGdIamtPURzqEH50heFRSsEiQ7hVafxJsaAyWHiukSJYd0 +nw2AagTjwThleDuqxQh3Ij3pDcErE+3oa1A5mYBVPxUqROjZ9h0KOfhW4LHD4n9fSqObC4hvawOY +4oj9FEwOrikAC1Idt+CnpPRAN8KL7rK81RqJldA7ZAmmZGy/n/HS/0+d+Icyx+28xjMe/Y2xPlMF +2rNk12mu8D05h6eWX2BiXC/YOaaMxtvWBlpbEsIgo0tqVpo7Q34wH7HtfVx5+VacTbGfvBwKIxu7 +33fWCys7azkGktQ4bCQ0mv2oU0xFZ1gjkoBNIWl9DVml/p1+vJ65b6zh+XEsa91WdkIOrQY6F/TJ +whWdDrIEjaMJrZ/W/hCBeaozd/Jyynx0FofIEAjoObRtmuxkXwjhazUCFUw7Htc2Wl8baG3MwuU5 +b2rSNYwjp72PCN/TGCoK9yXlzHoeh7XLOQX4MNRdEwGjMThmjYoJ0ZwKdtRBzQRCT/jS2liDzwbc +Q0dZYP4z+eYfxyNG8i381NwNgY46mDTcr6C1G0awZ5EQwrg1g6XyD6+2lnF/qGZQfx4/ClsHrcsG +DbTExubhtvZggrGo0SWa6NGVegw/f0PuIQW0kmau/kSSISzmdsbYhoqMxw9d2DZLtb8Fu4EJJHVO +OKqMFkRdv7vkep9ya6xgqgoLO624wT3jxbXtW3fbQjM6dcT9z/k3HfnNyQzdLE9/nzm5MkOWu8kJ +FLRp0gS8hWSoNgi2xeDQL5mpBkM6r87edNnUGtDBsCG0dHQ1HBK6cxBrkS9Xkqr1D8DqkNGtOdsL +R3GNcLlP8ibJESE4YgE5rHOTBBmCO3uogNAskct8nJ8eNwDzbnfh8XF2odddw+dka/+C/bC+VBiS +1AiSl49/BCqK979H5lIWWNJvLzZrBuFuw3XGTOO1AMdoRnFtMbvY2RtUSUB7IoDK168Gx96YwZtH +dGRnNEojHy4WfQRpgzZCjVy6Q5NtbTDzSVAM25XG0RBTCW4zybQYkiazE8+4W0rFkhQ6i9FwCDto +k1CaRIi+a20lWiwtNqWUHlHuhvHLJRRwNaNVHmuHvG5u5k4M9v6jqzkeDxuV8NuaHdj4HhhhyoaB +XWMq0ZU/YL3MHy8xaMcj+iEr3Tc9xc/Dxenk/X9XgOHZfMRCFka7elXx1gU1YpW0LolxY4/DxVTJ +V7d+YSDJjieqnqQEY91EPloSVJjhsrnaGHS8SEzkcNPgPz4heoYfGRmIpoLIGQB4qBqr9dB0PBg9 +3RxbCUN26cgxU9tufydG2aFtsnkRbmtQtAZZCucagOF7Da2Wfha8obsjnfqzYQVs7dcDLQmfTd5L +jYSXKr2eqAPGKxTin29xIqMREN4zfbJKqI5iqqLK1Wfmsw9o/JMNFQA2MA0RT2afvYLF0Ss61Mcn +ZNOeoLxXrH8QQ1PV2HVEPmkO5Gc1d2l4xSeJ7bXXtGaPECBh+/L4Hv7DzfHgLt0md78de0qQfdWu +881D5RxsvpUo71rWHa/0eUX+/91XhIe1Cc8o6Ii4qW6D3J4nt81UmtDnnSIxogsSZdkXQqa8QmaP +hv3G067Fiterk8MImVyjoqZIJAQoYWN6a32FQ7LCtDTuFG5eYHhH1AZGAoQD9IE6rqUOaYxRGMGI +qI5OL01J4iX3kOlkkWm8ADdKFQQ2K8gOQGxUMj3tJfWPyGcS5q6c5oB/1sQzPLPbAhDJtYbqVpw1 +xfAsef39nXVP0QSr3hm9+oY5IMhyQxC7oA4oDBVs77Mm1JpsUmMTEdRwaEU1BSBVdSqifPOtoNjq +6slcc2aDCjyD4hp6JOPXGptW8sNRt1KRaGQHWAfiVlAzV8lSuBWFrrCpHTUbfLMWKvM33/DjcCcw +bRBDRBy9VvbMK1/neewCGr5wDBBsLCaGkeGY1tKhoegQviFekvw7t8vPO4u3LWpLj7YyB4HfxZfQ +mFjCp2nXKBjMkltNmjV7GoLK8ONuFrFXSZhsUrLFYFdOOr0N0IIbpJErAGczEl7tnrPzu1xrAZgs +5GXtqLDeMuP1zLlUb01oR1ICKcHj2ggFZwnKdIg8/s9o8RWIhxXyELQ4dlWadjIj8V7CpSeGooJq +DVdXwMo7az7Nh8PyeyMdcfBcuOAGgaiupR+EIaPccbPkE09LWxEsacM33U1rmNSsmbDCZmZyxwO3 +/RykzMGD04DUwTBKnXr/3iR+eSF4RzN7RDQLM2eOnLQc3zbkzlYy+IFithFYHI2xx1AkWB20LVmn +Qp4beJyNMOyHQ4nHZbfSZ818h56WMyRLi7rX4Myy4o/FNfgdDRQyEXzzo04m9XbgM5pyeBX0W41S +M9mCgiHcOQJh7zFsnaRVFJZ7PyOrZqHLwr5xhtOvYMyOU5mjMoEyQuef0BoAKlWFjQYANGTFMPCI +nQkALYsEdjeMqlQJRPASpEAWIjgiDwCaFFhVwWbV/mAvBmXu3R/3tPDMAoVrgX3keMfHuPOAfk9k +guY6B0QmhRa0Vn3NfQ3dvCsqYwBVC0GpEjFq10d4qFM++iVN4g1kO09F4amL7qzxbcl1pVIc4DlR +BRvCJBuKwDA/Agd5lWwE77YoIsA6cDgdhlF30lTB03AcIc/tNhQkwMVm+NydysWfkmlLj7CCb0WZ +m26k+R3mqpN6kzehmMUY3CPuQBoLvKb6qtVfhH8tm2Nuq8BQVSkEBcvUBmCnyveVCBnlxXsuw53m +/R9z3R4XufP7lDMG2H34q/2nlTk50heiHwScUPs5dhYvTB3in/nP34+V5Brke3RvOqSyPdnrIyx5 +SLjGmUUD5qK1Qx5Tr2HgFOv7DU7r1zN2XPAuBdZ39JQzix0ijb0EUdva5H7UcnQ41zg6vou62YDX +A69bwjODVoozq/OMg6YMZtxCSWQOuAMbvT590AARd6v6hscQB8Rs1cz2wOHUOtvFYNzBs2fW4qcY +6rzT2MHsdE7XP73yVyfJ1+bzfhBbEvvTMAFPVSzTWgzUTJBI8oKBRBmuj95k9ew1GCguom3sebm7 +PU7xRWH68UaN0PIKvp5c+uRU08uBec+VSZ2GFV16pjNx1Uz1eP9HnTDSuJxqyTcIwMRaVEfZo9uv +8/QfpSDqfx9kcItB+9UIDNMdBtKtC3ELyiMfK/FCP7sfiDWtd5BkNSW/eFkPXboOqre+wsTKN5ek +f2BtAQegno7GZC85jgGGucuiPgizKImQhIX2KFXjkcsRKBEQdMqR1uJDpB4VtN6/TnjIfCc+cZBl +eoL9isHEHvu3jJbRmuXyugw920u76yBy1jEMAx+halMIKRYhTTd0zPBxnDUhzxDhh9Yvd/L+TBbR +v1kaHjh0t3ypgd7EmU/vSWZCRlZWQ2iATEfbs4DB4bGNDJgEQcNhkloxsbCg4PEwp3qNEy6iHdKI +eDpoZ0J2h8ClBTIk9pdEbYqO+ZghpImlZdIKUVHdD8+a1dUKo1b00GxTA6GiGTGKa3I5Ogxlyg5X +S7+/DXHUdCXMnQbMDHaWyjWDYUdl8UZzigylsKxGW2kjaXLcJ/ENwZeYXCe29pDUKB1nrCFaRkgu +pgTsJEJ1DrSpnpcxs6fh4Yxnp+tL7cw7pmow3IYGJxTJbyd7A0mlgjf/LLKxVnf9XIBaoYkmwt0r +TYuE8xXmEF69H1p8TTOZoRvIkwc1NIIYU1Try40Qh4JkGt1g2Wm1x1J0cXw3hTZ+cHQ2rXUBtnut +tsf58R+TTq+y1WHc0LTH2A4RizacyM2GxjZmEVa1IeqjebZJDawgGayBmyjKXUXMOz4/FOR2PXY4 +iwxv7amteMwHLHPSsN0yhQxGUGSelMZKBzdGy7gM7J6qNo+jTZB1ScM5xGHDAZKFhztLMUtFEtLR +olRS21WKqqUSamiJx2d0wPQaofDrgMpoSwP7f2oC6n95isp++SPGYMZIwFvJGzQmEndxIu7CNWOZ +LnYu49Yj36CJUzMIWBrsMQtEbcSuEqUG1LitbbLzwQN9JNzj3vnEPq+jHEwaCJUZCooBubLFInBD +lCv+jR25MZCRaxZ2/9ltPxeu7LDgLqx8N29OTwsgeDXqlDj9tSbsfFXeUdu8LZvtBiPbZKllNBPZ +4FmpbyvXh6/q9nLDEWWAGtR0YZRCNWK3LvRmlKoJ99TgHiOIzn893DcI0KPXN4zNM3QNrXBvk0MY +Nk1zmjLfOCQNrph+SPSTxnghcj3jwpQy647UgMZvjcbvZGYMjIIJgKJoYTLKzvymWH6aHlRAwCRC +cX3338U8O9zg+NRcWj7SwuMvWq+jbAeIOwIbcGSe85ZVkSrf1dM15JwgIQy6eKoOKjJCKDCBBQma +eId9Mg/hfvjCKxhs98HYOs7BhsZFPN3FBKhn56GlwLKzCyZ1NRxC6M7MtlQ0Iu7eWV2Vvo8CuXsa +pV8OMa/6zw+zryK6ztqWNso6TSnlzod4yjljp/d4/c/D6Hfui7cPkWRlx4lNN5HMFAZSyYQHKyEE +IGNN5GmOEpN4b1d3UZrW22fONIOutUfV1sOpt8Sim8Ry6JW4hNifysGXzqzBn5zj92UfxFNKwR6N +dtZ+mc1EzB0oMJmi/PeG1kGyrxobK5whYIrkBN4WvijNoJ4wAOQI0UYee0bTNLAxt7OCsSfUkvkx +NzqrUKcLg6EL9RUKvx8diLMUYY5e47HukTRctEruriwpUBQjELcS22jNG5poGbS5tnJzCHEPE2SA +6/1b+Rk9zSlq2nmZZhR8Ag75Os6C6Zr7vg+g/D9zwcrVGPWYMDG7kXMu7UXKaMhQJJZBltjiCCG3 +ENJbJWAiQ9jnGTpnGEtlENLXDiuAUIDFFBWQUUWJbvsqcI86Xk/da4OwpR4YqCykS7gBjciLCBki +QxL5Tlbjq5UipK90zEwx9UV3PWx7VQw6dpQEoRGyg704f6GG4Vq/vTIwFpGtwY73dioyqT8PGCZ5 +UEXrUITF68ghpIsGD3CWaAnzeCi8yhA5pCwgr7jc67FLS8z2nCOUY6VpUiyjiTrd8ZQZfxZz3luN +bw93Kx2zGdwlxurp5mXH7m22/Ds+lzfBlkhYHMchbVga5km2Z8IRqZ+VuSevOTysIQ37Hi87XkPv +N7ws/JEtOgLbDrj9B5YOyoQiqZovb+ZNwIYQ4gUmjMDF22TPuszCbLNRwGYIYwYDCVNXUPrXvdPr +5OiyQxNX1H8X6T9lMzqRegVRrgg5D82atyVclCPgsIfpx2lP1pYR/c3RAVsGMy2cx0j6aggf3o26 +kAQNADaHqwSObLm6rYcm0fG4hNuSMgd8elqdIxcTJ+zszxmGnjBhsymJBEga8w7MOLpU9/bcOqYb +l8O+cnM+W5cYPcLe33cTaiWXgePO4wpRRmfsnDl+ZRwKki7yzjQJkt135w7GPMJKXByhZerQIZED +I+5T+Cvuoy8lRMMhK+8I8lCYZGDZGnPaJ+D7XqQZO3Q2gGxtjGPlQLWS+FJKyQub+MR9nFIl7LxM +IIlsv0UjP9I81HhhAWZ3w0arOEgCK9Yyox0DbPu9+vYXejxfa5JuAKHcj+DhO4/y+Rw4/B1/KMyF +3QGI2q4QxlMIhjC/uVuGYwbo/1HgYxjsu6vAYAYTztE/uVIxxOJJUb/wXKdAUsZ6/0bFSKIIG0Yf +ySEWd12mv3s6Ej5G0gsGFtojZagSSAJe3IK2XhpDiI6HJlNjGjR0aZJB4h7adHPToGK8g5BB8ShR +NvX66yCsF/f7not4okyKAyMancqLJGXn8P5paNCABbLNwyyXiD5mYV1rX3/Sgd8x4YR5uCd/+36+ +JTv9ZtZ6bTt9wh599EmGCiwRgqnoGdSw5CcRDjIdWhsYoKos6ZhWSdsmrhVSBKdwc5w8k01sm512 +TAKsnuNLPGa9Jz9vM9Z1G+clOBU0tB6Sgs1xRFVi9JKdfiamdqEwKALqEl++jhi6PA+i2WIsIolK +EVSpDtGhTnLPALJPyvMMB+LFvNuZg/ASM61k4a7oXxoZnKCwaNxICEhI10sdyMdnJ3G6hA6bcOVo +ma/zMxstBr7eG7Egi54Q1joEcMVFW6+zgkSlKmNK7xvyyZ4NtVAskZEqd+FYndBkGgQVDicE0S1v +vQ5+sYFM0Yj+vYMBDBn/bYVVW7R9ypW+PGDH2jgNEScpDIzIHWLxDr+vXRULa94ivWFY30qaocdI +KqwCEyWJ6EKcyrFXcCsAqPTgVDHReu9Nnwui2Ut7EWeSKgsGlnenkGozLe1o9MvzboaaZumXxj/z +YuA1oaHGtYMeOpubDqad/uL4gnEFmVCNQMAdRJqsIVjPaE4ZGZk623DkPnkTZA8VAgAZJiQ2bKET +JIrJ6uKM5lq9Dz/hPghmjHfCmbKWzUikxxzC+RS2w9tbprBujdQaYayE20Boe+yLrfHiabtBYOJJ +hmBIBOh0t0d2ZKNTHTzMYnVcLtcATZZWOf4sgHPsOFtpIsAYQYQVQ4GQOOhcsP1IppVIaVjdDOgP +8x1u5GPjuYv4KfbueRY6GvPap4kV4XgWiVA6AQd0o6JB4mC5YOBvp2CspzCQBZuTdTiETtvYAeGv +xuMsDh/a1c41LB67TDlW1GGKyf/lx1889jNtvAs3ZmEEZhg1PgZE6OhvrtR9lxkstq6w5A/fTnKG +DcnAvusX6bbwWWvGZh9nCwfA/wePryZ7fIZgtuBSIgMGC5H3jUFE68tAKA6s9+cwyKz4WaEgr7Np +fSjlA0i20lLzO+CVrjdM+Neo5UFj4p1u2pxO+1nu5wjMn1Kxz+WgN46p4KhP/dQnl5FuP3Kb53ZR ++5nHS4yGgNSu/PMKTmmHPMf1TW8pQFzFL5u+aovsoS9qMa49EBeTI6NadNjrcc51X0S9XM7KBIHU +u0Zzk0X2jGPZFKEK5PEdAN0tiyQwFJwhpOs2UNM3FPjtaYzAKlhDnEJMoLIFYkUTKChE7TAmUNwO +BYWhSaxl840ehaplgVzgiOqYYQ9Ks+LjRM1uOu93kKl5WUz5tigiDT+EIw8IyvenPmcZWgqJZYRh +bOV5FC4siXSrKl4viG8x7ioS26vpaKaNADPM3GcGZnlsgcyAvg/pnin4lqfu2pMCt1tJTwMiC7eQ +GLAMlfU6/wcMZVA5pVbqUtd6zcOKxuHtI5YI4UGMfsZsL9IU0X+i4FNPjVOyvmWPtUFjOlxKTTPo +RMns0U7DNWQmEBqUp15xGQW7FCLfD6G+bsWagHinE1Rqm2KoKSEtf2ModHOs5fLwTdnjYBRkqW2U +GEYgUGU3buRAyGH9j44y9vthtM+0Gyqt5iuSQwa2kH5A+HNGWUoQ56qIJJUGmcRGDPVB0PgbEJFV +H5vBStDErRwA1BEEjf8ULiEyoK9iujM1csNy5goth8UPFeNRckWwFqcZ326W+OisY+WFdn0uYHDl +8X2ZtthhK83xNAWNDvlgcNKFyIInnLU5JSKrPQ28LdvGhwsmJ6lBZ3u45+7xkwbaVg6cS4xa1Xfb +a9A3OShRNlpp3uDDON4c2YHd1xw9lj67wdhjKG+MqThEkSV4aZVDIMyhB2mvJ814enqX6sPJ0snt +LyNeGebbad58n61/f0pRwoRve3PhB3AmTBhA4CISPSkYWPiNaR2MzGNEI4tBMHkVxuSaqJIOTxSe +3sFwJBSZpcgxyfUkSqltGTogCgkIZ2E66Dg48iprOhQW0F4tKLbIvXYDCY52Ar8ywnjpSJ8e0R3f +xDQ9SQEaMb61DbF0oDLy4utK+NBl5UFDOuwwh+y6SimCAfGN4R4WVC0jFNFAolXfsnxzJQgY/Get +tjbMca0mEaMaU6SFJC1b8Fl/PIVI3UsUjlmsvH6c8L2iXcgWY4fH4OSnBGb032EoKgcdm1wgwGAr +rKyDdv0/D10c/k1T0YhYHWzHgUGNCBYmgymlJpBvun2Nk6FY4EQ1tGSiDH105I2Yy41XZpw9PK6z +rJ/xruig5a5CjUk2HPmqMV6cckTkVIhNW20cZGtr5gRykePXXvtlDS21NIbiFRA4KeIZzlG31hdC +Jy/16liC+A9Rw02pf4jID8p67noRAFx48/Ac2qgKwydg/JUEazPUJSQ9W4bM03DiQWMgBnnXxm6M +aQTvn09SclkHXgmMAUxwIuzKGbNw3NVPEE3o7y49zD4HGyrR3CGI0xDWMjiMhAIRw8zliomFZ+K9 +zbzu5sXGjRsiu4yzBKc77Cs02BadCJ35zQl79GFetR3vlfMUp/JV4evRiD0ifwfRvCLLoLvsHoLh +Cb4/o0vNfQpKBjnBfkiBdSwWSHztAIo+AsyWzZ7pnBY2tWMZtY3ycgYLUhtPYcGSUxaR41PYyky+ +cHb0Txc21aFXQzkQ9tD1k5P6DxM3zDlPenkEIqxblt3leUw3LLzrmyFZAzcZYWc6YnORQ79dSfRX +WqSmQuvMXlqgD/3UiGQCb1an/jZlQ0DDtW0Mg1qkEcz1SCWYYBu3Ku7Wnct76Mx+rUpcYC1PaxCe +GEe0Ye3Z+b58GIZh2iSO5YSOxhIUjllWlVoOzhIDIeS9yBuhqEm+Wz7DIvbpI7rZSsmldBiSOY0J +50JDTdF/17gHd5PVnz3PkUxnFpbQe/GljMm+2nyiWYyi8se1Pgs7Io3KkZLKm60QMYsiznpSC20N +A23IASWiCzMKJHy9/tZDHq/WyZW90eb8hPGz+qEshg7JlMRA2hQH7ik3BoVPPUXa52z7veuLlw4c +LZaEa3wsQ5ttx2JtOURDuGAnZwKVqI52xTEwhYsVQqHWiyC+CDIeNPD3GChUhhuvm8NZIZooKdP2 +luZ1drBvrWNK9MEcVi46HN0hRBUY5y4k1l8eSJSMtyC2KiF3gy3t4y6CxJKW/hRHtetmsFBVjWrv +IpLpUMeOpV+LBbLl66RKYvVaAFgtq20zJasBqwM1oIHJStQH+TDje7mRKywsK6fCDqbZR9f1Pc/Z +8Lrs35uLnZ51zBJtIvC3hGqKIM8aSSNbpZcg6I1r67W3AyqEQys2FXlkft0eUgVDA54Ve2/r43ee +NlWI4PoQhb5gsxg2PzBnkjlwMKvpGx+wUapCCExUMJNYypmGQUKw6JagK/0f76kEl8o+XBz2UNb7 +soq8u4WmBbcw+gcf2vJ+Ci1MCHdJaw4PsTRCTRzq+y6/mzU4N7/vGVMZUnhihjvBuvenHzyOz0IB +6CVlJCeT3icVNkYCA27RXj5vuPV+ed4VQOnwt5Mz7KQ/AwfQJKl6SZgYCYMEhYQ9X+Xk3/DTO8s4 +Z4dtCOzGhtGMgBf/xdyRThQkEBpjdcA= +==== diff --git a/sys/contrib/dev/nve/basetype.h b/sys/contrib/dev/nve/basetype.h new file mode 100644 index 0000000..fd38148 --- /dev/null +++ b/sys/contrib/dev/nve/basetype.h @@ -0,0 +1,281 @@ +/***************************************************************************\ +|* *| +|* Copyright 2001-2004 NVIDIA Corporation. All Rights Reserved. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL *| +|* TO NVIDIA, CORPORATION. USE, REPRODUCTION OR DISCLOSURE TO ANY *| +|* THIRD PARTY IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORP. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROVIDED "AS IS" WITHOUT *| +|* EXPRESS OR IMPLIED WARRANTY OF ANY KIND, INCLUDING ALL IMPLIED *| +|* WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A *| +|* PARTICULAR PURPOSE. *| +|* *| +\***************************************************************************/ + + +/*++ + +File: + + basetype.h + + +Abstract: + + This file contains the base type definitions used by the networking driver. + + +Revision History: + + SNo. Date Author Description + 1. 2/7/2000 AJha Created + +*/ + +#ifndef _BASETYPE_H_ +#define _BASETYPE_H_ + +#ifndef IN +#define IN +#endif + +#ifndef OUT +#define OUT +#endif + +// +// Useful "types" + +#ifndef NULL +#define NULL 0 +#endif + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 0 +#endif + +#if 1 +// +// Don't use as these are going to be deleted soon. Use NV_ instead +// +#define VOID void +typedef VOID *PVOID; + +typedef unsigned char UCHAR; +typedef UCHAR * PUCHAR; +typedef unsigned short USHORT; +typedef USHORT * PUSHORT; +#ifdef linux +typedef unsigned int ULONG; +#else +typedef unsigned long ULONG; +#endif +typedef ULONG * PULONG; + +typedef char CHAR; +typedef short SHORT; +typedef long LONG; + +typedef unsigned int UINT; +typedef unsigned int *PUINT; + + +#endif + + +#define NV_VOID void +typedef NV_VOID *PNV_VOID; + +typedef unsigned long NV_BOOLEAN, *PNV_BOOLEAN; + +typedef unsigned char NV_UINT8, *PNV_UINT8; +typedef unsigned short NV_UINT16, *PNV_UINT16; +#ifdef linux +typedef unsigned int NV_UINT32, *PNV_UINT32; +#else +typedef unsigned long NV_UINT32, *PNV_UINT32; +#endif + +typedef signed char NV_SINT8, *PNV_SINT8; +typedef signed short NV_SINT16, *PNV_SINT16; +typedef signed long NV_SINT32, *PNV_SINT32; + + +#if defined(linux) + + typedef unsigned long long NV_UINT64, *PNV_UINT64; + typedef signed long long NV_SINT64, *PNV_SINT64; + +#else + #if _MSC_VER >= 1200 // MSVC 6.0 onwards + typedef unsigned __int64 NV_UINT64, *PNV_UINT64; + typedef signed __int64 NV_SINT64, *PNV_SINT64; + #else + typedef unsigned long NV_UINT64, *PNV_UINT64; + typedef signed long NV_SINT64, *PNV_SINT64; + #endif + +#endif + +#ifndef _AMD64_ +typedef unsigned int NV_UINT; +typedef signed int NV_INT; +#else + +#if defined(linux) + +typedef unsigned long long NV_UINT; +typedef signed long long NV_INT; + +#else + +typedef unsigned __int64 NV_UINT; +typedef signed __int64 NV_INT; + +#endif +#endif + + +// +// Floating point definitions +// +typedef float NV_REAL32; // 4-byte floating point +typedef double NV_REAL64; // 8-byte floating point + + + +// +// Bit defintions +// +#define NV_BIT(bitpos) (1 << (bitpos)) + +// NV_BIT_SET +// Sets the specified bit position (0..31). +// Parameter bits can be 1 byte to 4 bytes, but the caller needs to make sure bitpos fits into it. +// x = 0xA0 +// NV_BIT_SET(x, 1) +// Result: x = 0xA2 +#define NV_BIT_SET(bits, bitpos) ((bits) |= (NV_BIT(bitpos))) + +// NV_BIT_CLEAR +// Clears the specified bit position (0..31) +// Parameter bits can be 1 byte to 4 bytes, but the caller needs to make sure bitpos fits into it. +// x = 0xAA +// NV_BIT_CLEAR(x, 1) +// Result: x = 0xA8 +#define NV_BIT_CLEAR(bits, bitpos) ((bits) &= (~NV_BIT(bitpos))) + +// NV_BIT_GET +// Gets the bit at the specified bit position (0..31) +// Parameter bits can be 1 byte to 4 bytes, but the caller needs to make sure bitpos fits into it. +// Result is either 1 or 0. +// x = 0xAA +// NV_BIT_GET(x, 1) +// Result: x = 1 +#define NV_BIT_GET(bits, bitpos) (((bits) >> (bitpos)) & 0x0001) + + +// NV_BIT_GETVALUE +// Gets the value from a 32 bit ULONG at specified bit position. +// Parameter bits needs to be 4 bytes long. +// Ex. ul32 = 0xFEDCBA98 +// ulVal = NV_BIT_GETVALUE(ul32, 3, 0) : Gets value from Bit position 3 to 0 +// Result : ulVal = 8 +#define NV_BIT_GETVALUE(ulOrigValue, bitposHi, bitposLow) (((ulOrigValue) >> (bitposLow)) & (~(0xFFFFFFFF << ((bitposHi) - (bitposLow) +1)))) + +// NV_BIT_SETVALUE +// Set a value in a 32 bit ULONG at a specific bit position. +// Parameter bits needs to be 4 bytes long. +// Ex. ul32 = 0xFEDCBA98 +// NV_BIT_SETVALUE(ul32, 0xF, 3, 0) : Sets value at Bit position 3 to 0 +// Result : ul32 becomes 0xFEDCBA9F +#define NV_BIT_SETVALUE(ulOrigValue, ulWindowValue, bitposHi, bitposLow) \ + ((ulOrigValue) = ((((ulOrigValue) & (~ ((0xFFFFFFFF >> (31 - (bitposHi))) & (0xFFFFFFFF << (bitposLow))))) | ((ulWindowValue) << (bitposLow))))) + + +#define NV_BYTE(ulus, bytepos) ((ulus >> (8 * (bytepos))) & 0xFF) + + +#define SWAP_U16(us) ((((us) & 0x00FF) << 8) | \ + (((us) & 0xFF00) >> 8)) + +#define SWAP_U32(ul) ((((ul) & 0x000000FF) << 24) | \ + (((ul) & 0x0000FF00) << 8) | \ + (((ul) & 0x00FF0000) >> 8) | \ + (((ul) & 0xFF000000) >> 24)) + +#define NV_FIELD_OFFSET(TYPE, FIELD) ((NV_UINT32)((NV_UINT64)&((TYPE *)0)->FIELD)) + +#define ADDRESS_OFFSET(structure, member) ((NV_UINT32) ((NV_UINT8 *) &(structure).member \ + - (NV_UINT8 *) &(structure))) + + +#define NV_MIN(a, b) ((a < b) ? a : b) +#define NV_MAX(a, b) ((a > b) ? a : b) + +#ifdef AMD64 +#define PNV_VOID_TO_NV_UINT64(x) ((NV_UINT64)(x)) +#define PNV_VOID_TO_NV_UINT32(x) ((NV_UINT32)(NV_UINT64)(x)) +#define NV_UINT64_TO_PNV_VOID(x) ((PNV_VOID)(x)) +#define NV_UINT32_TO_PNV_VOID(x) ((PNV_VOID)(NV_UINT64)(x)) +#else +#define PNV_VOID_TO_NV_UINT64(x) ((NV_UINT64)(NV_UINT32)(x)) +#define PNV_VOID_TO_NV_UINT32(x) ((NV_UINT32)(x)) +#define NV_UINT64_TO_PNV_VOID(x) ((PNV_VOID)(NV_UINT32)(x)) +#define NV_UINT32_TO_PNV_VOID(x) ((PNV_VOID)(x)) +#endif + +#define NV_MAKE_TAG32(s) (((NV_UINT32)((s)[3]) << 24) | ((NV_UINT32)((s)[2]) << 16) | \ + ((NV_UINT32)((s)[1]) << 8) | ((NV_UINT32)((s)[0]))) + +#define NV_MAKE_TAG64(s) (((NV_UINT64)((s)[7]) << 56) | ((NV_UINT64)((s)[6]) << 48) | \ + ((NV_UINT64)((s)[5]) << 40) | ((NV_UINT64)((s)[4]) << 32) | \ + ((NV_UINT64)((s)[3]) << 24) | ((NV_UINT64)((s)[2]) << 16) | \ + ((NV_UINT64)((s)[1]) << 8) | ((NV_UINT64)((s)[0]))) + +typedef union _NVLARGE_INTEGER { + +#if 0 + // NO UNNAMED UNIONS ALLOWED !@ + struct { + NV_UINT32 LowPart; + NV_SINT32 HighPart; + }; +#endif + + struct { + NV_UINT32 LowPart; + NV_SINT32 HighPart; + } u; + + NV_SINT64 QuadPart; + +} NVLARGE_INTEGER, *PNVLARGE_INTEGER; + + +#ifndef LINUX +typedef unsigned short NV_WCHAR; +#else +typedef unsigned long NV_WCHAR; +#endif + +typedef NV_WCHAR *PNV_WSTR; + +#if defined(linux) +#if !defined(NV_API_CALL) +#if defined (__i386__) +#define NV_API_CALL __attribute__ ((regparm(0))) +#else +#define NV_API_CALL +#endif +#endif +#else +#define NV_API_CALL +#endif + +#endif // _BASETYPE_H_ diff --git a/sys/contrib/dev/nve/drvinfo.h b/sys/contrib/dev/nve/drvinfo.h new file mode 100644 index 0000000..41c659a --- /dev/null +++ b/sys/contrib/dev/nve/drvinfo.h @@ -0,0 +1,190 @@ +/***************************************************************************\ +|* *| +|* Copyright 2001-2003 NVIDIA, Corporation. All rights reserved. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL *| +|* TO NVIDIA, CORPORATION. USE, REPRODUCTION OR DISCLOSURE TO ANY *| +|* THIRD PARTY IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORP. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROVIDED "AS IS" WITHOUT *| +|* EXPRESS OR IMPLIED WARRANTY OF ANY KIND, INCLUDING ALL IMPLIED *| +|* WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A *| +|* PARTICULAR PURPOSE. *| +|* *| +\***************************************************************************/ + +/* + * This file contains the header info common to the network drivers and applications. + * Currently, these applications include ASF, co-installers, and qstats. + * + * + */ + +#ifndef _DRVINFO_H_ +#define _DRVINFO_H_ + +// Switch to byte packing, regardless of global packing specified by the compiler switch +#pragma pack(1) + +////////////////////////////////////////////////////////////////// +// For the ADAPTER_GetStatistics call used by qstats. This +// is the template used by the legacy driver. +#define MAX_TRANSMIT_COLISION_STATS 16 + +#define ADAPTER_STATS_LEGACY_VERSION 1 +#define ADAPTER_STATS_RM_VERSION 2 + +typedef struct _ADAPTER_STATS_V1 +{ + NV_UINT32 ulVersion; + + NV_UINT32 ulSuccessfulTransmissions; + NV_UINT32 ulFailedTransmissions; + NV_UINT32 ulRetryErrors; + NV_UINT32 ulUnderflowErrors; + NV_UINT32 ulLossOfCarrierErrors; + NV_UINT32 ulLateCollisionErrors; + NV_UINT32 ulDeferredTransmissions; + NV_UINT32 ulExcessDeferredTransmissions; + NV_UINT32 aulSuccessfulTransmitsAfterCollisions[MAX_TRANSMIT_COLISION_STATS]; + + NV_UINT32 ulMissedFrames; + NV_UINT32 ulSuccessfulReceptions; + NV_UINT32 ulFailedReceptions; + NV_UINT32 ulCRCErrors; + NV_UINT32 ulFramingErrors; + NV_UINT32 ulOverFlowErrors; + NV_UINT32 ulFrameErrorsPrivate; //Not for public. + NV_UINT32 ulNullBufferReceivePrivate; //Not for public, These are the packets which we didn't indicate to OS + + //interrupt related statistics + NV_UINT32 ulRxInterrupt; + NV_UINT32 ulRxInterruptUnsuccessful; + NV_UINT32 ulTxInterrupt; + NV_UINT32 ulTxInterruptUnsuccessful; + NV_UINT32 ulPhyInterrupt; + +} ADAPTER_STATS_V1, *PADAPTER_STATS_V1; +////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////// +// For the ADAPTER_GetStatistics call used by qstats. This +// is the template used by the FD. +typedef struct _ADAPTER_STATS +{ + NV_UINT32 ulVersion; + NV_UINT8 ulMacAddress[6]; + + // + // Tx counters. + // + NV_UINT64 ulSuccessfulTransmissions; + NV_UINT64 ulFailedTransmissions; + NV_UINT64 ulRetryErrors; + NV_UINT64 ulUnderflowErrors; + NV_UINT64 ulLossOfCarrierErrors; + NV_UINT64 ulLateCollisionErrors; + NV_UINT64 ulDeferredTransmissions; + NV_UINT64 ulExcessDeferredTransmissions; + NV_UINT64 aulSuccessfulTransmitsAfterCollisions[MAX_TRANSMIT_COLISION_STATS]; + + // + // New Tx counters for GigE. + // + NV_UINT64 ulTxByteCount; + + // + // Rx counters. + // + NV_UINT64 ulMissedFrames; + NV_UINT64 ulSuccessfulReceptions; + NV_UINT64 ulFailedReceptions; + NV_UINT64 ulCRCErrors; + NV_UINT64 ulLengthErrors; + NV_UINT64 ulFramingErrors; + NV_UINT64 ulOverFlowErrors; + NV_UINT64 ulRxNoBuffer; + NV_UINT64 ulFrameErrorsPrivate; //Not for public. + NV_UINT64 ulNullBufferReceivePrivate; //Not for public, These are the packets which we didn't indicate to OS + + // + // New Rx counters for GigE. + // + NV_UINT64 ulRxExtraByteCount; + NV_UINT64 ulRxFrameTooLongCount; + NV_UINT64 ulRxFrameAlignmentErrorCount; + NV_UINT64 ulRxLateCollisionErrors; + NV_UINT64 ulRxRuntPacketErrors; + + NV_UINT64 ulRxUnicastFrameCount; + NV_UINT64 ulRxMulticastFrameCount; + NV_UINT64 ulRxBroadcastFrameCount; + NV_UINT64 ulRxPromiscuousModeFrameCount; + + //Interrupt related statistics + NV_UINT64 ulRxInterrupt; + NV_UINT64 ulRxInterruptUnsuccessful; + NV_UINT64 ulTxInterrupt; + NV_UINT64 ulTxInterruptUnsuccessful; + NV_UINT64 ulPhyInterrupt; + + + // + // Handy things to know + // + NV_UINT64 ulDescriptorVersion; + NV_UINT64 ulPollingCfg; // configured for cpu or throughput + NV_UINT64 ulPollingState; // current optimizefor state. + + NV_UINT64 ulNumTxDesc; + NV_UINT64 ulNumRxDesc; + + // + // Useful to determine if TX is stuck. + // + NV_UINT64 ulNumTxPktsQueued; + NV_UINT64 ulNumTxPktsInProgress; + + // + // Rx Xsum Cntrs + // + NV_UINT64 ulNoRxPktsNoXsum; + NV_UINT64 ulNoRxPktsXsumIpPassTcpFail; + NV_UINT64 ulNoRxPktsXsumIpPassUdpFail; + NV_UINT64 ulNoRxPktsXsumIpFail; + NV_UINT64 ulNoRxPktsXsumIpPassNoTcpUdp; + NV_UINT64 ulNoRxPktsXsumIpPassTcpPass; + NV_UINT64 ulNoRxPktsXsumIpPassUdpPass; + NV_UINT64 ulNoRxPktsXsumReserved; + +#ifdef _PERF_LOOP_CNTRS + NV_UINT64 ulNumTxCmplsToProcess; + NV_UINT64 ulNumRxCmplsToProcess; + NV_UINT64 ulNumIntsToProcess; + + NV_UINT64 IntLoop0Cnt; + NV_UINT64 IntLoop1Cnt; + NV_UINT64 IntLoop2Cnt; + NV_UINT64 IntLoop3Cnt; + NV_UINT64 IntLoop4Cnt; + NV_UINT64 IntLoop5Cnt; + NV_UINT64 IntLoop6To10Cnt; + NV_UINT64 IntLoop11Cnt; + NV_UINT64 IntMaxLoopCnt; + + NV_UINT64 IntRxCnt0; + NV_UINT64 IntTxCnt0; + + NV_UINT64 MaxRxLoopCnt; + NV_UINT64 MaxTxLoopCnt; + +#endif +} ADAPTER_STATS, *PADAPTER_STATS; +////////////////////////////////////////////////////////////////// + +#pragma pack() + + +#endif // #define _DRVINFO_H_ + + diff --git a/sys/contrib/dev/nve/i386/nvenetlib.o.bz2.uu b/sys/contrib/dev/nve/i386/nvenetlib.o.bz2.uu new file mode 100644 index 0000000..2e27d7e --- /dev/null +++ b/sys/contrib/dev/nve/i386/nvenetlib.o.bz2.uu @@ -0,0 +1,316 @@ +begin-base64 640 nvenetlib.o.bz2 +QlpoOTFBWSZTWa2/tOcAMlF/////////////////////////////////////////////4EOTW9s1 +vHvub2a719HuPZ9m9711ToA09l3r3vfeHq+3uz6wACeAS+Wj77u6pd73vLXs67326l9sRLuPnjwd +afed99vu83XD0AqVU3l3s57vXPLl1LtXe7rHVaVHW2Hrcdzi7ZXSnde7r3ttgzvPe92Sedlu7uvD +3kcz08XnuDe7vbplss7p7Lt7bZpWgGu93ep1r3nhV5Lset2bzzr3uo93e7vDre1t51vQ9d2vfad5 +TyDvODQiBABMmgaJphMAACMaAE0aT00GRoaamp5HoymU9TxNJmEyNU9kYmSNiGk2KaeptGiemhPU +zQp4psT1NMGgU2nqelPITwnqaJtGiZNBoQmgBAAJowTTSNJ6ZGmSegjTAmBMjQZNTaGSjzKaPQKe +yFPNCnppMh6ngp7VB6no9NU9Q8k8psTCEzU9NCNoJ5GoeoPU8o9JoZpPU0ZMmglNCEgJoammmTVT +8pvVMZM0p6pvJinkpv0lPFPU9qmyT0nshT9DVPU2p+knlDY1PSR6n6o0Gmj1MmjQ/SnqGnqZDNTT +yhtQ9INHkEHojT01B6mI9TJ6EAepoGgaASaSJCQ0RPTQCaaTNNFPxNKeaKPKP1Q9Tw1T01GQGxIP +KPKB6h6g2o0/Umh4oAANBp6gAAAaBoANAANAaAAAA00APUDRJNTSeo9NTBPSDT0IGgNNGg0eo0aB +oNGmJiABoAGgA00ANBo0ADR6g0NANA0GmQepkxGm1GQGmjQYg9QGgYg0EiRCaACATCZNJ6mmGgAm +Rpk00aaaNGgDSYUeTTTE0YT0qfphNENT9KeFPKe0ZU3o1T009KfqnonknlPTKek8mFHhJvUTyaj1 +Mwo/KTQ9QYyjTygaO+aWNfxnh4iJ87nlDyU0CpjuSpB5qaUJcgAqHnezTFl+28oqByxKIESqCAk8 +Lz1kPQBn89Su4qvQRTlRnCwyUoUDLRT1Bglq3Jx4ND2povNwjEgSCAiz6MTmk7LSebPnZuLOzTeh +4SUg2dS2Gz2+65+PeWel4PU/B4nX8XtOPBWw7AFEHZZWptw51l4XbZnAPUnDGmh7xiozxwYcKlXV +1ZwlObytVju7iItx1YIpD/0anDd2JALNNcggQBE62C+qnxvAwikMZWQNn8GfxUk1gwp9hoSbbysC +gAqssZg2DtPYVxCH5HEAA6fbwhTnP+6N3vpkxpDastKtjNUhQlIWltItbX3TC8vRqRX7fiWL7pcl +3gmCjgDqfmbHf+pTQpej92aShP3gtn2Of6UK6X7uf8T2+tyd5k8CcY9mowvr2k9NsbZOhQWPL7vV +0HVYffYW442sd32/+RpvdZGswnrWxxEtrp3a53zYa6fqHj03S5FAhm9Z9U8tHOhBBfv0plOm2t6p +UYWzztO1BKDuzt9WIcNa9PpM3d+i512agvdrSyX9WxoRpE6jD94xLrahppk+lS5P0bVQWUSBpiwg +gAip1FgweK1zgkGKeGGPooL3/fDUN3+p0HWUNw99Tg+l99zDV7vh5zvp97t/+PK7zx14mWy2lalW +PqmFXEqrbdJ895+uen/jeed7x70Q6qVH4nz3ytfN6c7KpfwmLUrzDwKSmk50Cyet+SYq6dd/bpL1 +Vb2H4HH9lNlVIXQIxxmcJwdzBYrSFodn8IXfJUtEQ71tKBXbt29XQVDddidvGonk1IxaWNJX2pk8 +eRWVhYba63yWeXhCq1chiEwXLvp4ONT4fGfa+7rLVQZThXzdNrCi0X3f+OJ0el2HvVbNKSMTL4y1 +e5rrz2lZmB54YpgLMAxAMS8rsDWFuOIaVp9K3Pajs0+kR9rI8r4PdvmbQ/ohuB6jnabvMA3G+u/x +zLQ46finFCghD+H8f7f6zfaa/D/rVOw7us6n0nx5dGRlvelOlo0lGhQmKQxlhLyyg8e1xMPJd6KN +oh296VY12FJ8fFpOAAc9qA6olltfWlrV83Mq5dGC9VQWA5BBUcrzUdsbvX2l7LES7+PXZWmtm4X3 +jYDBAbEwQG63PX7qTVTNsUG530uv9hexXzer7vxDqMokkVMvn87W2OSPy6i2E3TZcuMyOkW1h1HL +7wtMTvMtm7fimpEg5bLgVEDcUPTyuuHtjJZMkGnaufGgMjWQLJYbXete49ueSN6BId5dorDHCC+L +WNsDGAs9WeMFhP2En1hNbnNBNyTxgRASYIYpk3W1gpmKnudDyvlfTXjnn2sH0vo4r2ZbGmMt/p2r +bGS6iShCSXjkesuXVlckkkkcNHGmmZufZDpMdtLkO6JjvTMbMw6aEA5FFofhO27fVfb998zWN9/E +M2K2pthpQLz7nNyyWLburcqQ3EQkOJCXvPH3uz+ft7FRY27IX13rmsvfQJeKz3z4rFyGblh5r/gx +1wOVPnT4sFeI728iuQ3FEByuy2exdAUtJN5LZXaoKbzUpPGlyXYonHfSUV6yl0loZwqngTuklVFK +I+VTwvVzyYYbfZs7LDmyI6vTJUVQy5cFF12bsXd2mbsrBQmmvi2zEndeGaV00RP0d+r304lFtpBO +vs/Wfpurs9rxB87woAx/V6qOXY6mop3n4/VftZ/nOix7CUPIhVbmWKexn/V5K3YLMFUiUIaXhQJo +3Zs9KCWEJql3Nnx/Qa+rn0xbvuOHw8RX6C9cb3I1DAWRBAoKKR2VCj0TkiQmBZZatCkEOz+hp7oa +u94337N1lHA8emvAde2yRLMgZmZMA2cTUefAprC+mMKkkPiEJ1QDcvbOYAutntwSJPcxnfNjcjAW +ZUVGPspd5HEh1Mj16sjBM8PBT5Myj9alG/9dzTfa0zSo2/oZvxGdN/JgfNcb3qR0Z9NrTRigs9bv +2MlCmdLOiIilGQXJJXIdkb5KG1KxyP3/TfB8fz2pdhymt4kzT4/LwLqwxoKRkMb+ljyyYuZUVZcZ +NECc4K7MEwbQrHdDm3dmotaPkM8TsXlnToa4QOSVB67A7+fAQGMCDXu4ug6OrjxI9a1l/bjQ4gKN +/6pX2DBLYWSgoGOFPSZMR71LWatEM3lfGaWtQZmWGPZ6kFLnq1h3LnTO4hbbVr1dijbVNykzEJIY +pTWc8MrDMiKPTdwJpvVYb4hvIOt0K5KmrjiqUqUd4VT8+m3um47fo57tNhTGFDM14LDTvmBoHoDA +UmgZ/9pvD1XE7fLUA4NUCHyRzCkha9HfF1qldbkh3DjLTQx42cN1IRFRBSwJyJQqWE3j/K7fKmSK +yuWxrgK1ZiPHHYeN8Xs2YHJMy21TWpBs0hycZtnZ9x19NKbLeJXoIIVTnTSvoU+NwSccjQw4MmSM +tNZVXSW61ovLeDtCsBTlaqiqqmKnGD6mn12qp2uOmaLkva59viepd6pRKKWlTqyZgSqxWJXmWvNO +5ve5TnnV668+A4LQVS2o8y5z0Q116Md2sVTsJyZq8XDY206E5jJTaa2tlYbHHG5ZrNZvJxvimw4d +tbbLu60ctl4TTtBH1nLDhmlMsrBFWKAsVBKaw0tKQ6Im0lqxFaFqQxKdoqSQkxQlqCgiZbVctbba +W1BBZthmze8zC87uau3aFtmNc5el7753Ac2cmBzaM+wpcukMuZASPIB6fw346/O50DeA+Jc6Evnx +gN5niRvPY0nWabUxS0CqK7E88y6Rd5uMcdvTeRzM/fW2XOeP9DivDGTO0YZBn86tRQ1aJNCU1rWt +KiGSaEw9E1EQCodNWxb6auTJeDpJtDdZ2UbSdooTafM7Ra5iIx6R9TylKNwKc0CtjxuB0mfSdEBi +BE2H1bTFsMCDmXpE2C0WAt4YWOeCaN37yEps/xdRfkWrkKltoRkzCiDDGgwvfpMnMT9DH691VPUI +aA403eK1+Dotnt+422gyew9mi99679+PsY/kbnHyMrZDF1rUDDU1I5ps2ewJBDkwbMESc5om8Ntx +L5CVFTlxceLZxplOWribch9r9L1nwNdXUONv3wY8FiWVnw1HlEXREO0mOYHTOnHNz+He39XV53Ve +x9rewa2OUuembjt/h8Wa1+IwSn3lWzIOQ2c5O3a49PufCp6Hi0A0kTisQZkHnVYWDUgDTolDJgZI +885KpJqqiAcnrUBIyIiB7iAAgYk2NIBGJhfatWbfq3iL0vOp/21ep7vBZ763nMAAuxAfcP2MkmHK +oQkX8yyYTE53Kctw0VjE2XLMBDSbBexaP27RZM6593g1GxY2hFtrguGdfW4OW0kB4TED3ThsPxNV +MO8aAL99WVjbHDsqgJ0ZNxCBKiySJ4FDeUBSTnOfB3fDw08Jis0QAjaDA81pWnQwPT/8TXkHEb9t +5ZU6I7doqsIHhMA84Hw0LBgs8FDYqQhtIoixRKLIieDHN9vUNR7HJS/YCiuloZjEa+Hbq+I2Yymu +i9TivJHGoixVRfF6mDsMFnBTmGwgMF2OccqYN7mwq4gQNioqQe0tBcShPEsE8KpMXQX11FkbhtqG +h1YyaYnmxUyRcVWRxNG2RYKiPt7eVKz3rJCfY2B4aaQRULOl4OPXjSjFVYaBbDYR81oRljOm2ZP6 +sxeDy9pt93Ql4zkWtTyZ57RjjE7kANpDeFlhi1o20Lrux2FM0iidcJMD8HR0eDQoLedN8MuIF0S6 +SatYTGAFwkw7JL9ctN9RwBCdmxSlYYY7RJhqE8ISBAfbYi+kgVkDw2SRQIewYc2BUBZFUUJPdoQO +iD06YQuWEAxkIG+dUUkCjBQIsJ4iHNhA2kyISUVFfJaCKyfDZ5W6fATbESKIiM8hkKe6shUFJFId +GpICwWIyCPuBCTsAz1rvrsAWEmmTrYT1zAsRiQ5sDuJO6wD5jPxTCT+YySe9YdhkhDkiwqQFAOYk +xgoAHYYGk0IfUpAmO4lRViM7QkVEFVEh7u18eyVh6DUDhhUFgjIqyE8T5VgYhDqQgoXZTuMhoZpB +YvqGYogIydIgGkA79rFADsoR67BEgx+OwUoyAshp+d7h/WhkNMU7TCrEUgsXw2s3wcC5oQUknWyK +ST2TJJUCBiKs+JaeRbI2hDdbUDPsX4DAJiV0OQqfkd/Qtk+M1++HmdTK7uKjX7en+o82s3W7Zz4k +WVDR/LOX3Znrq8w9WZ2PHGcD2W8qu0NhhgMCH3phTgfdT3fx+jFkenb/48/j0HtZXsSGxTK66Jgr ++AuJ6nfvOG5ysjtb+92R+fnbau/dOHuq3W10bj7md2X9Iomo+UKYmwOVzUZJd9Pv4IcaUcT/5AOS +Ysv2eTOQQAwISOu2jrgerc7luJYnIMEkmP+8hkpSUBdKV3vayQCgyK6tc8RxAeYMXXGWLKHLsx4v +Gk4LPhusz4/K+1yfk82WHkSOdtu47r9tf0+n8Mx0/199KRpanXlebFqtt9HrUtLnKstsujcdqRgX +7f08Gs8Dzug26eD9/ffKxdrtfE+xzUr/H2u8/EL3Gyfvbm1Giijk0XL4nu95Wb7p/9T9DFmQ+68V +g1OTPC/qXdhgO2qdnmLcD0tBns9nuumqLAmcCazke5mZnOUt1evhg4KFOeNms3Kz1FZ0fbT+UPtU +e7iinl1tcmjc6lDA/OYiGQIgT7LWagC0ZlvqVB65kh7EGAAWrowIX0xhRECpqjo59e/1dlY89Va4 +qISQrg+Ae3vy9LzC52HjfeJk++XqIhqVh37kSxh3PY+N0IUqjATMBn/EJY7exa+A1ukG7HcgUHhT +nl7PXzDY7PfjcFmshup2hFkhwBOBt/GM2nUGDBW1tbY1KwvcVgUYA0Lum0dO7TinIcd9j2+K+fpc +3ik3NboP2/3u8f6Ep4eOjZ6v3/S0Fe3lBv1q90DIS4mAyHiHUDENIoqGTfnP2PKtfb3B6n3KFTGn +MIGDFvZd8iKCjVfJu3dR4GFHvI8xBmrz64Yfju/VUqH0Imj23xUH2tX4kuGyKXAMafo56z+qr/r8 +HuMRf8vspxPGXCi8X2MZEKbd+J9Wm3M9vPoTUrFCGIy2gHxh19v2mZU6S2tra4lbjLW1tb29pcWt +rcW1tbW0LR1mUsLe2ztrPTvAKhMCrmK9Rz6CkMK8q8rUNmjLXvaR9pGS9BUVtahWIMbskeMcxsVL +11Ci2jYFxM5u8k7y/vaMQ3VbHn8wTAE0BDMCGozXE3sdC3oKnhcu9W8bWKlfVrklXbOetDmtTmmM +UeebgabGABY4ERU8M5sdz9eTE9Zs5nrUlmJJnX2Pqx+M9P4iRiUx/qhmY3zQl4jBf8aq5Cga+r+L +8E14mnj2xglFqcVslj0XaFzthYQRiNcgyDbzzHRFW52pq6ytqa5ssHYQxRi8D1hp69evXuddujkw +XqSbZg2I2WcKw2Q0A54c2OeEHcuTKk6nP3F7b8a/1FfH4or4BhA9eLWeJAWfD+nmU2uwML8F3Sz0 +9OzuLi4nz/NC32cw+DLkUp4Gj4PWaNiPlDRtJoTYFT0Rl5fOOEppB4y09y0+2EcnQu0GM52F4goZ +pvwODpXkZEpSpwNingvmXj+ulGaeEK6vhV9xYUlhWWFtY2MLLycWRO2hy8QhL5Sg2Om07Y0jaGJ4 +4fiZLCxZPEoIN1Cs7li0tLS7EiRIkSJEiRZ1wkpMU86BpbTzemvvfnf2R6vAH+OpRDjoEijF87/M +6OdyzQ9EL5q+IAoF0+qHtzlL9GlfhmtHaFh53Agbr+YOBncejnaEBS1jDkKcqRVvtyEBpCagvUL4 +mQjDEArR2lJFsQD2Uvxtbsznz/Sp9760qy9AVgCtEjgh3VAdaMi1Em+oDZB3QdHqmTs99WpPrOp8 +TF2WT2vU70uBmaq5QWBzdLYBbL8K2H/kXADG+N2BHjOKASIdLiPgzGVL4OmIb+dGErl0AEJa1kyv +Z4va393g4WPHFTei6NVUZt27Tr1+Ib79n8ONj1sFq1wcXf3xkUQlyZ7/ge9hUKpE16/4sDawaeHo +MU4DA+wktIIWqQcwY5/Z+X8PJ+VzN924QU5uuR7ApV/IyjAW0QUG0APmj6lFOZ1oYEk7pMxdV6Mk +uIXaf9foW0hKgQwQWKjy3buZZ5fCKADBVwX2Cv8w3TfbNhx771kYUTu9B6cHmWdQKwNMc6RDAExH +YgkA1iwBw5ubstJuEhKxdhwMaGCbjLhYJWuJyB2+F53y4bpLffvoHmMeu2CMdtn6hit18i3Yv+b+ +EmHblou3YyVQeKH1oC0zuxhzu/hUsrskBkWIDIvGaaMpqcoPX7yAEZw8saMHP4hkF7fosZt7In4f +pPIBNCCCfGFhdZ9CApV2jhB3MB0iQVEBJ67ZpUS8yEgR/L1i/Nnfr92d480M0jMdjxf8ngf1u952 +XI+DwbL/Gv3fqnJvXlH1hed4tuPHGeDDJhZ3rdQDjmZEClqlAhmY6FsgrS5fDr0ix2m7o8BxONku +BSy8Yto7yrJeDUVcffRJUyWJbLcmSGwF8/fl+5N+5C/Wp5bPgw6vgqqqxzgi64+vTzMmwGBJQ7gG +VDQmZAAy2Ghndp3H/HS69iDzeNgMciVgGAPyHFipn0Ce/pv7pKZ1bSWsVjWtSCXflNIkGdzluJJc +PgUi+D8Chc/peB8PsM1+DjZZ5vLSLgYv6d3lGwGjwuuTgGOHQ+TGWYIhHOz2qDfaxBlbPp/xLdcQ +K/6iji/aJRRRURnWKr9tIqLkDaS9b7WAw9n4L8Ga3I/dtL8TQjsBob5Qz+wM7WX3Zm735I8U5Awk +GPwiyFj3gDDtZQJJueWh7pOItnLr6/t+xcJ5tzuTUC3aIQohdMqajB1HI6p7Huuu+z4e8riFf13H +8AfFg2xEI5xhMjI4PEDQ5aj3DRybUBlGgGpLxvG1L8w+K0iwihI6f6mjL8u29iFSPhjjAINiD+5b +ieBg+XRMdI4hPhS/oGuFszWjZFzhvT9R/NhJkNvifWUtoZq8aMJeorG8V87odQrLisShrGRNgWqO +GGWzMz0PCih+USJqnjrLv/O8rgQJWC9VUoDU26VCWDRAECGpCK6MZgw1qtUIWP9X/n6essB9DJ9F +hAWwu8vl7vx32PNo2D7I0IJDIfCdqltlrgxzjzh/EeJnETjQ48g/wS67jzKCujazR1RsSAOmBgT8 +4uGpM5JTC86JyUNjbEvUYfCrPOK0TSQb1mLAQAiKui1MEbTrViQZA77u1eQAfjmB9hxNuY87KIV3 +ZOKRWlEPTgMPailgL6IaIfQeV3ST5jNnPKE+dvSttzObN7NRALn5jTM6WT1+VTBbOnFjff190s+q +zi+/ne6yAIvwEMC+/suTLPvOs0ZhyZe37DB9du5S2t7doaR+HTrTXvqV/l+bTohPsr3fzK9Em85Q +Ykbx3hLk/FdjHipBVYsL+NSigfHiibPS55IQPjTNSc3pZrfd1gVRZyEoRKwKioiYfnVss9yiqmjA +LG9JzHvWmERsHqmk+AeC/4PivTS4vBhvA5tBk48ZPCVktPKZe2c9FCf9dWWuxbwfnHJxHcPE6nES +lxPsff1slRk6aUJsQWWRqqhnnRB1/4qk9Y1iUokQxBjqfvMC9h9BayItX9OfP2cqyXLeCafevoGa +Yx4zUkqWMceiQRf0TeCHBWZ6ACVRnihK6lthUTtfVjOKIg7BjEMp6SLruRrZVjis05kBKnfmQDoD +f7/Upql8IY/KH9GApNEeQovf1vW+kjzXPuC7cTUu3TozvlMj/KQiWckPcQVxzgMvXnfBB8DTfsvR +mFli4rjpPYRWTR+GUMu+GRIXsmlqsD6I+lusUbdoD3/GnI8LGjGtxfHbHlZUCWQw3Xs4L3Msnvbx +FIUtMUmWBq96+AXJoFCP5mfuSP80jtvL3q3t1fTOr5fTddyuRyOappp7Cmms0EjCMM0by7qUHEIV +9ggUOTo1rSNY58wqpKz7cUrazNJpW3FCSIr5lnWLUGFPTH2GbyPcfinYuvb97JczUPinuBJJHxhD +pXIdVLiSsydRMaigo8SuCrLsVlks3leawuOFxW+FHScTk/xf+2/jxxnQoJgZO7TI2u4g/jnUEMxP +qBggLeR2jG3vd4ag4GkIWO4zPRNa39XxNzQdLEHTeHALfNabAMTbDzcEJFTFOFBvBlbm0YnS6aY0 +TIgMdNU7yF9DyjVloNvHGXudHD5yvem02pARIMyBmRmHuBM9HdwN/3U01egBsLXC2uAauSW6dUBB +voZOGhbP9Cm7YpT6ENCWE+ilkqbjiTZ892AT+aqsD79rJZ08fdd8M4M07NEXesaoBeLgLDHZ+DJm +REUTXgijCA0MuE+N0s3OR5T+5rMaPC10FVmsuDWuCx/hGteNEx/H6MHYP3mw0EGuOWPJlUE6HEI7 +udS4mrkM1hlxtpPePCbrTbArPSZxlnKPadMN8ew6a9fdzqlkgdN7O7qCC68knwwh8CCmFwv470XT +GM8zgel63b3mW3pmIZwTC6NGlco5fXiqVqHWA5fvEDzjPX4DoGsHHFaGKKe2GHXvsaw0ULJYhMaQ +EaF/XfuzwFDh66FotDYl6xNoc90NIj4Xh0MVkhxHEne8APT+R4L7Hs84YMbR0SB4AfIMuZfD7Ns+ +mNBSXANzC+HXruhUN1a20F4x3a0Qc8JE8eFwVOP6vczNHKQDhg8WsOhzcDjjfJUos2P3fxGs7yeu +1ypsaZ0vwOdHzPEemfm/32PgvbNC2w0Wy3HCZymlQ02MdZ55oINrqqbau5s2SojRO5xgKIXDoMsL +AaonLDdtO4lbiwGG9O6UPJZlWSpXDXFFNc/3OPtd4dsNIgaR+iNCO8YB3LR14JwLNfcdmuNOHGXi +2YJEEt2YQJijtOB0Zcam0kGb1gZkKAIyKEJ8tJITllCSjLoLyBJa2GSiZlNapmmYFcwCsrIcJd2Q +NXMm0NDB1kk2VZoq1VBKpSIVURUrQJd5SZyUyVQpub1g6iKIkTUJVYSDx7YvtPk/fzpyAnLpywEQ +YaKF6tmLkvVrDQPC3hgFa5xo1heCw2sNnBW8aXTApxcDNUhUlE3msIicNBVHOKYRAucZmrZrApuz +RnDON01rcrF++TgwPH+gaYRkOnHLCnTC4PRlA1k0OCJrTM0aZvWsdYyL4HILMtKspd4ZmMMTDeKZ +lJldGghczRoYh6jnTTdVYFzmOi61xSpyx4jnAmzrnCE1bWgYRYJQKZFEO8zCqhqouQxVmqUSXjjX +LLpm9bXaZt2zssqR5DS1SzE0REEjxSZEKhKmJhTMEuWkdOJ5RFZUVKTWlKompLxVNEIhpiCs0KId +36nqchnDzUTlgmcpl005utQr0Ga1hiac7Ro0CakqIaqA2O9tt5tUzB02ejNRjfeuxMjPPZkHnULr +waU+2c+RrZhYbpbDjbICiwRiJgoxCHaJkkmIZpQ1zsBSalQK0U3nojIjC3n57zkxhp4eiTptpNiA +fTHXxOIcCyu+zqGkXTKwHstDZqnTCHSRIApo67z92Wddst4ZAQ00uOz/c1xV3YyFQDhNX5kLK+Dq +B9aynBDePRO6OB2fhrd71tNQaxC7YypU0sAgYo7eUiA530RQ4D7BaMu1BAPvddovKBRVo4HQoa45 +i8xRnLunugNf9L4QbbqWasuuOpt//qqBaTDcsOhGg27GONxm7CYN2xjYkgq70ZN2qEut7zLGjTL4 +2HiCbEf0nZPXSTBtxfM+2cwqv2cC6Cw9KTPHUGIcmFYZwFhYDSFHI2B7FJnd7Iz17tn/quxF4hdU +Hs+q8Eccza7TaKgqaM4KDLolOdZ7CqbbHLozL3qQDOs6zCG1U4Nc0upYLbttDbYRpQKlhwug1lZl +ZkDt3hinn7EO6yq78kcAwneHdMiM39DrrUUMoa4xuQKBs5k3fspKV8zpi/bF6qnIJV0y5AXiqdm6 +CbNkTxEQHQNxQMxQ5i9f5xjhxQqT36FZOjVZEQD6DxbiLnj+i/F9T/r8j1XflbluIAoGlkoP9Eb4 +zwjHgwMTRJfvk56dFsIHQMpNxPQ/WhD2GnSZIayfp38VHh9TXy9FzkbBFoR/xRz86VuIblW9RFlH +LRhuY0DA0UrsVMojjKDkXjvNai9V1co6eB0Nb1cPI1tVOaWYPHWy6YMNGBJbOMsFfksc3NJAWIcM ++JT3Qjy1ZmIMjeLEZgvtm3az1YsF6T/NgzDg494gq5YG0sAAdT7Opp69Dvc4IHRr9PKetffr3ta5 +l7xE1w45uLOf051DS6g7WJShGOScDjqRwdoTJMobiEZycNZV9IAntnK/Cyuahdo20lj+/O1JHVsk +XLJjZ0alxbfdH7jbPf76o6H8mbh/S6nEpNkO20BhK0Cb2idk2bwsTeu711HQGXjSv0rFQtF1ZVZH +d/YyOj71A+F1tTlbYJjzjcuaafYP5qbzLx4e4sUY1o8glCdJNSHCaOvidD675/m0z9re5z1Pdd7k +U8Sk/T2gUoezR3I23tCn2zQs/E1bo3/B7VTtPQ76zRr5g/Bdm3alMW0ib8Q3ej1D6ZgYzn71Jbl9 +0zNYWKPQs6AGRblAqXQBnPDGu3TkmPXnUqjsZtJDIke16ovSQIlcS1cDgOcm3iwPgNYycV0oOV03 +cfH1PwfXjTk1CMA6KdB3VdcHQDMsgD5hPDBClyCIrXaz8wyDFDAgmZjCFQFW6Gcc6vP4YU+wcq04 +ctr9Jn6H99xUinivTYlRr9XXMeniVnfzIwIBfd6Wjxve5zuPbpl55lfx8nX3cinbmdN6/4vM5UYF +cWH9BAs8bupR8LiBLoJx+TCuMw091oqz9rqJTZTvlzT7NrvPShTeehTXdCq/DrvCw4zvHd3EGO7I +PXyXxgL9kWonQZRcbhXU8wITpfJT567I3PAquhD0QyMjodFkA5STkSD6xy8zj0MGceMfEgFMkX0A +LuGhBGbkDi+EvWMymR9TR6LaQJZUmSyhGIxgIRRVksy6JhZomOJur+nsz6ku4fK19x4WQNj0fxul +M8x5bO2JEiQ8ERDusoerSiX7FQqRTck/tet9+a0zd7n2fWEkjpmQrM4YSBNlocE4/AGvOcl99eS4 +6/Irl9IItTkz924gywypRNozwxpbI/cuBlxsmx34iTUtMkO0GPc0wPMmSIZ83WflWt1cfl2OOh0k +SHrPSoKHbYofSbhRpr1xrRJaKBoQ+pBSM/eiWIyEEQkJkIEowoySIz25knnpNaghOnPAhp9gFm3x +BK/IBskk3CHuAwPozr1kcu2chYT3lz5rCuzybOTDK8UB8ypjlsaMCQYHsymtzWISV7GTYRZ1DpBK +Luys4zbk2G2lhCucb3pOXECwJKWqycKJqMUdpboKXWCjNUQWZM6Ra1rcocTo1OcYGM5umS2nczli +8cswMYfg/jez7nooBahC8jzA264O36QbKZn3yOMk7y42ijaK9w4JGA8yZs2VFAo2IFPyu8mdfie0 +7odnjpysohXwBxFHKDVtSq1tKCwTq8Tly6XwjR4uie4I3C/6sqQlUxEwaKnI8P4aAWWTzNHGuJJZ +b+k8zrPL9l8vvidwDtJZLRRUWKLB7HY0BrShELYcOmbNc9IwlZT8juJHxvce0l7HOyM8uSPVye9p +w16EQ0fx5CUOTE4Qj9tyRttxkFLSWeF96nsLwb0Kt+Q+BFyZ5e0roUwPWCRcD3Mg5XbejvMDNy8w +wm1ZXLqPz6P4dhfXANUDrCCzWD4uRpg9D4X/7IEqUcwViJlX7PM5ETGy3D9/iCifQRwLWSG3v8Ec +nr7xBFUnOrYxX/E7XWhOztTLURMkHJLqKG1uEtojb8DDFtEYCkyMDH7f9t6u++fv5f8EakoDGcqU +3r6T9f+foazyO/lsQ7QVXx1wiCU3GO34WhYZqE0eYEYWgZGeoNtrl6v/rha5jayBnXnyqaj432+0 +L+6KLm3RDA9ex7re77LCOHAGouSzfVxQk2HGtCRklSAV48cysl0kyUW5E59eSWWRL1szHViPkkjn +e5hQzT7PJOzrPM2Oc/gYuEjOFww8nNBpsMkxsrp+Bf2N7ix4HU21cHfYCy+KgF0Rfyfqx8HCt1jF +zz3GdvdUTi+hYAufSEX2/AqWV0SAwiAwiUdlEWRmPlmIQtgXl4BwzDJMeUUUzo2hEGPGrl1VPaPY +IR4LSWp3EIGo0oaOkH39rzvn03Ms9DfzbqHZIDLQPlVQ9CRI7rYsttoQPb7bLvBtz9f877V2pnnC +LGAxmUK/DaIkhb6IwmAfTUyAwQNsuosL9p43m0UN4mKGBlwyMcypWGtFHBrMshM+J8GATwvN8DzT +zP5Xs8oL0ZVcfXRzJRru13Xce1exWgVAQHbZWWJuYgCjB++4ogaudURF2IYTKjIM1HBdzyuWVXsc +hQwiIIMlyY4StThMGAQ1bj3zvWqS7V0f/nf/C7vB0WfftIcRDEXLvugnMIRKskIEhgkNVvAjIQus +six52aan4HAqgJgYlbPbRGLC0EUimjC3mhHYzdOsSVpI1s1Jzz68jdVRNsAfZBEK3P9x8qavlu44 +dutVt3trjXbj9tbgSZTsh4P4mApNnkq5nbqUZRDAu4a2rBJNmRFbUHZ2Ri7di/0m5lRb0tTZZS1Q +zyR6GqbbyiecF8TaGJpN62DnMojGJIlZSLBVFFkUigpAI/y47ph+S5TUQQ4KexBACSptF8Xctlk5 +iUfCAOmARB3v/Cb2vk8b53sruH8MfavT3segqxjbZ0sEDbbGhtJjfL970+b9QppTQ22DYNrxLEpC +/IIDsf7YeO2/Icw1mp8g53IApQMqKoZKrjelKC2HLNIrLeuX591bbOfjrqYmdMruIGQUJ4gKgzsL +g707pBr0W+uVP9J1aOkRfO++NWePfvlulc8iSUKlkA7U1ijMCDHEeLDSGQScuD6HwIWAfRZu8Olj +QsEI/hMWXq/+xP4LtIXSQZSWgESJe6s3IVRY3Hkc6YuGfg/hxXS6xN4ajn3tQzdt9f8A/88sfz8O +6PMbTXX41RtwseliEa0xkxvLztB7hBRKA4oecAxMgntKKt79OGyTe0GQLxgKRO9n28iZE4EdCawD +3Aoj3o4ba3WNsSVAM3hVG5RBTCW9zybQY6RNZidospWDahN0lyLQEHhxJqE0iRF021lKwjodSzPB +Dun4UXvyyUUcGtGqj33c7B06tSPgsebLCop7lJQdWOA38xEHwUQBmOvH6muYfhGPMw9zqBDYfGGX +8XFVEfktVY/QpRDwECwmrfxthX3/1BxyYbwO4mL9Q67IuX26xYcPATkizVanFkrPtvt4sw3dF525 +nRdNvLd7SEa818BtxkLeJbXfbLihg2XT8omzvgiXcWDHgsNuTzDIB+1o9ZSTpY1IWaD4MELAyrhf +ey7ECyzLcIIdmAtcwOwEW1S3QdIcTi5ipNIOyOkIwxBWky5IuBU10RM4HIj1tMO4NoouiNXDSMgJ +JRdJW9eK5iFxW3yuSmZmOdUigZYCz6Xzc7lfznx9fVndCHn/S2222xQUrRixR5eQbMzQ2SxzddYB +oaRLJLBZ1UHMKzXzqJbl4AzzP8F7rEDgvmZ4INEQlJqw28tOrXQxoyEQ2NJ3ADf58xnGQ5AZJ0YD +4wbnNP0Xd0zGKTESJDIa2GgN94B77uern5lJvFvzEgvo7w7ctEs3WmdrW8cM5t1KRZGQHPgd7YKB +m/UWgqCvnilGwo2vHyrGXrLOqtE3BAbh7Uze4R3I2ElKvVLUtfqk0ShI7Uu1JUtDzSF0p3ugtDGM +nI+X5MK9scLbuu3v+TbmFTCplUQMZhJdTsEaGpUFdjSw+uNcrFJjmolXWqwsU4VdhuhBDdJIlWAy ++g6z6w+RbpXDxp8AM5sClcvZx18tqBKUkiBp5YuB3VJERUAd7LCAO1XSbT1pCDUap4irxB0gwLN+ +xwUpiMYNTZuS/1dp8d0bES4Z0a0OMsJWhs6/c39QIQucHSNkHLthCA6bCGBjbJsLIMm7AetKRL2j +2k9h2nwLDVEj6pOJ0OLG9Yf9pDibf0x3y6g1QSCENRH1rv+iUfKYoi7FDeIjOmkC8h4nhxsks/WH +Pq1h33pHtpOoLRPslKIiIKIJFKwNDG2QwhjaC4U42LFdrrSCmlr0qb+OrNEn8nUrWskxBp0U04+f +H3rgSWY7kvJWfYbovMQA4gtDRQNV/u3MtasEISDoBMPZ7XO0CoLMofLjFexLcYPRDZqK+efIQpXW +hlqCBpsfQ38Y3ISwzJm2oA3phwVnAVgi0LocN3DX2NOMsJgPOrtk78BQrvRl++WitkoZsWULb7Dt +KyyS3Kdeh2zwmbsHNemtHdV0S85rc+91qRVaatLvTuLTFX3KHM1+dTUYyJ7c0t7ycKzEFod0/BhQ +9ZjoXOWBwa4/WCDJozlVodp2c0dHsppMDPNcdsr1wnahtNHW5mukLrfna0qPpWaZDfTdZz6y2kHa +ToC9zNoltAymQzAR0y0AOw41HC8aAVzLGPWbpdk7jS7t6tVq+B1sQGYKSgFn240QhfASowAlaRCO +ZHkiiTIYQdvw02GoeMm+lpRQs7PyOtd3B6XUmJ4WIlAZXCFlQVs25ug4WWfkj15125sd9XJ/sNIA +xrTn+pkeH/XW7LHMhFWbSzg2/NcL5WPtVU4MgjoI5/fovO/E92bmdDHEyJUAmoGmMYxNjdLTghMY +x2S9zWL8/zv49zu7/1/sZvW7u9eFqB44NqqO0xqYdHmOHW6b3/dvcgQcxhAJQ3MVjvej7ypj8d/e +GRYr19XCecLRq6fx751Tm96CdNaeAlQHxAox8Y/IaVVujNa6RxwRzEo6Xjg7Y7G+OgkLJX8yIDk/ +zu1BCXXi/NWsct9569eTT3NJXgrtRoLwu34v4zcY0hYCrvyCEM+oc7JCW4XSUeVkmtpmluyMyMHO +Fb8jCGX2TLkL3dD8M976mZvhWiYHhKYMwYfLUGPrUe57NIWRejECkIHk0KpI1v1qEXyhG/K8bbDm +w+4uaYjUmp7tYctgy/lYGcYte2QMwRlr+4Gbn9baFsfAFm9+9FQmeDJmUjGLbGjQSyy6tEMp7q4Z +aP1Bnv9aZh5NLxSqJ072Gd/mdE8bZcWOI0o5Tllx+5jUNWxgpqhZEEEFgqOgrLTTWfNvWZYgynuj +MGDBGE/VYXOGXwYFCpoSoMiJTqzDCnUkxWXTSTEzEQokdAswo5MkQRbddHeo2gogpG3YBlvzaPG+ +5wW29sRE8rNiggjjsLNv/k8MjDi3ty5WQQ2223bbKkVoarZv91dkUUYgkbIEmSylPAzCc0XmB5TY +f+ohl+sUCE0WeG0t1gvcwfFDLvSIS07sd95PI8Fyi3C2iyWH1zvX3Woe9CxfL3yi6/OO/h3W0whP +Sa+UpZlQEvKFq8JqU4Wv93n3UjfNY4hkba23bUEmstjyBD4u4uYVeEiq0JqgXUxRlrDB0+QgFilD +ZsoSJgUpVuSPLP2DUfrpm/zDvFM6BLm2p08loIbwHtjpOstVtnXW2jTporvkC6Fmg0NHDI9cs0o+ +57bTLtzhr0+TGkNwnDcQwTXwok0NsZKIB3JQShp/GkSyPu/e1dAwAfN2GZfwOL39zO+fu+TTSfv6 +VMO69rrFuxSy+pAhWUQfubJgxxYFXzlP6A94GmhKyqi4H194zc3zoxvo9Z3p1vpOTbi3P1P0eozy +Dw+6nIrJIkKGJBYYJsS5bbSRp573dJMbDJYJXO4gj3tiQdzSzx5ZROBpSo0+YddgsyCHyulH72aD +uanl6uMAdSnKB4YieklWH8G2jPhPvk0mxD6RzhbUTdittW+hbkQfOvsc8APor6KHI7F+iGc5+1st +0aRs/c13t1VEnZqczA69rBVcjC7A7Dm65QLmUQdA4Qq2jsUE9ddLTnKhYR2qIvuSqzsEloI6FX+N +j9NN+L8MaYktiguz6wSt1TYY53qC+K96lzApZJs2urarb6QU4oYm7mK0L+RCFAoJXCFpSfNAMa/8 +E9vk23IBRSUNT5Myx5Bs37vu+oflM98zJ2rWMFBBEDhlEPame0wwYpqMoo7pmRESjViextMLYUti +lLRYRT8Ybww5hSiMYkYiiCk+IMKzo9NmjJ7PRhjKXk46sqBt3lQHdKhu71maURG2xqFueRmkVRKB +0ITIWo7w47LgLgej6I77+PW+5z2oipaZ93QdAjI4okBPh8PypN/BZiLh5wIJzK4cbwbXr6tyxXpd +sLgw8D9A+54hg85k/1uFKugbbhtf5uPThQ+EmrVT6jgurHWGHgoiygaUnyDCmtpvnqeimAo+gMF8 +QZ2eRKCLOksUFUPVZrPZjj17OjwRoa3T0rd2mbGvaRA02p0nTyDt+t76WwMCCVPzzwn3MLbdixmz +HJmVV7Zm5WbTnW5KLHj/I+halYCUaNFQqPssqBgH1f946nYphmsRvDPy+PG+yuUN2bvOTKtJMBPT +RB/U2+i84Rqyp0QaVndpdxbyg8oxdVWlRf0jHuqh2ezRi9x3ilGDwr6u/agomEMOGEMdtoeJvMu0 +46L9Adsrw8X171aB+V2pYWFQjfrHNBB0DbbyNCx+kR4j0rSV7noBS3sajSQZvRODwa8dLpZlOslB +zrCiLVK7u033hJCVLOhpxqZiu5RCCGJZeGFPLYogPMMQE7J2XbiHJoejym5wgRH5HVu0WA4BqHDM +BkJteabamUIzZBqNDccB+7w86xLYcW/6lJDLz31kqqO7z9EoiIRTQDKODvDYRs+nxrXA2tC5TcQV +HVtL6hmLriQWWvkeIQtnrtLPmLwTKjjalOzEDU2Zf8EiQM944L23ty0qCM8rkH+PU838fut7rep2 +81IhP3tHObODJCojtGDmxWZgnRogs44aCwcvXnT1NOlZS3IvPAzEr82IApRK3ZSSPyapvLY406uM +0SKhSMGixPoA1HJ6tGM+bsy0aBwiiqMzGGcMkdCkt9VdMQDEJCI4RCrutY3DWSBOw9AWR9t2daNc +cqPmeW4Q6D2k9TyukWPnYkkjHeN7aKwqIxmRYZC8PN6OxTQWmubGoYqXmO9itSDuPtwVzL3vAh6X +idPqeDzWHD0VhwMOtj3NXJJ/jTEU2M10veS9qWSHTkvqO1rMS+O1eVg8+nIIc2XAdKRcN8UYCvhd +j+TbWttkGJGJM1EY9d6ZZcsDMRegsZHGkGIZ9UrtSDPZedfzN0SSRpObQrjG+ad2/XlTCp8KcSyI +KNsQWWk33b2TV9rpmlZa9TKM1Bmzt5liOSsi0E1qhM9t9lX/JSficmN0yQHkvsuA+qPF2ufA4NLY +abETTL+bi8aQvZ63Qk9BUxK4njPlrxj25zDo0B/q/i2XBXw9PN8y9TRvYTpxFHPHoFJj8G2SFZ43 +ddxvIJZkLJZIcM/0mFKTHMgijJFVCvDYDG8NZqIdRB5hxZSXEEOz2B9WH3ZWHe7+5tIq9dfNC4wY ++skpIEGVkb8YsG+ctg+UDLeQrw+uYDjQgsGMNm37B0YqaxmGo+OWZr03Sw7F3fyRMdLBXWgyHZIJ +JRHq0pwYGKTFlDv2QkIu2bAzJwaLWbpbR3PaoIh2J/HFSVnnJyiJMljRvdSypf1kC4IHn4rAHdoO +Whkw4TjWoQJDkuNgbFu2oUIpiBRflMPkZTJqd2cQ63reBEJQ4AFJG8yCdWZSJhy91teG/1GyvUl1 +Fxlp5SIIQQNJBRF67FGb4/lfP0+FsGXvuS6kxZAlc9zv3tjOA/Wu5b3GwPA1TKh0z7latLsnOHYc +DtlMI2TAd5Xxu9k4ELIJiY3HhFad4/X9pAVHDgVf/QX1TBCyDR9+1yaDG5dJblVjh6U9ZLPv5pQV +4NzLVddy5ycJYlPwqslqhs3V+S2Lg1QcHuen6OQsebGgw1/KV5ygOXrl/aNVSAYyqgBYuFJYXRcl +tKIiXWMmv9m/61wNjBMgKAwA5Iz0CmGExQXq7QT1Qo6HF7TZMfMer+t6PWqpkRGhOOCu7hmvK2b6 +l/Mzr3ovgRmROaTEQgL47iaHBtIhpDaK4ycIaXJ7tzh9BkxEFxkMhPFPTmsspIzryay627MpmEqo +pZUZnyrox4Y3HGqx/F5SPOueV6OKzA/LZQCIU7vwVwmU+bsndj7KCKv9y7qNQ5cnCN3On41UMJv/ +02l3DEUZ0bx6Ya1zjNgdSSuuYHnXDOMPzQEG2Ou/gchDwOFeW1gXGgEtwZYYBJJGkaPPsJ7avhMI +oTbJqNIHBRkBg5BCcGWJAffTYVNE1JqxixLY5mNfWyBs5yB9lBkK5xDSadTs1OwibOD01SBESWQS +k/ATGIyAHKo59F2YQfTCwLa/Z7A45y3Fy7nsVh5wWKEXoQw7h6Q+bwOq8yrnSSTnAZgHzliMmaGs +AfX8aZp0GnYPnUYj8xGccAot5W3z7ZYTT/HYPjkuY6tPl8DKU97qF+MyFSE0F4xaIwCooi5qYmiC +6lrD+7YdAHVHzybr7xj08oU83iJZtivnuni1x7akNKSZKwhdtp7GeJw+AnNZir5WujrSquGZnlGj +MVVXrtVVXQF14mXWe3/JKVcQWX+mybP1ho0bOhEt5jwFmmCGjsnweF4NzPaQ5WoS91EvaLFvGTtu +MjmnaFCmdXpxPfWMejbxgKuetnWmOTp0BfJnNTcLG7ub90u/BgPTIopkAT/RJ7UCEqWMYI75JQ3u +r+LGFymNS43nFiUwszRCNiFUnZsYXWfDVdWZFj6DHVzfvxX+WMRFIGQLGeQOjBmD318rgmYomsJc +9Ai2XP3AvV+MnB4hkbqstkB7RBdTWtUNlNTddocS2DU6dyYdnTCIAjyyCxOidYICu9GmZ5mYdjse +naxCKChqlPa2gDDyfam/e8p8bF5IYbrpeWNAHjDHQslQv75hMwnFEQU3PbQ7ASw8z1VFsTXxJLUU +K2BRSIoD0kq6xsy+f3qtVZTRe5Z53iYolzbYGMbTfB59VCA6OhmuFKARXkHFRg5DAuM1+3TNRM24 +Hy8fo8GC9YIEMxKi6nFKL8J98ajMe8paGNcoOCs56dC4nEwVfUsOyVL0PUdiuoCB6I7WLJJvHvpt +rrpT/poofhP033/i3JUmPEPsuNEhJ99Gcz6LPW0fnZiCYfvOTT7/5f83P3w1zD0gylvrMC4msyDX +9kcXUJynxXjjun1Xt/oT+T2ef0aVK39/2aYsVGNChUtnrzKylrKUKtN5i4ZkpaLRQa0tDwHAcf49 +u0ZdBlV7c1RtxttzMFi9+yovS2zjzP5til7585MLDv98j+RN3sTr9lpTs4q5YBlLsERw13p9nl0p +VDKRhaGxtsbGMU7OYYbkEqZWdN4GDBGHhp2vF7Rs1OpwYpQSGk2KVTd4sYMRc3KRAzGLsz+SmLR+ +Pk38ty5rkZr35EZSubRyCXy5psQBYdCqigirUSUxxKEVQHMCAwjodYpaGjA0GSEP8VsqHDm7tJX4 +0HDnCuOya4RTTovYAShnfs1WNq+7N67etwWqYKx85ql/dUePUivGC7K+5MeROgozYLgVjNQ192dN +rzc65k5ueaKqaba4icbDr9SW8DDASgZDhP+P+jw6oqtjxcoTMYwTLtinlLwhWJaqgqxqChZuQYTF +aqgcRmCZElKQKt2w0cWZq3ahfofcb/HTOzql8LB2zVnD9h405ocVSMqiKMchXFOFA1iySx2DXKul +lyTTqNyIsGUUztjLmXUCNNCRS1eYiiiJ1G8vlaoEgbSRS0IzxiLeqqxDvQ72DuowUdin4D9qSaXJ +4BkXeZVYUCnD47DwS8wKVxsNvrEJ1m13aoJGF8f261bqxmrjNZlKMMoP/lgv14cjKoW5e7dbzXp6 +MT7SDZtI7NgsjkY9+esIbslppuiXfct8ugVSjbav7NAecPh2OHMr0Hrhm7kR0SNWYG98x3efv3R9 +MGDMGYNqPqTQRcs9yZqLrnWO9qEIu/MXhj/qyOImdfr++HUdCjh1SBXTVnShsnr9W0cDdOiUEEG6 +jiCCRascP2kfoZ9IYB1X70qiuEb1rBhiLoVqC19q8t/olx6e+esjAB63Dm+zyKoXW2J9LzHhRpRm +R7RqFClyOqPKuCSH6n67q/Acua7tsA5xnKBDxWEIsCKBr1eupk1T12ckmhGJILGIcncZkLYRMfFX +31h2DBUZopCJ6TnsAE/AEicQUG7UUgU4+/zHZb8Rs6qBJMduKhgNCiY3q9aLwXgmpKSd2obaEFKt +4pYfCm8ewb6qp8wcXlbUVn1aaSraP2P2dfNkteTbmyO1aA2ovm09i2qCEj45GcK7FtaiBj0WtI8p +vdgKHqonU9N55sl3lEx8wktSrYuWgdJ9xG4HaxZ0rYO9RppQ+WngTqzD4fcz6RqZSTSK6ZyH76xM +ahCODDVAZAaMTIMeF6VWn5tZphWN6LYpdhaKq69CvLRWy/39Jtf9OqHKIACvcnUmvRIm9SjlaREf +s1HxbGOf8LPTM1vE15cb0S7g5uYUht7r1UYenfoyOe47ymEd/tixTb/kfEuu0F6zymv8l9tTq65j +y7zRvV1kEq2NrjMC20sjwoRksntN8/2v0vk+/Kj9RoNYYVb/h3+PSvEklpSsRl8U9i3STmE6Fa0R +WFlYuB0Qlv0qLcI59hmfM+uFdkziu7KuuZJ2hEkROG5K4whMQ1RQqP3ftZiryDKWJvM3HMHJk9yy +cbeX6soJfJdTp0SL43Yb38q7Dnp09eIr7BQPlVknA2A2olmggKb5CEnzHKmsH6vWnyjczVJDLaWc +XzVxe8f3Pn3CvfvlUVSQ9fqPJt7nXXd1a5XhIQGAFoQwQYcMNB8hqIpkXweSFtHL2zGB1eCVDQJB +WKaMOvt08tgHWYduEvX19ZknAMBu7T/Tmty87P7N9UQQIT9OXM802uLyek6YKKIPOCaRqUkcT4gs +H+yrrzNELzzKoZLPGBTvtCS7lrPddedRitWZGPYJTKZJSTIRQGhTcKDE16EGaw7B6WQaWGeJWwOb +meK1JJNMaEsU/FnMVUz2uZC4BF+SwFPFHt/fZho52iFKyHZKPFhKIxUa/bvUsYFfqspj05xLIKSQ +gk0hWX+VfHpufUK9yi3vJW50u3adMCdFI6Ho1IpPWjU10JIKo5UIJZjSOMhgceXLz28yNK5K4Voi +7Tn7U9zVSYA5urmsJLelRptraoaGiJqIDNDGJjX69xfDNS1hQmW1DOdUY6fwaoEQmyzKUfjHtKWj +o31rUvkL+v5PrcNvho0LZWbjryzT97799/SgmEwkI9f4kXTUId6zHflRA2HGzHQZ5NEGS0sRQjRY +S1kqVbBCBUv7sveFSE4gw4HVhgiLmIedfPzfR/vVOf55ZyhJZkSRaLmIvDnzADnuzoCfKBrzGXYG +AWvJbdil75FUR4+hoRUapLE2ZdWB8N5IcH3f8mS2qzRHXJQ4cDDH3hIWZ/W42viTPvIHsh2WLa1E +WfdszFtjKPvPYmg1ossTeUTuw0YqTFLZbU8fPt3oc/vXbm/iooj+pVRl5D3LxkXLzF7fuXyIL6Yh +Qm7tXtu5guuhYbzZjj8ft6x/N0sfPZROPhWBjNMKh4qVChnu3J/tDY7V6ZI9vw4V/B7KXXMqshv8 +6e9WoXxhnz1/hG0GGNluNJ7jlGfQPiGJek08iZGz0CNAzLxZ2LKzM+jJn/mO0FALDWq7fkQiZlfc +lLA4R3bh1v7z+n5eCVKexaIy9Zs/dTqpPQ5/dyVl0jKRzcbiI1NjsOu2HSdFzxHTBI2pKKALQ0JJ +jTOaKSzam2UB30esF1Gxirpy5uKxFssVjlrMjosEC+PVhVXIjjwzt6H1sYXloedC/QhU7maKGdZC +xSHkyzMlshg9Srv1w6BwFS6K6PgCw2CtHh1QZ1a0kQTxuqUSGFBYowddAs/fJZEsfTMqRnhbFlMZ +AOT9E+Fvc0o30fQ8CjqLus6p+k18u925JF7hDruMJlspVPCcIw13uX85/S/lNh/Q728N/UYU7BoN +BfOAmDI+5MgtgZ+M+Y3NnmzdSx/dPTZGMp5WpjVyCqpyXAYhnBITYp2kez2kyfF2cjUHT8rJ4PS7 +zrVyrVkkUwYXY+j8l4SiFWlOz9v0u69zNScZwx2cu9YsEvwYqREsUHL+92VfONvwW2CxQ2m9Z7NG +jU91RuL43XReMtuo0PSxrI1mLHsMg4uFGqSN6Fccb9bYv1WqqRDc8VPNEQAJqbQRrxQraTZ/iW0D +3Fzf5dqnCXOz5qPsacc6+tv/Fxdfyvq6lCOPhelPU9H3k+ucrF+PJWYaBUNskzRCXH54Zeb9rpVn +TYvP58RTg7eCUZy3vtjhA0f4ouFhHyS2i9/33188U1We4UFhft9uJquxOoosVEu5zKcnKvWUe4vl +UdkphZeJDSbvT5WHrefmrwspbrAxDD6wlxbnNBCPMgZggCcueZmd8aO7/hpCwvQ4dRNHhJMRdaPs +mUfl/emJec1ZtEes7by7nMtcSRyn4b05EPkULEkbTngUpQERBIxNpQZMYaSz0zgzFk7m+3BNQ0lK +X4SZPFqEBg4pkH3Zi5DTYAxsaQXnboIEhc8OSQkPQNFhCdSQh305IHaI2hRSLARYsQWLFj2Twfqu +o5SdhgBs6NgcKdIYdkQvauMzN0rY+NELxR2c8FBBGbDBykE0MsSfzJgb+9X716t8jldjhPq+XS0n +lxDJJMJAGBkOYN5DEFbaKiLbYok+t+H4PD/h7ecPzKTnDHplVtvpXspioisRREjytV27SZpqw4tu +6LN6KY12zTjra5G5FxizWZgqk7qcnjVDbIcsMmFO/uYNhU2gXFpWHYTGcM8GO3Q207T/VEYkCcwO +ZmUByAMgGBioRCHyKg2agbvUIpzAAnJBAFoMrdk71DVKqsH7+ThCN2iAOb/ufvYVmz4h5MlY4tR/ +LVNDvTmve9yZ/VzZpoc7Kzf1PWM6YU6nuEuT6rBkv7+HQwhPrdZb5f4eX+n+0b9dbU1AcHT51X4E +rK9nXoXnGANV72H8GJFZ3q+YgPnkw2nvfd/T8FbP0Pk/2HbE+r7LuuY41FDuEohRWIiHK9mFrTRN +B/+LuSKcKEhW39pzgA== +==== diff --git a/sys/contrib/dev/nve/os.h b/sys/contrib/dev/nve/os.h new file mode 100644 index 0000000..4749543 --- /dev/null +++ b/sys/contrib/dev/nve/os.h @@ -0,0 +1,128 @@ +/***************************************************************************\ +|* *| +|* Copyright 2001-2004 NVIDIA Corporation. All Rights Reserved. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL *| +|* TO NVIDIA, CORPORATION. USE, REPRODUCTION OR DISCLOSURE TO ANY *| +|* THIRD PARTY IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORP. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROVIDED "AS IS" WITHOUT *| +|* EXPRESS OR IMPLIED WARRANTY OF ANY KIND, INCLUDING ALL IMPLIED *| +|* WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A *| +|* PARTICULAR PURPOSE. *| +|* *| +\***************************************************************************/ + +/* + FILE: os.h + DATE: 2/7/00 + + This file contains the os interface. Note that the os interface is + itself an OS-independent API. The OS specific module is implemented + by ndis.c for Win9X/NT and linuxnet.c for linux. +*/ +#ifndef _OS_H_ +#define _OS_H_ + +#include "phy.h" + +#define HDO_VERSION_STRING "HDR O: $Revision: #21 $"; + +// This is the maximum packet size that we will be sending +// #define MAX_PACKET_SIZE 2048 +//#define RX_BUFFER_SIZE 2048 + +#define MIN_PACKET_MTU_SIZE 576 +#define MAX_PACKET_MTU_SIZE 9202 +#define MAX_PACKET_SIZE_2048 2048 +#define MAX_PACKET_SIZE_1514 1514 +#define MAX_PACKET_SIZE_1518 1518 +#define MAX_PACKET_SIZE_JUMBO (9 * 1024) + +typedef struct _MEMORY_BLOCK +{ + PNV_VOID pLogical; + PNV_VOID pPhysical; + NV_UINT32 uiLength; +} MEMORY_BLOCK, *PMEMORY_BLOCK; + +#define ALLOC_MEMORY_NONCACHED 0x0001 +#define ALLOC_MEMORY_ALIGNED 0x0002 + +typedef struct _MEMORY_BLOCKEX +{ + PNV_VOID pLogical; + PNV_VOID pPhysical; + NV_UINT32 uiLength; + /* Parameter to OS layer to indicate what type of memory is needed */ + NV_UINT16 AllocFlags; + NV_UINT16 AlignmentSize; //always power of 2 + /* Following three fields used for aligned memory allocation */ + PNV_VOID pLogicalOrig; + NV_UINT32 pPhysicalOrigLow; + NV_UINT32 pPhysicalOrigHigh; + NV_UINT32 uiLengthOrig; +} MEMORY_BLOCKEX, *PMEMORY_BLOCKEX; + + +// The typedefs for the OS functions +typedef NV_API_CALL NV_SINT32 (* PFN_MEMORY_ALLOC) (PNV_VOID pOSCX, PMEMORY_BLOCK pMem); +typedef NV_API_CALL NV_SINT32 (* PFN_MEMORY_FREE) (PNV_VOID pOSCX, PMEMORY_BLOCK pMem); +typedef NV_API_CALL NV_SINT32 (* PFN_MEMORY_ALLOCEX) (PNV_VOID pOSCX, PMEMORY_BLOCKEX pMem); +typedef NV_API_CALL NV_SINT32 (* PFN_MEMORY_FREEEX) (PNV_VOID pOSCX, PMEMORY_BLOCKEX pMem); +typedef NV_API_CALL NV_SINT32 (* PFN_CLEAR_MEMORY) (PNV_VOID pOSCX, PNV_VOID pMem, NV_SINT32 iLength); +typedef NV_API_CALL NV_SINT32 (* PFN_STALL_EXECUTION) (PNV_VOID pOSCX, NV_UINT32 ulTimeInMicroseconds); +typedef NV_API_CALL NV_SINT32 (* PFN_ALLOC_RECEIVE_BUFFER) (PNV_VOID pOSCX, PMEMORY_BLOCK pMem, PNV_VOID *ppvID); +typedef NV_API_CALL NV_SINT32 (* PFN_FREE_RECEIVE_BUFFER) (PNV_VOID pOSCX, PMEMORY_BLOCK pMem, PNV_VOID pvID); +typedef NV_API_CALL NV_SINT32 (* PFN_PACKET_WAS_SENT) (PNV_VOID pOSCX, PNV_VOID pvID, NV_UINT32 ulSuccess); +typedef NV_API_CALL NV_SINT32 (* PFN_PACKET_WAS_RECEIVED) (PNV_VOID pOSCX, PNV_VOID pvADReadData, NV_UINT32 ulSuccess, NV_UINT8 *pNewBuffer, NV_UINT8 uc8021pPriority); +typedef NV_API_CALL NV_SINT32 (* PFN_LINK_STATE_HAS_CHANGED) (PNV_VOID pOSCX, NV_SINT32 nEnabled); +typedef NV_API_CALL NV_SINT32 (* PFN_ALLOC_TIMER) (PNV_VOID pvContext, PNV_VOID *ppvTimer); +typedef NV_API_CALL NV_SINT32 (* PFN_FREE_TIMER) (PNV_VOID pvContext, PNV_VOID pvTimer); +typedef NV_API_CALL NV_SINT32 (* PFN_INITIALIZE_TIMER) (PNV_VOID pvContext, PNV_VOID pvTimer, PTIMER_FUNC pvFunc, PNV_VOID pvFuncParameter); +typedef NV_API_CALL NV_SINT32 (* PFN_SET_TIMER) (PNV_VOID pvContext, PNV_VOID pvTimer, NV_UINT32 dwMillisecondsDelay); +typedef NV_API_CALL NV_SINT32 (* PFN_CANCEL_TIMER) (PNV_VOID pvContext, PNV_VOID pvTimer); + +typedef NV_API_CALL NV_SINT32 (* PFN_PREPROCESS_PACKET) (PNV_VOID pvContext, PNV_VOID pvADReadData, PNV_VOID *ppvID, + NV_UINT8 *pNewBuffer, NV_UINT8 uc8021pPriority); +typedef NV_API_CALL PNV_VOID (* PFN_PREPROCESS_PACKET_NOPQ) (PNV_VOID pvContext, PNV_VOID pvADReadData); +typedef NV_API_CALL NV_SINT32 (* PFN_INDICATE_PACKETS) (PNV_VOID pvContext, PNV_VOID *ppvID, NV_UINT32 ulNumPacket); +typedef NV_API_CALL NV_SINT32 (* PFN_LOCK_ALLOC) (PNV_VOID pOSCX, NV_SINT32 iLockType, PNV_VOID *ppvLock); +typedef NV_API_CALL NV_SINT32 (* PFN_LOCK_ACQUIRE) (PNV_VOID pOSCX, NV_SINT32 iLockType, PNV_VOID pvLock); +typedef NV_API_CALL NV_SINT32 (* PFN_LOCK_RELEASE) (PNV_VOID pOSCX, NV_SINT32 iLockType, PNV_VOID pvLock); +typedef NV_API_CALL PNV_VOID (* PFN_RETURN_BUFFER_VIRTUAL) (PNV_VOID pvContext, PNV_VOID pvADReadData); + +// Here are the OS functions that those objects below the OS interface +// can call up to. +typedef struct _OS_API +{ + // OS Context -- this is a parameter to every OS API call + PNV_VOID pOSCX; + + // Basic OS functions + PFN_MEMORY_ALLOC pfnAllocMemory; + PFN_MEMORY_FREE pfnFreeMemory; + PFN_MEMORY_ALLOCEX pfnAllocMemoryEx; + PFN_MEMORY_FREEEX pfnFreeMemoryEx; + PFN_CLEAR_MEMORY pfnClearMemory; + PFN_STALL_EXECUTION pfnStallExecution; + PFN_ALLOC_RECEIVE_BUFFER pfnAllocReceiveBuffer; + PFN_FREE_RECEIVE_BUFFER pfnFreeReceiveBuffer; + PFN_PACKET_WAS_SENT pfnPacketWasSent; + PFN_PACKET_WAS_RECEIVED pfnPacketWasReceived; + PFN_LINK_STATE_HAS_CHANGED pfnLinkStateHasChanged; + PFN_ALLOC_TIMER pfnAllocTimer; + PFN_FREE_TIMER pfnFreeTimer; + PFN_INITIALIZE_TIMER pfnInitializeTimer; + PFN_SET_TIMER pfnSetTimer; + PFN_CANCEL_TIMER pfnCancelTimer; + PFN_PREPROCESS_PACKET pfnPreprocessPacket; + PFN_PREPROCESS_PACKET_NOPQ pfnPreprocessPacketNopq; + PFN_INDICATE_PACKETS pfnIndicatePackets; + PFN_LOCK_ALLOC pfnLockAlloc; + PFN_LOCK_ACQUIRE pfnLockAcquire; + PFN_LOCK_RELEASE pfnLockRelease; + PFN_RETURN_BUFFER_VIRTUAL pfnReturnBufferVirtual; +} OS_API, *POS_API; + +#endif // _OS_H_ diff --git a/sys/contrib/dev/nve/phy.h b/sys/contrib/dev/nve/phy.h new file mode 100644 index 0000000..87596a5 --- /dev/null +++ b/sys/contrib/dev/nve/phy.h @@ -0,0 +1,164 @@ +/***************************************************************************\ +|* *| +|* Copyright 2001-2004 NVIDIA Corporation. All Rights Reserved. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROPRIETARY AND CONFIDENTIAL *| +|* TO NVIDIA, CORPORATION. USE, REPRODUCTION OR DISCLOSURE TO ANY *| +|* THIRD PARTY IS SUBJECT TO WRITTEN PRE-APPROVAL BY NVIDIA, CORP. *| +|* *| +|* THE INFORMATION CONTAINED HEREIN IS PROVIDED "AS IS" WITHOUT *| +|* EXPRESS OR IMPLIED WARRANTY OF ANY KIND, INCLUDING ALL IMPLIED *| +|* WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A *| +|* PARTICULAR PURPOSE. *| +|* *| +\***************************************************************************/ + +/* + FILE: phy.h + DATE: 2/7/00 + + This file contains the functional interface to the PHY. +*/ +#ifndef _PHY_H_ +#define _PHY_H_ + +//#include "basetype.h" +//#include "nvevent.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define DEFAULT_PHY_ADDRESS 1 + + +#define HDP_VERSION_STRING "HDR P: $Revision: #23 $" + +// +// Defaults for PHY timeout values. +// +#define PHY_POWER_ISOLATION_MS_TIMEOUT_DEFAULT 50 +#define PHY_RESET_MS_TIMEOUT_DEFAULT 50 +#define PHY_AUTONEG_MS_TIMEOUT_DEFAULT 3000 +#define PHY_LINK_UP_MS_TIMEOUT_DEFAULT 2400 +#define PHY_RDWR_US_TIMEOUT_DEFAULT 2048 +#define PHY_POWER_DOWN_US_TIMEOUT_DEFAULT 500 + + +///////////////////////////////////////////////////////////////////////// +// The phy module knows the values that need to go into the phy registers +// but typically the method of writing those registers is controlled by +// another module (usually the adapter because it is really the hardware +// interface.) Hence, the phy needs routines to call to read and write the +// phy registers. This structure with appropriate routines will be provided +// in the PHY_Open call. + +typedef NV_API_CALL NV_SINT32 (* PFN_READ_PHY) (PNV_VOID pvData, NV_UINT32 ulPhyAddr, NV_UINT32 ulPhyReg, NV_UINT32 *pulValue); +typedef NV_API_CALL NV_SINT32 (* PFN_WRITE_PHY) (PNV_VOID pvData, NV_UINT32 ulPhyAddr, NV_UINT32 ulPhyReg, NV_UINT32 ulValue); + +typedef struct PHY_SUPPORT_API +{ + PNV_VOID pADCX; + PFN_READ_PHY pfnRead; + PFN_WRITE_PHY pfnWrite; + // PFN_EVENT_OCCURED pfnEventOccurred; + + // + // These fields are passed down via the FD. FD get's them + // from the registry. They allow one to fine tune the timeout + // values in the PHY. + // + NV_UINT32 PhyPowerIsolationTimeoutInms; + NV_UINT32 PhyResetTimeoutInms; + NV_UINT32 PhyAutonegotiateTimeoutInms; + NV_UINT32 PhyLinkupTimeoutInms; + NV_UINT32 PhyPowerdownOnCloseInus; + +} PHY_SUPPORT_API, *PPHY_SUPPORT_API; +///////////////////////////////////////////////////////////////////////// + + +///////////////////////////////////////////////////////////////////////// +// The functional typedefs for the PHY Api +typedef NV_SINT32 (* PFN_PHY_INIT) (PNV_VOID pvContext, NV_UINT32 *pulLinkState, NV_UINT32 PhyMode); +typedef NV_SINT32 (* PFN_PHY_DEINIT) (PNV_VOID pvContext); +typedef NV_SINT32 (* PFN_PHY_CLOSE) (PNV_VOID pvContext); +typedef NV_SINT32 (* PFN_GET_LINK_SPEED) (PNV_VOID pvContext); +typedef NV_SINT32 (* PFN_GET_LINK_MODE) (PNV_VOID pvContext); +typedef NV_SINT32 (* PFN_GET_LINK_STATE) (PNV_VOID pvContext, NV_UINT32 *pulLinkState); +typedef NV_SINT32 (* PFN_IS_LINK_INITIALIZING) (PNV_VOID pvContext); +typedef NV_SINT32 (* PFN_RESET_PHY_INIT_STATE) (PNV_VOID pvContext); +typedef NV_SINT32 (* PFN_FORCE_SPEED_DUPLEX) (PNV_VOID pvContext, NV_UINT16 usSpeed, NV_UINT8 ucForceDpx, NV_UINT8 ucForceMode); +typedef NV_SINT32 (* PFN_PHY_POWERDOWN) (PNV_VOID pvContext); +typedef NV_SINT32 (* PFN_SET_LOW_SPEED_FOR_PM) (PNV_VOID pvContext); + + +typedef struct _PHY_API +{ + // This is the context to pass back in as the first arg on all + // the calls in the API below. + PNV_VOID pPHYCX; + + PFN_PHY_INIT pfnInit; + PFN_PHY_INIT pfnInitFast; + PFN_PHY_DEINIT pfnDeinit; + PFN_PHY_CLOSE pfnClose; + PFN_GET_LINK_SPEED pfnGetLinkSpeed; + PFN_GET_LINK_MODE pfnGetLinkMode; + PFN_GET_LINK_STATE pfnGetLinkState; + PFN_IS_LINK_INITIALIZING pfnIsLinkInitializing; + PFN_RESET_PHY_INIT_STATE pfnResetPhyInitState; + PFN_FORCE_SPEED_DUPLEX pfnForceSpeedDuplex; + PFN_PHY_POWERDOWN pfnPowerdown; + PFN_SET_LOW_SPEED_FOR_PM pfnSetLowSpeedForPM; +} PHY_API, *PPHY_API; +///////////////////////////////////////////////////////////////////////// + + +///////////////////////////////////////////////////////////////////////// +// This is the one function in the PHY interface that is publicly +// available. The rest of the interface is returned in the pPhyApi; +// The first argument needs to be cast to a POS_API structure ptr. +// On input the second argument is a ptr to a PPHY_SUPPORT_API. +// On output, the second argument should be treated as a ptr to a +// PPHY_API and set appropriately. +extern NV_SINT32 PHY_Open (PNV_VOID pvOSApi, PNV_VOID pPhyApi, NV_UINT32 *pulPhyAddr, NV_UINT32 *pulPhyConnected); +///////////////////////////////////////////////////////////////////////// + + +///////////////////////////////////////////////////////////////////////// +// Here are the error codes the phy functions can return. +#define PHYERR_NONE 0x0000 +#define PHYERR_COULD_NOT_ALLOC_CONTEXT 0x0001 +#define PHYERR_RESET_NEVER_FINISHED 0x0002 +#define PHYERR_NO_AVAILABLE_LINK_SPEED 0x0004 +#define PHYERR_INVALID_SETTINGS 0x0005 +#define PHYERR_READ_FAILED 0x0006 +#define PHYERR_WRITE_FAILED 0x0007 +#define PHYERR_NO_PHY 0x0008 +#define PHYERR_NO_RESOURCE 0x0009 +#define PHYERR_POWER_ISOLATION_TIMEOUT 0x000A +#define PHYERR_POWER_DOWN_TIMEOUT 0x000B +#define PHYERR_AUTONEG_TIMEOUT 0x000C +#define PHYERR_PHY_LINK_SPEED_UNCHANGED 0x000D + +#define PHY_INVALID_PHY_ADDR 0xFFFF; + +///////////////////////////////////////////////////////////////////////// + +// This value can be used in the ulPhyLinkSpeed field. +#define PHY_LINK_SPEED_UNKNOWN 0x0FFFFFFFF + +// +// Values used to configure PHY mode. +// +#define PHY_MODE_MII 1 +#define PHY_MODE_RGMII 2 + +typedef NV_VOID (* PTIMER_FUNC) (PNV_VOID pvContext); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif //_PHY_H_ |
