/* 
 * Copyright (c) 1993,1994
 *      Texas A&M University.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Texas A&M University
 *      and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Developers:
 *             David K. Hess, Douglas Lee Schales, David R. Safford
 *
 * Heavily modified for Metaware HighC + GNU C 2.8+
 *             Gisle Vanem 1998
 */

#ifndef __PCAP_NDIS_H
#define __PCAP_NDIS_H

#if defined (__HIGHC__)
  #define pascal          _CC(_CALLEE_POPS_STACK & ~_REVERSE_PARMS) /* calling convention */
  #define CALLBACK(foo)   pascal WORD foo
  #define PAS_PTR(x,arg)  typedef FAR WORD pascal (*x) arg
  #define GUARD()         _inline (0x9C,0xFA)   /* pushfd, cli */
  #define UNGUARD()       _inline (0x9D)        /* popfd */
  #define FAR             _far

#elif defined(__GNUC__)
  #define CALLBACK(foo)   WORD foo __attribute__((stdcall))
  #define PAS_PTR(x,arg)  typedef WORD (*x) arg __attribute__((stdcall))
  #define GUARD()         __asm__ __volatile__ ("pushfd; cli")
  #define UNGUARD()       __asm__ __volatile__ ("popfd")
  #define FAR

#elif defined (__TURBOC__)
  #define CALLBACK(foo)   WORD pascal foo
  #define PAS_PTR(x,arg)  typedef WORD pascal (_far *x) arg
  #define GUARD()         _asm { pushf; cli }
  #define UNGUARD()       _asm { popf }
  #define FAR             _far

#elif defined (__WATCOMC__)
  #define CALLBACK(foo)   WORD pascal foo
  #define PAS_PTR(x,arg)  typedef WORD pascal (_far *x) arg
  #define GUARD()         _disable()
  #define UNGUARD()       _enable()
  #define FAR             _far

#else
  #error Unsupported compiler
#endif


/*
 *  Forwards
 */
struct _ReqBlock;
struct _TxBufDescr;
struct _TDBufDescr;

/*
 * Protocol Manager API
 */
PAS_PTR (ProtMan, (struct _ReqBlock FAR*, WORD));

/*
 * System request
 */
PAS_PTR (SystemRequest, (DWORD, DWORD, WORD, WORD, WORD));

/*
 * MAC API
 */
PAS_PTR (TransmitChain, (WORD, WORD, struct _TxBufDescr FAR*, WORD));
PAS_PTR (TransferData,  (WORD*,WORD, struct _TDBufDescr FAR*, WORD));
PAS_PTR (Request,       (WORD, WORD, WORD, DWORD, WORD, WORD));
PAS_PTR (ReceiveRelease,(WORD, WORD));
PAS_PTR (IndicationOn,  (WORD));
PAS_PTR (IndicationOff, (WORD));


typedef enum {
        HARDWARE_NOT_INSTALLED  = 0,
        HARDWARE_FAILED_DIAG    = 1,
        HARDWARE_FAILED_CONFIG  = 2,
        HARDWARE_HARD_FAULT     = 3,
        HARDWARE_SOFT_FAULT     = 4,
        HARDWARE_OK             = 7,
        HARDWARE_MASK           = 0x0007,
        MAC_BOUND               = 0x0008,
        MAC_OPEN                = 0x0010,
        DIAG_IN_PROGRESS        = 0x0020
      } NdisMacStatus;

typedef enum {
        STATUS_RING_STATUS      = 1,
        STATUS_ADAPTER_CHECK    = 2,
        STATUS_START_RESET      = 3,
        STATUS_INTERRUPT        = 4,
        STATUS_END_RESET        = 5
      } NdisStatus;

typedef enum {
        FILTER_DIRECTED         = 1,
        FILTER_BROADCAST        = 2,
        FILTER_PROMISCUOUS      = 4,
        FILTER_SOURCE_ROUTE     = 8
      } NdisPacketFilter;

