VOID
SerialGetNextImmediate(
IN WDFREQUEST *CurrentOpRequest,
IN WDFQUEUE QueueToProcess,
IN WDFREQUEST *NewRequest,
IN BOOLEAN CompleteCurrent,
IN PSERIAL_DEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine is used to complete the current immediate
request. Even though the current immediate will always
be completed and there is no queue associated with it,
we use this routine so that we can try to satisfy
a wait for transmit queue empty event.
Arguments:
CurrentOpRequest - Pointer to the pointer that points to the
current write request. This should point
to CurrentImmediateRequest.
QueueToProcess - Always NULL.
NewRequest - Always NULL on exit to this routine.
CompleteCurrent - Should always be true for this routine.
Return Value:
None.
--*/
{
WDFREQUEST oldRequest = *CurrentOpRequest;
PREQUEST_CONTEXT reqContext = SerialGetRequestContext(oldRequest);
UNREFERENCED_PARAMETER(QueueToProcess);
UNREFERENCED_PARAMETER(CompleteCurrent);
ASSERT(Extension->TotalCharsQueued >= 1);
Extension->TotalCharsQueued--;
*CurrentOpRequest = NULL;
*NewRequest = NULL;
WdfInterruptSynchronize(
Extension->WdfInterrupt,
SerialProcessEmptyTransmit,
Extension
);
SerialCompleteRequest(oldRequest, reqContext->Status, reqContext->Information);
}
VOID
SerialTryToCompleteCurrent(
IN PSERIAL_DEVICE_EXTENSION Extension,
IN PFN_WDF_INTERRUPT_SYNCHRONIZE SynchRoutine OPTIONAL,
IN NTSTATUS StatusToUse,
IN WDFREQUEST *CurrentOpRequest,
IN WDFQUEUE QueueToProcess OPTIONAL,
IN WDFTIMER IntervalTimer OPTIONAL,
IN WDFTIMER TotalTimer OPTIONAL,
IN PSERIAL_START_ROUTINE Starter OPTIONAL,
IN PSERIAL_GET_NEXT_ROUTINE GetNextRequest OPTIONAL,
IN LONG RefType
)
/*++
Routine Description:
This routine attempts to remove all of the reasons there are
references on the current read/write. If everything can be completed
it will complete this read/write and try to start another.
NOTE: This routine assumes that it is called with the cancel
spinlock held.
Arguments:
Extension - Simply a pointer to the device extension.
SynchRoutine - A routine that will synchronize with the isr
and attempt to remove the knowledge of the
current request from the isr. NOTE: This pointer
can be null.
IrqlForRelease - This routine is called with the cancel spinlock held.
This is the irql that was current when the cancel
spinlock was acquired.
StatusToUse - The request's status field will be set to this value, if
this routine can complete the request.
Return Value:
None.
--*/
{
PREQUEST_CONTEXT reqContext;
ASSERTMSG("SerialTryToCompleteCurrent: CurrentOpRequest is NULL", *CurrentOpRequest);
reqContext = SerialGetRequestContext(*CurrentOpRequest);
if(RefType == SERIAL_REF_ISR || RefType == SERIAL_REF_XOFF_REF) {
//
// We can decrement the reference to "remove" the fact
// that the caller no longer will be accessing this request.
//
SERIAL_CLEAR_REFERENCE(
reqContext,
RefType
);
}
if (SynchRoutine) {
WdfInterruptSynchronize(
Extension->WdfInterrupt,
SynchRoutine,
Extension
);
}
//
// Try to run down all other references to this request.
//
SerialRundownIrpRefs(
CurrentOpRequest,
IntervalTimer,
TotalTimer,
Extension,
RefType
);
if(StatusToUse == STATUS_CANCELLED) {
//
// This function is called from a cancelroutine. So mark
// the request as cancelled. We need to do this because
// we may not complete the request below if somebody
// else has a reference to it.
// This state variable was added to avoid calling
// WdfRequestMarkCancelable second time on a request that
// has cancelled but wasn't completed in the cancel routine.
//
reqContext->Cancelled = TRUE;
}
//
// See if the ref count is zero after trying to complete everybody else.
//
if (!SERIAL_REFERENCE_COUNT(reqContext)) {
WDFREQUEST newRequest;
//
// The ref count was zero so we should complete this
// request.
//
// The following call will also cause the current request to be
// completed.
//
reqContext->Status = StatusToUse;
if (StatusToUse == STATUS_CANCELLED) {
reqContext->Information = 0;
}
if (GetNextRequest) {
GetNextRequest(
CurrentOpRequest,
QueueToProcess,
&newRequest,
TRUE,
Extension
);
if (newRequest) {
Starter(Extension);
}
} else {
WDFREQUEST oldRequest = *CurrentOpRequest;
//
// There was no get next routine. We will simply complete
// the request. We should make sure that we null out the
// pointer to the pointer to this request.
//
*CurrentOpRequest = NULL;
SerialCompleteRequest(oldRequest,
reqContext->Status,
reqContext->Information);
}
} else {
}
}
VOID
SerialStartImmediate(
IN PSERIAL_DEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine will calculate the timeouts needed for the
write. It will then hand the request off to the isr. It
will need to be careful incase the request has been canceled.
Arguments:
Extension - A pointer to the serial device extension.
Return Value:
None.
--*/
{
LARGE_INTEGER TotalTime = {0};
BOOLEAN UseATimer;
SERIAL_TIMEOUTS Timeouts;
PREQUEST_CONTEXT reqContext;
reqContext = SerialGetRequestContext(Extension->CurrentImmediateRequest);
SerialDbgPrintEx(TRACE_LEVEL_INFORMATION, DBG_IOCTLS, ">SerialStartImmediate(%p)\n",
Extension);
UseATimer = FALSE;
reqContext->Status = STATUS_PENDING;
//
// Calculate the timeout value needed for the
// request. Note that the values stored in the
// timeout record are in milliseconds. Note that
// if the timeout values are zero then we won't start
// the timer.
//
Timeouts = Extension->Timeouts;
if (Timeouts.WriteTotalTimeoutConstant ||
Timeouts.WriteTotalTimeoutMultiplier) {
UseATimer = TRUE;
//
// We have some timer values to calculate.
//
TotalTime.QuadPart
= (LONGLONG)((ULONG)Timeouts.WriteTotalTimeoutMultiplier);
TotalTime.QuadPart += Timeouts.WriteTotalTimeoutConstant;
TotalTime.QuadPart *= -10000;
}
//
// As the request might be going to the isr, this is a good time
// to initialize the reference count.
//
SERIAL_INIT_REFERENCE(reqContext);
//
// We give the request to to the isr to write out.
// We set a cancel routine that knows how to
// grab the current write away from the isr.
//
SerialSetCancelRoutine(Extension->CurrentImmediateRequest,
SerialCancelImmediate);
if (UseATimer) {
BOOLEAN result;
result = SerialSetTimer(
Extension->ImmediateTotalTimer,
TotalTime
);
if(result == FALSE) {
//
// Since the timer knows about the request we increment
// the reference count.
//
SERIAL_SET_REFERENCE(
reqContext,
SERIAL_REF_TOTAL_TIMER
);
}
}
WdfInterruptSynchronize(
Extension->WdfInterrupt,
SerialGiveImmediateToIsr,
Extension
);
SerialDbgPrintEx(TRACE_LEVEL_INFORMATION, DBG_IOCTLS,
"<SerialStartImmediate\n");
}
VOID
SerialFileCloseWorker(
IN WDFDEVICE Device
)
{
ULONG flushCount;
//
// This "timer value" is used to wait 10 character times
// after the hardware is empty before we actually "run down"
// all of the flow control/break junk.
//
LARGE_INTEGER tenCharDelay;
//
// Holds a character time.
//
LARGE_INTEGER charTime;
PSERIAL_DEVICE_EXTENSION extension = SerialGetDeviceExtension(Device);
PSERIAL_INTERRUPT_CONTEXT interruptContext = SerialGetInterruptContext(extension->WdfInterrupt);
SerialDbgPrintEx(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE, "In SerialEvtFileClose %wZ\n",
&extension->DeviceName);
//
// Acquire the interrupt state lock.
//
WdfWaitLockAcquire(interruptContext->InterruptStateLock, NULL);
//
// If the Interrupts are connected, then the hardware state has to be
// cleaned up now. Note that the EvtFileClose callback gets called for
// an open file object even though the interrupts have been disabled
// possibly due to a Surprise Remove PNP event. In such a case, the
// Interrupt object should not be used.
//
if (interruptContext->IsInterruptConnected) {
charTime.QuadPart = -SerialGetCharTime(extension).QuadPart;
//
// Do this now so that if the isr gets called it won't do anything
// to cause more chars to get sent. We want to run down the hardware.
//
SetDeviceIsOpened(extension, FALSE, FALSE);
//
// Synchronize with the isr to turn off break if it
// is already on.
//
WdfInterruptSynchronize(
extension->WdfInterrupt,
SerialTurnOffBreak,
extension
);
//
// Wait a reasonable amount of time (20 * fifodepth) until all characters
// have been emptied out of the hardware.
//
for (flushCount = (20 * 16); flushCount != 0; flushCount--) {
if ((READ_LINE_STATUS(extension, extension->Controller) &
(SERIAL_LSR_THRE | SERIAL_LSR_TEMT)) !=
(SERIAL_LSR_THRE | SERIAL_LSR_TEMT)) {
KeDelayExecutionThread(KernelMode, FALSE, &charTime);
} else {
break;
}
}
if (flushCount == 0) {
SerialMarkHardwareBroken(extension);
}
//
// Synchronize with the ISR to let it know that interrupts are
// no longer important.
//
WdfInterruptSynchronize(
extension->WdfInterrupt,
SerialMarkClose,
extension
);
//
// 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 & SERIAL_RX_XOFF) {
//
// Loop until the holding register is empty.
//
while (!(READ_LINE_STATUS(extension, extension->Controller) &
SERIAL_LSR_THRE)) {
KeDelayExecutionThread(
KernelMode,
FALSE,
&charTime
);
}
WRITE_TRANSMIT_HOLDING(extension,
extension->Controller,
extension->SpecialChars.XonChar
);
//
// Wait a reasonable amount of time for the characters
// to be emptied out of the hardware.
//
for (flushCount = (20 * 16); flushCount != 0; flushCount--) {
if ((READ_LINE_STATUS(extension, extension->Controller) &
(SERIAL_LSR_THRE | SERIAL_LSR_TEMT)) !=
(SERIAL_LSR_THRE | SERIAL_LSR_TEMT)) {
KeDelayExecutionThread(KernelMode, FALSE, &charTime);
} else {
break;
}
}
if (flushCount == 0) {
SerialMarkHardwareBroken(extension);
}
}
//
// The hardware is empty. Delay 10 character times before
// shut down all the flow control.
//
tenCharDelay.QuadPart = charTime.QuadPart * 10;
KeDelayExecutionThread(
KernelMode,
TRUE,
&tenCharDelay
);
#pragma prefast(suppress: __WARNING_INFERRED_IRQ_TOO_LOW, "This warning is because we are calling interrupt synchronize routine directly.")
SerialClrDTR(extension->WdfInterrupt, extension);
//
// 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 {
#pragma prefast(suppress: __WARNING_INFERRED_IRQ_TOO_HIGH, "This warning is due to suppressing the previous one.")
KeDelayExecutionThread(
KernelMode,
FALSE,
&charTime
);
} while (extension->CountOfTryingToLowerRTS);
//
// The execution path should no longer exist that
// is trying to push down the RTS. Well just
// make sure it's down by falling through to
// code that forces it down.
//
}
#pragma prefast(suppress: __WARNING_INFERRED_IRQ_TOO_LOW, "This warning is because we are calling interrupt synchronize routine directly.")
SerialClrRTS(extension->WdfInterrupt, extension);
//
// 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 Interrupt state lock.
//
WdfWaitLockRelease(interruptContext->InterruptStateLock);
//
// All is done. The port has been disabled from interrupting
// so there is no point in keeping the memory around.
//
extension->BufferSize = 0;
if (extension->InterruptReadBuffer != NULL) {
ExFreePool(extension->InterruptReadBuffer);
}
extension->InterruptReadBuffer = NULL;
//
// Make sure the wake is disabled.
//
ASSERT(!extension->IsWakeEnabled);
SerialDrainTimersAndDpcs(extension);
SerialDbgPrintEx(TRACE_LEVEL_VERBOSE, DBG_CREATE_CLOSE, "DPC's drained:\n");
//
// It's fine for the device to be powered off if there are no open handles.
//
WdfDeviceResumeIdle(Device);
//
// It's okay to allow the device to be stopped or removed.
//
// Note to anyone copying this sample as a starting point:
//
// This works in this driver simply because this driver supports exactly
// one open handle at a time. If it supported more, then it would need
// counting logic to determine when all the reasons for failing Stop/Remove
// were gone.
//
WdfDeviceSetStaticStopRemove(Device, TRUE);
return;
}
NTSTATUS
SerialDeviceFileCreateWorker (
IN WDFDEVICE Device
)
{
NTSTATUS status;
PSERIAL_DEVICE_EXTENSION extension = SerialGetDeviceExtension (Device);
//
// 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 = ExAllocatePoolWithTag(
NonPagedPool,
extension->BufferSize,
POOL_TAG
);
if (extension->InterruptReadBuffer) {
break;
}
}
case MmMediumSystem: {
extension->BufferSize = 1024;
extension->InterruptReadBuffer = ExAllocatePoolWithTag(
NonPagedPool,
extension->BufferSize,
POOL_TAG
);
if (extension->InterruptReadBuffer) {
break;
}
}
case MmSmallSystem: {
extension->BufferSize = 128;
extension->InterruptReadBuffer = ExAllocatePoolWithTag(
NonPagedPool,
extension->BufferSize,
POOL_TAG
);
}
}
if (!extension->InterruptReadBuffer) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// By taking a power reference by calling WdfDeviceStopIdle, we prevent the
// framework from powering down our device due to idle timeout when there
// is an open handle. Power reference also moves the device to D0 if we are
// idled out. If you fail create anywhere later in this routine, do make sure
// drop the reference.
//
status = WdfDeviceStopIdle(Device, TRUE);
if (!NT_SUCCESS(status)) {
return status;
}
//
// wakeup is not currently enabled
//
extension->IsWakeEnabled = FALSE;
//
// On a new open we "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;
//
// We 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;
extension->SendXonChar = FALSE;
extension->SendXoffChar = FALSE;
#if !DBG
//
// Clear out the statistics.
//
WdfInterruptSynchronize(
extension->WdfInterrupt,
SerialClearStats,
extension
);
#endif
//
// The escape char replacement must be reset upon every open.
//
extension->EscapeChar = 0;
//
// We don't want the device to be removed or stopped when there is an handle
//
// Note to anyone copying this sample as a starting point:
//
// This works in this driver simply because this driver supports exactly
// one open handle at a time. If it supported more, then it would need
// counting logic to determine when all the reasons for failing Stop/Remove
// were gone.
//
WdfDeviceSetStaticStopRemove(Device, FALSE);
//
// Synchronize with the ISR and let it know that the device
// has been successfully opened.
//
WdfInterruptSynchronize(
extension->WdfInterrupt,
SerialMarkOpen,
extension
);
return STATUS_SUCCESS;
}
VOID
NICEvtInterruptDpc(
IN WDFINTERRUPT WdfInterrupt,
IN WDFOBJECT WdfDevice
)
/*++
Routine Description:
DPC callback for ISR.
Arguments:
WdfInterrupt - Handle to the framework interrupt object
WdfDevice - Associated device object.
Return Value:
--*/
{
PFDO_DATA fdoData = NULL;
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_DPC, "--> NICEvtInterruptDpc\n");
fdoData = FdoGetData(WdfDevice);
WdfSpinLockAcquire(fdoData->RcvLock);
NICHandleRecvInterrupt(fdoData);
WdfSpinLockRelease(fdoData->RcvLock);
//
// Handle send interrupt
//
WdfSpinLockAcquire(fdoData->SendLock);
NICHandleSendInterrupt(fdoData);
WdfSpinLockRelease(fdoData->SendLock);
//
// Check if any queued Sends need to be reprocessed.
//
NICCheckForQueuedSends(fdoData);
//
// Start the receive unit if it had stopped
//
WdfSpinLockAcquire(fdoData->RcvLock);
NICStartRecv(fdoData);
WdfSpinLockRelease(fdoData->RcvLock);
//
// Re-enable the interrupt (disabled in MPIsr)
//
WdfInterruptSynchronize(
WdfInterrupt,
NICEnableInterrupt,
fdoData);
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_DPC, "<-- NICEvtInterruptDpc\n");
}
/*++
Routine Description:
This routine completes the old write as well as getting
a pointer to the next write.
The reason that we have have pointers to the current write
queue as well as the current write request is so that this
routine may be used in the common completion code for
read and write.
Arguments:
CurrentOpRequest - Pointer to the pointer that points to the
current write request.
QueueToProcess - Pointer to the write queue.
NewRequest - A pointer to a pointer to the request that will be the
current request. Note that this could end up pointing
to a null pointer. This does NOT necessaryly mean
that there is no current write. What could occur
is that while the cancel lock is held the write
queue ended up being empty, but as soon as we release
the cancel spin lock a new request came in from
SerialStartWrite.
CompleteCurrent - Flag indicates whether the CurrentOpRequest should
be completed.
Return Value:
None.
--*/
_Use_decl_annotations_
VOID
SerialGetNextWrite(
WDFREQUEST* CurrentOpRequest,
WDFQUEUE QueueToProcess,
WDFREQUEST* NewRequest,
BOOLEAN CompleteCurrent,
PSERIAL_DEVICE_EXTENSION Extension
)
{
PREQUEST_CONTEXT reqContext;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_WRITE, "++SerialGetNextWrite\r\n");
do {
reqContext = SerialGetRequestContext(*CurrentOpRequest);
// We could be completing a flush.
if (reqContext->MajorFunction == IRP_MJ_WRITE) {
ASSERT(Extension->TotalCharsQueued >= reqContext->Length);
Extension->TotalCharsQueued -= reqContext->Length;
} else if (reqContext->MajorFunction == IRP_MJ_DEVICE_CONTROL) {
WDFREQUEST request = *CurrentOpRequest;
PSERIAL_XOFF_COUNTER xc;
xc = reqContext->SystemBuffer;
// We should never have a xoff counter when we
// get to this point.
ASSERT(!Extension->CurrentXoffRequest);
// This could only be a xoff counter masquerading as
// a write request.
Extension->TotalCharsQueued--;
// Check to see of the xoff request has been set with success.
// This means that the write completed normally. If that
// is the case, and it hasn't been set to cancel in the
// meanwhile, then go on and make it the CurrentXoffRequest.
if (reqContext->Status != STATUS_SUCCESS || reqContext->Cancelled) {
// If Xoff request getting abandoned due to loss of
// Total timer - SERIAL_REF_TOTAL_TIMER
// we can just finish it off.
} else {
SerialSetCancelRoutine(request, SerialCancelCurrentXoff);
// We don't want to complete the current request now. This
// will now get completed by the Xoff counter code.
CompleteCurrent = FALSE;
// Give the counter to the isr.
Extension->CurrentXoffRequest = request;
WdfInterruptSynchronize(Extension->WdfInterrupt,
SerialGiveXoffToIsr,
Extension);
// Start the timer for the counter and increment
// the reference count since the timer has a
// reference to the request.
if (xc->Timeout) {
LARGE_INTEGER delta;
BOOLEAN result;
delta.QuadPart = -((LONGLONG)UInt32x32To64(1000,
xc->Timeout));
result = SerialSetTimer(Extension->XoffCountTimer,
delta);
if(result == FALSE) {
SERIAL_SET_REFERENCE(reqContext,
SERIAL_REF_TOTAL_TIMER);
}
}
}
}
// Note that the following call will (probably) also cause
// the current request to be completed.
SerialGetNextRequest(CurrentOpRequest,
QueueToProcess,
NewRequest,
CompleteCurrent,
Extension);
if (!*NewRequest) {
WdfInterruptSynchronize(Extension->WdfInterrupt,
SerialProcessEmptyTransmit,
Extension);
break;
} else if (SerialGetRequestContext(*NewRequest)->MajorFunction
== IRP_MJ_FLUSH_BUFFERS) {
// If we encounter a flush request we just want to get
// the next request and complete the flush.
//
// Note that if NewRequest is non-null then it is also
// equal to CurrentWriteRequest.
ASSERT((*NewRequest) == (*CurrentOpRequest));
SerialGetRequestContext(*NewRequest)->Status = STATUS_SUCCESS;
} else {
break;
}
} while (TRUE);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_WRITE, "--SerialGetNextWrite\r\n");
}
/*++
Routine Description:
This routine is used to start off any write. It initializes
the Iostatus fields of the request. It will set up any timers
that are used to control the write.
Arguments:
Extension - Points to the serial device extension
Return Value:
--*/
_Use_decl_annotations_
VOID
SerialStartWrite(
PSERIAL_DEVICE_EXTENSION Extension
)
{
LARGE_INTEGER totalTime;
BOOLEAN useAtimer;
SERIAL_TIMEOUTS timeouts;
PREQUEST_CONTEXT reqContext;
PREQUEST_CONTEXT reqContextXoff;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_WRITE,
"++SerialStartWrite(%p)\r\n", Extension);
totalTime.QuadPart = 0;
do {
reqContext = SerialGetRequestContext(Extension->CurrentWriteRequest);
// If there is an xoff counter then complete it.
// We see if there is a actually an Xoff counter request.
//
// If there is, we put the write request back on the head
// of the write list. We then complete the xoff counter.
// The xoff counter completing code will actually make the
// xoff counter back into the current write request, and
// in the course of completing the xoff (which is now
// the current write) we will restart this request.
if (Extension->CurrentXoffRequest) {
reqContextXoff =
SerialGetRequestContext(Extension->CurrentXoffRequest);
if (SERIAL_REFERENCE_COUNT(reqContextXoff)) {
// The reference count is non-zero. This implies that
// the xoff request has not made it through the completion
// path yet. We will increment the reference count
// and attempt to complete it ourseleves.
SERIAL_SET_REFERENCE(reqContextXoff, SERIAL_REF_XOFF_REF);
reqContextXoff->Information = 0;
// The following call will actually release the
// cancel spin lock.
SerialTryToCompleteCurrent(Extension,
SerialGrabXoffFromIsr,
STATUS_SERIAL_MORE_WRITES,
&Extension->CurrentXoffRequest,
NULL,
NULL,
Extension->XoffCountTimer,
NULL,
NULL,
SERIAL_REF_XOFF_REF);
} else {
// The request is well on its way to being finished.
// We can let the regular completion code do the
// work. Just release the spin lock.
}
}
useAtimer = FALSE;
// Calculate the timeout value needed for the
// request. Note that the values stored in the
// timeout record are in milliseconds. Note that
// if the timeout values are zero then we won't start
// the timer.
timeouts = Extension->timeouts;
if (timeouts.WriteTotalTimeoutConstant ||
timeouts.WriteTotalTimeoutMultiplier) {
useAtimer = TRUE;
// We have some timer values to calculate.
//
// Take care, we might have an xoff counter masquerading
// as a write.
totalTime.QuadPart =((LONGLONG)((UInt32x32To64((reqContext->MajorFunction == IRP_MJ_WRITE)?
(reqContext->Length) : (1),
timeouts.WriteTotalTimeoutMultiplier)
+ timeouts.WriteTotalTimeoutConstant)))
* -10000;
}
// The request may be going to the isr shortly. Now
// is a good time to initialize its reference counts.
SERIAL_INIT_REFERENCE(reqContext);
// We give the request to to the isr to write out.
// We set a cancel routine that knows how to
// grab the current write away from the isr.
SerialSetCancelRoutine(Extension->CurrentWriteRequest,
SerialCancelCurrentWrite);
if (useAtimer) {
BOOLEAN result;
result = SerialSetTimer(Extension->WriteRequestTotalTimer,
totalTime);
if(result == FALSE) {
// This timer now has a reference to the request.
SERIAL_SET_REFERENCE(reqContext, SERIAL_REF_TOTAL_TIMER );
}
}
WdfInterruptSynchronize(Extension->WdfInterrupt,
SerialGiveWriteToIsr,
Extension);
} while (FALSE);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_WRITE, "--SerialStartWrite\r\n");
return;
}
