path: root/private/mvdm/vdmredir/vrdlc.h

/*++

Copyright (c) 1991  Microsoft Corporation
Copyright (c) 1991  Nokia Data Systems

Module Name:

    vrdlc.h

Abstract:

    This module is the only header file of Windows/Nt VDM DLC
    interface module.

    ALL STRUCTURES IN THIS FILE WHICH REFERENCE STRUCTURES IN DOS MEMORY
    ARE BYTE PACKED

Author:

    Antti Saarenheimo (o-anttis) 26-01-1992

Revision History:

--*/

//
// constants
//

#define DOS_DLC_MAX_SAPS                128
#define DOS_DLC_MAX_LINKS               255
#define DOS_DLC_MAX_EVENTS              64

#define LLC_DIR_MODIFY_OPEN_PARMS       0x01
#define LLC_DIR_RESTORE_OPEN_PARMS      0x02
#define LLC_DIR_SET_USER_APPENDAGE      0x2d
#define LLC_DOS_SPECIAL_COMMAND         ((ULONG)(-1))
#define LLC_BREAK                       0x20

#define DOS_DLC_STATUS_NO_INDICATION    0x81

#define LLC_SET_LOCAL_BUSY_BUFFER       0x20

//
// VRDLC_COMMAND_COMPLETION - this value is placed in the CCB_CMD_CMPL field
// of every CCB2 that we issue that is NOT for the VDM. This value is used to
// filter out command completions for commands that are generated by the DOS
// DLC Emulator. This stops us passing command completions through to the
// VDM that are not intended for it!
//

#define VRDLC_COMMAND_COMPLETION        ((ULONG)(-2))

//
// buffer pool sizes
//

#define DOS_DLC_BUFFER_POOL_SIZE   0x00010000   // 64K
#define DOS_DLC_MIN_FREE_THRESHOLD 0x00002000   //  8K

//
// flags for CopyFrame
//

#define CF_CONTIGUOUS               0x00000001  // frame is contiguous
#define CF_BREAK                    0x00000002  // options specified Break
#define CF_PARTIAL                  0x00000004  // receiving partial frame

//
// default values for DOS parameter tables (DD_ = DOS DEFAULT). These replace
// the various parameters which can be specified as 0. They may be different
// to the corresponding defaults applicable to NT DLC, so we fill them in
// specifically
//

//
// defaults for BUFFER.GET:
//

#define DD_BUFFER_GET           1

//
// defaults for DIR.INITIALIZE:
//

#define DD_SRAM_ADDRESS_0       0xd800
#define DD_SRAM_ADDRESS_1       0xd400

//
// defaults for DIR.OPEN.ADAPTER, ADAPTER_PARMS:
//

#define DD_NUMBER_RCV_BUFFERS   8
#define DD_RCV_BUFFER_LENGTH    112
#define DD_DHB_BUFFER_LENGTH    600
#define DD_DATA_HOLD_BUFFERS    1

//
// defaults for DIR.OPEN.ADAPTER, DIRECT_PARMS:
//

#define DD_DIR_BUF_SIZE         160
#define DD_DIR_POOL_BLOCKS      256

//
// defaults for DIR.OPEN.ADAPTER, DLC_PARMS:
//

#define DD_DLC_MAX_SAP          2
#define DD_DLC_MAX_STATIONS     6
#define DD_DLC_MAX_GSAP         0
#define DD_DLC_T1_TICK_ONE      5
#define DD_DLC_T2_TICK_ONE      1
#define DD_DLC_Ti_TICK_ONE      25
#define DD_DLC_T1_TICK_TWO      25
#define DD_DLC_T2_TICK_TWO      10
#define DD_DLC_Ti_TICK_TWO      125

//
// defaults for DLC.OPEN.SAP:
//

#define DD_MAXOUT               2
#define DD_MAXIN                1
#define DD_MAX_RETRY_COUNT      8
#define DD_MAX_I_FIELD          600
#define DD_DLC_BUF_SIZE         160
#define DD_DLC_POOL_LEN         256

//
// macros
//

//
// DOS_PTR_TO_FLAT - given a DOS 16:16 pointer stored implicitly as a DWORD
//

#define DOS_PTR_TO_FLAT(a)  (PVOID)GetVDMAddr(HIWORD(a), LOWORD(a))

//
// NEW_DOS_ADDRESS - generate a new DOS_ADDRESS, given a base DOS_ADDRESS and
// a new pointer which is some number of bytes plus the base DOS_ADDRESS
// converted to a flat pointer. For example, a DOS_ADDRESS of 1234:0000 becomes
// (on x86) a flat pointer of 0x12340. We generate a new pointer 0x12380 and
// want to convert this address back to a DOS_ADDRESS. So we use this macro.
// Offset-wrap and segment update is automatically handled
//

#define NEW_DOS_ADDRESS(b, p)   ((b) + ((DWORD)(p) - (DWORD)DOS_PTR_TO_FLAT(b)))

//
// POOL_INDEX_FROM_SAP - get the index in aBufferPools for a given SAP/adapter
// combination. There are a maximum 127 SAPs per adapter, and 2 adapters which
// are available to DOS
//

#define POOL_INDEX_FROM_SAP(Sap, Adapter)   ((Sap & 0xfe) | Adapter)

//
// POOL_INDEX_FROM_ID - given a station ID (high byte = SAP, low byte = link
// station), get the index to the SAP's buffer pool in aBufferPools
//

#define POOL_INDEX_FROM_ID(Id, Adapter)     POOL_INDEX_FROM_SAP(HIBYTE(Id), Adapter)

//
// GET_POOL_INDEX - the original pool index macro
//

#define GET_POOL_INDEX(Adapter, usStationId)    POOL_INDEX_FROM_ID(usStationId, Adapter)

//
// macros which initialize CCBs and call AcsLan
//

#define DlcFlowControl(Adapter, StationId, Options)\
            LlcCommand(Adapter, LLC_DLC_FLOW_CONTROL, ((DWORD)Options << 16) + StationId)

#define DosDlcFlowControl(Adapter, StationId, Options)\
            LlcCommand(Adapter, LLC_DOS_DLC_FLOW_CONTROL, ((DWORD)Options << 16) + StationId)

