windows-server-2003/drivers/serial/mps/comtrol/rocket/driver/init.h

//--- init.h(common for vs and rk)

// use 2.04.03 format 3 part optional for non-released versions)
// use 2.05    format 2 part for released changes
#ifdef S_RK
  #ifdef NT50
    #define VER_PRODUCTVERSION_STR "4.50"
    #define VER_PRODUCTVERSION      4,50
  #else
    #define VER_PRODUCTVERSION_STR "4.50"
    #define VER_PRODUCTVERSION      4,50
  #endif
#else
  #ifdef NT50
    #define VER_PRODUCTVERSION_STR "2.50"
    #define VER_PRODUCTVERSION      2,50
  #else
    #define VER_PRODUCTVERSION_STR "2.50"
    #define VER_PRODUCTVERSION      2,50
  #endif
#endif

// these are now turned on or off in the sources file in rk or vs dir
//#define ROCKET
//#define VS1000
//#define NT50

// make the ExAllocatePool call "WDM-compatible" - use pool tags version
// with our tag "Rckt" (little endian format)

#ifdef NT50
  #ifdef POOL_TAGGING
    #ifdef ExAllocatePool
      #undef ExAllocatePool
    #endif
    #define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'tkcR')
  #endif
#endif

//	
//	define paths to Rockwell modem firmware...
//
#define	MODEM_CSREC_PATH	"\\SystemRoot\\system32\\ROCKET\\ctmmdmfw.rm"
#define	MODEM_CSM_SREC_PATH	"\\SystemRoot\\system32\\ROCKET\\ctmmdmld.rm"

//#define TRY_DYNAMIC_BINDING

// define to allow modem download for new pci rocketmodem 56k product(no flash)
#define MDM_DOWNLOAD

// these should be on, they are left in just in case(will strip out in future)
#define RING_FAKE
#define USE_SYNC_LOCKS
#define NEW_WAIT
#define NEW_WRITE_SYNC_LOCK
#define NEW_WAIT_SYNC_LOCK

#ifdef S_RK
// we can only use this on rocketport
#define NEW_FAST_TX
#endif

#define TRACE_PORT
#define USE_HAL_ASSIGNSLOT

// pnp bus-driver stuff
#define DO_BUS_EXTENDER

// attempted io-aliasing solution for nt5.0 to properly get resources
// for isa-bus cards using alias io space
#define DO_ISA_BUS_ALIAS_IO

#define GLOBAL_ASSERT
#define GLOBAL_TRACE
#define TRACE_PORT

#ifdef S_VS
#define MAX_NUM_BOXES 64
#else
#define MAX_NUM_BOXES 8
#endif

#define MAX_PORTS_PER_DEVICE 64

//---- following used to trace driver activity
//#define D_L0        0x00001L
//#define D_L2        0x00004L
//#define D_L4        0x00010L
//#define D_L6        0x00040L
//#define D_L7        0x00080L
//#define D_L8        0x00100L
//#define D_L9        0x00200L
//#define D_L10       0x00400L
//#define D_L11       0x00800L
#define D_Error     0x08000L
#define D_All       0xffffffffL

#define D_Nic       0x00002L
#define D_Hdlc      0x00008L
#define D_Port      0x00020L

#define D_Options      0x01000L
//---- following used to trace driver activity
#define D_Init         0x00010000L
#define D_Pnp          0x00020000L
#define D_Ioctl        0x00040000L
#define D_Write        0x00080000L
#define D_Read         0x00100000L
#define D_Ssci         0x00200000L
#define D_Thread       0x00400000L
#define D_Test         0x00800000L
#define D_PnpAdd       0x01000000L
#define D_PnpPower     0x02000000L

//Constant definitions for the I/O error code log values.
//  Values are 32 bit values layed out as follows:
//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
//   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
//  +---+-+-+-----------------------+-------------------------------+
//  |Sev|C|R|     Facility          |               Code            |
//  +---+-+-+-----------------------+-------------------------------+
//  where
//      Sev - is the severity code
//          00 - Success
//          01 - Informational
//          10 - Warning
//          11 - Error
//      C - is the Customer code flag
//      R - is a reserved bit
//      Facility - is the facility code
//      Code - is the facility's status code

// Define the facility codes
#define FACILITY_SERIAL_ERROR_CODE       0x6
#define FACILITY_RPC_STUBS               0x3
#define FACILITY_RPC_RUNTIME             0x2
#define FACILITY_IO_ERROR_CODE           0x4

// Define the severity codes
#define STATUS_SEVERITY_WARNING          0x2
#define STATUS_SEVERITY_SUCCESS          0x0
#define STATUS_SEVERITY_INFORMATIONAL    0x1
#define STATUS_SEVERITY_ERROR            0x3
#ifdef S_RK
#define SERIAL_RP_INIT_FAIL              ((NTSTATUS)0x80060001L)
#else
#define SERIAL_RP_INIT_FAIL              ((NTSTATUS)0xC0060001L)
#endif
#define SERIAL_RP_INIT_PASS              ((NTSTATUS)0x40060002L)
#define SERIAL_NO_SYMLINK_CREATED        ((NTSTATUS)0x80060003L)
#define SERIAL_NO_DEVICE_MAP_CREATED     ((NTSTATUS)0x80060004L)
#define SERIAL_NO_DEVICE_MAP_DELETED     ((NTSTATUS)0x80060005L)
#define SERIAL_UNREPORTED_IRQL_CONFLICT  ((NTSTATUS)0xC0060006L)
#define SERIAL_INSUFFICIENT_RESOURCES    ((NTSTATUS)0xC0060007L)
#define SERIAL_NO_PARAMETERS_INFO        ((NTSTATUS)0xC0060008L)
#define SERIAL_UNABLE_TO_ACCESS_CONFIG   ((NTSTATUS)0xC0060009L)
#define SERIAL_UNKNOWN_BUS               ((NTSTATUS)0xC006000AL)
#define SERIAL_BUS_NOT_PRESENT           ((NTSTATUS)0xC006000BL)
#define SERIAL_INVALID_USER_CONFIG       ((NTSTATUS)0xC006000CL)
#define SERIAL_RP_RESOURCE_CONFLICT      ((NTSTATUS)0xC006000DL)
#define SERIAL_RP_HARDWARE_FAIL          ((NTSTATUS)0xC006000EL)
#define SERIAL_DEVICEOBJECT_FAILED       ((NTSTATUS)0xC006000FL)
#define SERIAL_CUSTOM_ERROR_MESSAGE      ((NTSTATUS)0xC0060010L)
#define SERIAL_CUSTOM_INFO_MESSAGE       ((NTSTATUS)0x40060011L)
#define SERIAL_NT50_INIT_PASS            ((NTSTATUS)0x40060012L)

