serialdevice.cpp

这个是串口驱动程序开发包

#include "precomp.h"

#pragma warning( disable : 4355)
KdSerialDevice::KdSerialDevice() :
    m_KdDpc_CompleteWrite((KDDPC_CALLBACK)CompleteWrite, this),
    m_KdDpc_CompleteRead((KDDPC_CALLBACK)CompleteRead, this),
    m_KdDpc_CommError ((KDDPC_CALLBACK)CommError, this),
    m_KdDpc_CompleteImmediate ((KDDPC_CALLBACK)CompleteImmediate, this),
    m_KdDpc_CommWait ((KDDPC_CALLBACK)CompleteWait, this),
    m_KdDpc_XoffCountComplete ((KDDPC_CALLBACK)CompleteXoff, this),
    m_KdDpc_StartTimerLowerRTSDpc ((KDDPC_CALLBACK)StartTimerLowerRTS, this),

    m_KdTimer_TotalReadTimeoutDpc ((KDDPC_CALLBACK)ReadTimeout, this),
    m_KdTimer_ReadIntervalTimerDpc ((KDDPC_CALLBACK) IntervalReadTimeout, this),
    m_KdTimer_WriteRequestTotalTimerDpc ((KDDPC_CALLBACK) WriteTimeout, this),
    m_KdTimer_ReadRequestTotalTimerDpc ((KDDPC_CALLBACK) ReadTimeout, this),
    m_KdTimer_ImmediateTotalTimerDpc ((KDDPC_CALLBACK) TimeoutImmediate, this),
    m_KdTimer_XoffCountTimerDpc ((KDDPC_CALLBACK) TimeoutXoff, this),
    m_KdTimer_LowerRTSTimerDpc ((KDDPC_CALLBACK) InvokePerhapsLowerRTS, this)

{
    m_fRegisteredDeviceMap = FALSE;
    m_TopLevelIsr.pFunction = NULL;
    m_TopLevelIsr.Context = NULL;
    InitializeListHead(&m_TopLevelSharers);
    InitializeListHead(&m_CommonInterruptObject);
    RtlZeroMemory(&m_OriginalController,sizeof(m_OriginalController));
    RtlZeroMemory(&m_OriginalInterruptStatus,sizeof(m_OriginalInterruptStatus));
    RtlZeroMemory(&m_IntervalTime,sizeof(m_IntervalTime));
    RtlZeroMemory(&m_ShortIntervalAmount,sizeof(m_ShortIntervalAmount));
    RtlZeroMemory(&m_LongIntervalAmount,sizeof(m_LongIntervalAmount));
    RtlZeroMemory(&m_CutOverAmount,sizeof(m_CutOverAmount));
    RtlZeroMemory(&m_LastReadTime,sizeof(m_LastReadTime));
    m_IntervalTimeToUse = NULL;
    m_Isr.pFunction = NULL;
    m_Isr.Context = NULL;
    m_pController = NULL;
    m_pInterruptStatus = NULL;
    InitializeListHead(&m_ReadQueue);
    InitializeListHead(&m_WriteQueue);
    InitializeListHead(&m_MaskQueue);
    InitializeListHead(&m_PurgeQueue);
    m_WriteLength = 0;
    m_WriteCurrentChar = NULL;
    m_InterruptReadBuffer = NULL;
    m_ReadBufferBase = NULL;
    m_CharsInInterruptBuffer = 0;
    m_CurrentCharSlot = NULL;
    m_LastCharSlot = NULL;
    m_FirstReadableChar = NULL;
    m_LockPtr = NULL;
    m_BufferSize = 0;
    m_BufferSizePt8 = 0;
    m_NumberNeededForRead = 0;
    m_IsrWaitMask = 0;
    m_HistoryMask = 0;
    m_IrpMaskLocation = NULL;
    m_TXHolding = 0;
    m_RXHolding = 0;
    m_ErrorWord = 0;
    m_TotalCharsQueued = 0;
    m_CountOnLastRead = 0;
    m_ReadByIsr = 0;
    m_CurrentBaud = 0;
    m_CountSinceXoff = 0;
    m_CountOfTryingToLowerRTS = 0;
    m_SupportedBauds = 0;
    m_ClockRate = 0;
    m_TxFifoAmount = 0;
    m_PermitShare = 0;
    RtlZeroMemory(&m_Timeouts,sizeof(m_Timeouts));
    RtlZeroMemory(&m_SpecialChars,sizeof(m_SpecialChars));
    RtlZeroMemory(&m_HandFlow,sizeof(m_HandFlow));
    RtlZeroMemory(&m_PerfStats,sizeof(m_PerfStats));
    m_LineControl = 0;
    m_DeviceIsOpened = 0;
    m_UnMapRegisters = 0;
    m_UnMapStatus = 0;
    m_HoldingEmpty = 0;
    m_TransmitImmediate = 0;
    m_EmptiedTransmit = 0;
    m_PortOnAMultiportCard = 0;
    m_ImmediateChar = 0;
    m_ValidDataMask = 0;
    m_EscapeChar = 0;
    m_SendXonChar = 0;
    m_SendXoffChar = 0;
    m_FifoPresent = 0;
    m_Jensen = 0;
    m_RxFifoTrigger = 0;
    m_InterruptShareable = 0;
    m_CreatedSymbolicLink = 0;
}


KdSerialDevice::~KdSerialDevice()
/*++
Routine Description:
    This routine will deallocate all of the memory used for
    a particular device.  It will also disconnect any resources
    if need be.
--*/
{
    DebugDump(DBG_DIAG3, ("in ~KdSerialDevice for device: %x\n",this) );

    // Disconnect the interrupt object first so that some spurious
    // interrupt doesn't cause us to dereference some memory we've
    // already given up.

    m_KdInterrupt.Disconnect();

    // Get rid of all external naming as well as removing
    // the device map entry.
    if (m_fRegisteredDeviceMap)
    {
        NTSTATUS status = RtlDeleteRegistryValue(
                     RTL_REGISTRY_DEVICEMAP,
                     L"SERIALCOMM",
                     (LPWSTR)((LPCWSTR)m_sNtNameForPort)
                     );

        if (!NT_SUCCESS(status)) 
        {
            KdSerialDriver::LogError(
                55,
                status,
                SERIAL_NO_DEVICE_MAP_DELETED,
                this,
                m_OriginalController,
                m_sSymbolicLinkName
                );
            DebugDump(DBG_ERRORS, ("Couldn't delete value entry %ws\n", (PCWSTR)m_sDeviceName) );
        }

        // If necessary, unmap the device registers.
        if (m_pController) 
            delete m_pController;

        if (m_pInterruptStatus) 
            delete m_pInterruptStatus;

        if (m_Isr.pFunction) 
        {
            DebugDump(DBG_DIAG5, ("About to do a propagate delete on\n"
                 "------- device: %x for port %ws\n",
                 this,(PCWSTR)m_sDeviceName) );
            PropagateDeleteSharers(&IoGetConfigurationInformation()->SerialCount);
        }
    }
}

BOOLEAN KdSerialDevice::IsrCallBack(KdIrq *Irq, PVOID Context)
{
    PSERIAL_ISR_CONTEXT pIsr = PSERIAL_ISR_CONTEXT (Context);
    // Irq is not used in any of our ISRs
    if (pIsr->pFunction)
        (this->*(pIsr->pFunction)) (pIsr->Context);
    else
        return FALSE;

    return TRUE;
}