#define InitializeCcb(pCcb, AdapterNumber, Command, pParameter) \
            RtlZeroMemory((pCcb), sizeof(*(pCcb)));\
            RtlZeroMemory((pParameter), sizeof(*(pParameter)));\
            (pCcb)->uchAdapterNumber = (UCHAR)AdapterNumber;\
            (pCcb)->uchDlcCommand = (UCHAR)Command;\
            (pCcb)->u.pParameterTable = (PLLC_PARMS)(pParameter)

#define InitializeCcb2(pCcb, AdapterNumber, Command) \
            RtlZeroMemory((pCcb), sizeof(*(pCcb)));\
            (pCcb)->uchAdapterNumber = (UCHAR)AdapterNumber;\
            (pCcb)->uchDlcCommand = (UCHAR)Command;

#define ReceiveCancel(AdapterNumber, pCcb) \
            LlcCommand(AdapterNumber, LLC_RECEIVE_CANCEL, (DWORD)pCcb)

//
// DLC_ERROR_STATUS - after calling AcsLan, if an error was returned by AcsLan
// then return that, else get the return code out of the CCB and return that
//

#define DLC_ERROR_STATUS(AcslanStatus, uchDlcStatus) \
            (DWORD)((AcslanStatus == 0) ? (DWORD)uchDlcStatus : (DWORD)AcslanStatus)

//
// VRDLC_ALLOC - standard allocation strategy in VDM REDIR DLC functions
//

#define VRDLC_ALLOC(Bytes)  LocalAlloc(LMEM_FIXED, Bytes)

//
// VRDLC_FREE - companion to VRDLC_ALLOC - standard allocation free strategy
//

#define VRDLC_FREE(Pointer) LocalFree((HLOCAL)Pointer)

//
// SAP_ID - get the SAP from a station ID word. Used as array index 0..127
// (corresponding to SAP 0..254 step 2)
//

#define SAP_ID(stationId)   (HIBYTE(stationId) >> 1)

//
// LINK_ID - get the link station ID from a station ID word. Used as array index
// 0..254 (corresponding to link station 1..255)
//

#define LINK_ID(stationId)  (LOBYTE(stationId) - 1)
//
// types
//

union _LLC_DOS_PARMS;
typedef union _LLC_DOS_PARMS LLC_DOS_PARMS, *PLLC_DOS_PARMS;
typedef DWORD DOS_ADDRESS;
typedef DOS_ADDRESS DPLLC_DOS_BUFFER;

//
// LLC_DOS_BUFFER - this is a union of all the DOS DLC data buffers. There are
// basically 3 kinds: Buffer 1, the first buffer in a chain which contains net
// address info, this can be in contigous or non-contiguous form, and Buffer 2
// format which is the 2nd and subsequent buffers in a chain. DLC uses the
// buffers for received data. Transmit data (passed from the app to DLC) can
// use a buffer (or chain of buffers) from the pool or can source its own
// buffer. The latter is preferred since taking buffers which DLC would use
// for receiving data can leave DLC in the local busy state (ie no receive
// buffers)
//

#include <packon.h>

typedef union _LLC_DOS_BUFFER {

    //
    // pNext is just a pointer so we can follow the chain
    //

    union _LLC_DOS_BUFFER * pNext;

    //
    // NextDosBuffer is the Buffer 2 structure defined in the IBM Lan Tech.
    // Ref. pg 2-45
    //

    struct _NextDosBuffer {
        union _LLC_DOS_BUFFER * pNextBuffer;// next frame segment
        WORD        cbFrame;                // length of the whole rcvd frame
        WORD        cbBuffer;               // length of this segment
        WORD        offUserData;            // offset of data from descr header
        WORD        cbUserData;             // length of the data
    } Next;

    //
    // NotContiguous is the Not contiguous MAC/Data Buffer 1 structure defined
    // in IBM Lan Tech. Ref. pg 2-42
    //

    struct _DosDlcNotContiguousFirstBuffer {
        union _LLC_DOS_BUFFER * pNextBuffer;  // next frame segment
        WORD            cbFrame;        // length of entire frame
        WORD            cbBuffer;       // length of this buffer
        WORD            offUserData;    // user data in this struct
        WORD            cbUserData;     // length of user data
        WORD            usStationId;    // ssnn station id
        UCHAR           uchOptions;     // option byte from RECEIVE param tbl
        UCHAR           uchMsgType;     // the message type
        WORD            cBuffersLeft;   // number of basic buffer units left
        UCHAR           uchRcvFS;       // the received frame status
        UCHAR           uchAdapterNumber;  // current adapter number
        UCHAR           cbLanHeader;    // length of the LAN header
        UCHAR           cbDlcHeader;    // length of the DLC header
        UCHAR           auchLanHeader[32];// LAN header of the received frame
        UCHAR           auchDlcHeader[4]; // DLC header of the received frame
    } NotContiguous;

    //
    // Contiguous is the Contiguous MAC/Data Buffer 1 structure defined
    // in IBM Lan Tech. Ref. pg 2-43
    //

    struct _DosDlcContiguousFirstBuffer {
        union _LLC_DOS_BUFFER * pNextBuffer;  // next frame segment
        WORD            cbFrame;        // length of entire frame
        WORD            cbBuffer;       // length of this buffer
        WORD            offUserData;    // user data in this struct
        WORD            cbUserData;     // length of user data
        WORD            usStationId;    // ssnn station id
        UCHAR           uchOptions;     // option byte from RECEIVE param tbl
        UCHAR           uchMsgType;     // the message type
        WORD            cBuffersLeft;   // number of basic buffer units left
        UCHAR           uchRcvFS;       // the received frame status
        UCHAR           uchAdapterNumber;
    } Contiguous;
} LLC_DOS_BUFFER, *PLLC_DOS_BUFFER;

#include <packoff.h>

//
// DOS_DLC_BUFFER_POOL - there is one of these per each SAP per adapter (max.
// 127 SAPs per adapter * max. 2 adapters = 256), kept in an array. This
// structure maintains basic information about the DOS buffer pool - its
// starting address (dpBuffer) in DOS 16:16 format, the size of an individual
// buffer in the pool (BufferSize) and the number of buffers in the pool
// (BufferCount). A buffer must be an integral multiple of 16 bytes, a minimum
// length of 80 bytes and not exceeding 64K-16 (0xfff0 = 65520)
//

typedef struct _DOS_DLC_BUFFER_POOL {
    DOS_ADDRESS dpBuffer;
    WORD BufferSize;
    WORD BufferCount;
    WORD MaximumBufferCount;
} DOS_DLC_BUFFER_POOL, *PDOS_DLC_BUFFER_POOL;