// max number of nic cards we will allow
#define VS1000_MAX_NICS 6

#ifdef GLOBAL_ASSERT
#define GAssert(id, exp ) { if (!(exp)) our_assert(id, __LINE__); }
#else
#define GAssert(id, exp )
#endif

#ifdef GLOBAL_TRACE

#define GTrace3(_Mask,_LeadStr, _Msg,_P1,_P2, _P3) \
  { if (Driver.GTraceFlags & _Mask) TTprintf(_LeadStr, _Msg, _P1, _P2, _P3); }

#define GTrace2(_Mask,_LeadStr, _Msg,_P1,_P2) \
  { if (Driver.GTraceFlags & _Mask) TTprintf(_LeadStr, _Msg, _P1, _P2); }

#define GTrace1(_Mask,_LeadStr, _Msg,_P1) \
  { if (Driver.GTraceFlags & _Mask) TTprintf(_LeadStr, _Msg, _P1); }

#define GTrace(_Mask_, _LeadStr, _Msg_) \
  { if (Driver.GTraceFlags & _Mask_) OurTrace(_LeadStr, _Msg_); }
//#define GMark(c, x)
#else
#define GTrace2(_Mask,_LeadStr, _Msg,_P1, _P2) {}
#define GTrace1(_Mask,_LeadStr, _Msg,_P1) {}
#define GTrace(_Mask_, _LeadStr, _Msg_) {}
//#define GMark(c, x) {}
#endif

// following are for debug, when checked build is made DBG is defined
// and the messages go to our debug queue and the nt debug string output.
#if DBG
#define DTrace3(_Mask_,_LeadStr,_Msg_,_P1_,_P2_,_P3_) \
  { if (RocketDebugLevel & _Mask_) TTprintf(_LeadStr,_Msg_,_P1_,_P2_,_P3_); }

#define DTrace2(_Mask_,_LeadStr,_Msg_,_P1_,_P2_) \
  { if (RocketDebugLevel & _Mask_) TTprintf(_LeadStr,_Msg_,_P1_,_P2_); }

#define DTrace1(_Mask_,_LeadStr,_Msg_,_P1_) \
  { if (RocketDebugLevel & _Mask_) TTprintf(_LeadStr,_Msg_,_P1_); }

#define DTrace(_Mask_,_LeadStr,_Msg_) \
  { if (RocketDebugLevel & _Mask_) OurTrace(_LeadStr, _Msg_); }

#define DPrintf(_Mask_,_Msg_) \
  { if (RocketDebugLevel & _Mask_) Tprintf _Msg_; }
#else
#define DTrace3(_Mask,_LeadStr, _Msg,_P1, _P2, _P3) {}
#define DTrace2(_Mask,_LeadStr, _Msg,_P1, _P2) {}
#define DTrace1(_Mask,_LeadStr, _Msg,_P1) {}
#define DTrace(_Mask_, _LeadStr, _Msg_) {}
#define DPrintf(_Mask_,_Msg_) {}
#endif


#ifdef TRACE_PORT

#define ExtTrace4(_Ext_,_Mask_,_Msg_,_P1_,_P2_,_P3_, _P4_) \
  { if (_Ext_->TraceOptions & 1) Tprintf(_Msg_,_P1_,_P2_,_P3_,_P4_); }

#define ExtTrace3(_Ext_,_Mask_,_Msg_,_P1_,_P2_,_P3_) \
  { if (_Ext_->TraceOptions & 1) Tprintf(_Msg_,_P1_,_P2_,_P3_); }

#define ExtTrace2(_Ext_,_Mask_,_Msg_,_P1_,_P2_) \
  { if (_Ext_->TraceOptions & 1) Tprintf(_Msg_,_P1_,_P2_); }

#define ExtTrace1(_Ext_,_Mask_,_Msg_,_P1_) \
  { if (_Ext_->TraceOptions & 1) Tprintf(_Msg_,_P1_); }

#define ExtTrace(_Ext_,_Mask_,_Msg_) \
  { if (_Ext_->TraceOptions & 1) Tprintf(_Msg_); }
#else
#define ExtTrace3(_Mask_,_Msg_,_P1_,_P2_,_P3_) {}
#define ExtTrace2(_Mask_,_Msg_,_P1_,_P2_) {}
#define ExtTrace1(_Mask_,_Msg_,_P1_) {}
#define ExtTrace(_Mask_,_Msg_) {}
#endif

#if DBG
#define MyAssert( exp ) { if (!(exp)) MyAssertMessage(__FILE__, __LINE__); }

# ifdef S_VS
#define MyKdPrint(_Mask_,_Msg_) \
  { \
    if (_Mask_ & RocketDebugLevel) { \
      DbgPrint ("VS:"); \
      DbgPrint _Msg_; \
    } \
  } 
# else
#define MyKdPrint(_Mask_,_Msg_) \
  { \
    if (_Mask_ & RocketDebugLevel) { \
      DbgPrint ("RK:"); \
      DbgPrint _Msg_; \
    } \
  } 
