pnpdrv.cpp

RTL8139 网卡驱动源码 for WinCE.net CEPC

//****************************************************************************
//                             File PNPDRV.CPP
//
//                            PnP driver object
//
//                     Copyright (c) APSoft, 1998-2002.
//                          All rights reserved.
//
//****************************************************************************


extern "C"
{
#include <ntddk.h>                          // Main DDK's include
}

#include <drvclass.h>                       // Derived driver class header file
#include <pnpdrv.h>                         // Class declaration
#include <pnpdev.h>                         // Device class
#include <utils.h>                          // Utils methods

//--------------------------- Global variables -------------------------------

_MAIN_CLASS * g_pPnPDriver = NULL;          // Global driver object

#if DBG
char szAssertMsg[] = "\nAssertion failed: File %s, Line %d\n";
#endif                                      // #if DBG


//****************************************************************************
//                            --- OnUnload ---
//
// Purpose: Unload routine
//   Input: PDRIVER_OBJECT  pDrvObject - Driver object
//  Output: none
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
extern "C" void OnUnload(PDRIVER_OBJECT pDrvObject)
{
    if (g_pPnPDriver != NULL)
        delete g_pPnPDriver;
}

//****************************************************************************
//                           --- DriverEntry ---
//
// Purpose: Entry point of driver
//   Input: PDRIVER_OBJECT      pDrvObject - Driver object
//          PUNICODE_STRING     pusRegPath - Registry path
//  Output: NTSTATUS                       - Operation status
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT pDrvObject, PUNICODE_STRING pusRegPath)
{
    NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;// Assumes, failed

    g_pPnPDriver      = new _MAIN_CLASS(pDrvObject, pusRegPath);
    ASSERTS_PNPDRV(g_pPnPDriver != NULL);

    if (g_pPnPDriver != NULL)
        ntStatus      = STATUS_SUCCESS;

    pDrvObject->DriverUnload = OnUnload;    // Set UNLOAD routine

    return ntStatus;
}

///////////////////////////////////////////////////////////////////////////////
//                          --- IRP Dispatch ---                             //
///////////////////////////////////////////////////////////////////////////////


typedef BOOLEAN  (CPnpDriver::* PFNMJHANDLER)(PDEVICE_OBJECT  pDevice,
                                              PIRP            pIrp,
                                              NTSTATUS      & ntStatus);

static PFNMJHANDLER MjDispatch[] =
{
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_CREATE                   0x00
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_CREATE_NAMED_PIPE        0x01
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_CLOSE                    0x02
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_READ                     0x03
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_WRITE                    0x04
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_QUERY_INFORMATION        0x05
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_SET_INFORMATION          0x06
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_QUERY_EA                 0x07
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_SET_EA                   0x08
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_FLUSH_BUFFERS            0x09
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_QUERY_VOLUME_INFORMATION 0x0a
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_SET_VOLUME_INFORMATION   0x0b
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_DIRECTORY_CONTROL        0x0c
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_FILE_SYSTEM_CONTROL      0x0d
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_DEVICE_CONTROL           0x0e
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_INTERNAL_DEVICE_CONTROL  0x0f
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_SHUTDOWN                 0x10
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_LOCK_CONTROL             0x11
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_CLEANUP                  0x12
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_CREATE_MAILSLOT          0x13
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_QUERY_SECURITY           0x14
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_SET_SECURITY             0x15
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_POWER                    0x16
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_SYSTEM_CONTROL           0x17
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_DEVICE_CHANGE            0x18
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_QUERY_QUOTA              0x19
    CPnpDriver::DefIrpMjHandler,            // IRP_MJ_SET_QUOTA                0x1a
    CPnpDriver::DefIrpMjHandler             // IRP_MJ_PNP                      0x1b
};

///////////////////////////////////////////////////////////////////////////////
//                         --- Class CPnpDriver ---                          //
///////////////////////////////////////////////////////////////////////////////