//
// DOS DLC CCB aka CCB1 - see definition in IBM Lan Tech. Ref. pg 2-6
//

#include <packon.h>

typedef struct _LLC_DOS_CCB {
    UCHAR   uchAdapterNumber;       // Adapter 0 or 1
    UCHAR   uchDlcCommand;          // DLC command
    UCHAR   uchDlcStatus;           // DLC command completion code
    UCHAR   uchReserved1;           // reserved for DLC DLL
    struct _LLC_DOS_CCB *pNext;     // queued another CCB
    DWORD   ulCompletionFlag;       // used in command completion
    union {
        PLLC_DOS_PARMS pParms;      // pointer to the parameter table
        struct {
            WORD    usStationId;    // Station id
            WORD    usParameter;    // optional parameter
        } dlc;
        struct {
            WORD    usParameter0;   // first optional parameter
            WORD    usParameter1;   // second optional parameter
        } dir;
        UCHAR   auchBuffer[4];      // group/functional address
        DWORD   ulParameter;
    } u;
} LLC_DOS_CCB, *PLLC_DOS_CCB;

//
// additional parameter tables not defined in (sdk\inc\) DLCAPI.H (or where
// CCB1 parameter tables different from those defined in DLCAPI.H)
//

//
// LLC_DOS_DIR_INITIALIZE_PARMS - CCB1 DIR.INITIALIZE parameter table
//

typedef struct {
    WORD    BringUps;
    WORD    SharedRamAddress;
    WORD    Reserved;
    DWORD   AdapterCheckExit;
    DWORD   NetworkStatusExit;
    DWORD   PcErrorExit;
} LLC_DOS_DIR_INITIALIZE_PARMS, *PLLC_DOS_DIR_INITIALIZE_PARMS;

//
// ADAPTER_PARMS, DIRECT_PARMS, DLC_PARMS and NCB_PARMS - these are the
// parameter tables which are passed in to DIR.OPEN.ADAPTER
//

//
// ADAPTER_PARMS - parameters returned from the adapter support s/w
//

typedef struct _ADAPTER_PARMS {
    WORD    OpenErrorCode;          // error detected opening adapter
    WORD    OpenOptions;            // options for Token Ring only:

    //
    // OpenOptions Bit Meanings
    //
    //  This has been paraphrased from the IBM Lan Tech. Ref. p3-22. I don't
    //  understand most of it, but I think I made it easier to read than the
    //  IBM technicalese. Note: ONLY MEANINGFUL TO TOKEN RING ADAPTER
    //
    // Bit 15: Wrap Interface
    //          The adapter doesn't attach to the network; instead, all
    //          transmitted data is reflected back as received data
    //
    // Bit 14: Disable Hard Error
    //          Stops network status change involving "Hard Error" and
    //          "Transmit Beacon" bits from generating interrupt
    //
    // Bit 13: Disable Soft Errors
    //          Stops network status change involving "Soft Error" bit
    //          generating interrupt
    //
    // Bit 12: Pass Adapter MAC Frames
    //          Unsupported MAC frames are passed to the direct station.
    //          If OFF, these frames are ignored
    //
    // Bit 11: Pass Attention MAC Frames
    //          Passes attention MAC frames which are not the same as the last
    //          received Attention MAC Frame to the direct station. If OFF,
    //          these frames are not passed to the direct station (ie App)
    //
    // Bit 10: Reserved
    //          Should be zero, but not checked by adapter
    //
    // Bit  9: Pass Parameter Table
    //          If the adapter is already open, returns options specified
    //
    // Bit  8: Contender
    //          If ON, this adapter will participate in monitor contention
    //          (claim token), should the need arise. If OFF, and it is
    //          another adapter decides it is necessary to claim the token,
    //          this adapter will not participate
    //
    //          If this adapter decides it is necessary to determine a new
    //          active monitor, this adapter will initiate monitor contention
    //          processing IRRESPECTIVE OF THE VALUE OF THIS BIT
    //
    // Bit  7: Pass Beacon MAC Frames
    //          Pass to direct station first Beacon MAC frame and all subsequent
    //          Beacon MAC frames having a change in source address or beacon type
    //
    // Bit  6: Reserved
    //          Should be zero, but not checked by adapter
    //
    // Bit  5: Remote Program Load
    //          Only implemented on 16/4 adapters. Prevents adapter becoming
    //          a monitor during open process. If ON, will cause this adapter
    //          to fail the open if there are no other active adapters on the
    //          ring when it tries to insert itself
    //
    // Bit  4: Token Release
    //          Only implemented on 16/4 adapters and only available when
    //          operating at 16 Mbps. OFF: use early token release (default).
    //          ON: selects no early token release for adapter a 16 Mbps
    //
    // Bit  3: Reserved  \
    // Bit  2: Reserved   >  Should be 0, but are not checked by adapter
    // Bit  1: Reserved  /
    // Bit  0: Reserved /
    //

    BYTE    NodeAddress[6];         // this adapter's address
    DWORD   GroupAddress;           // group address to set
    DWORD   FunctionalAddress;      // functional address to set
    WORD    NumberReceiveBuffers;   // number of receive buffers
    WORD    ReceiveBufferLength;    // size of receive buffer
    WORD    DataHoldBufferLength;   // size of transmit data hold buffer
    BYTE    NumberDataHoldBuffers;  // returned: only by Token Ring
    BYTE    Reserved;
    WORD    OpenLock;               // Protection code to control closing adapter
                                    // This is NOT RETURNED when OpenOptions.9
                                    // is set (Pass parameter table)
    DWORD   ProductId;              // 18-byte product ID
                                    // This is NOT RETURNED when OpenOptions.9
                                    // is set (Pass parameter table)
    //
    // according to table 3-9 in IBM LAN Tech. Ref. (p3-25) the ProductId field
    // should point at an 18-byte buffer formatted like so:
    //
    //  Byte 0      0x01 indicates workstation
    //  Byte 1      0x10
    //  Byte 2-5    last 4 digits from workstation serial number in EBCDIC
    //  Byte 6-17   0x00
    //
} ADAPTER_PARMS, *PADAPTER_PARMS;

//
// DIRECT_PARMS - input parameters defining Direct Station for adapter
//

