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.
905 lines
25 KiB
905 lines
25 KiB
/*--------------------------------------------------------------------------
|
|
*
|
|
* 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;
|
|
}
|
|
|
|
|
|
|