# endif
#define MyKdPrintUnicode(_Mask_,_PUnicode_)\
  if(_Mask_ & RocketDebugLevel) \
    {  \
    ANSI_STRING tempstr; \
    RtlUnicodeStringToAnsiString(&tempstr,_PUnicode_,TRUE); \
    DbgPrint("%s",tempstr.Buffer);\
    RtlFreeAnsiString(&tempstr); \
    }
#else    
#define MyAssert( exp ) {}
#define MyKdPrint(_Mask_,_Msg_) {}
#define MyKdPrintUnicode(_Mask_,_PUnicode_) {}
#endif //DBG

#define SERIAL_NONE_PARITY  ((UCHAR)0x00)
#define SERIAL_ODD_PARITY   ((UCHAR)0x08)
#define SERIAL_EVEN_PARITY  ((UCHAR)0x18)
#define SERIAL_MARK_PARITY  ((UCHAR)0x28)
#define SERIAL_SPACE_PARITY ((UCHAR)0x38)
#define SERIAL_PARITY_MASK  ((UCHAR)0x38)

// This should be enough space to hold the numeric suffix of the device name.
// #define DEVICE_NAME_DELTA 20

// Default xon/xoff characters.
#define SERIAL_DEF_XON  0x11
#define SERIAL_DEF_XOFF 0x13

// Reasons that reception may be held up.
#define SERIAL_RX_DTR       ((ULONG)0x01)
#define SERIAL_RX_XOFF      ((ULONG)0x02)
#define SERIAL_RX_RTS       ((ULONG)0x04)
#define SERIAL_RX_DSR       ((ULONG)0x08)

// Reasons that transmission may be held up.
#define SERIAL_TX_CTS       ((ULONG)0x01)
#define SERIAL_TX_DSR       ((ULONG)0x02)
#define SERIAL_TX_DCD       ((ULONG)0x04)
#define SERIAL_TX_XOFF      ((ULONG)0x08)
#define SERIAL_TX_BREAK     ((ULONG)0x10)
#define ST_XOFF_FAKE        ((ULONG)0x20)  // added for SETXOFF(kpb)

// These values are used by the routines that can be used
// to complete a read (other than interval timeout) to indicate
// to the interval timeout that it should complete.
#define SERIAL_COMPLETE_READ_CANCEL ((LONG)-1)
#define SERIAL_COMPLETE_READ_TOTAL ((LONG)-2)
#define SERIAL_COMPLETE_READ_COMPLETE ((LONG)-3)

//--- flags for MdmCountry (ROW country code)
#define ROW_NOT_USED        0
#define ROW_AUSTRIA         1
#define ROW_BELGIUM         2
#define ROW_DENMARK         3
#define ROW_FINLAND         4
#define ROW_FRANCE          5
#define ROW_GERMANY         6
#define ROW_IRELAND         7
#define ROW_ITALY           8
#define ROW_LUXEMBOURG      9
#define ROW_NETHERLANDS     10
#define ROW_NORWAY          11
#define ROW_PORTUGAL        12
#define ROW_SPAIN           13
#define ROW_SWEDEN          14
#define ROW_SWITZERLAND     15
#define ROW_UK              16
#define ROW_GREECE          17
#define ROW_ISRAEL          18
#define ROW_CZECH_REP       19
#define ROW_CANADA          20
#define ROW_MEXICO          21
#define ROW_USA             22         
#define ROW_NA              ROW_USA         
#define ROW_HUNGARY         23
#define ROW_POLAND          24
#define ROW_RUSSIA          25
#define ROW_SLOVAC_REP      26
#define ROW_BULGARIA        27
// 28
// 29
#define ROW_INDIA           30
// 31
// 32
// 33
// 34
// 35
// 36
// 37
// 38
// 39
#define ROW_AUSTRALIA       40
#define ROW_CHINA           41
#define ROW_HONG_KONG       42
#define ROW_JAPAN           43
#define ROW_PHILIPPINES     ROW_JAPAN
#define ROW_KOREA           44
// 45
#define ROW_TAIWAN          46
#define ROW_SINGAPORE       47
#define ROW_NEW_ZEALAND     48

#define ROW_DEFAULT         ROW_USA



// Ext->DeviceType:  // DEV_PORT, DEV_DRIVER, DEV_BOARD
#define DEV_PORT   0
#define DEV_BOARD  1

/* Configuration information structure for one port */
typedef struct {
  char Name[12];
  ULONG LockBaud;
  ULONG TxCloseTime;
  int WaitOnTx : 1;
  int RS485Override : 1;
  int RS485Low : 1;
  int Map2StopsTo1 : 1;
  int MapCdToDsr : 1;
  int RingEmulate : 1;
} PORT_CONFIG;