typedef struct _DIRECT_PARMS {

    //
    // the direct buffer size is min. 80 bytes, and must be integral multiple
    // of 16-bytes. If 0, default of 160 is used
    //

    WORD    DirectBufferSize;       // size of buffers in direct buffer pool


    //
    // direct pool blocks - number of 16-byte blocks in direct station buffer
    // pool. If 0, default of 256 is used (= 4096 byte buffer pool)
    //

    WORD    DirectPoolBlocks;       // size of buffer in 16-byte blocks


    //
    // direct buffer pool - segment address in workstation memory where direct
    // station buffer pool is created. Spec. doesn't say what happens if there
    // is a non-zero (or any, for that matter) offset. If 0, the application
    // must build the direct station buffer pool, in which case DirectBufferSize
    // must indicate the size of each buffer
    //

    DWORD   DirectBufferPool;       // start address of direct buffer pool


    //
    // adapter check exit - vectors to this address when the adapter detects
    // an internal error. If 0, the value specified in DIR.INITIALIZE is used
    //

    DWORD   AdapterCheckExit;       // I/O appendage exit: adapter check


    //
    // network status exit - vectors to this address when the network status
    // changes (whatever that means). If 0, the value specified by
    // DIR.INITIALIZE is used
    //

    DWORD   NetworkStatusExit;      // I/O appendage exit: network status change


    //
    // PC error exit - vectors to this address when the adapter s/w detects an
    // error in the workstation (!). If 0, the value specified by DIR.INITIALIZE
    // is used
    //

    DWORD   PcErrorExit;            // I/O appendage exit: error in workstation


    //
    // adapter work area - segment of area of w/s memory which is to be used
    // by the adapter. Ignored if  AdapterWorkAreaRequested is 0
    //

    DWORD   AdapterWorkArea;        // TR: adapter work are


    //
    // adapter work area length (requested) - the size of the workspace area,
    // the segment of which is specified in AdapterWorkArea. Size is calculated
    // thus: Number of SAPs x 36 + Number of stations (links) x 6 + 48
    //

    WORD    AdapterWorkAreaRequested; // TR: work area length requested


    //
    // adapter work area length (actual) - this value is returned by the
    // adapter. It is the amount of the work area used by the adapter (in bytes).
    // If this is greater than AdapterWorkAreaRequested then an error is returned
    // (0x12)

    WORD    AdapterWorkAreaActual;  // TR: actual work area length taken

} DIRECT_PARMS, *PDIRECT_PARMS;

//
// DLC_PARMS - returned values defining DLC limits
//

typedef struct _DLC_PARMS {

    //
    // maximum number of concurrently opened SAPs: limited by available
    // adapter memory and/or workspace memory. Maximum is 127 (126 if NetBIOS
    // is specified). If 0, the default 2 is used
    //

    BYTE    MaxSaps;                // maximum number of SAPs


    //
    // maximum number of concurrently opened link stations: limited by
    // available adapter and/or work area memory in workstation. Maximum is 255
    // for Token Ring, Ethernet or PC Network. If 0, the default of 6 is used
    //

    BYTE    MaxStations;            // maximum number of link stations


    //
    // maximum number of group SAPs concurrently opened. If 0, no group SAPs
    // can be opened. Maximum value is 126 for Token Ring, 125 for PC Network
    // and Ethernet
    //

    BYTE    MaxGroupSaps;           // maximum number of group SAPs


    //
    // maximum number of SAPs assigned to a group. Maximum is 127 for Token
    // Ring, 126 for PC Network and Ethernet
    //

    BYTE    MaxGroupMembers;        // maximum members per group SAP


    //
    // Timers. There are 3 timers: T1 is the Response Timer; T2 is the Inactivity
    // Timer; and Ti is the Receiver Acknowledgement Timer.
    //
    // Timers are set to a multiple of 40ms. They count down and interrupt the
    // adapter when they reach 0. Timer values can be between 1 and 10. If it
    // is between 1 and 5, the short timer tick (TICK_ONE) is used and is
    // referred to as group 1. If the number is between 6 and 10, the long timer
    // tick (TICK_TWO) is used and is referred to as group 2. The timer value is
    // the number (6 to 10) minus 5 multiplied by the long tick value.
    //

    //
    // Tick1 - number of 40 ms ticks for short DLC timer. Defaults (if 0):
    //  T1 5 (200ms-400ms)
    //  T2 1 (40ms-80ms)
    //  Ti 25 (1s-2s)
    //

    BYTE    T1Tick1;                // Timer 1 short timer
    BYTE    T2Tick1;                // Timer 2 short timer
    BYTE    TiTick1;                // Timer i short timer


    //
    // Tick2 - number of 40 ms ticks for long DLC timer. Default (if 0):
    //  T1 25 (1s-2s)
    //  T2 10 (400ms-800ms)
    //  Ti 125 (5s-10s)
    //

    BYTE    T1Tick2;                // Timer 1 long timer
    BYTE    T2Tick2;                // Timer 2 long timer
    BYTE    TiTick2;                // Timer i long timer
} DLC_PARMS, *PDLC_PARMS;

//
// NCB_PARMS - we are not interested in running DOS NETBIOS over DOS DLC (are we?)
//

typedef struct _NCB_PARMS {
    BYTE    Reserved1[4];       // adapter work area
    BYTE    TimerT1;
    BYTE    TimerT2;
    BYTE    TimerTi;
    BYTE    MaxOut;
    BYTE    MaxIn;
    BYTE    MaxOutIncr;
    BYTE    MaxRetry;
    BYTE    Reserved2[4];
    BYTE    NcbAccessPri;
    BYTE    MaxStations;
    BYTE    Reserved3[19];
    BYTE    MaxNames;
    BYTE    MaxNcbs;
    BYTE    MaxSessions;
    BYTE    Reserved4[2];
    BYTE    Options;
    WORD    PoolLength;
    DWORD   PoolAddress;
    BYTE    TxTimeout;
    BYTE    TxCount;
} NCB_PARMS, *PNCB_PARMS;

//
// LLC_DOS_DIR_OPEN_ADAPTER_PARMS is the CCB1 DIR.OPEN.ADAPTER parameter table
//