typedef enum {
        REQ_INITIATE_DIAGNOSTICS     = 1,
        REQ_READ_ERROR_LOG           = 2,
        REQ_SET_STATION_ADDRESS      = 3,
        REQ_OPEN_ADAPTER             = 4,
        REQ_CLOSE_ADAPTER            = 5,
        REQ_RESET_MAC                = 6,
        REQ_SET_PACKET_FILTER        = 7,
        REQ_ADD_MULTICAST_ADDRESS    = 8,
        REQ_DELETE_MULTICAST_ADDRESS = 9,
        REQ_UPDATE_STATISTICS        = 10,
        REQ_CLEAR_STATISTICS         = 11,
        REQ_INTERRUPT_REQUEST        = 12,
        REQ_SET_FUNCTIONAL_ADDRESS   = 13,
        REQ_SET_LOOKAHEAD            = 14
      } NdisGeneralRequest;

typedef enum {
        SF_BROADCAST             = 0x00000001L,
        SF_MULTICAST             = 0x00000002L,
        SF_FUNCTIONAL            = 0x00000004L,
        SF_PROMISCUOUS           = 0x00000008L,
        SF_SOFT_ADDRESS          = 0x00000010L,
        SF_STATS_CURRENT         = 0x00000020L,
        SF_INITIATE_DIAGS        = 0x00000040L,
        SF_LOOPBACK              = 0x00000080L,
        SF_RECEIVE_CHAIN         = 0x00000100L,
        SF_SOURCE_ROUTING        = 0x00000200L,
        SF_RESET_MAC             = 0x00000400L,
        SF_OPEN_CLOSE            = 0x00000800L,
        SF_INTERRUPT_REQUEST     = 0x00001000L,
        SF_SOURCE_ROUTING_BRIDGE = 0x00002000L,
        SF_VIRTUAL_ADDRESSES     = 0x00004000L
      } NdisMacServiceFlags;

typedef enum {
        REQ_INITIATE_BIND        = 1,
        REQ_BIND                 = 2,
        REQ_INITIATE_PREBIND     = 3,
        REQ_INITIATE_UNBIND      = 4,
        REQ_UNBIND               = 5
      } NdisSysRequest;

typedef enum  {
        PM_GET_PROTOCOL_MANAGER_INFO      = 1,
        PM_REGISTER_MODULE                = 2,
        PM_BIND_AND_START                 = 3,
        PM_GET_PROTOCOL_MANAGER_LINKAGE   = 4,
        PM_GET_PROTOCOL_INI_PATH          = 5,
        PM_REGISTER_PROTOCOL_MANAGER_INFO = 6,
        PM_INIT_AND_REGISTER              = 7,
        PM_UNBIND_AND_STOP                = 8,
        PM_BIND_STATUS                    = 9,
        PM_REGISTER_STATUS                = 10
      } NdisProtManager;


typedef enum {
        ERR_SUCCESS                      = 0x00,
        ERR_WAIT_FOR_RELEASE             = 0x01,
        ERR_REQUEST_QUEUED               = 0x02,
        ERR_FRAME_NOT_RECOGNIZED         = 0x03,
        ERR_FRAME_REJECTED               = 0x04,
        ERR_FORWARD_FRAME                = 0x05,
        ERR_OUT_OF_RESOURCE              = 0x06,
        ERR_INVALID_PARAMETER            = 0x07,
        ERR_INVALID_FUNCTION             = 0x08,
        ERR_NOT_SUPPORTED                = 0x09,
        ERR_HARDWARE_ERROR               = 0x0A,
        ERR_TRANSMIT_ERROR               = 0x0B,
        ERR_NO_SUCH_DESTINATION          = 0x0C,
        ERR_BUFFER_TOO_SMALL             = 0x0D,
        ERR_ALREADY_STARTED              = 0x20,
        ERR_INCOMPLETE_BINDING           = 0x21,
        ERR_DRIVER_NOT_INITIALIZED       = 0x22,
        ERR_HARDWARE_NOT_FOUND           = 0x23,
        ERR_HARDWARE_FAILURE             = 0x24,
        ERR_CONFIGURATION_FAILURE        = 0x25,
        ERR_INTERRUPT_CONFLICT           = 0x26,
        ERR_INCOMPATIBLE_MAC             = 0x27,
        ERR_INITIALIZATION_FAILED        = 0x28,
        ERR_NO_BINDING                   = 0x29,
        ERR_NETWORK_MAY_NOT_BE_CONNECTED = 0x2A,
        ERR_INCOMPATIBLE_OS_VERSION      = 0x2B,
        ERR_ALREADY_REGISTERED           = 0x2C,
        ERR_PATH_NOT_FOUND               = 0x2D,
        ERR_INSUFFICIENT_MEMORY          = 0x2E,
        ERR_INFO_NOT_FOUND               = 0x2F,
        ERR_GENERAL_FAILURE              = 0xFF
      } NdisError;

