/*-------------------------------------------------------------------------- * * Copyright (C) Cyclades Corporation, 1996-2001. * All rights reserved. * * Cyclom-Y Port Driver * * This file: cyyport.h * * Description: Type definitions and data for the Cyclom-Y Port * Driver * * Notes: This code supports Windows 2000 and x86 processor. * * Complies with Cyclades SW Coding Standard rev 1.3. * *-------------------------------------------------------------------------- */ /*------------------------------------------------------------------------- * * Change History * *-------------------------------------------------------------------------- * * *-------------------------------------------------------------------------- */ #define POOL_TAGGING 1 #ifdef POOL_TAGGING #undef ExAllocatePool #undef ExAllocatePoolWithQuota #define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'PyyC') #define ExAllocatePoolWithQuota(a,b) ExAllocatePoolWithQuotaTag(a,b,'PyyC') #endif // // The following definition is used to include/exclude changes made for power // support in the driver. If non-zero the support is included. If zero the // support is excluded. // #define POWER_SUPPORT 1 #define CYYDIAG1 (DPFLTR_INFO_LEVEL + 1) #define CYYDIAG2 (DPFLTR_INFO_LEVEL + 2) #define CYYDIAG3 (DPFLTR_INFO_LEVEL + 3) #define CYYDIAG4 (DPFLTR_INFO_LEVEL + 4) #define CYYDIAG5 (DPFLTR_INFO_LEVEL + 5) #define CYYIRPPATH (DPFLTR_INFO_LEVEL + 6) #define CYYINITCODE (DPFLTR_INFO_LEVEL + 7) #define CYYTRACECALLS (DPFLTR_INFO_LEVEL + 8) #define CYYPNPPOWER (DPFLTR_INFO_LEVEL + 9) #define CYYFLOW (DPFLTR_INFO_LEVEL + 10) #define CYYERRORS (DPFLTR_INFO_LEVEL + 11) #define CYYDBGALL ((ULONG)0xFFFFFFFF) #define CYY_DBG_DEFAULT CYYDBGALL // // Some default driver values. We will check the registry for // them first. // #define CYY_UNINITIALIZED_DEFAULT 1234567 #define CYY_PERMIT_SHARE_DEFAULT 0 #define CYY_RX_FIFO_DEFAULT 8 #define CYY_TX_FIFO_DEFAULT MAX_CHAR_FIFO // // This define gives the default Object directory // that we should use to insert the symbolic links // between the NT device name and namespace used by // that object directory. #define DEFAULT_DIRECTORY L"DosDevices" // // For the above directory, the serial port will // use the following name as the suffix of the serial // ports for that directory. It will also append // a number onto the end of the name. That number // will start at 1. #define DEFAULT_SERIAL_NAME L"COM" // // // This define gives the default NT name for // for serial ports detected by the firmware. // This name will be appended to Device prefix // with a number following it. The number is // incremented each time encounter a serial // port detected by the firmware. Note that // on a system with multiple busses, this means // that the first port on a bus is not necessarily // \Device\Serial0. // #define DEFAULT_NT_SUFFIX L"Cyyport" //#define CYY_VENDOR_ID 0x120e //#define CYY_LO_DEV_ID 0x100 //#define CYY_HI_DEV_ID 0x101 // Defines for OutputRS232 #define CYY_LC_RTS 0x01 #define CYY_LC_DTR 0x02 typedef struct _CONFIG_DATA { PHYSICAL_ADDRESS PhysicalRuntime; PHYSICAL_ADDRESS TranslatedRuntime; PHYSICAL_ADDRESS PhysicalBoardMemory; PHYSICAL_ADDRESS TranslatedBoardMemory; ULONG RuntimeLength; ULONG BoardMemoryLength; ULONG PortIndex; ULONG BusNumber; ULONG RuntimeAddressSpace; ULONG BoardMemoryAddressSpace; ULONG RxFIFO; ULONG TxFIFO; INTERFACE_TYPE InterfaceType; KINTERRUPT_MODE InterruptMode; ULONG OriginalVector; ULONG OriginalIrql; ULONG TrVector; ULONG TrIrql; KAFFINITY Affinity; } CONFIG_DATA,*PCONFIG_DATA; // // This structure contains configuration data, much of which // is read from the registry. // typedef struct _CYY_REGISTRY_DATA { PDRIVER_OBJECT DriverObject; ULONG ControllersFound; ULONG DebugLevel; ULONG ShouldBreakOnEntry; ULONG RxFIFODefault; ULONG TxFIFODefault; ULONG PermitShareDefault; ULONG PermitSystemWideShare; UNICODE_STRING Directory; UNICODE_STRING NtNameSuffix; UNICODE_STRING DirectorySymbolicName; LIST_ENTRY ConfigList; } CYY_REGISTRY_DATA,*PCYY_REGISTRY_DATA; // To support Break command #define NO_BREAK 0 #define SEND_BREAK 1 #define STOP_BREAK 2 #define DISABLE_ETC 3 // Default xon/xoff characters. #define CYY_DEF_XON 0x11 #define CYY_DEF_XOFF 0x13 // Reasons why reception may be held up. #define CYY_RX_DTR ((ULONG)0x01) #define CYY_RX_XOFF ((ULONG)0x02) #define CYY_RX_RTS ((ULONG)0x04) #define CYY_RX_DSR ((ULONG)0x08) // Reasons why transmission may be held up. #define CYY_TX_CTS ((ULONG)0x01) #define CYY_TX_DSR ((ULONG)0x02) #define CYY_TX_DCD ((ULONG)0x04) #define CYY_TX_XOFF ((ULONG)0x08) #define CYY_TX_BREAK ((ULONG)0x10) //Line status in RDSR Register #define CYY_LSR_OE 0x01 //Overrun Error #define CYY_LSR_FE 0x02 //Framing Error #define CYY_LSR_PE 0x04 //Parity Error #define CYY_LSR_BI 0x08 //Break Interrupt #define CYY_LSR_ERROR 0x0f //Overrun+Framing+Parity+Break // These values are used by the routines that can be used // to complete a read (other than interval timeout) to indicate // #define CYY_COMPLETE_READ_CANCEL ((LONG)-1) #define CYY_COMPLETE_READ_TOTAL ((LONG)-2) #define CYY_COMPLETE_READ_COMPLETE ((LONG)-3) typedef struct _CYY_DEVICE_STATE { // // TRUE if we need to set the state to open // on a powerup // BOOLEAN Reopen; UCHAR Srer; UCHAR Cor1; UCHAR Cor2; UCHAR Cor3; UCHAR Schr1; UCHAR Schr2; UCHAR Mcor1; UCHAR Mcor2; UCHAR Rtpr; UCHAR Msvr1; UCHAR Msvr2; UCHAR Rbpr; UCHAR Tbpr; UCHAR Rcor; UCHAR Tcor; } CYY_DEVICE_STATE, *PCYY_DEVICE_STATE; #if DBG #define CyyLockPagableSectionByHandle(_secHandle) \ { \ MmLockPagableSectionByHandle((_secHandle)); \ InterlockedIncrement(&CyyGlobals.PAGESER_Count); \ } #define CyyUnlockPagableImageSection(_secHandle) \ { \ InterlockedDecrement(&CyyGlobals.PAGESER_Count); \ MmUnlockPagableImageSection(_secHandle); \ } #define CYY_LOCKED_PAGED_CODE() \ if ((KeGetCurrentIrql() > APC_LEVEL) \ && (CyyGlobals.PAGESER_Count == 0)) { \ KdPrint(("CYYPORT: Pageable code called at IRQL %d without lock \n", \ KeGetCurrentIrql())); \ ASSERT(FALSE); \ } #else #define CyyLockPagableSectionByHandle(_secHandle) \ { \ MmLockPagableSectionByHandle((_secHandle)); \ } #define CyyUnlockPagableImageSection(_secHandle) \ { \ MmUnlockPagableImageSection(_secHandle); \ } #define CYY_LOCKED_PAGED_CODE() #endif // DBG #define CyyRemoveQueueDpc(_dpc, _pExt) \ { \ if (KeRemoveQueueDpc((_dpc))) { \ InterlockedDecrement(&(_pExt)->DpcCount); \ } \ } typedef struct _CYY_DEVICE_EXTENSION { // PKSERVICE_ROUTINE ptIsr; // PVOID ptContext; // struct _CYY_DEVICE_EXTENSION *ptExtension[CYY_MAX_PORTS]; // ULONG nchannel; BOOLEAN LieRIDSR; // // This holds the isr that should be called from our own // dispatching isr for "cards" that are trying to share the // same interrupt. // // PKSERVICE_ROUTINE TopLevelOurIsr; // // This holds the context that should be used when we // call the above service routine. // // PVOID TopLevelOurIsrContext; // // This links together all of the different "cards" that are // trying to share the same interrupt of a non-mca machine. // // LIST_ENTRY TopLevelSharers; // // This circular doubly linked list links together all // devices that are using the same interrupt object. // NOTE: This does not mean that they are using the // same interrupt "dispatching" routine. // // LIST_ENTRY CommonInterruptObject; // // This links together all devobjs that this driver owns. // It is needed to search when starting a new device. // LIST_ENTRY AllDevObjs; // For reporting resource usage, we keep around the physical // address we got from the registry. // PHYSICAL_ADDRESS OriginalRuntimeMemory; // For reporting resource usage, we keep around the physical // address we got from the registry. // PHYSICAL_ADDRESS OriginalBoardMemory; // // 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; // // We keep a pointer around to our device name for dumps // and for creating "external" symbolic links to this // device. // UNICODE_STRING DeviceName; // // This points to the object directory that we will place // a symbolic link to our device name. // UNICODE_STRING ObjectDirectory; // // This points to the device name for this device // sans device prefix. // UNICODE_STRING NtNameForPort; // // This points to the symbolic link name that will be // linked to the actual nt device name. // UNICODE_STRING SymbolicLinkName; // // This points to the pure "COMx" name // UNICODE_STRING DosName; // // 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; // // After initialization of the driver is complete, this // will either be NULL or point to the routine that the // kernel will call when an interrupt occurs. // // If the pointer is null then this is part of a list // of ports that are sharing an interrupt and this isn't // the first port that we configured for this interrupt. // // If the pointer is non-null then this routine has some // kind of structure that will "eventually" get us into // the real serial isr with a pointer to this device extension. // // NOTE: On an MCA bus (except for multiport cards) this // is always a pointer to the "real" serial isr. PKSERVICE_ROUTINE OurIsr; // // This will generally point right to this device extension. // // However, when the port that this device extension is // "managing" was the first port initialized on a chain // of ports that were trying to share an interrupt, this // will point to a structure that will enable dispatching // to any port on the chain of sharers of this interrupt. // PVOID OurIsrContext; PUCHAR Runtime; // Virtual Address Pointer to the PLX Runtime memory PUCHAR BoardMemory; // Virtual Address Pointer to the first CD1400 onboard PUCHAR Cd1400; // Virtual Address Pointer to the CD1400 of this port PHYSICAL_ADDRESS OriginalCd1400; // Physical address to the CD1400 or this port UCHAR CdChannel; // Channel number within the CD1400 // // Points to the interrupt object for used by this device. // PKINTERRUPT Interrupt; // // 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; // // This list head is used to contain the time ordered list // of set and wait mask requests. Access to this list is protected by // the global cancel spinlock. // LIST_ENTRY MaskQueue; // // 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 // affect the wait mask operations. // PIRP CurrentMaskIrp; // // 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 send an immediate // character. // PIRP CurrentImmediateIrp; // // Points to the irp that is being used to count the number // of characters received after an xoff (as currently defined // by the IOCTL_CYY_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; // // 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 is a buffer for the read processing. // // The buffer works as a ring. When the character is read from // the device it will be place at the end of the ring. // // Characters are only placed in this buffer at interrupt level // although character may be read at any level. The pointers // that manage this buffer may not be updated except at interrupt // level. // PUCHAR InterruptReadBuffer; // // This is a pointer to the first character of the buffer into // which the interrupt service routine is copying characters. // PUCHAR ReadBufferBase; // // This is a count of the number of characters in the interrupt // buffer. This value is set and read at interrupt level. Note // that this value is only *incremented* at interrupt level so // it is safe to read it at any level. When characters are // copied out of the read buffer, this count is decremented by // a routine that synchronizes with the ISR. // ULONG CharsInInterruptBuffer; // // Points to the first available position for a newly received // character. This variable is only accessed at interrupt level and // buffer initialization code. // PUCHAR CurrentCharSlot; // // This variable is used to contain the last available position // in the read buffer. It is updated at open and at interrupt // level when switching between the users buffer and the interrupt // buffer. // PUCHAR LastCharSlot; // // This marks the first character that is available to satisfy // a read request. Note that while this always points to valid // memory, it may not point to a character that can be sent to // the user. This can occur when the buffer is empty. // PUCHAR FirstReadableChar; // // Pointer to the lock variable returned for this extension when // locking down the driver // PVOID LockPtr; BOOLEAN LockPtrFlag; // // 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; // // 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 holds the current baud rate for the device. // ULONG CurrentBaud; // // 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; // // This ulong is incremented each time something trys to start // the execution path that tries to lower the RTS line when // doing transmit toggling. If it "bumps" into another path // (indicated by a false return value from queueing a dpc // and a TRUE return value tring to start a timer) it will // decrement the count. These increments and decrements // are all done at device level. Note that in the case // of a bump while trying to start the timer, we have to // go up to device level to do the decrement. // ULONG CountOfTryingToLowerRTS; // // This ULONG is used to keep track of the "named" (in ntddser.h) // baud rates that this particular device supports. // ULONG SupportedBauds; // // This value holds the span (in units of bytes) of the register // set controlling this port. This is constant over the life // of the port. // ULONG RuntimeLength; // // This value holds the span (in units of bytes) of the interrupt // status register associated with this port. This is constant // over the life of the port. // ULONG BoardMemoryLength; // // The number of characters to push out if a fifo is present. // ULONG TxFifoAmount; // // Set to indicate that it is ok to share interrupts within the device. // ULONG PermitShare; // // 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; // // Holds performance statistics that applications can query. // Reset on each open. Only set at device level. // SERIALPERF_STATS PerfStats; // // This holds what we beleive to be the current value of // the line control register. // // 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. // UCHAR msvr; UCHAR cor1; // // 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 DeviceIsOpened; // // This is only accessed at interrupt level. It keeps track // of whether the holding register is empty. // BOOLEAN HoldingEmpty; // // This variable is only accessed at interrupt level. It // indicates that we want to transmit a character immediately. // That is - in front of any characters that could be transmitting // from a normal write. // BOOLEAN TransmitImmediate; // // This variable is only accessed at interrupt level. Whenever // a wait is initiated this variable is set to false. // Whenever any kind of character is written it is set to true. // Whenever the write queue is found to be empty the code that // is processing that completing irp will synchonize with the interrupt. // If this synchronization code finds that the variable is true and that // there is a wait on the transmit queue being empty then it is // certain that the queue was emptied and that it has happened since // the wait was initiated. // BOOLEAN EmptiedTransmit; // // This simply indicates that the port associated with this // extension is part of a multiport card. // // BOOLEAN PortOnAMultiportCard; // // We keep the following values around so that we can connect // to the interrupt and report resources after the configuration // record is gone. // ULONG Vector; KIRQL Irql; ULONG OriginalVector; ULONG OriginalIrql; KINTERRUPT_MODE InterruptMode; KAFFINITY ProcessorAffinity; ULONG RuntimeAddressSpace; ULONG BoardMemoryAddressSpace; ULONG BusNumber; INTERFACE_TYPE InterfaceType; // // Port index no for multiport devices // ULONG PortIndex; // // We hold the character that should be transmitted immediately. // // Note that we can't use this to determine whether there is // a character to send because the character to send could be // zero. // UCHAR ImmediateChar; // // This holds the mask that will be used to mask off unwanted // data bits of the received data (valid data bits can be 5,6,7,8) // The mask will normally be 0xff. This is set while the control // lock is held since it wouldn't have adverse effects on the // isr if it is changed in the middle of reading characters. // (What it would do to the app is another question - but then // the app asked the driver to do it.) // UCHAR ValidDataMask; // // The application can turn on a mode,via the // IOCTL_CYY_LSRMST_INSERT ioctl, that will cause the // serial driver to insert the line status or the modem // status into the RX stream. The parameter with the ioctl // is a pointer to a UCHAR. If the value of the UCHAR is // zero, then no insertion will ever take place. If the // value of the UCHAR is non-zero (and not equal to the // xon/xoff characters), then the serial driver will insert. // UCHAR EscapeChar; // REMOVED FANNY // // // // This boolean will be true if a 16550 is present *and* enabled. // // // BOOLEAN FifoPresent; // // // // // This denotes that this particular port is an on the motherboard // // port for the Jensen hardware. On these ports the OUT2 bit // // which is used to enable/disable interrupts is always hight. // // // BOOLEAN Jensen; // // This is the water mark that the rxfifo should be // set to when the fifo is turned on. This is not the actual // value, but the encoded value that goes into the register. // UCHAR RxFifoTrigger; // // Says whether this device can share interrupts with devices // other than serial devices. // BOOLEAN InterruptShareable; // // 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; // // Records whether we actually created an entry in SERIALCOMM // at driver load time. If we didn't create it, we won't try // to destroy it when the device is removed. // BOOLEAN CreatedSerialCommEntry; // // 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 lock will be used to protect the accept / reject state // transitions and flags of the driver It must be acquired // before a cancel lock // KSPIN_LOCK FlagsLock; // // 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 when the transmit immediate char // character is given to the hardware. It will simply complete // the irp. // KDPC CompleteImmediateDpc; // // This dpc is fired off if the transmit immediate char // character times out. The dpc routine will "grab" the // irp from the isr and time it out. // KDPC TotalImmediateTimeoutDpc; // // 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 dpc is fired off only from device level to start off // a timer that will queue a dpc to check if the RTS line // should be lowered when we are doing transmit toggling. // KDPC StartTimerLowerRTSDpc; // // This dpc is fired off when a timer expires (after one // character time), so that code can be invoked that will // check to see if we should lower the RTS line when // doing transmit toggling. // KDPC PerhapsLowerRTSDpc; // // This DPC is fired to set an event stating that all other // DPC's have been finish for this device extension so that // paged code may be unlocked. // KDPC IsrUnlockPagesDpc; // // 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 is the kernal timer structure used to handle // total time request timing. // KTIMER ImmediateTotalTimer; // // This timer is used to timeout the xoff counter // io. // KTIMER XoffCountTimer; // // This timer is used to invoke a dpc one character time // after the timer is set. That dpc will be used to check // whether we should lower the RTS line if we are doing // transmit toggling. // KTIMER LowerRTSTimer; // // This is a pointer to the next lower device in the IRP stack. // PDEVICE_OBJECT LowerDeviceObject; // // This is where keep track of the power state the device is in. // DEVICE_POWER_STATE PowerState; // // Pointer to the driver object // PDRIVER_OBJECT DriverObject; // // Event used to do some synchronization with the devices underneath me // (namely ACPI) // KEVENT SerialSyncEvent; // // 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; // // Count of pending IRP's // ULONG PendingIRPCnt; // // Accepting requests? // ULONG DevicePNPAccept; // // No IRP's pending event // KEVENT PendingIRPEvent; // // PNP State // ULONG PNPState; // // Misc Flags // ULONG Flags; // // Open count // LONG OpenCount; // // Start sync event // KEVENT CyyStartEvent; // // Current state during powerdown // CYY_DEVICE_STATE DeviceState; // // Device stack capabilites // DEVICE_POWER_STATE DeviceStateMap[PowerSystemMaximum]; // // Event to signal transition to D0 completion // KEVENT PowerD0Event; // // List of stalled IRP's // LIST_ENTRY StalledIrpQueue; // // Mutex on open status // FAST_MUTEX OpenMutex; // // Mutex on close // FAST_MUTEX CloseMutex; // // TRUE if we own power policy // BOOLEAN OwnsPowerPolicy; // // SystemWake from devcaps // SYSTEM_POWER_STATE SystemWake; // // DeviceWake from devcaps // DEVICE_POWER_STATE DeviceWake; // // Our PDO // PDEVICE_OBJECT Pdo; // // Should we enable wakeup // BOOLEAN SendWaitWake; // // Pending wait wake IRP // PIRP PendingWakeIrp; // // 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; // // Pending DPC count // ULONG DpcCount; // // Pending DPC event // KEVENT PendingDpcEvent; // // Should we expose external interfaces? // ULONG SkipNaming; // // CD1400 clock (Revision G runs at 25Mhz, later versions runs at 60Mhz) // ULONG CDClock; // // MSVR register that controls RTS. // ULONG MSVR_RTS; // // MSVR register that controls DTR. // ULONG MSVR_DTR; // // RTS bit in the MSVR register. // UCHAR RTSset; // // DTR bit in the MSVR register. // UCHAR DTRset; // // Receive Time-out Period Register. // ULONG Rtpr; // // Com port number. // //ULONG Com; // // This flag tells how the ISR should handle Break. // ULONG BreakCmd; // // Flag to indicate if Command Failure error was already logged. // Only one log per driver load. Otherwise, the system may crash if // too many logs start happening. // BOOLEAN CmdFailureLog; // // It indicates if the board is PCI or ISA. // ULONG IsPci; // // PCI slot where the board is inserted. // ULONG PciSlot; // // Flag to indicate that COR3 was set using RxFifoTrigger set by application // BOOLEAN RxFifoTriggerUsed; } CYY_DEVICE_EXTENSION,*PCYY_DEVICE_EXTENSION; #define CYY_PNPACCEPT_OK 0x0L #define CYY_PNPACCEPT_REMOVING 0x1L #define CYY_PNPACCEPT_STOPPING 0x2L #define CYY_PNPACCEPT_STOPPED 0x4L #define CYY_PNPACCEPT_SURPRISE_REMOVING 0x8L #define CYY_PNP_ADDED 0x0L #define CYY_PNP_STARTED 0x1L #define CYY_PNP_QSTOP 0x2L #define CYY_PNP_STOPPING 0x3L #define CYY_PNP_QREMOVE 0x4L #define CYY_PNP_REMOVING 0x5L #define CYY_PNP_RESTARTING 0x6L #define CYY_FLAGS_CLEAR 0x0L #define CYY_FLAGS_STARTED 0x1L #define CYY_FLAGS_STOPPED 0x2L #define CYY_FLAGS_BROKENHW 0x4L // // When dealing with a multi-port device (that is possibly // daisy chained with other multi-port device), the interrupt // service routine will actually be a routine that determines // which port on which board is actually causing the interrupt. // // The following structure is used so that only one device // extension will actually need to connect to the interrupt. // The following structure which is passed to the interrupt // service routine contains the addresses of all of the // interrupt status registers (there will be multiple // status registers when multi-port cards are chained). It // will contain the addresses of all the extensions whose // devices are being serviced by this interrupt. // typedef struct _CYY_DISPATCH { PUCHAR Cd1400[CYY_MAX_PORTS]; PCYY_DEVICE_EXTENSION Extensions[CYY_MAX_PORTS]; ULONG IsPci; } CYY_DISPATCH,*PCYY_DISPATCH; // // We use this to query into the registry as to whether we // should break at driver entry. // extern CYY_REGISTRY_DATA driverDefaults; // // This is exported from the kernel. It is used to point // to the address that the kernel debugger is using. // extern PUCHAR *KdComPortInUse; typedef enum _CYY_MEM_COMPARES { AddressesAreEqual, AddressesOverlap, AddressesAreDisjoint } CYY_MEM_COMPARES,*PCYY_MEM_COMPARES; typedef struct _CYY_GLOBALS { LIST_ENTRY AllDevObjs; PVOID PAGESER_Handle; UNICODE_STRING RegistryPath; KSPIN_LOCK GlobalsSpinLock; #if DBG ULONG PAGESER_Count; #endif // DBG } CYY_GLOBALS, *PCYY_GLOBALS; extern CYY_GLOBALS CyyGlobals; typedef struct _SERIAL_PTR_CTX { ULONG isPointer; PHYSICAL_ADDRESS Port; ULONG Vector; } SERIAL_PTR_CTX, *PSERIAL_PTR_CTX; #define DEVICE_OBJECT_NAME_LENGTH 128 #define SYMBOLIC_NAME_LENGTH 128 #define SERIAL_DEVICE_MAP L"SERIALCOMM" // // Return values for mouse detection callback // #define SERIAL_FOUNDPOINTER_PORT 1 #define SERIAL_FOUNDPOINTER_VECTOR 2 #define CyyCompleteRequest(PDevExt, PIrp, PriBoost) \ { \ CyyDbgPrintEx(CYYIRPPATH, "Complete Irp: %X\n", (PIrp)); \ IoCompleteRequest((PIrp), (PriBoost)); \ CyyIRPEpilogue((PDevExt)); \ } #define SERIAL_WMI_GUID_LIST_SIZE 5 extern WMIGUIDREGINFO SerialWmiGuidList[SERIAL_WMI_GUID_LIST_SIZE];