typedef struct _LLC_DOS_DIR_OPEN_ADAPTER_PARMS {
    PADAPTER_PARMS  pAdapterParms;
    PDIRECT_PARMS   pDirectParms;
    PDLC_PARMS      pDlcParms;
    PNCB_PARMS      pNcbParms;
} LLC_DOS_DIR_OPEN_ADAPTER_PARMS, *PLLC_DOS_DIR_OPEN_ADAPTER_PARMS;

//
// LLC_DOS_RECEIVE_PARMS is the CCB1 RECEIVE parameter table
//

typedef struct _LLC_DOS_RECEIVE_PARMS {
    WORD        usStationId;    // SAP, link station or direct id
    WORD        usUserLength;   // length of user data in buffer header
    DWORD       ulReceiveExit;  // the received data handler
    PLLC_BUFFER pFirstBuffer;   // first buffer in the pool
    UCHAR       uchOptions;     // defines how the frame is received
} LLC_DOS_RECEIVE_PARMS,  *PLLC_DOS_RECEIVE_PARMS;

//
// LLC_DOS_RECEIVE_PARMS_EX is an extended version of the LLC_DOS_RECEIVE_PARMS
// parameter table. We keep extra information - the DOS address of the original
// CCB and the original RECEIVE_DATA completion exit routine
//

typedef struct _LLC_DOS_RECEIVE_PARMS_EX {
    WORD        usStationId;            // SAP, link station or direct id
    WORD        usUserLength;           // length of user data in buffer header
    DWORD       ulReceiveExit;          // the received data handler
    PLLC_BUFFER pFirstBuffer;           // first buffer in the pool
    UCHAR       uchOptions;             // defines how the frame is received
    UCHAR       auchReserved1[3];       //
    UCHAR       uchRcvReadOption;       // defines if rcv frames are chained
    UCHAR       auchReserved2[3];       // align dpOriginalCcbAddress on DWORD
    DOS_ADDRESS dpOriginalCcbAddress;   // dos address of orginal ccb
    DOS_ADDRESS dpCompletionFlag;       // orginal completion flag
} LLC_DOS_RECEIVE_PARMS_EX,  *PLLC_DOS_RECEIVE_PARMS_EX;

//
// LLC_DOS_RECEIVE_MODIFY_PARMS is the parameter table for RECEIVE.MODIFY which
// we don't seem to support in NT native DLC
//

typedef struct {
    WORD    StationId;                  // SAP & link station Id
    WORD    UserLength;                 // length of user area in buffer
    DWORD   ReceivedDataExit;           // address of routine to call with data
    DWORD   FirstBuffer;                // pointer to first buffer from pool
    DWORD   Subroutine;                 // address of routine to call to get app buffer
} LLC_DOS_RECEIVE_MODIFY_PARMS, *PLLC_DOS_RECEIVE_MODIFY_PARMS;

//
// LLC_DOS_TRANSMIT_PARMS this structure is identical to LLC_TRANSMIT_PARMS
// except that there is no XMIT_READ_OPTION byte on the end, and the types of
// the fields are different, although the sizes are the same: eg. DOS_ADDRESS
// instead of PVOID or PLLC_XMIT_BUFFER
//

typedef struct _LLC_DOS_TRANSMIT_PARMS {
    WORD        usStationId;            // SAP and link station ID
    BYTE        uchTransmitFs;          // returned: Frame Status
    BYTE        uchRemoteSap;           // remote SAP we're talking to
    DOS_ADDRESS pXmitQueue1;            // address of 1st buffer queue. Not pooled
    DOS_ADDRESS pXmitQueue2;            // address of 2nd buffer queue. Pooled
    WORD        cbBuffer1;              // length of data in pBuffer1
    WORD        cbBuffer2;              // length of data in pBuffer2
    DOS_ADDRESS pBuffer1;               // address of 1st data buffer
    DOS_ADDRESS pBuffer2;               // address of 2nd data buffer
} LLC_DOS_TRANSMIT_PARMS, *PLLC_DOS_TRANSMIT_PARMS;

typedef struct _LLC_MODIFY_OPEN_PARMS {
    WORD        usBufferSize;           // block size of dlc buffers (>=80)
    WORD        cPoolBlocks;            // number of 16 bytes blocks in buffer
    DOS_ADDRESS dpPoolAddress;
    DOS_ADDRESS dpAdapterCheckExit;
    DOS_ADDRESS dpNetworkStatusExit;
    DOS_ADDRESS dpPcErrorExit;
    WORD        usOpenOption;
} LLC_MODIFY_OPEN_PARMS, *PLLC_MODIFY_OPEN_PARMS;

typedef struct _DOS_DLC_DIRECT_PARMS {
    WORD        usBufferSize;           // block size of dlc buffers (>=80)
    WORD        cPoolBlocks;            // number of 16 bytes blocks in buffer
    DOS_ADDRESS dpPoolAddress;          //
    DOS_ADDRESS dpAdapterCheckExit;
    DOS_ADDRESS dpNetworkStatusExit;
    DOS_ADDRESS dpPcErrorExit;
    DWORD       ulReserved1;
    WORD        usReserved2;
    WORD        usReserved3;
} DOS_DLC_DIRECT_PARMS, *PDOS_DLC_DIRECT_PARMS;

typedef struct _DOS_DLC_OPEN_SAP_PARMS {
    WORD        usStationId;            // SAP or link station id
    WORD        usUserStatValue;        // reserved for user
    UCHAR       uchT1;                  // response timer
    UCHAR       uchT2;                  // aknowledgment timer
    UCHAR       uchTi;                  // inactivity timer
    UCHAR       uchMaxOut;              // max tramists without ack
    UCHAR       uchMaxIn;               // max receives without ack
    UCHAR       uchMaxOutIncr;          // dynamic window increment value
    UCHAR       uchMaxRetryCnt;         // N2 value (retries)
    UCHAR       uchMaxMembers;          // maximum members for group SAP
    WORD        usMaxI_Field;           // maximum length of the Info field
    UCHAR       uchSapValue;            // SAP value to be assigned
    UCHAR       uchOptionsPriority;     // SAP options and access priority
    UCHAR       uchcStationCount;       // maximum number of link stations in sap
    UCHAR       uchReserved2[2];        //
    UCHAR       cGroupCount;            // number of group SAPs of this SAP
    PUCHAR      pGroupList;             // offset to the group list
    DWORD       DlcStatusFlags;         // User notify flag for DLC status changes
    WORD        usBufferSize;           // size of individual buffer in bytes
    WORD        cPoolBlocks;            // number of 16-byte blocks in pool
    DOS_ADDRESS dpPoolAddress;          // address of Buffer Pool (may be 0)
} DOS_DLC_OPEN_SAP_PARMS,  *PDOS_DLC_OPEN_SAP_PARMS;