#define NDIS_PARAM_INTEGER   0
#define NDIS_PARAM_STRING    1

#define NDIS_TX_BUF_LENGTH   8
#define NDIS_TD_BUF_LENGTH   1
#define NDIS_RX_BUF_LENGTH   8

#define NDIS_PTR_PHYSICAL    0
#define NDIS_PTR_VIRTUAL     2

#define NDIS_PATH    "PROTMAN$"


typedef struct _CommonChars {
        WORD  tableSize;
        BYTE  majorNdisVersion;        /* 2 - Latest version */
        BYTE  minorNdisVersion;        /* 0                  */
        WORD  reserved1;
        BYTE  majorModuleVersion;
        BYTE  minorModuleVersion;
        DWORD moduleFlags;
        /* 0 - Binding at upper boundary supported
         * 1 - Binding at lower boundary supported
         * 2 - Dynamically bound.
         * 3-31 - Reserved, must be zero.
         */
        BYTE  moduleName[16];
        BYTE  protocolLevelUpper;
        /* 1 - MAC
         * 2 - Data Link
         * 3 - Network
         * 4 - Transport
         * 5 - Session
         * -1 - Not specified
         */
        BYTE  interfaceUpper;
        BYTE  protocolLevelLower;
        /* 0 - Physical
         * 1 - MAC
         * 2 - Data Link
         * 3 - Network
         * 4 - Transport
         * 5 - Session
         * -1 - Not specified
         */
        BYTE  interfaceLower;
        WORD  moduleId;
        WORD  moduleDS;
        SystemRequest systemRequest;
        BYTE *serviceChars;
        BYTE *serviceStatus;
        BYTE *upperDispatchTable;
        BYTE *lowerDispatchTable;
        BYTE *reserved2;            /* Must be NULL */
        BYTE *reserved3;            /* Must be NULL */
      } CommonChars;


typedef struct _MulticastList {
        WORD   maxMulticastAddresses;
        WORD   numberMulticastAddresses;
        BYTE   multicastAddress[16][16];
      } MulticastList;


typedef struct _MacChars {
        WORD   tableSize;
        BYTE   macName[16];
        WORD   addressLength;
        BYTE   permanentAddress[16];
        BYTE   currentAddress[16];
        DWORD  currentFunctionalAddress;
        MulticastList *multicastList;
        DWORD  linkSpeed;
        DWORD  serviceFlags;
        WORD   maxFrameSize;
        DWORD  txBufferSize;
        WORD   txBufferAllocSize;
        DWORD  rxBufferSize;
        WORD   rxBufferAllocSize;
        BYTE   ieeeVendor[3];
        BYTE   vendorAdapter;
        BYTE  *vendorAdapterDescription;
        WORD   interruptLevel;
        WORD   txQueueDepth;
        WORD   maxDataBlocks;
      } MacChars;


typedef struct _ProtocolChars {
        WORD   length;
        BYTE   name[16];
        WORD   type;
      } ProtocolChars;