/* Configuration information structure for one board or vs1000("device") */
typedef struct
{
#ifdef S_RK
   unsigned int MudbacIO;              /* I/O address of MUDBAC */
   PUCHAR pMudbacIO;                   /* NT ptrs to I/O address of MUDBAC */
   unsigned int BaseIoAddr;   // normal io-address
   unsigned int TrBaseIoAddr; // translated io-address
   PUCHAR       pBaseIoAddr;  // final indirect mapped handle for io-address
   unsigned int BaseIoSize;            /* 44H for 1st isa, 40 for isa addition, etc */
   unsigned int ISABrdIndex;           /* 0 for first, 1 for second, etc(isa only) */
   unsigned int AiopIO[AIOP_CTL_SIZE]; /* I/O addresses of AIOPs */
   PUCHAR pAiopIO[AIOP_CTL_SIZE];      /* NT ptrs to I/O address of AIOPs */
   //int NumChan;                        /* number of channels on this controller */
   // use NumPorts instead
   int NumAiop;                        /* number of Aiops on board */
   unsigned int RocketPortFound;       /* indicates ctl was found and init'd */
   INTERFACE_TYPE BusType;             /* PCIBus or Isa */
   int PCI_DevID;
   int PCI_RevID;
   int PCI_SVID;
   int PCI_SID;

   int Irq;
   int InterruptMode;
   int IrqLevel;
   int IrqVector;
   int Affinity;

   int TrInterruptMode;
   int TrIrqLevel;
   int TrIrqVector;
   int TrAffinity;

   int PCI_Slot;
   int BusNumber;

   int IsRocketPortPlus;  // true if rocketport plus hardware
#else
   int IsHubDevice;  // true if device(RHub) uses slower baud clock
#endif

  BOOLEAN HardwareStarted;

  BYTE MacAddr[6];      // vs1000
  int BackupServer;     // vs1000
  int BackupTimer;      // vs1000

  //int StartComIndex;   // starting com-port index
  ULONG Hardware_ID;     // software derived hardware id(used for nt50 now)
  ULONG IoAddress;      // user interface io-address selection

  int ModemDevice;       // true for RocketModems & Vs2000
  int NumPorts;         // configured number of ports on this device

  ULONG ClkRate;  // def:36864000=rcktport, 44236800=rplus, 18432000=rhub
  ULONG ClkPrescaler;  // def:14H=rcktport, 12H=rplus, 14H=rhub

#ifdef NT50
       // this holds the pnp-name we use as a registry key to hold
       // our device parameters in the registry for RocketPort & NT50
  char szNt50DevObjName[50];  // typical: "Device_002456
#else
  int  DevIndex;  // nt40 keeps simple linear list of devices 0,1,2...
#endif

  PORT_CONFIG port[MAX_PORTS_PER_DEVICE];  // our read in port configuration

} DEVICE_CONFIG;

#define TYPE_RM_VS2000  1       
#define TYPE_RMII       2       
#define TYPE_RM_i       3


// forward declaration
typedef struct _SERIAL_DEVICE_EXTENSION *PSERIAL_DEVICE_EXTENSION;

