pnpmn.cpp

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

                            {
                                KEVENT   kEvent;    // Complete event
                                NTSTATUS ntStatus;  // PoRequestPowerIrp status

                                pwState.DeviceState = PowerDeviceD3;

                                KeInitializeEvent(&kEvent,
                                                   NotificationEvent,
                                                   FALSE);

                                BOOLEAN  f = KeGetCurrentIrql() < DISPATCH_LEVEL;
                                ntStatus   = PoRequestPowerIrp(m_pDevObject,
                                                               IRP_MN_SET_POWER,
                                                               pwState,
                                                               f ? PowerRequest : NULL,
                                                               f ? &kEvent      : NULL,
                                                               NULL);

                                if (ntStatus == STATUS_PENDING && f)
                                    KeWaitForSingleObject(&kEvent,
                                                           Executive,
                                                           KernelMode,
                                                           FALSE,
                                                           NULL);
                            }               // if (m_DeviceState != PowerDevice

                            m_SystemState = pwState.SystemState;
                        }
                        else
                            if (pwState.SystemState < m_SystemState)
                            {
                                // Powering Up
                                fHookIt = TRUE;
                            }
                            break;
                }
                break;

            default:
                ntStatus = STATUS_NOT_SUPPORTED;
                break;
        }                                   // switch (pStack->MinorFunction)

        if (ntStatus == STATUS_NOT_SUPPORTED)
        {
            PoStartNextPowerIrp(pIrp);
            IoSkipCurrentIrpStackLocation(pIrp);
            ntStatus = PoCallDriver(m_pNextStackDevice, pIrp);
        }                                   // if (ntStatus == ...
        else
        {
            IoCopyCurrentIrpStackLocationToNext(pIrp);

            if (!NT_SUCCESS(ntStatus))
            {
                pIrp->IoStatus.Status = ntStatus;
                PoStartNextPowerIrp(pIrp);
                IoCompleteRequest(pIrp, IO_NO_INCREMENT);
            }
            else
                if (fHookIt)
                {
                    IoSetCompletionRoutine(pIrp, PowerComplete, this,
                                           TRUE, TRUE,          TRUE);

                    ntStatus = PoCallDriver(m_pNextStackDevice, pIrp);
                }                           // if (fHookIt)
                else
                {
                    PoStartNextPowerIrp(pIrp);
                    ntStatus = PoCallDriver(m_pNextStackDevice, pIrp);
                }                           // else
        }                                   // else

        UnlockDevice();
    }                                       // else

    STRACE_PNPDRV("<< CPnpDevice::OnIrpPower()- ntStatus=%08X\n", ntStatus);
    return fRet;
}

//****************************************************************************
//                      --- CPnpDevice::OnIrpPnP ---
//
// Purpose: Handle IRP_MJ_PNP request
//   Input: PIRP         pIrp     - I/O request package
//          NTSTATUS   & ntStatus - Operation status
//  Output: BOOLEAN               - TRUE if request was completed
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
BOOLEAN CPnpDevice::OnIrpPnP(PIRP pIrp, NTSTATUS & ntStatus)
{
    STRACE_PNPDRV(">> CPnpDevice::OnIrpPnP()\n");

    if (!LockDevice())
    {
        pIrp->IoStatus.Status = ntStatus = STATUS_DELETE_PENDING;
        IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    }                                       // if (!NT_SUCCESS(ntStatus))
    else
    {
        PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);

        ULONG uCode = pStack->MinorFunction;
        if (uCode >= sizeof(PnPDispatch) / sizeof(PnPDispatch[0]))
        {
            ntStatus = DefPnPHandler(pIrp);
            UnlockDevice();
        }                                   // if (uCode >= sizeof(...
        else
        {
            ntStatus = (this->*(PnPDispatch[uCode]))(pIrp);
            if (uCode != IRP_MN_REMOVE_DEVICE)
                UnlockDevice();
        }                                   // else
    }                                       // else

    STRACE_PNPDRV("<< CPnpDevice::OnIrpPnP()- ntStatus=%08X\n", ntStatus);
    return TRUE;
}

//****************************************************************************
//                    --- CPnpDevice::DefPnPHandler ---
//
// Purpose: Default PnP handler
//   Input: PIRP     pIrp - I/O request package
//  Output: NTSTATUS      - Operation status
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
NTSTATUS CPnpDevice::DefPnPHandler(PIRP pIrp)
{
    NTSTATUS ntStatus = ForwardAndWait(m_pNextStackDevice, pIrp);

    pIrp->IoStatus.Status = ntStatus;
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    return ntStatus;
}