typedef struct _MacUpperDispatch {
        CommonChars      *backPointer;
        Request           request;
        TransmitChain     transmitChain;
        TransferData      transferData;
        ReceiveRelease    receiveRelease;
        IndicationOn      indicationOn;
        IndicationOff     indicationOff;
      } MacUpperDispatch;


typedef struct _MacStatusTable {
        WORD   tableSize;
        DWORD  lastDiag;
        DWORD  macStatus;
        WORD   packetFilter;
        BYTE  *mediaSpecificStats;
        DWORD  lastClear;
        DWORD  totalFramesRx;
        DWORD  totalFramesCrc;
        DWORD  totalBytesRx;
        DWORD  totalDiscardBufSpaceRx;
        DWORD  totalMulticastRx;
        DWORD  totalBroadcastRx;
        DWORD  obsolete1[5];
        DWORD  totalDiscardHwErrorRx;
        DWORD  totalFramesTx;
        DWORD  totalBytesTx;
        DWORD  totalMulticastTx;
        DWORD  totalBroadcastTx;
        DWORD  obsolete2[2];
        DWORD  totalDiscardTimeoutTx;
        DWORD  totalDiscardHwErrorTx;
      } MacStatusTable;


typedef struct _ProtDispatch {
        CommonChars *backPointer;
        DWORD        flags;
        /* 0 - handles non-LLC frames
         * 1 - handles specific-LSAP LLC frames
         * 2 - handles specific-LSAP LLC frames
         * 3-31 - reserved must be 0
         */
        void  (*requestConfirm) (void);
        void  (*transmitConfirm) (void);
        void  (*receiveLookahead) (void);
        void  (*indicationComplete) (void);
        void  (*receiveChain) (void);
        void  (*status) (void);
      } ProtDispatch;


typedef struct _ReqBlock {
        WORD      opcode;
        WORD      status;
        BYTE FAR *pointer1;
        BYTE FAR *pointer2;
        WORD      word1;
      } ReqBlock;


typedef struct _TxBufDescrRec {
        BYTE   txPtrType;
        BYTE   dummy;
        WORD   txDataLen;
        BYTE  *txDataPtr;
      } TxBufDescrRec;


typedef struct _TxBufDescr {
        WORD          txImmedLen;
        BYTE         *txImmedPtr;
        WORD          txDataCount;
        TxBufDescrRec txBufDescrRec[NDIS_TX_BUF_LENGTH];
      } TxBufDescr;


typedef struct _TDBufDescrRec {
        BYTE   tDPtrType;
        BYTE   dummy;
        WORD   tDDataLen;
        BYTE  *tDDataPtr;
      } TDBufDescrRec;


typedef struct _TDBufDescr {
        WORD          tDDataCount;
        TDBufDescrRec tDBufDescrRec[NDIS_TD_BUF_LENGTH];
      } TDBufDescr;


typedef struct _RxBufDescrRec {
        WORD   rxDataLen;
        BYTE  *rxDataPtr;
      } RxBufDescrRec;


typedef struct _RxBufDescr {
        WORD          rxDataCount;
        RxBufDescrRec rxBufDescrRec[NDIS_RX_BUF_LENGTH];
      } RxBufDescr;


typedef struct _PktBuf {
	struct _PktBuf *nextLink;
	struct _PktBuf *prevLink;
        int    handle;
        int    length;
        int    packetLength;
        DWORD  sequence;
        BYTE  *buffer;
      } PktBuf;


typedef struct _CardHandle {
        BYTE         moduleName[16];
        CommonChars *common;
      } CardHandle;


typedef struct _BindingsList {
        WORD  numBindings;
        BYTE  moduleName[2][16];
      } BindingsList;


typedef struct _FailingModules {
        BYTE  upperModuleName[16];
        BYTE  lowerModuleName[16];
      } FailingModules;


typedef union _HardwareAddress {
        BYTE  bytes[6];
        WORD  words[3];
        struct {
          BYTE bytes[6];
        } addr;
      } HardwareAddress;