//****************************************************************************
//                     --- CPnpDriver::CPnpDriver ---
//
// Purpose: CPnpDriver object constructor
//   Input: PDRIVER_OBJECT  pDrvObject - Driver object
//          PUNICODE_STRING pusRegPath - Registry path
//  Output: none
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
CPnpDriver::CPnpDriver(PDRIVER_OBJECT pDrvObject, PUNICODE_STRING pusRegPath)
{
//---------------------------- Save variables --------------------------------

    m_pDrvObject                                = pDrvObject;
    AllocateUnicodeString(&m_usRegPath, pusRegPath);

//-------------------------- Set IRP dispatchers -----------------------------

    SetIrpDispatch();
    m_pDrvObject->DriverExtension->AddDevice    = _OnAddDevice;
}

//****************************************************************************
//                     --- CPnpDriver::~CPnpDriver ---
//
// Purpose: CPnpDriver object destructor
//   Input: none
//  Output: none
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
CPnpDriver::~CPnpDriver(void)
{
    RtlFreeUnicodeString(&m_usRegPath);
}

//****************************************************************************
//                      --- CPnpDriver::GetObject ---
//
// Purpose: Get driver's object
//   Input: none
//  Output: _MAIN_CLASS *    - Object
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
_MAIN_CLASS * CPnpDriver::GetObject(void)
{
    return g_pPnPDriver;
}

//****************************************************************************
//                   --- CPnpDriver::SetIrpDispatch ---
//
// Purpose: Set IRP dispatchers
//   Input: none
//  Output: none
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
void CPnpDriver::SetIrpDispatch(void)
{
    PDRIVER_DISPATCH * pMjFn = m_pDrvObject->MajorFunction;
    for (int iIndex = 0; iIndex <= IRP_MJ_MAXIMUM_FUNCTION; iIndex++)
        *pMjFn++ = _GenericIrpHandler;
}

//****************************************************************************
//                  --- CPnpDriver::GenericIrpHandler ---
//
// Purpose: Generic IRP handler
//   Input: PDEVICE_OBJECT pDevice - Target device
//          PIRP           pIrp    - I/O request package
//  Output: NTSTATUS               - Operation status
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
NTSTATUS CPnpDriver::GenericIrpHandler(PDEVICE_OBJECT pDevice, PIRP pIrp)
{
    NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;// Assumes, failed

    if (pIrp != NULL)
    {
        PIO_STACK_LOCATION pIoStack   = IoGetCurrentIrpStackLocation(pIrp);
        ULONG              uFunction  = pIoStack->MajorFunction;
        BOOLEAN            fCompleted = FALSE;

        ASSERTS_PNPDRV(uFunction < sizeof(MjDispatch) / sizeof(MjDispatch[0]));

        if (uFunction < sizeof(MjDispatch) / sizeof(MjDispatch[0]))
        {
            PFNMJHANDLER p = MjDispatch[uFunction];
            fCompleted = (this->*p)(pDevice, pIrp, ntStatus);
        }                                   // if (uFunction < sizeof(...

        if (!fCompleted && ntStatus != STATUS_PENDING)
        {
            pIrp->IoStatus.Status = ntStatus;
            IoCompleteRequest(pIrp, IO_NO_INCREMENT);
        }                                   // if (!fCompleted && ntStatus ...
    }                                       // if (pIrp != NULL)

    return ntStatus;
}

//****************************************************************************
//                   --- CPnpDriver::DefIrpMjHandler ---
//
// Purpose: Default IRP_MJ_ request handler
//   Input: PDEVICE_OBJECT   pDevice  - Target device
//          PIRP             pIrp     - I/O request package
//          NTSTATUS       & ntStatus - Status
//  Output: BOOLEAN                   - TRUE if request was completed
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
BOOLEAN CPnpDriver::DefIrpMjHandler(PDEVICE_OBJECT pDevice, PIRP pIrp, NTSTATUS & ntStatus)
{
    BOOLEAN fCompleted = FALSE;             // Assumes, not completed

    if (pDevice != NULL)
    {
        CPnpDevice * p = (CPnpDevice *)pDevice->DeviceExtension;
        ASSERTS_PNPDRV(p != NULL);

        if (p != NULL)
            fCompleted = p->DispatchMjRequest(pIrp, ntStatus);
        else
            ntStatus = STATUS_UNSUCCESSFUL;
    }                                       // if (pDevice != NULL)
    else
        ntStatus = STATUS_UNSUCCESSFUL;

    return fCompleted;
}