typedef struct _SERIAL_DEVICE_EXTENSION {
    USHORT DeviceType;  // DEV_PORT, DEV_BOARD
    USHORT BoardNum;    // 0,1,2,3 for DEV_BOARD type

    BOOLEAN         IsPDO;  // a nt50 pnp thing, tells if we are a pdo or fdo
    char NtNameForPort[32];     // like "RocketPort0"
    char SymbolicLinkName[16];  // like "COM5"
#ifdef S_VS
    //int box_num;  // index into box & hdlc array
    SerPort *Port;  // if a DEV_PORT type extension
    PortMan *pm;    // if a DEV_BOARD type extension
    Hdlc    *hd;    // if a DEV_BOARD type extension

    //int DeviceNum;  // index into total port array
#else
    CHANPTR_T ChP;                  // ptr to channel structure
    CHANNEL_T ch;                   // our board channel structure
#endif
    unsigned int UniqueId; // 0,1,2,3... CreateBoardDevice() bumps...

    // if we are DEV_BOARD, the this points to next board extension
    // if we are DEV_PORT, then it points to our parent board
    PSERIAL_DEVICE_EXTENSION   board_ext;

    // if we are DEV_BOARD, the this points to start of port extensions
    // if we are DEV_PORT, then it points to next port extension
    PSERIAL_DEVICE_EXTENSION   port_ext;  // next port extension

    // if we are DEV_BOARD, the this points to start of pdo port extensions
    PSERIAL_DEVICE_EXTENSION   port_pdo_ext;  // next pdo port extension

    ULONG BaudRate;                 // NT defined baud rate      
    SERIAL_LINE_CONTROL LineCtl;    // NT defined line control
    ULONG ModemStatus;              // NT defined modem status
    ULONG DTRRTSStatus;             // NT defined modem status

    USHORT DevStatus;     // device status

    //unsigned int FlowControl;
    //unsigned int DetectEn;
#ifdef S_RK
    USHORT io_reported; // flag to tell if we have io,irq to unreport.
    ULONG EventModemStatus;         // used to detect change for events
    unsigned int ModemCtl;
    unsigned int IntEnables;		// RP specific ints to enable
#endif
    int PortIndex;      // if port: index into ports on board(0,1,2..)

#ifdef TXBUFFER
    //PUCHAR TxBuf;
    //LONG TxIn;
    //LONG TxOut;
    //LONG TxBufSize;
#endif
    Queue RxQ;

    // Used to keep ISR from completing a read while it is being started.
    BOOLEAN ReadPending;

      // This value is set by the read code to hold the time value
      // used for read interval timing.  We keep it in the extension
      // so that the interval timer dpc routine determine if the
      // interval time has passed for the IO.
    LARGE_INTEGER IntervalTime;

      // These two values hold the "constant" time that we should use
      // to delay for the read interval time.
    LARGE_INTEGER ShortIntervalAmount;
    LARGE_INTEGER LongIntervalAmount;

      // This holds the value that we use to determine if we should use
      // the long interval delay or the short interval delay.
    LARGE_INTEGER CutOverAmount;

      // This holds the system time when we last time we had
      // checked that we had actually read characters.  Used
      // for interval timing.
    LARGE_INTEGER LastReadTime;

      // This points the the delta time that we should use to
      // delay for interval timing.
    PLARGE_INTEGER IntervalTimeToUse;

      // Points to the device object that contains
      // this device extension.
    PDEVICE_OBJECT DeviceObject;

      // This list head is used to contain the time ordered list
      // of read requests.  Access to this list is protected by
      // the global cancel spinlock.
    LIST_ENTRY ReadQueue;

      // This list head is used to contain the time ordered list
      // of write requests.  Access to this list is protected by
      // the global cancel spinlock.
    LIST_ENTRY WriteQueue;

      // Holds the serialized list of purge requests.
    LIST_ENTRY PurgeQueue;

      // This points to the irp that is currently being processed
      // for the read queue.  This field is initialized by the open to
      // NULL.
      // This value is only set at dispatch level.  It may be
      // read at interrupt level.
    PIRP CurrentReadIrp;

      // This points to the irp that is currently being processed
      // for the write queue.
      // This value is only set at dispatch level.  It may be
      // read at interrupt level.
    PIRP CurrentWriteIrp;

      // Points to the irp that is currently being processed to
      // purge the read/write queues and buffers.
    PIRP CurrentPurgeIrp;

      // Points to the current irp that is waiting on a comm event.
    PIRP CurrentWaitIrp;

      // Points to the irp that is being used to count the number
      // of characters received after an xoff (as currently defined
      // by the IOCTL_SERIAL_XOFF_COUNTER ioctl) is sent.
    PIRP CurrentXoffIrp;

      // Holds the number of bytes remaining in the current write irp.
      // This location is only accessed while at interrupt level.
    ULONG WriteLength;

      // The syncronization between the various threads in this
      // driver is hosed up in places, besides being really confusing.
      // This is an attempt to have a protected flag which is set
      // to 1 if the ISR owns the currentwriteirp, 2 if the ISR
      // is in the progress of ending the IRP(going to serialcompletewrite),
      // and 0 when it is complete.  The starter routine sets it
      // from 0 to 1 to give a new irp to the isr/timer routine for
      // processing.  The ISR sets it from 1 to 2 when it queues
      // the DPC to finalize the irp.  The DPC sets it from 2 to
      // 0 when it completes the irp.  The cancel or timer routines
      // must run a synchronized routine which guarentees sole access
      // to this flag.  Looks if it is 1, if it is 1 then it takes
      // by setting it to zero, and returning a flag to indicate to
      // the caller to finalize the irp.  If it is a 2, it assumes
      // the isr has arranged to finalize the irp.  Geez-O-Pete
      // what a lot of silly gears!
    ULONG WriteBelongsToIsr;

      // Holds a pointer to the current character to be sent in
      // the current write.
      // This location is only accessed while at interrupt level.
    PUCHAR WriteCurrentChar;

      // This variable holds the size of whatever buffer we are currently
      // using.
    ULONG BufferSize;

      // This variable holds .8 of BufferSize. We don't want to recalculate
      // this real often - It's needed when so that an application can be
      // "notified" that the buffer is getting full.
    ULONG BufferSizePt8;

      // This value holds the number of characters desired for a
      // particular read.  It is initially set by read length in the
      // IRP.  It is decremented each time more characters are placed
      // into the "users" buffer buy the code that reads characters
      // out of the typeahead buffer into the users buffer.  If the
      // typeahead buffer is exhausted by the read, and the reads buffer
      // is given to the isr to fill, this value is becomes meaningless.
    ULONG NumberNeededForRead;

      // This mask will hold the bitmask sent down via the set mask
      // ioctl.  It is used by the interrupt service routine to determine
      // if the occurence of "events" (in the serial drivers understanding
      // of the concept of an event) should be noted.
    ULONG IsrWaitMask;

      // This mask will always be a subset of the IsrWaitMask.  While
      // at device level, if an event occurs that is "marked" as interesting
      // in the IsrWaitMask, the driver will turn on that bit in this
      // history mask.  The driver will then look to see if there is a
      // request waiting for an event to occur.  If there is one, it
      // will copy the value of the history mask into the wait irp, zero
      // the history mask, and complete the wait irp.  If there is no
      // waiting request, the driver will be satisfied with just recording
      // that the event occured.  If a wait request should be queued,
      // the driver will look to see if the history mask is non-zero.  If
      // it is non-zero, the driver will copy the history mask into the
      // irp, zero the history mask, and then complete the irp.
    ULONG HistoryMask;

      // This is a pointer to the where the history mask should be
      // placed when completing a wait.  It is only accessed at
      // device level.
      // We have a pointer here to assist us to synchronize completing a wait.
      // If this is non-zero, then we have wait outstanding, and the isr still
      // knows about it.  We make this pointer null so that the isr won't
      // attempt to complete the wait.
      // We still keep a pointer around to the wait irp, since the actual
      // pointer to the wait irp will be used for the "common" irp completion
      // path.
    ULONG *IrpMaskLocation;
    ULONG WaitIsISRs;  // 1=owned by isr.c(expicit help)
    ULONG DummyIrpMaskLoc;  // Point the IrpMaskLocation here when not in use

      // This mask holds all of the reason that transmission
      // is not proceeding.  Normal transmission can not occur
      // if this is non-zero.
      // This is only written from interrupt level.
      // This could be (but is not) read at any level.
    ULONG TXHolding;

      // This mask holds all of the reason that reception
      // is not proceeding.  Normal reception can not occur
      // if this is non-zero.
      // This is only written from interrupt level.
      // This could be (but is not) read at any level.
    ULONG RXHolding;

      // This holds the reasons that the driver thinks it is in
      // an error state.
      // This is only written from interrupt level.
      // This could be (but is not) read at any level.
    ULONG ErrorWord;

      // This keeps a total of the number of characters that
      // are in all of the "write" irps that the driver knows
      // about.  It is only accessed with the cancel spinlock
      // held.
    ULONG TotalCharsQueued;

      // This holds a count of the number of characters read
      // the last time the interval timer dpc fired.  It
      // is a long (rather than a ulong) since the other read
      // completion routines use negative values to indicate
      // to the interval timer that it should complete the read
      // if the interval timer DPC was lurking in some DPC queue when
      // some other way to complete occurs.
    LONG CountOnLastRead;

      // This is a count of the number of characters read by the
      // isr routine.  It is *ONLY* written at isr level.  We can
      // read it at dispatch level.
    ULONG ReadByIsr;

      // This is the number of characters read since the XoffCounter
      // was started.  This variable is only accessed at device level.
      // If it is greater than zero, it implies that there is an
      // XoffCounter ioctl in the queue.
    LONG CountSinceXoff;

      // Holds the timeout controls for the device.  This value
      // is set by the Ioctl processing.
      // It should only be accessed under protection of the control
      // lock since more than one request can be in the control dispatch
      // routine at one time.
    SERIAL_TIMEOUTS Timeouts;

      // This holds the various characters that are used
      // for replacement on errors and also for flow control.
      // They are only set at interrupt level.
    SERIAL_CHARS SpecialChars;

      // This structure holds the handshake and control flow
      // settings for the serial driver.
      // It is only set at interrupt level.  It can be
      // be read at any level with the control lock held.
    SERIAL_HANDFLOW HandFlow;

      // We keep track of whether the somebody has the device currently
      // opened with a simple boolean.  We need to know this so that
      // spurious interrupts from the device (especially during initialization)
      // will be ignored.  This value is only accessed in the ISR and
      // is only set via synchronization routines.  We may be able
      // to get rid of this boolean when the code is more fleshed out.
    BOOLEAN DeviceIsOpen;

      // Records whether we actually created the symbolic link name
      // at driver load time.  If we didn't create it, we won't try
      // to distry it when we unload.
    BOOLEAN CreatedSymbolicLink;

      // We place all of the kernel and Io subsystem "opaque" structures
      // at the end of the extension.  We don't care about their contents.
      // This lock will be used to protect various fields in
      // the extension that are set (& read) in the extension
      // by the io controls.
    KSPIN_LOCK ControlLock;

      // This points to a DPC used to complete read requests.
    KDPC CompleteWriteDpc;

      // This points to a DPC used to complete read requests.
    KDPC CompleteReadDpc;

      // This dpc is fired off if the timer for the total timeout
      // for the read expires.  It will execute a dpc routine that
      // will cause the current read to complete.
    KDPC TotalReadTimeoutDpc;

      // This dpc is fired off if the timer for the interval timeout
      // expires.  If no more characters have been read then the
      // dpc routine will cause the read to complete.  However, if
      // more characters have been read then the dpc routine will
      // resubmit the timer.
    KDPC IntervalReadTimeoutDpc;

      // This dpc is fired off if the timer for the total timeout
      // for the write expires.  It will execute a dpc routine that
      // will cause the current write to complete.
    KDPC TotalWriteTimeoutDpc;

      // This dpc is fired off if a comm error occurs.  It will
      // execute a dpc routine that will cancel all pending reads
      // and writes.
    KDPC CommErrorDpc;

      // This dpc is fired off if an event occurs and there was
      // a irp waiting on that event.  A dpc routine will execute
      // that completes the irp.
    KDPC CommWaitDpc;

      // This dpc is fired off if the timer used to "timeout" counting
      // the number of characters received after the Xoff ioctl is started
      // expired.
    KDPC XoffCountTimeoutDpc;

      // This dpc is fired off if the xoff counter actually runs down
      // to zero.
    KDPC XoffCountCompleteDpc;

      // This is the kernal timer structure used to handle
      // total read request timing.
    KTIMER ReadRequestTotalTimer;

      // This is the kernal timer structure used to handle
      // interval read request timing.
    KTIMER ReadRequestIntervalTimer;

      // This is the kernal timer structure used to handle
      // total time request timing.
    KTIMER WriteRequestTotalTimer;

      // This timer is used to timeout the xoff counter
      // io.
    KTIMER XoffCountTimer;

    USHORT sent_packets;   // number of write() packets
    USHORT  rec_packets;    // number of read() packets

    SERIALPERF_STATS OurStats;  // our non-resetable stats
    SERIALPERF_STATS OldStats;  // performance monitor statistics(resetable)

    USHORT TraceOptions;  // Debug Trace Options. 1=trace, 2=in data, 4=out dat
       // 8 = isr level events

    USHORT ISR_Flags;  // bit flags used to control ISR, detects EV_TXEMPTY
        // used by NT virt-driver to embed modem status changes in input stream
    unsigned char escapechar; 
    unsigned char Option;  // used for per port options
                                 
    void *TraceExt;  // Debug Trace Extension

    PORT_CONFIG *port_config; // if a port extension, points to port config data
    DEVICE_CONFIG *config;    // if a board extension, points to config data

    //KEVENT SerialSyncEvent;
#ifdef S_RK
    CONTROLLER_T *CtlP; // if a board extension, points to controller struct
#endif

    // This is to tell the driver that we have received a QUERY_POWER asking 
    // to power down.  The driver will then queue any open requests until after
    // the power down.
    BOOLEAN ReceivedQueryD3;
#ifdef NT50
    PDEVICE_OBJECT  Pdo;  // new PnP object used to open registry.
    PDEVICE_OBJECT  LowerDeviceObject;  // new PnP stack arrangement.
    // This is where keep track of the power state the device is in.
    DEVICE_POWER_STATE PowerState;

    // String where we keep the symbolic link that is returned to us when we
    // register our device under the COMM class with the Plug and Play manager.
    //
	UNICODE_STRING  DeviceClassSymbolicName;
#endif
    // Count of pending IRP's
    ULONG PendingIRPCnt;
    
    // Accepting requests?
    ULONG DevicePNPAccept;

    // No IRP's pending event
    KEVENT PendingIRPEvent;

    // PNP State
    ULONG PNPState;

    // Used by PnP.c module
    //BOOLEAN DeviceIsOpened;

    BOOLEAN FdoStarted;

#ifdef RING_FAKE
    BYTE ring_char;   // used to implement RING emulation via software
    BYTE ring_timer;  // used to implement RING emulation via software
#endif

#ifdef NT50
    // WMI Information
    WMILIB_CONTEXT WmiLibInfo;

    // Name to use as WMI identifier
    UNICODE_STRING WmiIdentifier;

    // WMI Comm Data
    SERIAL_WMI_COMM_DATA WmiCommData;

    // WMI HW Data
    SERIAL_WMI_HW_DATA WmiHwData;

    // WMI Performance Data
    SERIAL_WMI_PERF_DATA WmiPerfData;
#endif

} SERIAL_DEVICE_EXTENSION,*PSERIAL_DEVICE_EXTENSION;