typedef struct _FddiHeader {
        BYTE             frameControl;
        HardwareAddress  etherDestHost;
        HardwareAddress  etherSrcHost;
      } FddiHeader;


typedef struct _EthernetIIHeader {
        HardwareAddress  etherDestHost;
        HardwareAddress  etherSrcHost;
        WORD             etherType;
      } EthernetIIHeader;


typedef struct _Ieee802Dot5Header {
        HardwareAddress  etherDestHost;
        HardwareAddress  etherSrcHost;
        BYTE             routeInfo[30];
      } Ieee802Dot5Header;


typedef struct _Ieee802Dot2SnapHeader {
        BYTE  dsap;                      /* 0xAA */
        BYTE  ssap;                      /* 0xAA */
        BYTE  control;                   /* 3    */
        BYTE protocolId[5];
      } Ieee802Dot2SnapHeader;


/*
 *  Prototypes
 */
extern char *NdisLastError        (void);
extern int   NdisOpen             (void);
extern int   NdisInit             (int promis);
extern int   NdisRegisterAndBind  (int promis);
extern void  NdisShutdown         (void);
extern void  NdisCheckMacFeatures (struct _CardHandle *card);
extern int   NdisSendPacket       (struct _PktBuf *pktBuf, int macId);

/*
 *  Assembly "glue" functions
 */
extern int systemRequestGlue();
extern int requestConfirmGlue();
extern int transmitConfirmGlue();
extern int receiveLookaheadGlue();
extern int indicationCompleteGlue();
extern int receiveChainGlue();
extern int statusGlue();

/*
 *  IOCTL function
 */
#ifdef __SMALL__
extern int _far NdisGetLinkage (int handle, char *data, int size);
#else
extern int NdisGetLinkage (int handle, char *data, int size);
#endif

/*
 *  NDIS callback handlers
 */
CALLBACK (NdisSystemRequest     (DWORD,DWORD, WORD, WORD, WORD));
CALLBACK (NdisRequestConfirm    ( WORD, WORD, WORD, WORD, WORD,WORD));
CALLBACK (NdisTransmitConfirm   ( WORD, WORD, WORD, WORD, WORD));
CALLBACK (NdisReceiveLookahead  ( WORD, WORD, WORD, BYTE*, BYTE*, WORD));
CALLBACK (NdisReceiveChain      ( WORD, WORD, WORD, struct _RxBufDescr*, BYTE*, WORD));
CALLBACK (NdisStatusProc        ( WORD, WORD, BYTE*, WORD,WORD));
CALLBACK (NdisIndicationComplete( WORD, WORD));

BYTE *NdisAllocStack (void);
void  NdisFreeStack  (BYTE*);

#ifdef __HIGHC__
  #define RENAME_ASM_SYM(x) pragma Alias(x,"@" #x "")  /* prepend `@' */
  #define RENAME_C_SYM(x)   pragma Alias(x,"_" #x "")  /* prepend `_' */

  RENAME_ASM_SYM (systemRequestGlue);
  RENAME_ASM_SYM (requestConfirmGlue);
  RENAME_ASM_SYM (transmitConfirmGlue);
  RENAME_ASM_SYM (receiveLookaheadGlue);
  RENAME_ASM_SYM (indicationCompleteGlue);
  RENAME_ASM_SYM (receiveChainGlue);
  RENAME_ASM_SYM (statusGlue);
  RENAME_ASM_SYM (NdisGetLinkage);
  RENAME_C_SYM   (NdisSystemRequest);
  RENAME_C_SYM   (NdisRequestConfirm);
  RENAME_C_SYM   (NdisTransmitConfirm);
  RENAME_C_SYM   (NdisReceiveLookahead);
  RENAME_C_SYM   (NdisIndicationComplete);
  RENAME_C_SYM   (NdisReceiveChain);
  RENAME_C_SYM   (NdisStatusProc);
  RENAME_C_SYM   (NdisAllocStack);
  RENAME_C_SYM   (NdisFreeStack);
#endif

#endif