/*++ Copyright (c) 1998-2000 Microsoft Corporation Module Name: fdo.c Abstract: This module handles IRPs for PCI FDO's. Author: Adrian J. Oney (adriao) & Andrew Thornton (andrewth) 10-20-1998 Revision History: --*/ #include "pcip.h" NTSTATUS PciFdoIrpStartDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpQueryRemoveDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpRemoveDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpCancelRemoveDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpStopDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpQueryStopDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpCancelStopDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpQueryCapabilities( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpQueryInterface( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpQueryLegacyBusInformation( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpDeviceUsageNotification( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); NTSTATUS PciFdoIrpSurpriseRemoval( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ); VOID PciGetHotPlugParameters( IN PPCI_FDO_EXTENSION Fdo ); #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE, PciAddDevice) #pragma alloc_text(PAGE, PciInitializeFdoExtensionCommonFields) #pragma alloc_text(PAGE, PciFdoIrpStartDevice) #pragma alloc_text(PAGE, PciFdoIrpQueryRemoveDevice) #pragma alloc_text(PAGE, PciFdoIrpRemoveDevice) #pragma alloc_text(PAGE, PciFdoIrpCancelRemoveDevice) #pragma alloc_text(PAGE, PciFdoIrpQueryStopDevice) #pragma alloc_text(PAGE, PciFdoIrpStopDevice) #pragma alloc_text(PAGE, PciFdoIrpCancelStopDevice) #pragma alloc_text(PAGE, PciFdoIrpQueryDeviceRelations) #pragma alloc_text(PAGE, PciFdoIrpQueryInterface) #pragma alloc_text(PAGE, PciFdoIrpQueryCapabilities) #pragma alloc_text(PAGE, PciFdoIrpDeviceUsageNotification) #pragma alloc_text(PAGE, PciFdoIrpSurpriseRemoval) #pragma alloc_text(PAGE, PciFdoIrpQueryLegacyBusInformation) #pragma alloc_text(PAGE, PciGetHotPlugParameters) #endif // // The following is used to determine if we failed to get a // reasonable configuration from the PDO (in AddDevice) more // than once. If only once, we try to guess, if twice, we're // in big trouble. // static BOOLEAN HaveGuessedConfigOnceAlready = FALSE; /*++ The majority of functions in this file are called based on their presence in Pnp and Po dispatch tables. In the interests of brevity the arguments to all those functions will be described below: NTSTATUS PciXxxPdo( IN PIRP Irp, IN PIO_STACK_LOCATION IrpStack, IN PPCI_EXTENSION DeviceExtension ) Routine Description: This function handles the Xxx requests for a given PCI FDO or PDO. Arguments: Irp - Points to the IRP associated with this request. IrpStack - Points to the current stack location for this request. DeviceExtension - Points to the device's extension. Return Value: Status code that indicates whether or not the function was successful. STATUS_NOT_SUPPORTED indicates that the IRP should be completed without changing the Irp->IoStatus.Status field otherwise it is updated with this status. --*/ #define PCI_MAX_MINOR_POWER_IRP 0x3 #define PCI_MAX_MINOR_PNP_IRP 0x18 PCI_MN_DISPATCH_TABLE PciFdoDispatchPowerTable[] = { { IRP_DISPATCH, PciFdoWaitWake }, // 0x00 - IRP_MN_WAIT_WAKE { IRP_DOWNWARD, PciIrpNotSupported }, // 0x01 - IRP_MN_POWER_SEQUENCE { IRP_DOWNWARD, PciFdoSetPowerState }, // 0x02 - IRP_MN_SET_POWER { IRP_DOWNWARD, PciFdoIrpQueryPower }, // 0x03 - IRP_MN_QUERY_POWER { IRP_DOWNWARD, PciIrpNotSupported } // - UNHANDLED Power IRP }; PCI_MN_DISPATCH_TABLE PciFdoDispatchPnpTable[] = { { IRP_UPWARD, PciFdoIrpStartDevice }, // 0x00 - IRP_MN_START_DEVICE { IRP_DOWNWARD, PciFdoIrpQueryRemoveDevice }, // 0x01 - IRP_MN_QUERY_REMOVE_DEVICE { IRP_DISPATCH, PciFdoIrpRemoveDevice }, // 0x02 - IRP_MN_REMOVE_DEVICE { IRP_DOWNWARD, PciFdoIrpCancelRemoveDevice }, // 0x03 - IRP_MN_CANCEL_REMOVE_DEVICE { IRP_DOWNWARD, PciFdoIrpStopDevice }, // 0x04 - IRP_MN_STOP_DEVICE { IRP_DOWNWARD, PciFdoIrpQueryStopDevice }, // 0x05 - IRP_MN_QUERY_STOP_DEVICE { IRP_DOWNWARD, PciFdoIrpCancelStopDevice }, // 0x06 - IRP_MN_CANCEL_STOP_DEVICE { IRP_DOWNWARD, PciFdoIrpQueryDeviceRelations }, // 0x07 - IRP_MN_QUERY_DEVICE_RELATIONS { IRP_DISPATCH, PciFdoIrpQueryInterface }, // 0x08 - IRP_MN_QUERY_INTERFACE { IRP_UPWARD, PciFdoIrpQueryCapabilities }, // 0x09 - IRP_MN_QUERY_CAPABILITIES { IRP_DOWNWARD, PciIrpNotSupported }, // 0x0A - IRP_MN_QUERY_RESOURCES { IRP_DOWNWARD, PciIrpNotSupported }, // 0x0B - IRP_MN_QUERY_RESOURCE_REQUIREMENTS { IRP_DOWNWARD, PciIrpNotSupported }, // 0x0C - IRP_MN_QUERY_DEVICE_TEXT { IRP_DOWNWARD, PciIrpNotSupported }, // 0x0D - IRP_MN_FILTER_RESOURCE_REQUIREMENTS { IRP_DOWNWARD, PciIrpNotSupported }, // 0x0E - NOT USED { IRP_DOWNWARD, PciIrpNotSupported }, // 0x0F - IRP_MN_READ_CONFIG { IRP_DOWNWARD, PciIrpNotSupported }, // 0x10 - IRP_MN_WRITE_CONFIG { IRP_DOWNWARD, PciIrpNotSupported }, // 0x11 - IRP_MN_EJECT { IRP_DOWNWARD, PciIrpNotSupported }, // 0x12 - IRP_MN_SET_LOCK { IRP_DOWNWARD, PciIrpNotSupported }, // 0x13 - IRP_MN_QUERY_ID { IRP_DOWNWARD, PciIrpNotSupported }, // 0x14 - IRP_MN_QUERY_PNP_DEVICE_STATE { IRP_DOWNWARD, PciIrpNotSupported }, // 0x15 - IRP_MN_QUERY_BUS_INFORMATION { IRP_UPWARD, PciFdoIrpDeviceUsageNotification }, // 0x16 - IRP_MN_DEVICE_USAGE_NOTIFICATION { IRP_DOWNWARD, PciFdoIrpSurpriseRemoval }, // 0x17 - IRP_MN_SURPRISE_REMOVAL { IRP_DOWNWARD, PciFdoIrpQueryLegacyBusInformation }, // 0x18 - IRP_MN_QUERY_LEGACY_BUS_INFORMATION { IRP_DOWNWARD, PciIrpNotSupported } // - UNHANDLED PNP IRP }; // // This is the major function dispatch table for Fdo's // PCI_MJ_DISPATCH_TABLE PciFdoDispatchTable = { PCI_MAX_MINOR_PNP_IRP, PciFdoDispatchPnpTable, // Pnp irps PCI_MAX_MINOR_POWER_IRP, PciFdoDispatchPowerTable, // Power irps IRP_DOWNWARD, PciIrpNotSupported, // SystemControl - just pass down! IRP_DOWNWARD, PciIrpNotSupported // DeviceControl - just pass down! }; NTSTATUS PciFdoIrpStartDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) /*++ Routine Description: Handler routine for start IRPs. This allows PDO filters to modify the allocated resources if they are filtering resource requirements. Called after completion. Arguments: DeviceObject - Supplies the device object Irp - Supplies the IRP_MN_START_DEVICE irp. FdoExtension - Supplies the FDO extension Return Value: ERROR_SUCCESS if successful NTSTATUS error code otherwise --*/ { NTSTATUS status; PPCI_FDO_EXTENSION fdoExtension; PPCI_PDO_EXTENSION pdoExtension; PCM_RESOURCE_LIST resources; UCHAR barType[PCI_TYPE1_ADDRESSES] = {0,0}; ULONG index; PCM_PARTIAL_RESOURCE_DESCRIPTOR currentResource; PIO_RESOURCE_DESCRIPTOR currentRequirement; PAGED_CODE(); if (!NT_SUCCESS(Irp->IoStatus.Status)) { return STATUS_NOT_SUPPORTED; } fdoExtension = (PPCI_FDO_EXTENSION) DeviceExtension; status = PciBeginStateTransition(DeviceExtension, PciStarted); if (!NT_SUCCESS(status)) { return status; } // // If this is a PCI-PCI bridge then check if it has any bars and if so exclude // them from the list used to initialize the arbiters. // resources = IrpSp->Parameters.StartDevice.AllocatedResources; if (resources && !PCI_IS_ROOT_FDO(fdoExtension)) { ASSERT(resources->Count == 1); pdoExtension = PCI_BRIDGE_PDO(fdoExtension); if (pdoExtension->Resources) { if (pdoExtension->HeaderType == PCI_BRIDGE_TYPE) { // // If there are any bars they are at the beginning of the list // so "begin at the beginning which is a very good place to start". // currentResource = resources->List[0].PartialResourceList.PartialDescriptors; for (index = 0; index < PCI_TYPE1_ADDRESSES; index++) { // // Extract the requirement we asked for to determine if this // bridge implements any bars (index 0 and 1 in the Limits // array) // currentRequirement = &pdoExtension->Resources->Limit[index]; // // CmResourceTypeNull indicates that we didn't request any // resources so the bar is not implemented and there is nothing // to prune out. // if (currentRequirement->Type != CmResourceTypeNull) { ASSERT(currentResource->Type == currentRequirement->Type); // // Save away the type so we can restore it later // barType[index] = currentResource->Type; // // Null out the resource so we don't configure the arbiters to // use it // currentResource->Type = CmResourceTypeNull; // // Advance the pointer into the started resources by 2 // descriptors to skip over the device private // ASSERT((currentResource+1)->Type == CmResourceTypeDevicePrivate); currentResource+=2; } } } } } // // Initialize the arbiters // status = PciInitializeArbiterRanges(fdoExtension, resources); // // Restore the original resource list if we changed it // if (resources && !PCI_IS_ROOT_FDO(fdoExtension) && pdoExtension->Resources) { currentResource = resources->List[0].PartialResourceList.PartialDescriptors; for (index = 0; index < PCI_TYPE1_ADDRESSES; index++) { if (barType[index] != CmResourceTypeNull) { currentResource->Type = barType[index]; // // Advance the pointer into the started resources by 2 // descriptors to skip over the device private // ASSERT((currentResource+1)->Type == CmResourceTypeDevicePrivate); currentResource+=2; } } } if (!NT_SUCCESS(status)) { PciCancelStateTransition(DeviceExtension, PciStarted); return status; } PciCommitStateTransition(DeviceExtension, PciStarted); return STATUS_SUCCESS; } NTSTATUS PciFdoIrpQueryRemoveDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PAGED_CODE(); return PciBeginStateTransition(DeviceExtension, PciDeleted); } NTSTATUS PciFdoIrpRemoveDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PPCI_FDO_EXTENSION fdoExtension; PPCI_PDO_EXTENSION pdox; PDEVICE_OBJECT attachedDevice; NTSTATUS status; PAGED_CODE(); fdoExtension = (PPCI_FDO_EXTENSION) DeviceExtension; ExAcquireFastMutex(&fdoExtension->ChildListMutex); while (fdoExtension->ChildPdoList) { pdox = (PPCI_PDO_EXTENSION) fdoExtension->ChildPdoList; #if DBG PciDebugPrint( PciDbgVerbose, "PCI Killing PDO %p PDOx %p (b=%d, d=%d, f=%d)\n", pdox->PhysicalDeviceObject, pdox, PCI_PARENT_FDOX(pdox)->BaseBus, pdox->Slot.u.bits.DeviceNumber, pdox->Slot.u.bits.FunctionNumber ); ASSERT(pdox->DeviceState == PciNotStarted); #endif PciPdoDestroy(pdox->PhysicalDeviceObject); } ExReleaseFastMutex(&fdoExtension->ChildListMutex); // // Destroy any secondary extensions associated with // this FDO. // while (fdoExtension->SecondaryExtension.Next) { PcipDestroySecondaryExtension( &fdoExtension->SecondaryExtension, NULL, fdoExtension->SecondaryExtension.Next ); } // // Destroy the FDO. // // The IRP needs to go down the device stack but we // need to remove the device from the stack so grab // the next object first, then detach, then pass it // down. // PciDebugPrint( PciDbgInformative, "PCI FDOx (%p) destroyed.", fdoExtension ); // // Note that a filter above us may have failed Start. If this is so, we get // no query because the "devnode" has never been started... // if (!PciIsInTransitionToState(DeviceExtension, PciDeleted)) { status = PciBeginStateTransition(DeviceExtension, PciDeleted); ASSERT(NT_SUCCESS(status)); } PciCommitStateTransition(DeviceExtension, PciDeleted); PciRemoveEntryFromList(&PciFdoExtensionListHead, &fdoExtension->List, &PciGlobalLock); attachedDevice = fdoExtension->AttachedDeviceObject; IoDetachDevice(attachedDevice); IoDeleteDevice(fdoExtension->FunctionalDeviceObject); Irp->IoStatus.Status = STATUS_SUCCESS; IoSkipCurrentIrpStackLocation(Irp); return IoCallDriver(attachedDevice, Irp); } NTSTATUS PciFdoIrpCancelRemoveDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PAGED_CODE(); PciCancelStateTransition(DeviceExtension, PciDeleted); return STATUS_SUCCESS; } NTSTATUS PciFdoIrpStopDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PAGED_CODE(); PciCommitStateTransition(DeviceExtension, PciStopped); return STATUS_SUCCESS; } NTSTATUS PciFdoIrpQueryStopDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PAGED_CODE(); PciBeginStateTransition(DeviceExtension, PciStopped); // // We don't support multilevel rebalance so we can't stop host bridges. // return STATUS_UNSUCCESSFUL; } NTSTATUS PciFdoIrpCancelStopDevice( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PAGED_CODE(); PciCancelStateTransition(DeviceExtension, PciStopped); return STATUS_SUCCESS; } NTSTATUS PciFdoIrpQueryDeviceRelations( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PAGED_CODE(); if (IrpSp->Parameters.QueryDeviceRelations.Type == BusRelations) { return PciQueryDeviceRelations( (PPCI_FDO_EXTENSION) DeviceExtension, (PDEVICE_RELATIONS *) &Irp->IoStatus.Information ); } // // No other relation types need to be handled. // return STATUS_NOT_SUPPORTED; } NTSTATUS PciFdoIrpQueryCapabilities( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) /*++ Routine Description: Snoops the results of a QUERY CAPABILITIES IRP that got sent downwards. This saves us having to send our own for things like the device's power characteristics. Arguments: DeviceObject - Supplies the device object Irp - Supplies the IRP_MN_QUERY_CAPABILITIES irp. FdoExtension - Supplies the FDO extension Return Value: STATUS_SUCCESS --*/ { PDEVICE_CAPABILITIES capabilities; PPCI_FDO_EXTENSION fdoExtension; PAGED_CODE(); fdoExtension = (PPCI_FDO_EXTENSION) DeviceExtension; ASSERT_PCI_FDO_EXTENSION(fdoExtension); PciDebugPrint( PciDbgQueryCap, "PCI - FdoQueryCapabilitiesCompletion (fdox %08x) child status = %08x\n", fdoExtension, Irp->IoStatus.Status ); // // Grab a pointer to the capablities for easy referencing // capabilities = IrpSp->Parameters.DeviceCapabilities.Capabilities; // // Remember what the system wake and device wake level are // fdoExtension->PowerState.SystemWakeLevel = capabilities->SystemWake; fdoExtension->PowerState.DeviceWakeLevel = capabilities->DeviceWake; // // Grab the S-state to D-State mapping // RtlCopyMemory( fdoExtension->PowerState.SystemStateMapping, capabilities->DeviceState, (PowerSystemShutdown + 1) * sizeof(DEVICE_POWER_STATE) ); #if DBG if (PciDebug & PciDbgQueryCap) { PciDebugDumpQueryCapabilities(capabilities); } #endif return STATUS_SUCCESS; } NTSTATUS PciFdoIrpQueryLegacyBusInformation( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PAGED_CODE(); return PciQueryLegacyBusInformation( (PPCI_FDO_EXTENSION) DeviceExtension, (PLEGACY_BUS_INFORMATION *) &Irp->IoStatus.Information ); } NTSTATUS PciFdoIrpDeviceUsageNotification( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PPCI_FDO_EXTENSION fdoExtension; PAGED_CODE(); fdoExtension = (PPCI_FDO_EXTENSION) DeviceExtension; if (NT_SUCCESS(Irp->IoStatus.Status)) { return PciLocalDeviceUsage(&fdoExtension->PowerState, Irp); } else { return STATUS_NOT_SUPPORTED; } } NTSTATUS PciFdoIrpQueryInterface( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PPCI_FDO_EXTENSION fdoExtension; NTSTATUS status; PAGED_CODE(); fdoExtension = (PPCI_FDO_EXTENSION) DeviceExtension; ASSERT_PCI_FDO_EXTENSION(fdoExtension); // NTRAID #54671 - 4/20/2000 - andrewth // // We might want to do a synchronizing state // transition here so we don't attempt to get the interface during a // stop/remove sequence. // // We shouldn't hold interfaces when something isn't // started. But we won't boot unless we hack the below.... // //if (fdoExtension->DeviceState != PciStarted) { if (fdoExtension->DeviceState == PciDeleted) { return PciPassIrpFromFdoToPdo(DeviceExtension, Irp); } status = PciQueryInterface( fdoExtension, IrpSp->Parameters.QueryInterface.InterfaceType, IrpSp->Parameters.QueryInterface.Size, IrpSp->Parameters.QueryInterface.Version, IrpSp->Parameters.QueryInterface.InterfaceSpecificData, IrpSp->Parameters.QueryInterface.Interface, FALSE ); if (NT_SUCCESS(status)) { Irp->IoStatus.Status = status; return PciPassIrpFromFdoToPdo(DeviceExtension, Irp); } else if (status == STATUS_NOT_SUPPORTED) { // // Status == STATUS_NOT_SUPPORTED. Pass IRP down the stack // and see if anyone else is kind enough to provide this // interface. // status = PciCallDownIrpStack(DeviceExtension, Irp); if (status == STATUS_NOT_SUPPORTED) { // // If nobody provided the interface, try again at // this level. // status = PciQueryInterface( fdoExtension, IrpSp->Parameters.QueryInterface.InterfaceType, IrpSp->Parameters.QueryInterface.Size, IrpSp->Parameters.QueryInterface.Version, IrpSp->Parameters.QueryInterface.InterfaceSpecificData, IrpSp->Parameters.QueryInterface.Interface, TRUE ); } } if (status != STATUS_NOT_SUPPORTED) { Irp->IoStatus.Status = status; } else { status = Irp->IoStatus.Status; } IoCompleteRequest(Irp, IO_NO_INCREMENT); return status; } NTSTATUS PciFdoIrpSurpriseRemoval( IN PIRP Irp, IN PIO_STACK_LOCATION IrpSp, IN PPCI_COMMON_EXTENSION DeviceExtension ) { PPCI_FDO_EXTENSION fdoExtension; NTSTATUS status; PAGED_CODE(); fdoExtension = (PPCI_FDO_EXTENSION) DeviceExtension; status = PciBeginStateTransition(DeviceExtension, PciSurpriseRemoved); ASSERT(NT_SUCCESS(status)); if (NT_SUCCESS(status)) { PciCommitStateTransition(DeviceExtension, PciSurpriseRemoved); status = PciBeginStateTransition(DeviceExtension, PciDeleted); } return status; } NTSTATUS PciAddDevice( IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject ) /*++ Routine Description: Given a physical device object, this routine creates a functional device object for it. Arguments: DriverObject - Pointer to our driver's DRIVER_OBJECT structure. PhysicalDeviceObject - Pointer to the physical device object for which we must create a functional device object. Return Value: NT status. --*/ { PDEVICE_OBJECT functionalDeviceObject = NULL; PDEVICE_OBJECT attachedTo = NULL; PPCI_FDO_EXTENSION fdoExtension = NULL; PPCI_FDO_EXTENSION pciParentFdoExtension; PPCI_PDO_EXTENSION pdoExtension; PCM_PARTIAL_RESOURCE_DESCRIPTOR descriptor; NTSTATUS status; PSINGLE_LIST_ENTRY nextEntry; HANDLE deviceRegistryHandle; ULONG resultLength; UNICODE_STRING hackFlagsString; UCHAR infoBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG) - 1]; PKEY_VALUE_PARTIAL_INFORMATION info = (PKEY_VALUE_PARTIAL_INFORMATION) infoBuffer; PAGED_CODE(); PciDebugPrint(PciDbgAddDevice, "PCI - AddDevice (a new bus).\n"); // // Find out if the PDO was created by the PCI driver. That is, // if it is a child or a root bus. Validate a few things before // going any further. // pciParentFdoExtension = PciFindParentPciFdoExtension(PhysicalDeviceObject, &PciGlobalLock); if (pciParentFdoExtension) { // // The PDO was created by this driver, therefore we can look at // the extension. Get it and verify it's ours. // pdoExtension = (PPCI_PDO_EXTENSION)PhysicalDeviceObject->DeviceExtension; ASSERT_PCI_PDO_EXTENSION(pdoExtension); // // The only thing we should get an add device that is a // child device is a PCI-PCI bridge. // if ((pdoExtension->BaseClass != PCI_CLASS_BRIDGE_DEV) || (pdoExtension->SubClass != PCI_SUBCLASS_BR_PCI_TO_PCI)) { PciDebugPrint( PciDbgAlways, "PCI - PciAddDevice for Non-Root/Non-PCI-PCI bridge,\n" " Class %02x, SubClass %02x, will not add.\n", pdoExtension->BaseClass, pdoExtension->SubClass ); ASSERT((pdoExtension->BaseClass == PCI_CLASS_BRIDGE_DEV) && (pdoExtension->SubClass == PCI_SUBCLASS_BR_PCI_TO_PCI)); status = STATUS_INVALID_DEVICE_REQUEST; goto cleanup; } PciDebugPrint(PciDbgAddDevice, "PCI - AddDevice (new bus is child of bus 0x%x).\n", pciParentFdoExtension->BaseBus ); if (!PciAreBusNumbersConfigured(pdoExtension)) { // // This bridge isn't configured and if we had been able to we would // already have done so // PciDebugPrint( PciDbgAddDevice | PciDbgInformative, "PCI - Bus numbers not configured for bridge (0x%x.0x%x.0x%x)\n", pciParentFdoExtension->BaseBus, pdoExtension->Slot.u.bits.DeviceNumber, pdoExtension->Slot.u.bits.FunctionNumber, pdoExtension->Dependent.type1.PrimaryBus ); status = STATUS_INVALID_DEVICE_REQUEST; goto cleanup; } } // // We've been given the PhysicalDeviceObject for a PCI bus. Create the // functionalDeviceObject. Our FDO will be nameless. // status = IoCreateDevice( DriverObject, // our driver object sizeof(PCI_FDO_EXTENSION), // size of our extension NULL, // our name FILE_DEVICE_BUS_EXTENDER, // device type 0, // device characteristics FALSE, // not exclusive &functionalDeviceObject // store new device object here ); if (!NT_SUCCESS(status)) { goto cleanup; } fdoExtension = (PPCI_FDO_EXTENSION)functionalDeviceObject->DeviceExtension; // // We have our functionalDeviceObject, initialize it. // PciInitializeFdoExtensionCommonFields( fdoExtension, functionalDeviceObject, PhysicalDeviceObject ); // // Now attach to the PDO we were given. // attachedTo = IoAttachDeviceToDeviceStack(functionalDeviceObject, PhysicalDeviceObject); if (attachedTo == NULL) { ASSERT(attachedTo != NULL); status = STATUS_NO_SUCH_DEVICE; goto cleanup; } fdoExtension->AttachedDeviceObject = attachedTo; // // Get the access registers and base bus number for this bus. // If this bus was discovered by this driver, then the PDO was // created by this driver and will be on one of the PDO lists // under one of the FDOs owned by this driver. Otherwise it // is a new root,.... use magic. // if (pciParentFdoExtension) { // // This physical device was discovered by this driver. // Get the bus number from the PDO extension. // PSINGLE_LIST_ENTRY secondaryExtension; fdoExtension->BaseBus = pdoExtension->Dependent.type1.SecondaryBus; // // Copy the access methods from the root fdo and set // the root fdo back pointer. // fdoExtension->BusRootFdoExtension = pciParentFdoExtension->BusRootFdoExtension; // // Point the PDOextension to the new FDOextension (also indicates // the object is a bridge) and vice versa. // pdoExtension->BridgeFdoExtension = fdoExtension; fdoExtension->ParentFdoExtension = pciParentFdoExtension; // // Cause the requirements list to be reevaluated. // PciInvalidateResourceInfoCache(pdoExtension); } else { PVOID buffer; // // Get the boot configuration (CmResourceList) for // this PDO. This gives us the bus number and the // ranges covered by this host bridge. // status = PciGetDeviceProperty( PhysicalDeviceObject, DevicePropertyBootConfiguration, &buffer ); if (NT_SUCCESS(status)) { #if DBG PciDebugPrint(PciDbgAddDeviceRes, "PCI - CM RESOURCE LIST FROM ROOT PDO\n"); PciDebugPrintCmResList(PciDbgAddDeviceRes, buffer); #endif descriptor = PciFindDescriptorInCmResourceList( CmResourceTypeBusNumber, buffer, NULL ); } else { descriptor = NULL; } if (descriptor != NULL) { // // Sanity check, some servers are aproaching // 256 busses but as there is no way to deal with // numbering bridges under a bus > 256 and we don't // have raw and translated bus numbers yet - it had // better be < 0xFF! // ASSERT(descriptor->u.BusNumber.Start <= 0xFF); ASSERT(descriptor->u.BusNumber.Start + descriptor->u.BusNumber.Length - 1 <= 0xFF); fdoExtension->BaseBus = (UCHAR)descriptor->u.BusNumber.Start; fdoExtension->MaxSubordinateBus = (UCHAR)(descriptor->u.BusNumber.Start + descriptor->u.BusNumber.Length - 1); PciDebugPrint(PciDbgAddDevice, "PCI - Root Bus # 0x%x->0x%x.\n", fdoExtension->BaseBus, fdoExtension->MaxSubordinateBus ); } else { // // HaveGuessedConfigOnceAlready is used to tell // if have multiple roots and no config info. If // this happens we end up gussing the bus number // as zero, doing this more than once is not good. // if (HaveGuessedConfigOnceAlready) { KeBugCheckEx(PCI_BUS_DRIVER_INTERNAL, PCI_BUGCODE_TOO_MANY_CONFIG_GUESSES, (ULONG_PTR)PhysicalDeviceObject, 0, 0); } PciDebugPrint( PciDbgAlways, "PCI Will use default configuration.\n" ); HaveGuessedConfigOnceAlready = TRUE; fdoExtension->BaseBus = 0; } fdoExtension->BusRootFdoExtension = fdoExtension; } // // Organise access to config space // status = PciGetConfigHandlers(fdoExtension); if (!NT_SUCCESS(status)) { goto cleanup; } // // Initialize arbiters for this FDO. // status = PciInitializeArbiters(fdoExtension); if (!NT_SUCCESS(status)) { goto cleanup; } // // Indicate this is a REAL FDO extension that is part of a REAL // FDO. (Fake extensions exist to assist in the enumeration of // busses which PCI isn't the real controller for (eg CardBus). // fdoExtension->Fake = FALSE; // // Insert this Fdo in the list of PCI parent Fdos. // PciInsertEntryAtTail(&PciFdoExtensionListHead, &fdoExtension->List, &PciGlobalLock); #if defined(_WIN64) // // Update the legacy hardware tree that would have been build by the ARC // firmware or NTDetect which don't exist here. // status = PciUpdateLegacyHardwareDescription(fdoExtension); if (!NT_SUCCESS(status)) { goto cleanup; } #endif // // Check if there are any hacks to apply to this bus. // These are located under the device registry key in a value called HackFlags // status = IoOpenDeviceRegistryKey(PhysicalDeviceObject, PLUGPLAY_REGKEY_DEVICE, KEY_ALL_ACCESS, &deviceRegistryHandle ); if (!NT_SUCCESS(status)) { goto cleanup; } PciConstStringToUnicodeString(&hackFlagsString, L"HackFlags"); status = ZwQueryValueKey(deviceRegistryHandle, &hackFlagsString, KeyValuePartialInformation, info, sizeof(infoBuffer), &resultLength ); ZwClose(deviceRegistryHandle); // // If we have valid data in the registry then remember it // if (NT_SUCCESS(status) && (info->Type == REG_DWORD) && (info->DataLength == sizeof(ULONG))) { fdoExtension->BusHackFlags = *((PULONG)(&info->Data)); } // // We can receive IRPs now... // functionalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING; // // Get any hotplug parameters (we send IRPS for this so it must be after // DO_DEVICE_INITIALIZING is cleared so we can deal with them) // PciGetHotPlugParameters(fdoExtension); return STATUS_SUCCESS; cleanup: ASSERT(!NT_SUCCESS(status)); // // Destroy any secondary extensions associated with // this FDO. // if (fdoExtension) { while (fdoExtension->SecondaryExtension.Next) { PcipDestroySecondaryExtension( &fdoExtension->SecondaryExtension, NULL, fdoExtension->SecondaryExtension.Next ); } } if (attachedTo) { IoDetachDevice(attachedTo); } if (functionalDeviceObject) { IoDeleteDevice(functionalDeviceObject); } return status; } VOID PciInitializeFdoExtensionCommonFields( IN PPCI_FDO_EXTENSION FdoExtension, IN PDEVICE_OBJECT Fdo, IN PDEVICE_OBJECT Pdo ) { RtlZeroMemory(FdoExtension, sizeof(PCI_FDO_EXTENSION)); FdoExtension->ExtensionType = PciFdoExtensionType; FdoExtension->PhysicalDeviceObject = Pdo; FdoExtension->FunctionalDeviceObject = Fdo; FdoExtension->PowerState.CurrentSystemState = PowerSystemWorking; FdoExtension->PowerState.CurrentDeviceState = PowerDeviceD0; FdoExtension->IrpDispatchTable = &PciFdoDispatchTable; ExInitializeFastMutex(&FdoExtension->SecondaryExtMutex); ExInitializeFastMutex(&FdoExtension->ChildListMutex); PciInitializeState((PPCI_COMMON_EXTENSION) FdoExtension); } VOID PciGetHotPlugParameters( IN PPCI_FDO_EXTENSION Fdo ) /*++ Description: Runs the _HPP (described below) on the device and saves the parameters if available Method (_HPP, 0) { Return (Package(){ 0x00000008, // CacheLineSize in DWORDS 0x00000040, // LatencyTimer in PCI clocks 0x00000001, // Enable SERR (Boolean) 0x00000001 // Enable PERR (Boolean) }) Arguments: Fdo - The PDO extension for the bridge Return Value: TRUE - if the parameters are available, FASLE otherwise --*/ { #ifndef HPPTESTING NTSTATUS status; ACPI_EVAL_INPUT_BUFFER input; PACPI_EVAL_OUTPUT_BUFFER output = NULL; ULONG count; PACPI_METHOD_ARGUMENT argument; ULONG outputSize = sizeof(ACPI_EVAL_OUTPUT_BUFFER) + sizeof(ACPI_METHOD_ARGUMENT) * PCI_HPP_PACKAGE_COUNT; PAGED_CODE(); output = ExAllocatePool(PagedPool | POOL_COLD_ALLOCATION, outputSize); if (!output) { status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } RtlZeroMemory(&input, sizeof(ACPI_EVAL_INPUT_BUFFER)); RtlZeroMemory(output, outputSize); // // Send a IOCTL to ACPI to request it to run the _HPP method on this device // if the method it is present // input.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE; input.MethodNameAsUlong = (ULONG)'PPH_'; // // PciSendIoctl deals with sending this from the top of the stack. // status = PciSendIoctl(Fdo->PhysicalDeviceObject, IOCTL_ACPI_EVAL_METHOD, &input, sizeof(ACPI_EVAL_INPUT_BUFFER), output, outputSize ); if (!NT_SUCCESS(status)) { // // Inherit them from my parent (If I have one) // if (!PCI_IS_ROOT_FDO(Fdo)) { RtlCopyMemory(&Fdo->HotPlugParameters, &Fdo->ParentFdoExtension->HotPlugParameters, sizeof(Fdo->HotPlugParameters) ); } } else { if (output->Count != PCI_HPP_PACKAGE_COUNT) { goto exit; } // // Check they are all integers and in the right bounds // for (count = 0; count < PCI_HPP_PACKAGE_COUNT; count++) { ULONG current; if (output->Argument[count].Type != ACPI_METHOD_ARGUMENT_INTEGER) { goto exit; } current = output->Argument[count].Argument; switch (count) { case PCI_HPP_CACHE_LINE_SIZE_INDEX: case PCI_HPP_LATENCY_TIMER_INDEX: // // These registers are only a UCHAR in length // if (current > 0xFF) { goto exit; } break; case PCI_HPP_ENABLE_SERR_INDEX: case PCI_HPP_ENABLE_PERR_INDEX: // // These are booleans - 1 or 0 // if (current > 1) { goto exit; } break; } } // // Finally save them and remember we got them. // Fdo->HotPlugParameters.CacheLineSize = (UCHAR)output->Argument[PCI_HPP_CACHE_LINE_SIZE_INDEX].Argument; Fdo->HotPlugParameters.LatencyTimer = (UCHAR)output->Argument[PCI_HPP_LATENCY_TIMER_INDEX].Argument; Fdo->HotPlugParameters.EnableSERR = (BOOLEAN)output->Argument[PCI_HPP_ENABLE_SERR_INDEX].Argument; Fdo->HotPlugParameters.EnablePERR = (BOOLEAN)output->Argument[PCI_HPP_ENABLE_PERR_INDEX].Argument; Fdo->HotPlugParameters.Acquired = TRUE; } exit: if (output) { ExFreePool(output); } #else Fdo->HotPlugParameters.CacheLineSize = 0x8; Fdo->HotPlugParameters.LatencyTimer = 0x20; Fdo->HotPlugParameters.EnableSERR = 0; Fdo->HotPlugParameters.EnablePERR = 0; Fdo->HotPlugParameters.Acquired = TRUE; #endif }