//--- bits for Option field in extension
#define OPTION_RS485_OVERRIDE    0x0001  // always use 485 mode
#define OPTION_RS485_SOFTWARE_TOGGLE 0x0002  // port in toggle mode
#define OPTION_RS485_HIGH_ACTIVE  0x0004  // use hardware to toggle rts low

//--- bit flags for ISR_Flags
#define TX_NOT_EMPTY       0x0001

#define SERIAL_PNPACCEPT_OK       0x0L
#define SERIAL_PNPACCEPT_REMOVING 0x1L
#define SERIAL_PNPACCEPT_STOPPING 0x2L
#define SERIAL_PNPACCEPT_STOPPED  0x4L

#define SERIAL_PNP_ADDED          0x0L
#define SERIAL_PNP_STARTED        0x1L
#define SERIAL_PNP_QSTOP          0x2L
#define SERIAL_PNP_STOPPING       0x3L
#define SERIAL_PNP_QREMOVE        0x4L
#define SERIAL_PNP_REMOVING       0x5L

#define SERIAL_FLAGS_CLEAR	  0x0L
#define SERIAL_FLAGS_STARTED      0x1L

typedef struct _DRIVER_CONTROL {

    PDRIVER_OBJECT GlobalDriverObject;

    // copy of RegistryPath into DriverEntry, with room for adding options
    UNICODE_STRING RegPath;

    // working global RegistryPath string, , with room for adding options
    UNICODE_STRING OptionRegPath;

    // head link of all board extensions
    PSERIAL_DEVICE_EXTENSION board_ext;

    USHORT VerboseLog;   // boolean flag tells to log verbose to eventlog.
    USHORT ScanRate;     // scan rate in milliseconds
    USHORT PreScaler;    // optional prescaler value for rocketport boards

    USHORT MdmCountryCode; // country code for ROW RocketModems
    USHORT MdmSettleTime;  // time to allow modems to settle (unit=0.10 sec)

    ULONG  load_testing;  // load testing(creates artificial load in isr.c)
#ifdef S_VS

    // This is the names of the NIC cards which we get from the Registry.
    // Used to specify the nic card when we do an OpenAdapter call.
    char *BindNames;  // list of strings, null, null terminated [VS1000_MAX_BINDINGS];

#ifdef OLD_BINDING_GATHER
    PWCHAR BindString;  // binding in registry, tells us what nic cards we have

    // This is the names of the NIC cards which we get from the Registry.
    // Used to specify the nic card when wee do an OpenAdapter call.
    UNICODE_STRING NicName[VS1000_MAX_BINDINGS];

    int num_nics;  // number of nic cards in system which we use

    int num_bindings;  // number of nic card bindings in our NicName list
      // there may be lots of old useless bindings with NT, PCI adapters
      // leave an old binding resident for each slot they are booted in
      // under nt50, pcmcia adapters also have inactive bindings.

#endif

#ifdef TRY_DYNAMIC_BINDING
    // bind passes in a handle as a reference, when we get an un-bind
    // we get passed in another handle.  At unbind time, we look up in
    // this table to figure which nic card it references.
    NDIS_HANDLE  BindContext[VS1000_MAX_NICS];
#endif

    Nic *nics;    // our open nic adapters, array of Nic structs.

    //Hdlc *hd;     // array of Hdlc structs(NumBoxes # of elements)
    //PortMan *pm;  // array of PortMan structs(NumBoxes # of elements)
    //SerPort *sp;  // total array of serial-port structs(1 per port)

      // tells if thread needs to save off a detected mac-address back
      // to config reg area.
    PSERIAL_DEVICE_EXTENSION AutoMacDevExt; 
#endif

#ifdef S_RK
    ULONG SetupIrq;  // Irq used, 0 if none, 1 if PCI automatic
#endif
    PKINTERRUPT InterruptObject;

    // Timer fields
    KTIMER PollTimer;
    LARGE_INTEGER PollIntervalTime;
    KDPC TimerDpc;
    //USHORT TotalNTPorts;  // count of ports registered with NT
    ULONG PollCnt;  // count of interrupts/timer ticks
    ULONG WriteDpcCnt;
    USHORT TimerCreated;
    USHORT InRocketWrite;

    ULONG TraceOptions;  // bit flags, tells what driver parts to trace
    ULONG TraceFlags;
    Queue DebugQ;        // data output buffer for driver debug log
    PSERIAL_DEVICE_EXTENSION DebugExt;
    KSPIN_LOCK DebugLock;
    ULONG DebugTimeOut;  // used to timeout inactive debug sessions.

#ifdef S_RK
    USHORT RS485_Flags;  // 1H bit set if Reverse hardware type
                         //       clear if driver toggles RTS high
#endif

    ULONG GTraceFlags;  // trace flags, global.
    ULONG mem_alloced;  // track how much memory we are using

#ifdef S_VS
    UCHAR *MicroCodeImage;  // mem buf for micro code to download to unit
    ULONG MicroCodeSize;    // size of it in bytes

    // This is the handle for the protocol returned by ndisregisterprotocol
    NDIS_HANDLE NdisProtocolHandle;
    ULONG ndis_version;  // 3=NT3.51, 4=NT4.0(includes dynamic binding)

      // for auto-find boxes, make a list of boxes which respond with
      // there mac address.  Keep 2 extra bytes, byte [6] is for
      // flags in response tells us if main-driver-app loaded, 
      // while last byte[7] we stuff with the nic-index which responded.
    int   NumBoxMacs;
    BYTE  BoxMacs[MAX_NUM_BOXES*8];
    // following is a counter per mac-address added to list where
    // the list entry will be removed after it ticks down to zero.
    // when the mac-address is added to the list or found again,
    // the counter is initialized to some non-zero value(say 5)
    // and then each time a broadcast query is sent out, all the
    // counters are decremented by 1.  When they hit zero, they
    // are removed from the list.
    BYTE  BoxMacsCounter[MAX_NUM_BOXES];
#else

    UCHAR *ModemLoaderCodeImage;	// --> mem buf for modem loader code to download to unit
    ULONG ModemLoaderCodeSize;		// size in bytes

    UCHAR *ModemCodeImage;		// --> mem buf for modem code to download to unit
    ULONG ModemCodeSize;		// size in bytes
#endif

    int NoPnpPorts;  // flag to tell if we should eject port pdo's
#ifdef S_RK
    PSERIAL_DEVICE_EXTENSION irq_ext; // board ext doing global irq, null if not used
#endif
    //int NT50_PnP;

    int NumDevices; // configuration count of NumDevices for NT4.0
    int Stop_Poll;  // flag to stop poll access

    KSPIN_LOCK TimerLock;   // Timer DPC(ISR) lock to sync up code
#ifdef S_VS
    HANDLE threadHandle;
    int threadCount;
    //int TotalNTPorts;  // this should go away(vs uses it)
#endif
   LARGE_INTEGER IsrSysTime;  // ISR service routine gets this every time
                              // so we know what are time base is.
   LARGE_INTEGER LastIsrSysTime;  // used to recalculate the tick rate periodically
   ULONG TickBaseCnt;  // used to recalculate the tick rate periodically
     // this is the isr-tick rate in 100us units.  Timers called by the
     // isr-service routine can assume they are called periodically based
     // on this rate.  Needed for accurate time bases(VS protocol timers).
   ULONG Tick100usBase;

   // one of these made, and is used to support the global driver
   // object which the applications can open and talk to driver.
   PSERIAL_DEVICE_EXTENSION   driver_ext;

} DRIVER_CONTROL;

