pnp.c File Reference

#include "precomp.h"
#include <debug.h>

Include dependency graph for pnp.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS	Bus_PlugInDevice (struct acpi_device *Device, PFDO_DEVICE_DATA FdoData)
NTSTATUS NTAPI	Bus_PnP (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	Bus_FDO_PnP (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpStack, PFDO_DEVICE_DATA DeviceData)
NTSTATUS	Bus_StartFdo (PFDO_DEVICE_DATA FdoData, PIRP Irp)
NTSTATUS	Bus_SendIrpSynchronously (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	Bus_CompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS	Bus_DestroyPdo (PDEVICE_OBJECT Device, PPDO_DEVICE_DATA PdoData)
VOID	Bus_InitializePdo (PDEVICE_OBJECT Pdo, PFDO_DEVICE_DATA FdoData)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 3 of file pnp.c.

Function Documentation

Bus_CompletionRoutine()

NTSTATUS NTAPI Bus_CompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 369 of file pnp.c.

{
    UNREFERENCED_PARAMETER (DeviceObject);
 
    //
    // If the lower driver didn't return STATUS_PENDING, we don't need to
    // set the event because we won't be waiting on it.
    // This optimization avoids grabbing the dispatcher lock and improves perf.
    //
    if (Irp->PendingReturned != FALSE) {
 
        KeSetEvent ((PKEVENT) Context, IO_NO_INCREMENT, FALSE);
    }
    return STATUS_MORE_PROCESSING_REQUIRED; // Keep this IRP
}

Referenced by Bus_SendIrpSynchronously().

Bus_DestroyPdo()

NTSTATUS Bus_DestroyPdo	(	PDEVICE_OBJECT	Device,
		PPDO_DEVICE_DATA	PdoData
	)

Definition at line 390 of file pnp.c.

{
    PAGED_CODE ();
 
    //
    // BusEnum does not queue any irps at this time so we have nothing to do.
    //
 
    //
    // Free any resources.
    //
 
    if (PdoData->HardwareIDs) {
        ExFreePoolWithTag(PdoData->HardwareIDs, 'DpcA');
        PdoData->HardwareIDs = NULL;
    }
 
    DPRINT("\tDeleting PDO: 0x%p\n", Device);
    IoDeleteDevice (Device);
    return STATUS_SUCCESS;
}

Bus_FDO_PnP()

NTSTATUS Bus_FDO_PnP	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PIO_STACK_LOCATION	IrpStack,
		PFDO_DEVICE_DATA	DeviceData
	)

Definition at line 72 of file pnp.c.

{
    NTSTATUS            status;
    ULONG               length, prevcount, numPdosPresent;
    PLIST_ENTRY         entry;
    PPDO_DEVICE_DATA    pdoData;
    PDEVICE_RELATIONS   relations, oldRelations;
 
    PAGED_CODE ();
 
    switch (IrpStack->MinorFunction) {
 
    case IRP_MN_START_DEVICE:
 
        status = Bus_StartFdo (DeviceData, Irp);
 
 
        //
        // We must now complete the IRP, since we stopped it in the
        // completion routine with MORE_PROCESSING_REQUIRED.
        //
 
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
 
        return status;
 
    case IRP_MN_QUERY_STOP_DEVICE:
 
        //
        // The PnP manager is trying to stop the device
        // for resource rebalancing.
        //
        SET_NEW_PNP_STATE(DeviceData->Common, StopPending);
        Irp->IoStatus.Status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_CANCEL_STOP_DEVICE:
 
        //
        // The PnP Manager sends this IRP, at some point after an
        // IRP_MN_QUERY_STOP_DEVICE, to inform the drivers for a
        // device that the device will not be stopped for
        // resource reconfiguration.
        //
        //
        // First check to see whether you have received cancel-stop
        // without first receiving a query-stop. This could happen if
        //  someone above us fails a query-stop and passes down the subsequent
        // cancel-stop.
        //
 
        if (StopPending == DeviceData->Common.DevicePnPState)
        {
            //
            // We did receive a query-stop, so restore.
            //
            RESTORE_PREVIOUS_PNP_STATE(DeviceData->Common);
            ASSERT(DeviceData->Common.DevicePnPState == Started);
        }
        Irp->IoStatus.Status = STATUS_SUCCESS; // We must not fail the IRP.
        break;
 
    case IRP_MN_QUERY_DEVICE_RELATIONS:
 
        DPRINT("\tQueryDeviceRelation Type: %s\n",
                    DbgDeviceRelationString(\
                    IrpStack->Parameters.QueryDeviceRelations.Type));
 
        if (BusRelations != IrpStack->Parameters.QueryDeviceRelations.Type) {
            //
            // We don't support any other Device Relations
            //
            break;
        }
 
 
        ExAcquireFastMutex (&DeviceData->Mutex);
 
        oldRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;
        if (oldRelations) {
            prevcount = oldRelations->Count;
            if (!DeviceData->NumPDOs) {
                //
                // There is a device relations struct already present and we have
                // nothing to add to it, so just call IoSkip and IoCall
                //
                ExReleaseFastMutex (&DeviceData->Mutex);
                break;
            }
        }
        else  {
            prevcount = 0;
        }
 
        //
        // Calculate the number of PDOs actually present on the bus
        //
        numPdosPresent = 0;
        for (entry = DeviceData->ListOfPDOs.Flink;
             entry != &DeviceData->ListOfPDOs;
             entry = entry->Flink) {
            pdoData = CONTAINING_RECORD (entry, PDO_DEVICE_DATA, Link);
            numPdosPresent++;
        }
 
        //
        // Need to allocate a new relations structure and add our
        // PDOs to it.
        //
 
        length = sizeof(DEVICE_RELATIONS) +
                (((numPdosPresent + prevcount) - 1) * sizeof (PDEVICE_OBJECT));
 
        relations = ExAllocatePoolWithTag(PagedPool, length, 'IpcA');
 
        if (NULL == relations) {
            //
            // Fail the IRP
            //
            ExReleaseFastMutex (&DeviceData->Mutex);
            Irp->IoStatus.Status = status = STATUS_INSUFFICIENT_RESOURCES;
            IoCompleteRequest (Irp, IO_NO_INCREMENT);
            return status;
 
        }
 
        //
        // Copy in the device objects so far
        //
        if (prevcount) {
            RtlCopyMemory (relations->Objects, oldRelations->Objects,
                                      prevcount * sizeof (PDEVICE_OBJECT));
        }
 
        relations->Count = prevcount + numPdosPresent;
 
        //
        // For each PDO present on this bus add a pointer to the device relations
        // buffer, being sure to take out a reference to that object.
        // The Plug & Play system will dereference the object when it is done
        // with it and free the device relations buffer.
        //
 
        for (entry = DeviceData->ListOfPDOs.Flink;
             entry != &DeviceData->ListOfPDOs;
             entry = entry->Flink) {
 
            pdoData = CONTAINING_RECORD (entry, PDO_DEVICE_DATA, Link);
            relations->Objects[prevcount] = pdoData->Common.Self;
            ObReferenceObject (pdoData->Common.Self);
            prevcount++;
        }
 
        DPRINT("\t#PDOs present = %d\n\t#PDOs reported = %d\n",
                             DeviceData->NumPDOs, relations->Count);
 
        //
        // Replace the relations structure in the IRP with the new
        // one.
        //
        if (oldRelations) {
            ExFreePoolWithTag(oldRelations, 0);
        }
        Irp->IoStatus.Information = (ULONG_PTR) relations;
 
        ExReleaseFastMutex (&DeviceData->Mutex);
 
        //
        // Set up and pass the IRP further down the stack
        //
        Irp->IoStatus.Status = STATUS_SUCCESS;
        break;
 
    default:
 
        //
        // In the default case we merely call the next driver.
        // We must not modify Irp->IoStatus.Status or complete the IRP.
        //
 
        break;
    }
 
    IoSkipCurrentIrpStackLocation (Irp);
    status = IoCallDriver (DeviceData->NextLowerDriver, Irp);
    return STATUS_SUCCESS;
}

Referenced by Bus_PnP().

Bus_InitializePdo()

VOID Bus_InitializePdo	(	PDEVICE_OBJECT	Pdo,
		PFDO_DEVICE_DATA	FdoData
	)

Definition at line 417 of file pnp.c.

{
    PPDO_DEVICE_DATA pdoData;
    int acpistate;
    DEVICE_POWER_STATE ntState;
 
    PAGED_CODE ();
 
    pdoData = (PPDO_DEVICE_DATA)  Pdo->DeviceExtension;
 
    DPRINT("pdo 0x%p, extension 0x%p\n", Pdo, pdoData);
 
    if (pdoData->AcpiHandle)
        acpi_bus_get_power(pdoData->AcpiHandle, &acpistate);
    else
        acpistate = ACPI_STATE_D0;
 
    switch(acpistate)
    {
        case ACPI_STATE_D0:
            ntState = PowerDeviceD0;
            break;
        case ACPI_STATE_D1:
            ntState = PowerDeviceD1;
            break;
        case ACPI_STATE_D2:
            ntState = PowerDeviceD2;
            break;
        case ACPI_STATE_D3:
            ntState = PowerDeviceD3;
            break;
        default:
            DPRINT1("Unknown power state (%d) returned by acpi\n",acpistate);
            ntState = PowerDeviceUnspecified;
            break;
    }
 
    //
    // Initialize the rest
    //
    pdoData->Common.IsFDO = FALSE;
    pdoData->Common.Self =  Pdo;
 
    pdoData->ParentFdo = FdoData->Common.Self;
 
 
    INITIALIZE_PNP_STATE(pdoData->Common);
 
    pdoData->Common.DevicePowerState = ntState;
    pdoData->Common.SystemPowerState = FdoData->Common.SystemPowerState;
 
    ExAcquireFastMutex (&FdoData->Mutex);
    InsertTailList(&FdoData->ListOfPDOs, &pdoData->Link);
    FdoData->NumPDOs++;
    ExReleaseFastMutex (&FdoData->Mutex);
 
    // This should be the last step in initialization.
    Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
}

Referenced by Bus_PlugInDevice().

Bus_PlugInDevice()

NTSTATUS Bus_PlugInDevice	(	struct acpi_device *	Device,
		PFDO_DEVICE_DATA	FdoData
	)

Definition at line 22 of file acpienum.c.

{
    PDEVICE_OBJECT      pdo;
    PPDO_DEVICE_DATA    pdoData;
    NTSTATUS            status;
    ULONG               index;
    WCHAR               temp[256];
    PLIST_ENTRY         entry;
 
    PAGED_CODE ();
 
    //Don't enumerate the root device
    if (Device->handle == ACPI_ROOT_OBJECT)
        return STATUS_SUCCESS;
 
    /* Check we didnt add this already */
    for (entry = FdoData->ListOfPDOs.Flink;
        entry != &FdoData->ListOfPDOs; entry = entry->Flink)
    {
        struct acpi_device *CurrentDevice;
 
        pdoData = CONTAINING_RECORD (entry, PDO_DEVICE_DATA, Link);
 
        //dont duplicate devices
        if (pdoData->AcpiHandle == Device->handle)
            return STATUS_SUCCESS;
 
        //check everything but fixed feature devices
        if (pdoData->AcpiHandle)
            acpi_bus_get_device(pdoData->AcpiHandle, &CurrentDevice);
        else
            continue;
 
        //check if the HID matches
        if (!strcmp(Device->pnp.hardware_id, CurrentDevice->pnp.hardware_id))
        {
            //check if UID exists for both and matches
            if (Device->flags.unique_id && CurrentDevice->flags.unique_id &&
                !strcmp(Device->pnp.unique_id, CurrentDevice->pnp.unique_id))
            {
                /* We have a UID on both but they're the same so we have to ignore it */
                DPRINT1("Detected duplicate device: %hs %hs\n", Device->pnp.hardware_id, Device->pnp.unique_id);
                return STATUS_SUCCESS;
            }
            else if (!Device->flags.unique_id && !CurrentDevice->flags.unique_id)
            {
                /* No UID so we can only legally have 1 of these devices */
                DPRINT1("Detected duplicate device: %hs\n", Device->pnp.hardware_id);
                return STATUS_SUCCESS;
            }
        }
    }
 
    DPRINT("Exposing PDO\n"
           "======AcpiHandle:   %p\n"
           "======HardwareId:     %s\n",
           Device->handle,
           Device->pnp.hardware_id);
 
 
    //
    // Create the PDO
    //
 
    DPRINT("FdoData->NextLowerDriver = 0x%p\n", FdoData->NextLowerDriver);
 
    status = IoCreateDevice(FdoData->Common.Self->DriverObject,
                              sizeof(PDO_DEVICE_DATA),
                              NULL,
                              FILE_DEVICE_CONTROLLER,
                              FILE_AUTOGENERATED_DEVICE_NAME,
                              FALSE,
                              &pdo);
 
    if (!NT_SUCCESS (status)) {
        return status;
    }
 
    pdoData = (PPDO_DEVICE_DATA) pdo->DeviceExtension;
    pdoData->AcpiHandle = Device->handle;
 
    //
    // Copy the hardware IDs
    //
        index = 0;
        index += swprintf(&temp[index],
                            L"ACPI\\%hs",
                            Device->pnp.hardware_id);
        temp[index++] = UNICODE_NULL;
 
        index += swprintf(&temp[index],
                            L"*%hs",
                            Device->pnp.hardware_id);
        temp[index++] = UNICODE_NULL;
        temp[index++] = UNICODE_NULL;
 
        pdoData->HardwareIDs = ExAllocatePoolWithTag(NonPagedPool, index*sizeof(WCHAR), 'DpcA');
 
 
    if (!pdoData->HardwareIDs) {
        IoDeleteDevice(pdo);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory (pdoData->HardwareIDs, temp, index*sizeof(WCHAR));
    Bus_InitializePdo (pdo, FdoData);
 
    //
    // Device Relation changes if a new pdo is created. So let
    // the PNP system now about that. This forces it to send bunch of pnp
    // queries and cause the function driver to be loaded.
    //
 
    //IoInvalidateDeviceRelations (FdoData->UnderlyingPDO, BusRelations);
 
    return status;
}

Referenced by ACPIEnumerateDevices().

Bus_PnP()

NTSTATUS NTAPI Bus_PnP	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 25 of file pnp.c.

{
    PIO_STACK_LOCATION      irpStack;
    NTSTATUS                status;
    PCOMMON_DEVICE_DATA     commonData;
 
    PAGED_CODE ();
 
    irpStack = IoGetCurrentIrpStackLocation (Irp);
    ASSERT (IRP_MJ_PNP == irpStack->MajorFunction);
 
    commonData = (PCOMMON_DEVICE_DATA) DeviceObject->DeviceExtension;
 
 
    if (commonData->IsFDO) {
        DPRINT("FDO %s IRP:0x%p\n",
                      PnPMinorFunctionString(irpStack->MinorFunction),
                      Irp);
        //
        // Request is for the bus FDO
        //
        status = Bus_FDO_PnP (
                    DeviceObject,
                    Irp,
                    irpStack,
                    (PFDO_DEVICE_DATA) commonData);
    } else {
        DPRINT("PDO %s IRP: 0x%p\n",
                      PnPMinorFunctionString(irpStack->MinorFunction),
                      Irp);
        //
        // Request is for the child PDO.
        //
        status = Bus_PDO_PnP (
                    DeviceObject,
                    Irp,
                    irpStack,
                    (PPDO_DEVICE_DATA) commonData);
    }
 
    return status;
}

Referenced by DriverEntry().

Bus_SendIrpSynchronously()

NTSTATUS Bus_SendIrpSynchronously	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 322 of file pnp.c.

{
    KEVENT   event;
    NTSTATUS status;
 
    PAGED_CODE();
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
 
    IoCopyCurrentIrpStackLocationToNext(Irp);
 
    IoSetCompletionRoutine(Irp,
                           Bus_CompletionRoutine,
                           &event,
                           TRUE,
                           TRUE,
                           TRUE
                           );
 
    status = IoCallDriver(DeviceObject, Irp);
 
    //
    // Wait for lower drivers to be done with the Irp.
    // Important thing to note here is when you allocate
    // the memory for an event in the stack you must do a
    // KernelMode wait instead of UserMode to prevent
    // the stack from getting paged out.
    //
 
    if (status == STATUS_PENDING) {
       KeWaitForSingleObject(&event,
                             Executive,
                             KernelMode,
                             FALSE,
                             NULL
                             );
       status = Irp->IoStatus.Status;
    }
 
    return status;
}

Bus_StartFdo()

NTSTATUS Bus_StartFdo	(	PFDO_DEVICE_DATA	FdoData,
		PIRP	Irp
	)

Definition at line 267 of file pnp.c.

{
    NTSTATUS status;
    POWER_STATE powerState;
    ACPI_STATUS AcpiStatus;
 
    PAGED_CODE ();
 
    FdoData->Common.DevicePowerState = PowerDeviceD0;
    powerState.DeviceState = PowerDeviceD0;
    PoSetPowerState ( FdoData->Common.Self, DevicePowerState, powerState );
 
    SET_NEW_PNP_STATE(FdoData->Common, Started);
 
    AcpiStatus = AcpiInitializeSubsystem();
    if(ACPI_FAILURE(AcpiStatus)){
        DPRINT1("Unable to AcpiInitializeSubsystem\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    AcpiStatus = AcpiInitializeTables(NULL, 16, 0);
    if (ACPI_FAILURE(AcpiStatus)){
        DPRINT1("Unable to AcpiInitializeTables\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    AcpiStatus = AcpiLoadTables();
    if(ACPI_FAILURE(AcpiStatus)){
        DPRINT1("Unable to AcpiLoadTables\n");
        AcpiTerminate();
        return STATUS_UNSUCCESSFUL;
    }
 
    status = acpi_create_volatile_registry_tables();
    if (!NT_SUCCESS(status))
    {
        DPRINT1("Unable to create ACPI tables in registry\n");
    }
 
    DPRINT("Acpi subsystem init\n");
    /* Initialize ACPI bus manager */
    AcpiStatus = acpi_init();
    if (!ACPI_SUCCESS(AcpiStatus)) {
        DPRINT1("acpi_init() failed with status 0x%X\n", AcpiStatus);
        AcpiTerminate();
        return STATUS_UNSUCCESSFUL;
    }
    status = ACPIEnumerateDevices(FdoData);
 
    return status;
}

Referenced by Bus_FDO_PnP().