typedef struct _DOS_DIR_STATUS_PARMS {
    UCHAR       auchPermanentAddress[6];// permanent encoded address
    UCHAR       auchNodeAddress[6];     // adapter's network address
    UCHAR       auchGroupAddress[4];    // adapter's group address
    UCHAR       auchFunctAddr[4];       // adapter's functional address
    UCHAR       uchMaxSap;              // maximum allowable SAP
    UCHAR       uchOpenSaps;            // number of currently open saps
    UCHAR       uchMaxStations;         // max number of stations (always 253)
    UCHAR       uchOpenStation;         // number of open stations (only up to 253)
    UCHAR       uchAvailStations;       // number of available stations (always 253)
    UCHAR       uchAdapterConfig;       // adapter configuration flags
    UCHAR       auchMicroCodeLevel[10]; // microcode level
    DOS_ADDRESS dpAdapterParmsAddr;     // shared RAM address of adapter parms
    DOS_ADDRESS dpAdapterMacAddr;       // shared RAM address of adapter MAC buffer
    DOS_ADDRESS dpTimerTick;            // address of DLC timer tick counter
    USHORT      usLastNetworkStatus;    // most recent network status issued
    DOS_ADDRESS dpExtendedParms;        // address of extended status table
} DOS_DIR_STATUS_PARMS, *PDOS_DIR_STATUS_PARMS;

typedef struct {
    DOS_ADDRESS dpAdapterCheckExit;     // adapter check appendage
    DOS_ADDRESS dpNetworkStatusExit;    // network status change appendage
    DOS_ADDRESS dpPcErrorExit;          // workstation error appendage
} LLC_DIR_SET_USER_APPENDAGE_PARMS, *PLLC_DIR_SET_USER_APPENDAGE_PARMS;

#include <packoff.h>

union _LLC_DOS_PARMS {
    LLC_BUFFER_FREE_PARMS       BufferFree;
    LLC_BUFFER_GET_PARMS        BufferGet;
    LLC_DLC_CONNECT_PARMS       DlcConnectStation;
    LLC_DLC_MODIFY_PARMS        DlcModify;
    LLC_DLC_OPEN_SAP_PARMS      DlcOpenSap;
    LLC_DLC_OPEN_STATION_PARMS  DlcOpenStation;
    LLC_DLC_REALLOCATE_PARMS    DlcReallocate;
    LLC_DLC_SET_THRESHOLD_PARMS DlcSetThreshold;
    LLC_DLC_STATISTICS_PARMS    DlcStatistics;
    LLC_DIR_INITIALIZE_PARMS    DirInitialize;
    LLC_MODIFY_OPEN_PARMS       DirModifyOpenParms;
    LLC_DIR_OPEN_ADAPTER_PARMS  DirOpenAdapter;
    LLC_DIR_OPEN_DIRECT_PARMS   DirOpenDirect;
    LLC_DIR_READ_LOG_PARMS      DirReadLog;
    LLC_DIR_SET_EFLAG_PARMS     DirSetExceptionFlags;
    LLC_DIR_SET_USER_APPENDAGE_PARMS    DirSetUserAppendage;
    LLC_DIR_STATUS_PARMS        DirStatus;
    DOS_DIR_STATUS_PARMS        DosDirStatus;
    LLC_READ_PARMS              Read;
    LLC_DOS_RECEIVE_PARMS_EX    Receive;
    LLC_DOS_RECEIVE_PARMS       DosReceive;
    LLC_TRANSMIT_PARMS          Transmit;
    LLC_TRANSMIT2_COMMAND       Transmit2;
    LLC_TRACE_INITIALIZE_PARMS  TraceInitialize;
    DOS_DLC_OPEN_SAP_PARMS      DosDlcOpenSap;
};

//
// ADAPTER_TYPE - what type of network adapter we have - Token Ring, Ethernet
// or (less likely) PC network
//

typedef enum {
    TokenRing,
    Ethernet,
    PcNetwork,
    UnknownAdapter
} ADAPTER_TYPE;

//
// LOCAL_BUSY_STATE - a link station can be in 1 of 3 emulated local-busy
// (buffer) states:
//
//  NOT_BUSY
//      the station doesn't have any backed-up I-frames pending
//
//  BUSY
//      the station is in emulated local-busy(buffer) state and a
//      DLC.FLOW.CONTROL(local-busy(buffer), set) has been sent to
//      the DLC device driver
//
//  BUSY_BUFFER
//      to get out of BUSY state into CLEARING, we need at least one buffer and
//      a DLC.FLOW.CONTROL from the app. Because apps can issue DLC.FLOW.CONTROL
//      and BUFFER.FREE in the wrong order, we need an AND of these 2 commands
//      to get going again. So we have this intermediate state where we are
//      awaiting either command to restart I-Frame reception
//
//  BUSY_FLOW
//      Together with BUSY_BUFFER, used to create a hysteresis whereby we can't
//      reach CLEARING from BUSY without getting both a DLC.FLOW.CONTROL and
//      BUFFER.FREE
//
//  CLEARING
//      the VDM app has cleared the emulated local-busy state, but
//      the DLC device driver is still in local-busy (buffer) state.
//      When the last deferred I-Frame is indicated to the VDM app,
//      the NT device driver local-busy(buffer) state will be reset
//      and normal service will resume
//
//
// State transitions:
//
//  NOT_BUSY -> BUSY
//      occurs when we discover there aren't enough DOS buffers to
//      receive an I-Frame. This transition is distinguished by the
//      following actions:
//
//          1. DLC.FLOW.CONTROL(local-busy(buffer), set) is indicated to
//             the DLC device driver
//          2. the received I-Frame is dequeued from the event queue for
//             this adapter and queued on the LocalBusyInfo.Queue
//          3. a local-busy(buffer) DLC status change event is indicated to
//             the DOS DLC app
//
//  BUSY -> BUSY_FLOW/BUSY_BUFFER
//      occurs when either a DLC.FLOW.CONTROL or BUFFER.FREE (resp) is issued
//
//  BUSY_FLOW/BUSY_BUFFER -> CLEARING
//      occurs when the DOS DLC app indicates we can continue receiving.
//      This is done when the other (DLC.FLOW.CONTROL or BUFFER.FREE) required
//      command is issued
//      This transition is distinguished by the following actions:
//
//          1. DOS DLC app issues DLC.FLOW.CONTROL(local-busy(buffer), reset)
//          2. DOS DLC app *may* issue BUFFER.FREE to return receive
//             buffers to the SAP pool
//
//  CLEARING -> NOT_BUSY
//      occurs when we indicate the last deferred receive to the DOS DLC
//      app. At this point we can do the following:
//
//          1. issue DLC.FLOW.CONTROL(local-busy(buffer), reset) to the
//             device driver
//
//  CLEARING -> BUSY
//      occurs when, during indicating deferred received I-Frames to the DOS
//      DLC app, we once again run out of buffers. Again, we indicate a DLC
//      status change of local-busy(buffer) to the DOS DLC app, but WE DO NOT
//      indicate local-busy(buffer) to the DLC device driver (it is still in
//      local-busy(buffer) state)
//