//****************************************************************************
//                    --- CPnpDevice::OnStartDevice ---
//
// Purpose: Start device
//   Input: PIRP     pIrp - I/O request package
//  Output: NTSTATUS      - Operation status
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
NTSTATUS CPnpDevice::OnStartDevice(PIRP pIrp)
{
    STRACE_PNPDRV(">> CPnpDevice::OnStartDevice()\n");

    NTSTATUS ntStatus = PreStartDevice(pIrp);// Pre-start device calls

    if (NT_SUCCESS(ntStatus))
    {
        ntStatus = ForwardAndWait(m_pNextStackDevice, pIrp);

        if (NT_SUCCESS(ntStatus))
        {
            PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);

            PCM_RESOURCE_LIST p = pStack->Parameters.StartDevice.
                                  AllocatedResourcesTranslated;

#if DBG
            if (p != NULL)
                OutCmResourceList(p, "IRP_MN_START_DEVICE");
#endif                                      // #if DBG

            ntStatus = StartDevice(p ? &p->List[0].PartialResourceList : NULL);

            if (NT_SUCCESS(ntStatus))
            {
                m_DeviceState  = PowerDeviceD0;
                m_SystemState  = PowerSystemWorking;
                m_uPnpState   &= ~PNP_DEVICE_FAILED;

                POWER_STATE State;
                State.DeviceState = PowerDeviceD0;
                PoSetPowerState(m_pDevObject, DevicePowerState, State);
            }
        }
    }

    PostStartDevice(pIrp, ntStatus);

    pIrp->IoStatus.Status = ntStatus;
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);

    STRACE_PNPDRV("<< CPnpDevice::OnStartDevice()- ntStatus=%08X\n", ntStatus);
    return ntStatus;
}

//****************************************************************************
//                    --- CPnpDevice::OnDeviceState ---
//
// Purpose: Handle query device state request
//   Input: PIRP     pIrp - I/O request package
//  Output: NTSTATUS      - Operation status
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
NTSTATUS CPnpDevice::OnDeviceState(PIRP pIrp)
{
    STRACE_PNPDRV(">> CPnpDevice::OnDeviceState()\n");

    NTSTATUS ntStatus = ForwardAndWait(m_pNextStackDevice, pIrp);

    if (ntStatus == STATUS_NOT_SUPPORTED        ||
        ntStatus == STATUS_NOT_IMPLEMENTED      ||
        ntStatus == STATUS_INVALID_DEVICE_REQUEST)
    {
        ntStatus = STATUS_SUCCESS;
    }

  #define BAD_PNP_STATE (PNP_DEVICE_DISABLED           |  \
                         PNP_DEVICE_DONT_DISPLAY_IN_UI |  \
                         PNP_DEVICE_FAILED             |  \
                         PNP_DEVICE_REMOVED)

    if (NT_SUCCESS(ntStatus) && !(pIrp->IoStatus.Information & BAD_PNP_STATE))
        pIrp->IoStatus.Information |= m_uPnpState;

    pIrp->IoStatus.Status = ntStatus;
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);

    STRACE_PNPDRV("<< CPnpDevice::OnDeviceState()- ntStatus=%08X\n", ntStatus);
    return ntStatus;
}

//****************************************************************************
//                    --- CPnpDevice::OnStopDevice ---
//
// Purpose: Handle stop device
//   Input: PIRP     pIrp - I/O request package
//  Output: NTSTATUS      - Operation status
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
NTSTATUS CPnpDevice::OnStopDevice(PIRP pIrp)
{
    STRACE_PNPDRV(">> CPnpDevice::OnStopDevice()\n");

    PreStopDevice();
    NTSTATUS ntStatus = DefPnPHandler(pIrp);
    StopDevice();

    m_uPnpState = PNP_DEVICE_FAILED;

    STRACE_PNPDRV("<< CPnpDevice::OnStopDevice()- ntStatus=%08X\n", ntStatus);
    return ntStatus;
}

//****************************************************************************
//                   --- CPnpDevice::OnRemoveDevice ---
//
// Purpose: Handle remove device request
//   Input: PIRP     pIrp - I/O request package
//  Output: NTSTATUS      - Operation status
// Written: by Anton V. Krivenko 4/9/2002
//****************************************************************************
NTSTATUS CPnpDevice::OnRemoveDevice(PIRP pIrp)
{
    STRACE_PNPDRV(">> CPnpDevice::OnRemoveDevice()\n");

    m_fRemoving = TRUE;

    PreRemoveDevice(pIrp);                  // Pre-remove device calls

    UnlockDevice();
    UnlockDevice();

    KeWaitForSingleObject(&m_evRemove, Executive, KernelMode, FALSE, NULL);

    StopDevice();

    NTSTATUS ntStatus = ForwardAndWait(m_pNextStackDevice, pIrp);

    m_uPnpState = PNP_DEVICE_REMOVED;

    pIrp->IoStatus.Status = ntStatus;
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);

    delete this;

    STRACE_PNPDRV("<< CPnpDevice::OnRemoveDevice()- ntStatus=%08X\n", ntStatus);
    return ntStatus;
}