archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/drivers/serial/mps/cyclades/z/cyzport/cyzopcl.c

905 lines
25 KiB
Raw Blame History

/*--------------------------------------------------------------------------
*
* Copyright (C) Cyclades Corporation, 1997-2001.
* All rights reserved.
*
* Cyclades-Z Port Driver
*
* This file: cyzopcl.c
*
* Description: This module contains the code related to opening,
* closing and cleaning up in the Cyclades-Z Port driver.
*
* Notes: This code supports Windows 2000 and Windows XP,
* x86 and IA64 processors.
*
* Complies with Cyclades SW Coding Standard rev 1.3.
*
*--------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* Change History
*
*--------------------------------------------------------------------------
*
*
*--------------------------------------------------------------------------
*/
#include "precomp.h"
BOOLEAN
CyzMarkOpen(
IN PVOID Context
);
BOOLEAN
CyzNullSynch(
IN PVOID Context
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGESER,CyzGetCharTime)
#pragma alloc_text(PAGESER,CyzMarkClose)
#pragma alloc_text(PAGESER,CyzCleanup)
#pragma alloc_text(PAGESER,CyzClose)
#pragma alloc_text(PAGESER,CyzMarkClose)
#pragma alloc_text(PAGESER,CyzMarkOpen)
#pragma alloc_text(PAGESER,CyzCreateOpen)
//
// Always paged
//
//#pragma alloc_text(PAGESRP0,CyzCreateOpen) Moved to PAGESER, because of raised IRQL during spin lock.
//#pragma alloc_text(PAGESRP0,SerialDrainUART)
#endif // ALLOC_PRAGMA
BOOLEAN
CyzNullSynch(
IN PVOID Context
)
/*------------------------------------------------------------------------
Just a bogus little routine to synch with the ISR.
------------------------------------------------------------------------*/
{
UNREFERENCED_PARAMETER(Context);
return FALSE;
}
NTSTATUS
CyzCreateOpen(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*--------------------------------------------------------------------------
CyzCreateOpen()
Description: We connect up to the interrupt for the create/open
and initialize the structures needed to maintain an open for a
device.
Arguments:
DeviceObject - Pointer to the device object for this device
Irp - Pointer to the IRP for the current request
Return Value: The function value is the final status of the call
--------------------------------------------------------------------------*/
{
PCYZ_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
NTSTATUS localStatus;
#ifdef POLL
KIRQL pollIrql;
KIRQL pollingIrql;
PCYZ_DISPATCH pDispatch = extension->OurIsrContext;
#endif
PAGED_CODE();
if (extension->PNPState != CYZ_PNP_STARTED) {
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Lock out changes to PnP state until we have our open state decided
//
ExAcquireFastMutex(&extension->OpenMutex);
if ((localStatus = CyzIRPPrologue(Irp, extension)) != STATUS_SUCCESS) {
ExReleaseFastMutex(&extension->OpenMutex);
if(localStatus != STATUS_PENDING) {
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
}
return localStatus;
}
if (InterlockedIncrement(&extension->OpenCount) != 1) {
ExReleaseFastMutex(&extension->OpenMutex);
InterlockedDecrement(&extension->OpenCount);
Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
return STATUS_ACCESS_DENIED;
}
CyzDbgPrintEx(CYZIRPPATH, "Dispatch entry for: %x\n", Irp);
CyzDbgPrintEx(CYZDIAG3, "In CyzCreateOpen\n");
LOGENTRY(LOG_MISC, ZSIG_OPEN,
extension->PortIndex+1,
0,
0);
// Before we do anything, let's make sure they aren't trying
// to create a directory. This is a silly, but what's a driver to do!?
if (IoGetCurrentIrpStackLocation(Irp)->Parameters.Create.Options &
FILE_DIRECTORY_FILE) {
ExReleaseFastMutex(&extension->OpenMutex);
Irp->IoStatus.Status = STATUS_NOT_A_DIRECTORY;
Irp->IoStatus.Information = 0;
InterlockedDecrement(&extension->OpenCount);
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
return STATUS_NOT_A_DIRECTORY;
}
// Create a buffer for the RX data when no reads are outstanding.
extension->InterruptReadBuffer = NULL;
extension->BufferSize = 0;
switch (MmQuerySystemSize()) {
case MmLargeSystem: {
extension->BufferSize = 4096;
extension->InterruptReadBuffer = ExAllocatePool(
NonPagedPool,
extension->BufferSize);
if (extension->InterruptReadBuffer) {
break;
}
}
case MmMediumSystem: {
extension->BufferSize = 1024;
extension->InterruptReadBuffer = ExAllocatePool(
NonPagedPool,
extension->BufferSize);
if (extension->InterruptReadBuffer) {
break;
}
}
case MmSmallSystem: {
extension->BufferSize = 128;
extension->InterruptReadBuffer = ExAllocatePool(
NonPagedPool,
extension->BufferSize);
}
}
if (!extension->InterruptReadBuffer) {
ExReleaseFastMutex(&extension->OpenMutex);
extension->BufferSize = 0;
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Information = 0;
InterlockedDecrement(&extension->OpenCount);
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Ok, it looks like we really are going to open. Lock down the
// driver.
//
CyzLockPagableSectionByHandle(CyzGlobals.PAGESER_Handle);
//
// Power up the stack
//
(void)CyzGotoPowerState(DeviceObject, extension, PowerDeviceD0);
//
// Not currently waiting for wake up
//
extension->SendWaitWake = FALSE;
// "flush" the read queue by initializing the count of characters.
extension->CharsInInterruptBuffer = 0;
extension->LastCharSlot = extension->InterruptReadBuffer +
(extension->BufferSize - 1);
extension->ReadBufferBase = extension->InterruptReadBuffer;
extension->CurrentCharSlot = extension->InterruptReadBuffer;
extension->FirstReadableChar = extension->InterruptReadBuffer;
extension->TotalCharsQueued = 0;
// set up the default xon/xoff limits.
extension->HandFlow.XoffLimit = extension->BufferSize >> 3;
extension->HandFlow.XonLimit = extension->BufferSize >> 1;
extension->WmiCommData.XoffXmitThreshold = extension->HandFlow.XoffLimit;
extension->WmiCommData.XonXmitThreshold = extension->HandFlow.XonLimit;
extension->BufferSizePt8 = ((3*(extension->BufferSize>>2))+
(extension->BufferSize>>4));
//
// Mark the device as busy for WMI
//
extension->WmiCommData.IsBusy = TRUE;
extension->IrpMaskLocation = NULL;
extension->HistoryMask = 0;
extension->IsrWaitMask = 0;
#if !DBG
// Clear out the statistics.
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzClearStats(extension);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
#else
KeSynchronizeExecution(extension->Interrupt,CyzClearStats,extension);
#endif
#endif
extension->EscapeChar = 0;
// Synchronize with the ISR and mark the device as open
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzMarkOpen(extension);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
#else
KeSynchronizeExecution(extension->Interrupt,CyzMarkOpen,extension);
#endif
// Include this port in the list of Extensions, so that the next polling cycle will
// consider it a working port.
#ifdef POLL
KeAcquireSpinLock(&pDispatch->PollingLock,&pollingIrql);
pDispatch->Extensions[extension->PortIndex] = extension;
if (!pDispatch->PollingStarted) {
// Start polling timer
KeSetTimerEx(
&pDispatch->PollingTimer,
pDispatch->PollingTime,
pDispatch->PollingPeriod,
&pDispatch->PollingDpc
);
pDispatch->PollingStarted = TRUE;
pDispatch->PollingDrained = FALSE;
}
KeReleaseSpinLock(&pDispatch->PollingLock,pollingIrql);
#endif
Irp->IoStatus.Status = STATUS_SUCCESS;
//
// We have been marked open, so now the PnP state can change
//
ExReleaseFastMutex(&extension->OpenMutex);
localStatus = Irp->IoStatus.Status;
Irp->IoStatus.Information=0L;
if (!NT_SUCCESS(localStatus)) {
if (extension->InterruptReadBuffer != NULL) {
ExFreePool(extension->InterruptReadBuffer);
extension->InterruptReadBuffer = NULL;
}
InterlockedDecrement(&extension->OpenCount);
}
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
return localStatus;
}
NTSTATUS
CyzClose(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*--------------------------------------------------------------------------
CyzClose()
Description: We simply disconnect the interrupt for now.
Arguments:
DeviceObject - Pointer to the device object for this device
Irp - Pointer to the IRP for the current request
Return Value: The function value is the final status of the call
--------------------------------------------------------------------------*/
{
LARGE_INTEGER tenCharDelay;
LARGE_INTEGER sixtyfourCharDelay;
LARGE_INTEGER charTime;
LARGE_INTEGER d200ms = RtlConvertLongToLargeInteger(-200*10000);
LARGE_INTEGER d100ms = RtlConvertLongToLargeInteger(-100*10000);
PCYZ_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
ULONG tx_put, tx_get, tx_bufsize;
ULONG waitAmount1, waitAmount2;
struct BUF_CTRL *buf_ctrl;
ULONG txempty;
CYZ_CLOSE_SYNC S;
#ifdef POLL
KIRQL pollIrql;
#endif
NTSTATUS status;
//
// Number of opens still active
//
LONG openCount;
//
// Number of DPC's still pending
//
ULONG pendingDPCs;
ULONG flushCount;
//
// Grab a mutex
//
ExAcquireFastMutex(&extension->CloseMutex);
//
// We succeed a close on a removing device
//
if ((status = CyzIRPPrologue(Irp, extension)) != STATUS_SUCCESS) {
CyzDbgPrintEx(DPFLTR_INFO_LEVEL, "Close prologue failed for: %x\n",
Irp);
if (status == STATUS_DELETE_PENDING) {
extension->BufferSize = 0;
ExFreePool(extension->InterruptReadBuffer);
extension->InterruptReadBuffer = NULL;
status = Irp->IoStatus.Status = STATUS_SUCCESS;
}
if (status != STATUS_PENDING) {
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
openCount = InterlockedDecrement(&extension->OpenCount);
ASSERT(openCount == 0);
}
ExReleaseFastMutex(&extension->CloseMutex);
return status;
}
ASSERT(extension->OpenCount >= 1);
if (extension->OpenCount < 1) {
CyzDbgPrintEx(DPFLTR_ERROR_LEVEL, "Close open count bad for: 0x%x\n",
Irp);
CyzDbgPrintEx(DPFLTR_ERROR_LEVEL, "Count: %x Addr: 0x%x\n",
extension->OpenCount, &extension->OpenCount);
ExReleaseFastMutex(&extension->CloseMutex);
Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
return STATUS_INVALID_DEVICE_REQUEST;
}
CyzDbgPrintEx(CYZIRPPATH, "Dispatch entry for: %x\n", Irp);
CyzDbgPrintEx(CYZDIAG3, "In CyzClose\n");
LOGENTRY(LOG_MISC, ZSIG_CLOSE,
extension->PortIndex+1,
0,
0);
charTime.QuadPart = -CyzGetCharTime(extension).QuadPart;
extension->DeviceIsOpened = FALSE;
// Turn break off in case it is on
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzTurnOffBreak(extension);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
#else
KeSynchronizeExecution(extension->Interrupt,CyzTurnOffBreak,extension);
#endif
// Wait until all characters have been emptied out of the hardware.
// Calculate number of bytes that are still in the firmware
buf_ctrl = extension->BufCtrl;
tx_put = CYZ_READ_ULONG(&buf_ctrl->tx_put);
tx_get = CYZ_READ_ULONG(&buf_ctrl->tx_get);
tx_bufsize = extension->TxBufsize;
if (tx_put >= tx_get) {
waitAmount1 = tx_put - tx_get;
waitAmount2 = 0;
} else {
waitAmount1 = tx_bufsize - tx_get;
waitAmount2 = tx_put;
}
flushCount = waitAmount1 + waitAmount2;
flushCount += 64 + 10; // Add number of bytes that could be in the hardware FIFO
// plus 10 for safety.
// Wait for transmission to be emptied.
S.Extension = extension;
S.Data = &txempty;
for (; flushCount != 0; flushCount--) {
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzCheckIfTxEmpty(&S);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
#else
KeSynchronizeExecution(extension->Interrupt,CyzCheckIfTxEmpty,&S);
#endif
if (txempty) {
break;
}
KeDelayExecutionThread(KernelMode,FALSE,&charTime);
}
// TODO FANNY: SHOULD WE CALL SerialMarkHardwareBroken()? SEE LATER...
// Synchronize with the ISR to let it know that interrupts are
// no longer important.
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzMarkClose(extension);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
#else
KeSynchronizeExecution(extension->Interrupt,CyzMarkClose,extension);
#endif
// If the driver has automatically transmitted an Xoff in
// the context of automatic receive flow control then we
// should transmit an Xon.
if (extension->RXHolding & CYZ_RX_XOFF) {
CyzIssueCmd(extension,C_CM_SENDXON,0L,FALSE);
//TODO FANNY: SHOULD WE CALL SerialMarkHardwareBroken()? SEE LATER...
}
// The hardware is hopefully empty. Delay 10 chars before dropping DTR.
tenCharDelay.QuadPart = charTime.QuadPart * 10;
KeDelayExecutionThread(KernelMode,TRUE,&tenCharDelay);
#ifdef POLL
CyzClrDTR(extension);
#else
KeSynchronizeExecution(extension->Interrupt,CyzClrDTR,extension);
#endif
// We have to be very careful how we clear the RTS line.
// Transmit toggling might have been on at some point.
//
// We know that there is nothing left that could start
// out the "polling" execution path. We need to
// check the counter that indicates that the execution
// path is active. If it is then we loop delaying one
// character time. After each delay we check to see if
// the counter has gone to zero. When it has we know that
// the execution path should be just about finished. We
// make sure that we still aren't in the routine that
// synchronized execution with the ISR by synchronizing
// ourselve with the ISR.
if (extension->CountOfTryingToLowerRTS) {
do {
KeDelayExecutionThread(KernelMode,FALSE,&charTime);
} while (extension->CountOfTryingToLowerRTS);
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzNullSynch(NULL);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
#else
KeSynchronizeExecution(extension->Interrupt,CyzNullSynch,NULL);
#endif
}
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzClrRTS(extension);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
#else
KeSynchronizeExecution(extension->Interrupt,CyzClrRTS,extension);
#endif
#ifdef POLL
KeAcquireSpinLock(&extension->PollLock,&pollIrql);
CyzDisableHw(extension);
KeReleaseSpinLock(&extension->PollLock,pollIrql);
CyzTryToDisableTimer(extension);
#else
KeSynchronizeExecution(extension->Interrupt,CyzDisableHw,extension);
#endif
// Clean out the holding reasons (since we are closed).
extension->RXHolding = 0;
extension->TXHolding = 0;
//
// Mark device as not busy for WMI
//
extension->WmiCommData.IsBusy = FALSE;
// Release the buffers.
extension->BufferSize = 0;
if (extension->InterruptReadBuffer != NULL) { // added in DDK build 2072
ExFreePool(extension->InterruptReadBuffer);
}
extension->InterruptReadBuffer = NULL;
//
// Stop waiting for wakeup
//
extension->SendWaitWake = FALSE;
if (extension->PendingWakeIrp != NULL) {
IoCancelIrp(extension->PendingWakeIrp);
}
//
// Power down our device stack
//
(void)CyzGotoPowerState(DeviceObject, extension, PowerDeviceD3);
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information=0L;
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
//
// Unlock the pages. If this is the last reference to the section
// then the driver code will be flushed out.
//
//
// First, we have to let the DPC's drain. No more should be queued
// since we aren't taking interrupts now....
//
pendingDPCs = InterlockedDecrement(&extension->DpcCount);
LOGENTRY(LOG_CNT, 'DpD7', 0, extension->DpcCount, 0); // Added in build 2128
if (pendingDPCs) {
CyzDbgPrintEx(CYZDIAG1,"Draining DPC's: %x\n", Irp);
KeWaitForSingleObject(&extension->PendingDpcEvent, Executive,
KernelMode, FALSE, NULL);
}
CyzDbgPrintEx(CYZDIAG1, "DPC's drained: %x\n", Irp);
//
// Pages must be locked to release the mutex, so don't unlock
// them until after we release the mutex
//
ExReleaseFastMutex(&extension->CloseMutex);
//
// Reset for next open
//
InterlockedIncrement(&extension->DpcCount);
LOGENTRY(LOG_CNT, 'DpI6', 0, extension->DpcCount, 0); // Added in build 2128
openCount = InterlockedDecrement(&extension->OpenCount);
//
// Open count may be non-zero if someone was trying to open
// at the same time we decremented
//
// ASSERT(openCount == 0);
CyzUnlockPagableImageSection(CyzGlobals.PAGESER_Handle);
return STATUS_SUCCESS;
}
BOOLEAN
CyzMarkOpen(
IN PVOID Context
)
/*------------------------------------------------------------------------
CyzMarkOpen()
Routine Description: This routine mark the fact that somebody opened
the device and its worthwhile to pay attention to interrupts.
Arguments:
Context - Really a pointer to the device extension.
Return Value: This routine always returns FALSE.
------------------------------------------------------------------------*/
{
PCYZ_DEVICE_EXTENSION extension = Context;
CyzReset(extension);
extension->DeviceIsOpened = TRUE;
extension->ErrorWord = 0;
return FALSE;
}
BOOLEAN
CyzDisableHw(IN PVOID Context)
/*++
Routine Description:
This routine disables the UART and puts it in a "safe" state when
not in use (like a close or powerdown).
Arguments:
Context - Really a pointer to the device extension.
Return Value:
This routine always returns FALSE.
--*/
{
PCYZ_DEVICE_EXTENSION extension = Context;
ULONG channel;
struct CH_CTRL *ch_ctrl;
ch_ctrl = extension->ChCtrl;
CYZ_WRITE_ULONG(&ch_ctrl->op_mode,C_CH_DISABLE);
CyzIssueCmd(extension,C_CM_IOCTL,0L,FALSE);
CyzIssueCmd(extension,C_CM_RESET,0L,FALSE);
return FALSE;
}
#ifdef POLL
BOOLEAN
CyzTryToDisableTimer(IN PVOID Context)
/*++
Routine Description:
This routine disables the timer if all other ports in the board are already closed
or powered down.
Arguments:
Context - Really a pointer to the device extension.
Return Value:
This routine always returns FALSE.
--*/
{
PCYZ_DEVICE_EXTENSION extension = Context;
ULONG channel;
PCYZ_DISPATCH pDispatch;
KIRQL oldIrql;
pDispatch = extension->OurIsrContext;
KeAcquireSpinLock(&pDispatch->PollingLock,&oldIrql);
pDispatch->Extensions[extension->PortIndex] = NULL;
for (channel=0; channel<pDispatch->NChannels; channel++) {
if (pDispatch->Extensions[channel])
break;
}
if (channel == pDispatch->NChannels) {
BOOLEAN cancelled;
pDispatch->PollingStarted = FALSE;
cancelled = KeCancelTimer(&pDispatch->PollingTimer);
if (cancelled) {
pDispatch->PollingDrained = TRUE;
}
KeRemoveQueueDpc(&pDispatch->PollingDpc);
}
KeReleaseSpinLock(&pDispatch->PollingLock,oldIrql);
return FALSE;
}
#endif
BOOLEAN
CyzMarkClose(
IN PVOID Context
)
/*------------------------------------------------------------------------
CyzMarkClose()
Routine Description: This routine merely sets a boolean to false to
mark the fact that somebody closed the device and it's no longer
worthwhile to pay attention to interrupts.
Arguments:
Context - Really a pointer to the device extension.
Return Value: This routine always returns FALSE.
------------------------------------------------------------------------*/
{
PCYZ_DEVICE_EXTENSION extension = Context;
struct CH_CTRL *ch_ctrl;
ch_ctrl = extension->ChCtrl;
CYZ_WRITE_ULONG(&ch_ctrl->intr_enable,C_IN_DISABLE);
CyzIssueCmd(extension,C_CM_IOCTL,0L,FALSE);
extension->DeviceIsOpened = FALSE;
return FALSE;
}
NTSTATUS
CyzCleanup(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*------------------------------------------------------------------------
CyzCleanup()
Routine Description: This function is used to kill all longstanding
IO operations.
Arguments:
DeviceObject - Pointer to the device object for this device
Irp - Pointer to the IRP for the current request
Return Value: The function value is the final status of the call
------------------------------------------------------------------------*/
{
PCYZ_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
NTSTATUS status;
PAGED_CODE();
//
// We succeed a cleanup on a removing device
//
if ((status = CyzIRPPrologue(Irp, extension)) != STATUS_SUCCESS) {
if (status == STATUS_DELETE_PENDING) {
status = Irp->IoStatus.Status = STATUS_SUCCESS;
}
if (status != STATUS_PENDING) {
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
}
return status;
}
CyzDbgPrintEx(CYZIRPPATH, "Dispatch entry for: %x\n", Irp);
CyzKillPendingIrps(DeviceObject);
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information=0L;
CyzCompleteRequest(extension, Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
LARGE_INTEGER
CyzGetCharTime(
IN PCYZ_DEVICE_EXTENSION Extension
)
/*------------------------------------------------------------------------
CyzGetCharTime()
Routine Description: return the number of 100 nanosecond intervals
there are in one character time.
Arguments:
Extension - Just what it says.
Return Value: 100 nanosecond intervals in a character time.
------------------------------------------------------------------------*/
{
ULONG dataSize;
ULONG paritySize;
ULONG stopSize;
ULONG charTime;
ULONG bitTime;
LARGE_INTEGER tmp;
if ((Extension->CommDataLen & C_DL_CS) == C_DL_CS5) {
dataSize = 5;
} else if ((Extension->CommDataLen & C_DL_CS) == C_DL_CS6) {
dataSize = 6;
} else if ((Extension->CommDataLen & C_DL_CS) == C_DL_CS7) {
dataSize = 7;
} else {
dataSize = 8;
}
paritySize = 1;
if ((Extension->CommParity & C_PR_PARITY) == C_PR_NONE) {
paritySize = 0;
}
if ((Extension->CommDataLen & C_DL_STOP) == C_DL_1STOP) {
stopSize = 1;
} else {
stopSize = 2;
}
//
// First we calculate the number of 100 nanosecond intervals
// are in a single bit time (Approximately).
//
bitTime = (10000000+(Extension->CurrentBaud-1))/Extension->CurrentBaud;
charTime = bitTime + ((dataSize+paritySize+stopSize)*bitTime);
tmp.QuadPart = charTime;
return tmp;
}