typedef struct {
	char	*imagepath;
	char	*imagetype;
	UCHAR	*image;
	ULONG	imagesize;
	int		rc;
} MODEM_IMAGE;

/* Configuration information structure for one port */
typedef struct {
  ULONG BusNumber;
  ULONG PCI_Slot;
  ULONG PCI_DevID;
  ULONG PCI_RevID;
  ULONG BaseIoAddr;
  ULONG Irq;
  ULONG NumPorts;
  ULONG PCI_SVID;
  ULONG PCI_SID;
  ULONG Claimed;  // 1 if we assigned or used it.
} PCI_CONFIG;

typedef
NTSTATUS
(*PSERIAL_START_ROUTINE) (
    IN PSERIAL_DEVICE_EXTENSION
    );

typedef
VOID
(*PSERIAL_GET_NEXT_ROUTINE) (
    IN PIRP *CurrentOpIrp,
    IN PLIST_ENTRY QueueToProcess,
    OUT PIRP *NewIrp,
    IN BOOLEAN CompleteCurrent,
    PSERIAL_DEVICE_EXTENSION Extension
    );

typedef struct _SERIAL_UPDATE_CHAR {
    PSERIAL_DEVICE_EXTENSION Extension;
    ULONG CharsCopied;
    BOOLEAN Completed;
    } SERIAL_UPDATE_CHAR,*PSERIAL_UPDATE_CHAR;