typedef enum {
    NOT_BUSY = 0,
    CLEARING,
    BUSY,
    BUSY_BUFFER,
    BUSY_FLOW
} LOCAL_BUSY_STATE;

//
// LOCAL_BUSY_INFO - this structure maintains a local-busy(buffer) state
// indicator and a pointer to a queue of deferred received I-Frames per link
// station per adapter
//

typedef struct {

    //
    // State maintains the tri-state of the link station w.r.t. received I-Frames
    //
    //  NOT_BUSY
    //      nothing queued on Queue, get next completed event from event Q
    //
    //  BUSY
    //      local-busy(buffer) state has been set in DLC driver,
    //      awaiting buffers & flow control command from DOS DLC app
    //
    //  CLEARING
    //      DOS DLC app has submitted DLC.FLOW.CONTROL(local_busy(buffer), reset)
    //      command, we are now trying to indicate deferred received I-Frames to
    //      DOS DLC app, pending enough DOS receive buffers
    //

    LOCAL_BUSY_STATE State;

    //
    // Queue - when in BUSY and CLEARING states, maintains a linked list of
    // completed NT READ CCBs containing received I-Frames
    //

    PLLC_CCB Queue;

#if DBG

    //
    // track queue depth for each link station in debug version
    //

    DWORD Depth;
#endif

} LOCAL_BUSY_INFO;

//
// MAX_I_FRAME_DEPTH - we don't expect the queue of deferred I-Frames to grow
// beyond this small number. The deferred I-Frame queue is a buffer between
// running out of receive buffers & restarting I-Frame reception
//

#define MAX_I_FRAME_DEPTH   64  // !

//
// DOS_ADAPTER - there is one of these for each DOS adapter (i.e. 2 max.). The
// structure contains information about the virtual state of each DOS adapter.
// We record such information as the parameters used to open the adapter, the
// exit addresses and the direct station information
//

typedef struct {

    //
    // AdapterType - tells us what type (class?) of adapter we are using. We
    // mainly use this to differentiate the types of values we return based
    // on whether this is a Token Ring adapter. We get the information from
    // the NT DIR.STATUS command
    //

    ADAPTER_TYPE AdapterType;

    //
    // IsOpen will be TRUE when this adapter has been successfully opened
    //

    BOOLEAN IsOpen;

    //
    // DirectStationOpen is TRUE when the direct station has been initialized
    // for this adapter. This is required because the direct station is opened
    // separately from the adapter in NT, but DOS expects both to be opened
    // simultaneously. Hence, we only issue a DIR.OPEN.DIRECT when the DOS app
    // issues a request for the direct station
    //

    BOOLEAN DirectStationOpen;

    //
    // if DirectReceive is TRUE then there is a receive outstanding on the
    // direct station for this adapter
    //

    BOOLEAN DirectReceive;

    //
    // if WaitingRestore is TRUE then we must get a DIR.RESTORE.OPEN.PARMS
    // before we can accept the next DIR.MODIFY.OPEN.PARMS
    //

    BOOLEAN WaitingRestore;

    //
    // BufferFree is TRUE when a BUFFER_FREE has been successfully issued for
    // any station ID belonging to this adapter
    //

    BOOLEAN BufferFree;

    //
    // BufferPool is the buffer pool for this adapter's direct station
    //

    PVOID BufferPool;

    //
    // CurrentExceptionHandlers and PreviousExceptionHandlers are the addresses
    // of exception 'exit' routines in DOS memory which are called asynchronously
    // if one of the special exceptions occurs. These are mapped to exception
    // flags in NT DLC and are presented as such in the READ CCB (ulCompletionFlag)
    //
    // exception handlers are always presented in the following order:
    //
    //  Adapter Check Exit
    //  Network Status Exit
    //  PC Error Exit
    //

    DWORD CurrentExceptionHandlers[3];
    DWORD PreviousExceptionHandlers[3];

    //
    // DlcStatusChangeAppendage - this appendage pointer is supplied in DLC.OPEN.SAP
    // - one for each SAP. We need to keep them here because the emulator can
    // generate its own DLC status change call-backs (local-busy(buffer))
    //

    DWORD DlcStatusChangeAppendage[DOS_DLC_MAX_SAPS];

    //
    // LastNetworkStatusChange is the last network status change we recorded.
    // This is reported in DIR.STATUS
    //

    WORD LastNetworkStatusChange;

    //
    // UserStatusValue - we have to record the USER_STAT_VALUE from each
    // successful DLC.OPEN.SAP. This is returned to the DLC status change
    // appendage. We need this info for when we generate our own status change
    // event (ie when we detect emulated local busy (buffer) state)
    //

    WORD UserStatusValue[DOS_DLC_MAX_SAPS];

    //
    // AdapterParms are the actual adapter parameters that this adapter was
    // opened with - either specified in the DIR.OPEN.ADAPTER from the DOS
    // app, or those which we use internally when we automatically open the
    // adapter
    //

    ADAPTER_PARMS AdapterParms;

    //
    // DlcSpecified will be TRUE if the DLC_PARMS table was given when the
    // adapter was opened (either by DIR.OPEN.ADAPTER from DOS app, or by
    // DIR.OPEN.ADAPTER from automatic open)
    //

    BOOLEAN DlcSpecified;

    //
    // DlcParms - the DLC parameters specified in the open
    //

    DLC_PARMS DlcParms;

    //
    // AdapterCloseCcb - used in asynchronous adapter close when close is
    // initiated by emulator
    //

    LLC_CCB AdapterCloseCcb;

    //
    // DirectCloseCcb - used in asynchronous direct station close when close is
    // initiated by emulator
    //

    LLC_CCB DirectCloseCcb;

    //
    // ReadCcb - pointer to current READ CCB for this adapter
    //

    PLLC_CCB ReadCcb;

    //
    // EventQueueCritSec - must hold this while accessing EventQueue
    //

    CRITICAL_SECTION EventQueueCritSec;

    //
    // EventQueue - linked list of pending completed READ CCBs. These are linked
    // by pNext field which is not normally used by READ CCB. The event queue is
    // a serialized list of asynchronous events which have occurred for this
    // adapter. Events are command completions, transmit completions, received
    // data frames and status changes
    //

    PLLC_CCB EventQueueHead;    // pointer to READ CCB at head of queue
    PLLC_CCB EventQueueTail;    //    "     "   "   "  "  end  "    "
    DWORD QueueElements;        // count of elements currently on EventQueue

    //
    // LocalBusyCritSec - must hold this while accessing DeferredReceives or
    // LocalBusyInfo array
    //

    CRITICAL_SECTION LocalBusyCritSec;

    //
    // DeferredReceives - reference count of number of link stations for this
    // adapter which are in local busy (buffer) state. Accessed while holding
    // LocalBusyCritSec. Serves as a boolean: check for !0 to discover if there
    // are deferred receives before checking all of LocalBusyInfo
    //

    DWORD DeferredReceives;

    //
    // FirstIndex and LastIndex - the start & stop points for searches through
    // LocalBusyInfo. These are used in an attempt to improve searching, since
    // for the vast majority of time, very few of the 255 possible slots in
    // LocalBusyInfo will be used
    //
    // NOTE: these are array indicies, NOT link station ids (index = id - 1)
    //

    DWORD FirstIndex;
    DWORD LastIndex;

    //
    // LocalBusyInfo - when a link station is in emulated local busy (buffer)
    // state, we dequeue any completed received I-Frames from the event queue
    // and link them onto the LocalBusyInfo list. For each adapter, there are
    // 255 lists - one per link station (there are 255 possible link stations
    // per adapter). The deferred receives are a list of completed NT READ CCBs
    // linked by CCB.pNext field. The lists serve as a buffer between realizing
    // we are out of buffers and the DLC device driver receiving the
    // DLC.FLOW.CONTROL(set, buffer) command. The lists are not expected to
    // grow very long
    //
    // This array combines the state of each link station for this adapter w.r.t.
    // local-busy(buffer) and maintains the list of deferred I-Frames.
    //
    // The array is accessed both by the main VDM thread and the EventHandlerThread
    // and so must only be accessed when holding LocalBusyCritSec
    //
    // Since there are 255 possible link stations per adapter and since the
    // Direct Station doesn't support link stations, link station 01 uses slot
    // 0, etc.
    //

    LOCAL_BUSY_INFO LocalBusyInfo[DOS_DLC_MAX_LINKS];

} DOS_ADAPTER, *PDOS_ADAPTER;

#define NO_LINKS_BUSY   ((DWORD)0x7fffffff)

//
// DOS DLC prototypes and externals
//

extern PLLC_BUFFER aOverflowedData[];
extern DWORD OpenedAdapters;
extern DOS_ADDRESS dpVdmWindow;

//
// vrdlc5c.c
//

VOID
VrDlc5cHandler(
    VOID
    );

VOID
CompleteCcbProcessing(
    IN LLC_STATUS Status,
    IN LLC_DOS_CCB UNALIGNED * pCcb,
    IN PLLC_PARMS pNtParms
    );

LLC_STATUS
LlcCommand(
    IN  UCHAR   AdapterNumber,
    IN  UCHAR   Command,
    IN  DWORD   Parameter
    );

LLC_STATUS
BufferFree(
    IN  UCHAR   AdapterNumber,
    IN  PVOID   pFirstBuffer,
    OUT LPWORD  pusBuffersLeft
    );

VOID
VrVdmWindowInit(
    VOID
    );

VOID
TerminateDlcEmulation(
    VOID
    );

//
// vrdlcbuf.c
//

VOID
InitializeBufferPools(
    VOID
    );

LLC_STATUS
CreateBufferPool(
    IN  DWORD   PoolIndex,
    IN  DOS_ADDRESS dpBuffer,
    IN  WORD    BufferCount,
    IN  WORD    BufferSize
    );

VOID
DeleteBufferPool(
    IN  DWORD   PoolIndex
    );

LLC_STATUS
GetBuffers(
    IN  DWORD   PoolIndex,
    IN  WORD    BuffersToGet,
    IN  DPLLC_DOS_BUFFER *pdpBuffer,
    OUT LPWORD  pusBuffersLeft,
    IN  BOOLEAN PartialList,
    OUT PWORD   BuffersGot OPTIONAL
    );

LLC_STATUS
FreeBuffers(
    IN  DWORD   PoolIndex,
    IN  DPLLC_DOS_BUFFER dpBuffer,
    OUT LPWORD  pusBuffersLeft
    );

WORD
CalculateBufferRequirement(
    IN UCHAR Adapter,
    IN WORD StationId,
    IN PLLC_BUFFER pFrame,
    IN LLC_DOS_PARMS UNALIGNED * pDosParms,
    OUT PWORD BufferSize
    );

LLC_STATUS
CopyFrame(
    IN PLLC_BUFFER pFrame,
    IN DPLLC_DOS_BUFFER DosBuffers,
    IN WORD UserLength,
    IN WORD BufferSize,
    IN DWORD Flags
    );

BOOLEAN
AllBuffersInPool(
    IN DWORD PoolIndex
    );

//
// vrdlcpst.c
//

VOID
VrDlcInitialize(
    VOID
    );

BOOLEAN
VrDlcHwInterrupt(
    VOID
    );

BOOLEAN
ResetEmulatedLocalBusyState(
    IN BYTE AdapterNumber,
    IN WORD StationId,
    IN BYTE DlcCommand
    );

BOOLEAN
InitializeEventHandler(
    VOID
    );

PLLC_CCB
InitiateRead(
    IN DWORD AdapterNumber,
    OUT LLC_STATUS* ErrorStatus
    );