//
// The following simple structure is used to send a pointer
// the device extension and an ioctl specific pointer
// to data.
//
typedef struct _SERIAL_IOCTL_SYNC {
    PSERIAL_DEVICE_EXTENSION Extension;
    PVOID Data;
    } SERIAL_IOCTL_SYNC,*PSERIAL_IOCTL_SYNC;

//
// Return values for mouse detection callback
//
//#define SERIAL_FOUNDPOINTER_PORT   1
//#define SERIAL_FOUNDPOINTER_VECTOR 2

//
// The following three macros are used to initialize, increment
// and decrement reference counts in IRPs that are used by
// this driver.  The reference count is stored in the fourth
// argument of the irp, which is never used by any operation
// accepted by this driver.
//
#define SERIAL_REF_ISR         (0x00000001)
#define SERIAL_REF_CANCEL      (0x00000002)
#define SERIAL_REF_TOTAL_TIMER (0x00000004)
#define SERIAL_REF_INT_TIMER   (0x00000008)
#define SERIAL_REF_XOFF_REF    (0x00000010)


#define SERIAL_INIT_REFERENCE(Irp) { \
    ASSERT(sizeof(LONG) <= sizeof(PVOID)); \
    IoGetCurrentIrpStackLocation((Irp))->Parameters.Others.Argument4 = NULL; \
    }

#define SERIAL_SET_REFERENCE(Irp,RefType) \
   do { \
       LONG _refType = (RefType); \
       PLONG _arg4 = (PVOID)&IoGetCurrentIrpStackLocation((Irp))->Parameters.Others.Argument4; \
       GAssert(515,!(*_arg4 & _refType)); \
       *_arg4 |= _refType; \
   } while (0)

#define SERIAL_CLEAR_REFERENCE(Irp,RefType) \
   do { \
       LONG _refType = (RefType); \
       PLONG _arg4 = (PVOID)&IoGetCurrentIrpStackLocation((Irp))->Parameters.Others.Argument4; \
       *_arg4 &= ~_refType; \
   } while (0)
       //GAssert(516,*_arg4 & _refType); \  (pull out, not valid, kpb, 1-18-98)

//#define SERIAL_INC_REFERENCE(Irp) \
//   ((*((LONG *)(&(IoGetCurrentIrpStackLocation((Irp)))->Parameters.Others.Argument4)))++)

//#define SERIAL_DEC_REFERENCE(Irp) \
//   ((*((LONG *)(&(IoGetCurrentIrpStackLocation((Irp)))->Parameters.Others.Argument4)))--)

#define SERIAL_REFERENCE_COUNT(Irp) \
    ((LONG)((IoGetCurrentIrpStackLocation((Irp))->Parameters.Others.Argument4)))

extern ULONG RocketDebugLevel;
extern DRIVER_CONTROL Driver;   // driver related options and references

#ifdef S_RK
extern PCI_CONFIG PciConfig[MAX_NUM_BOXES+1];  // array of all our pci-boards in sys
#endif

extern  int	LoadModemCode(char *firm_pathname,char *flm_pathname);
extern  void FreeModemFiles();