drivers/bus/pcix/fdo.c

   1 /*
   2  * PROJECT:         ReactOS PCI Bus Driver
   3  * LICENSE:         BSD - See COPYING.ARM in the top level directory
   4  * FILE:            drivers/bus/pci/fdo.c
   5  * PURPOSE:         FDO Device Management
   6  * PROGRAMMERS:     ReactOS Portable Systems Group
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include <pci.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 /* GLOBALS ********************************************************************/
  16
  17 SINGLE_LIST_ENTRY PciFdoExtensionListHead;
  18 BOOLEAN PciBreakOnDefault;
  19
  20 PCI_MN_DISPATCH_TABLE PciFdoDispatchPowerTable[] =
  21 {
  22     {IRP_DISPATCH, (PCI_DISPATCH_FUNCTION)PciFdoWaitWake},
  23     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  24     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoSetPowerState},
  25     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpQueryPower},
  26     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported}
  27 };
  28
  29 PCI_MN_DISPATCH_TABLE PciFdoDispatchPnpTable[] =
  30 {
  31     {IRP_UPWARD,   (PCI_DISPATCH_FUNCTION)PciFdoIrpStartDevice},
  32     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpQueryRemoveDevice},
  33     {IRP_DISPATCH, (PCI_DISPATCH_FUNCTION)PciFdoIrpRemoveDevice},
  34     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpCancelRemoveDevice},
  35     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpStopDevice},
  36     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpQueryStopDevice},
  37     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpCancelStopDevice},
  38     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpQueryDeviceRelations},
  39     {IRP_DISPATCH, (PCI_DISPATCH_FUNCTION)PciFdoIrpQueryInterface},
  40     {IRP_UPWARD,   (PCI_DISPATCH_FUNCTION)PciFdoIrpQueryCapabilities},
  41     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  42     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  43     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  44     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  45     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  46     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  47     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  48     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  49     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  50     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  51     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  52     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported},
  53     {IRP_UPWARD,   (PCI_DISPATCH_FUNCTION)PciFdoIrpDeviceUsageNotification},
  54     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpSurpriseRemoval},
  55     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciFdoIrpQueryLegacyBusInformation},
  56     {IRP_DOWNWARD, (PCI_DISPATCH_FUNCTION)PciIrpNotSupported}
  57 };
  58
  59 PCI_MJ_DISPATCH_TABLE PciFdoDispatchTable =
  60 {
  61     IRP_MN_QUERY_LEGACY_BUS_INFORMATION,
  62     PciFdoDispatchPnpTable,
  63     IRP_MN_QUERY_POWER,
  64     PciFdoDispatchPowerTable,
  65     IRP_DOWNWARD,
  66     (PCI_DISPATCH_FUNCTION)PciIrpNotSupported,
  67     IRP_DOWNWARD,
  68     (PCI_DISPATCH_FUNCTION)PciIrpNotSupported
  69 };
  70
  71 /* FUNCTIONS ******************************************************************/
  72
  73 NTSTATUS
  74 NTAPI
  75 PciFdoIrpStartDevice(IN PIRP Irp,
  76                      IN PIO_STACK_LOCATION IoStackLocation,
  77                      IN PPCI_FDO_EXTENSION DeviceExtension)
  78 {
  79     NTSTATUS Status;
  80     PCM_RESOURCE_LIST Resources;
  81     PAGED_CODE();
  82
  83     /* The device stack must be starting the FDO in a success path */
  84     if (!NT_SUCCESS(Irp->IoStatus.Status)) return STATUS_NOT_SUPPORTED;
  85
  86     /* Attempt to switch the state machine to the started state */
  87     Status = PciBeginStateTransition(DeviceExtension, PciStarted);
  88     if (!NT_SUCCESS(Status)) return Status;
  89
  90     /* Check for any boot-provided resources */
  91     Resources = IoStackLocation->Parameters.StartDevice.AllocatedResources;
  92     if ((Resources) && !(PCI_IS_ROOT_FDO(DeviceExtension)))
  93     {
  94         /* These resources would only be for non-root FDOs, unhandled for now */
  95         ASSERT(Resources->Count == 1);
  96         UNIMPLEMENTED;
  97         while (TRUE);
  98     }
  99
 100     /* Initialize the arbiter for this FDO */
 101     Status = PciInitializeArbiterRanges(DeviceExtension, Resources);
 102     if (!NT_SUCCESS(Status))
 103     {
 104         /* Cancel the transition if this failed */
 105         PciCancelStateTransition(DeviceExtension, PciStarted);
 106         return Status;
 107     }
 108
 109     /* Again, check for boot-provided resources for non-root FDO */
 110     if ((Resources) && !(PCI_IS_ROOT_FDO(DeviceExtension)))
 111     {
 112         /* Unhandled for now */
 113         ASSERT(Resources->Count == 1);
 114         UNIMPLEMENTED;
 115         while (TRUE);
 116     }
 117
 118     /* Commit the transition to the started state */
 119     PciCommitStateTransition(DeviceExtension, PciStarted);
 120     return STATUS_SUCCESS;
 121 }
 122
 123 NTSTATUS
 124 NTAPI
 125 PciFdoIrpQueryRemoveDevice(IN PIRP Irp,
 126                            IN PIO_STACK_LOCATION IoStackLocation,
 127                            IN PPCI_FDO_EXTENSION DeviceExtension)
 128 {
 129     UNIMPLEMENTED;
 130     while (TRUE);
 131     return STATUS_NOT_SUPPORTED;
 132 }
 133
 134 NTSTATUS
 135 NTAPI
 136 PciFdoIrpRemoveDevice(IN PIRP Irp,
 137                       IN PIO_STACK_LOCATION IoStackLocation,
 138                       IN PPCI_FDO_EXTENSION DeviceExtension)
 139 {
 140     UNIMPLEMENTED;
 141     while (TRUE);
 142     return STATUS_NOT_SUPPORTED;
 143 }
 144
 145 NTSTATUS
 146 NTAPI
 147 PciFdoIrpCancelRemoveDevice(IN PIRP Irp,
 148                             IN PIO_STACK_LOCATION IoStackLocation,
 149                             IN PPCI_FDO_EXTENSION DeviceExtension)
 150 {
 151     UNIMPLEMENTED;
 152     while (TRUE);
 153     return STATUS_NOT_SUPPORTED;
 154 }
 155
 156 NTSTATUS
 157 NTAPI
 158 PciFdoIrpStopDevice(IN PIRP Irp,
 159                     IN PIO_STACK_LOCATION IoStackLocation,
 160                     IN PPCI_FDO_EXTENSION DeviceExtension)
 161 {
 162     UNIMPLEMENTED;
 163     while (TRUE);
 164     return STATUS_NOT_SUPPORTED;
 165 }
 166
 167 NTSTATUS
 168 NTAPI
 169 PciFdoIrpQueryStopDevice(IN PIRP Irp,
 170                          IN PIO_STACK_LOCATION IoStackLocation,
 171                          IN PPCI_FDO_EXTENSION DeviceExtension)
 172 {
 173     UNIMPLEMENTED;
 174     while (TRUE);
 175     return STATUS_NOT_SUPPORTED;
 176 }
 177
 178 NTSTATUS
 179 NTAPI
 180 PciFdoIrpCancelStopDevice(IN PIRP Irp,
 181                           IN PIO_STACK_LOCATION IoStackLocation,
 182                           IN PPCI_FDO_EXTENSION DeviceExtension)
 183 {
 184     UNIMPLEMENTED;
 185     while (TRUE);
 186     return STATUS_NOT_SUPPORTED;
 187 }
 188
 189 NTSTATUS
 190 NTAPI
 191 PciFdoIrpQueryDeviceRelations(IN PIRP Irp,
 192                               IN PIO_STACK_LOCATION IoStackLocation,
 193                               IN PPCI_FDO_EXTENSION DeviceExtension)
 194 {
 195     NTSTATUS Status;
 196     PAGED_CODE();
 197
 198     /* Are bus relations being queried? */
 199     if (IoStackLocation->Parameters.QueryDeviceRelations.Type != BusRelations)
 200     {
 201         /* The FDO is a bus, so only bus relations can be obtained */
 202         Status = STATUS_NOT_SUPPORTED;
 203     }
 204     else
 205     {
 206         /* Scan the PCI bus and build the device relations for the caller */
 207         Status = PciQueryDeviceRelations(DeviceExtension,
 208                                          (PDEVICE_RELATIONS*)
 209                                          &Irp->IoStatus.Information);
 210     }
 211
 212     /* Return the enumeration status back */
 213     return Status;
 214 }
 215
 216 NTSTATUS
 217 NTAPI
 218 PciFdoIrpQueryInterface(IN PIRP Irp,
 219                         IN PIO_STACK_LOCATION IoStackLocation,
 220                         IN PPCI_FDO_EXTENSION DeviceExtension)
 221 {
 222     NTSTATUS Status;
 223     PAGED_CODE();
 224     ASSERT(DeviceExtension->ExtensionType == PciFdoExtensionType);
 225
 226     /* Deleted extensions don't respond to IRPs */
 227     if (DeviceExtension->DeviceState == PciDeleted)
 228     {
 229         /* Hand it back to try to deal with it */
 230         return PciPassIrpFromFdoToPdo(DeviceExtension, Irp);
 231     }
 232
 233     /* Query our driver for this interface */
 234     Status = PciQueryInterface(DeviceExtension,
 235                                IoStackLocation->Parameters.QueryInterface.
 236                                InterfaceType,
 237                                IoStackLocation->Parameters.QueryInterface.
 238                                Size,
 239                                IoStackLocation->Parameters.QueryInterface.
 240                                Version,
 241                                IoStackLocation->Parameters.QueryInterface.
 242                                InterfaceSpecificData,
 243                                IoStackLocation->Parameters.QueryInterface.
 244                                Interface,
 245                                FALSE);
 246     if (NT_SUCCESS(Status))
 247     {
 248         /* We found it, let the PDO handle it */
 249         Irp->IoStatus.Status = Status;
 250         return PciPassIrpFromFdoToPdo(DeviceExtension, Irp);
 251     }
 252     else if (Status == STATUS_NOT_SUPPORTED)
 253     {
 254         /* Otherwise, we can't handle it, let someone else down the stack try */
 255         Status = PciCallDownIrpStack(DeviceExtension, Irp);
 256         if (Status == STATUS_NOT_SUPPORTED)
 257         {
 258             /* They can't either, try a last-resort interface lookup */
 259             Status = PciQueryInterface(DeviceExtension,
 260                                        IoStackLocation->Parameters.QueryInterface.
 261                                        InterfaceType,
 262                                        IoStackLocation->Parameters.QueryInterface.
 263                                        Size,
 264                                        IoStackLocation->Parameters.QueryInterface.
 265                                        Version,
 266                                        IoStackLocation->Parameters.QueryInterface.
 267                                        InterfaceSpecificData,
 268                                        IoStackLocation->Parameters.QueryInterface.
 269                                        Interface,
 270                                        TRUE);
 271         }
 272     }
 273
 274     /* Has anyone claimed this interface yet? */
 275     if (Status == STATUS_NOT_SUPPORTED)
 276     {
 277         /* No, return the original IRP status */
 278         Status = Irp->IoStatus.Status;
 279     }
 280     else
 281     {
 282         /* Yes, set the new IRP status */
 283         Irp->IoStatus.Status = Status;
 284     }
 285
 286     /* Complete this IRP */
 287     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 288     return Status;
 289 }
 290
 291 NTSTATUS
 292 NTAPI
 293 PciFdoIrpQueryCapabilities(IN PIRP Irp,
 294                            IN PIO_STACK_LOCATION IoStackLocation,
 295                            IN PPCI_FDO_EXTENSION DeviceExtension)
 296 {
 297     PDEVICE_CAPABILITIES Capabilities;
 298     PAGED_CODE();
 299     ASSERT_FDO(DeviceExtension);
 300
 301     /* Get the capabilities */
 302     Capabilities = IoStackLocation->Parameters.DeviceCapabilities.Capabilities;
 303
 304     /* Inherit wake levels and power mappings from the higher-up capabilities */
 305     DeviceExtension->PowerState.SystemWakeLevel = Capabilities->SystemWake;
 306     DeviceExtension->PowerState.DeviceWakeLevel = Capabilities->DeviceWake;
 307     RtlCopyMemory(DeviceExtension->PowerState.SystemStateMapping,
 308                   Capabilities->DeviceState,
 309                   sizeof(DeviceExtension->PowerState.SystemStateMapping));
 310
 311     /* Dump the capabilities and return success */
 312     PciDebugDumpQueryCapabilities(Capabilities);
 313     return STATUS_SUCCESS;
 314 }
 315
 316 NTSTATUS
 317 NTAPI
 318 PciFdoIrpDeviceUsageNotification(IN PIRP Irp,
 319                                  IN PIO_STACK_LOCATION IoStackLocation,
 320                                  IN PPCI_FDO_EXTENSION DeviceExtension)
 321 {
 322     UNIMPLEMENTED;
 323     while (TRUE);
 324     return STATUS_NOT_SUPPORTED;
 325 }
 326
 327 NTSTATUS
 328 NTAPI
 329 PciFdoIrpSurpriseRemoval(IN PIRP Irp,
 330                          IN PIO_STACK_LOCATION IoStackLocation,
 331                          IN PPCI_FDO_EXTENSION DeviceExtension)
 332 {
 333     UNIMPLEMENTED;
 334     while (TRUE);
 335     return STATUS_NOT_SUPPORTED;
 336 }
 337
 338 NTSTATUS
 339 NTAPI
 340 PciFdoIrpQueryLegacyBusInformation(IN PIRP Irp,
 341                                    IN PIO_STACK_LOCATION IoStackLocation,
 342                                    IN PPCI_FDO_EXTENSION DeviceExtension)
 343 {
 344     UNIMPLEMENTED;
 345     while (TRUE);
 346     return STATUS_NOT_SUPPORTED;
 347 }
 348
 349 VOID
 350 NTAPI
 351 PciGetHotPlugParameters(IN PPCI_FDO_EXTENSION FdoExtension)
 352 {
 353     ACPI_EVAL_INPUT_BUFFER InputBuffer;
 354     PACPI_EVAL_OUTPUT_BUFFER OutputBuffer;
 355     ULONG Length;
 356     NTSTATUS Status;
 357     PAGED_CODE();
 358
 359     /* We should receive 4 parameters, per the HPP specification */
 360     Length = sizeof(ACPI_EVAL_OUTPUT_BUFFER) + 4 * sizeof(ACPI_METHOD_ARGUMENT);
 361
 362     /* Allocate the buffer to hold the parameters */
 363     OutputBuffer = ExAllocatePoolWithTag(PagedPool, Length, PCI_POOL_TAG);
 364     if (!OutputBuffer) return;
 365
 366     /* Initialize the output and input buffers. The method is _HPP */
 367     RtlZeroMemory(OutputBuffer, Length);
 368     *(PULONG)InputBuffer.MethodName = 'PPH_';
 369     InputBuffer.Signature = ACPI_EVAL_INPUT_BUFFER_SIGNATURE;
 370     do
 371     {
 372         /* Send the IOCTL to the ACPI driver */
 373         Status = PciSendIoctl(FdoExtension->PhysicalDeviceObject,
 374                               IOCTL_ACPI_EVAL_METHOD,
 375                               &InputBuffer,
 376                               sizeof(InputBuffer),
 377                               OutputBuffer,
 378                               Length);
 379         if (!NT_SUCCESS(Status))
 380         {
 381             /* The method failed, check if we can salvage data from parent */
 382             if (!PCI_IS_ROOT_FDO(FdoExtension))
 383             {
 384                 /* Copy the root bus' hot plug parameters */
 385                 FdoExtension->HotPlugParameters = FdoExtension->ParentFdoExtension->HotPlugParameters;
 386             }
 387
 388             /* Nothing more to do on this path */
 389             break;
 390         }
 391
 392         /* ACPI sent back some data. 4 parameters are expected in the output */
 393         if (OutputBuffer->Count != 4) break;
 394
 395         /* HotPlug PCI Support not yet implemented */
 396         UNIMPLEMENTED;
 397         while (TRUE);
 398     } while (FALSE);
 399
 400     /* Free the buffer and return */
 401     ExFreePoolWithTag(OutputBuffer, 0);
 402 }
 403
 404 VOID
 405 NTAPI
 406 PciInitializeFdoExtensionCommonFields(PPCI_FDO_EXTENSION FdoExtension,
 407                                       IN PDEVICE_OBJECT DeviceObject,
 408                                       IN PDEVICE_OBJECT PhysicalDeviceObject)
 409 {
 410     /* Initialize the extension */
 411     RtlZeroMemory(FdoExtension, sizeof(PCI_FDO_EXTENSION));
 412
 413     /* Setup the common fields */
 414     FdoExtension->PhysicalDeviceObject = PhysicalDeviceObject;
 415     FdoExtension->FunctionalDeviceObject = DeviceObject;
 416     FdoExtension->ExtensionType = PciFdoExtensionType;
 417     FdoExtension->PowerState.CurrentSystemState = PowerSystemWorking;
 418     FdoExtension->PowerState.CurrentDeviceState = PowerDeviceD0;
 419     FdoExtension->IrpDispatchTable = &PciFdoDispatchTable;
 420
 421     /* Initialize the extension locks */
 422     KeInitializeEvent(&FdoExtension->SecondaryExtLock, SynchronizationEvent, TRUE);
 423     KeInitializeEvent(&FdoExtension->ChildListLock, SynchronizationEvent, TRUE);
 424
 425     /* Initialize the default state */
 426     PciInitializeState(FdoExtension);
 427 }
 428
 429 NTSTATUS
 430 NTAPI
 431 PciAddDevice(IN PDRIVER_OBJECT DriverObject,
 432              IN PDEVICE_OBJECT PhysicalDeviceObject)
 433 {
 434     PCM_RESOURCE_LIST Descriptor;
 435     PDEVICE_OBJECT AttachedTo;
 436     PPCI_FDO_EXTENSION FdoExtension;
 437     PPCI_FDO_EXTENSION ParentExtension;
 438     PPCI_PDO_EXTENSION PdoExtension;
 439     PDEVICE_OBJECT DeviceObject;
 440     UCHAR Buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
 441     PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)Buffer;
 442     NTSTATUS Status;
 443     HANDLE KeyHandle;
 444     UNICODE_STRING ValueName;
 445     ULONG ResultLength;
 446     PAGED_CODE();
 447     DPRINT1("PCI - AddDevice (a new bus). PDO: %p (Driver: %wZ)\n",
 448             PhysicalDeviceObject, &PhysicalDeviceObject->DriverObject->DriverName);
 449
 450     /* Zero out variables so failure path knows what to do */
 451     AttachedTo = NULL;
 452     FdoExtension = NULL;
 453     PdoExtension = NULL;
 454     do
 455     {
 456         /* Check if there's already a device extension for this bus */
 457         ParentExtension = PciFindParentPciFdoExtension(PhysicalDeviceObject,
 458                                                        &PciGlobalLock);
 459         if (ParentExtension)
 460         {
 461             /* Make sure we find a real PDO */
 462             PdoExtension = PhysicalDeviceObject->DeviceExtension;
 463             ASSERT_PDO(PdoExtension);
 464
 465             /* Make sure it's a PCI-to-PCI bridge */
 466             if ((PdoExtension->BaseClass != PCI_CLASS_BRIDGE_DEV) ||
 467                 (PdoExtension->SubClass != PCI_SUBCLASS_BR_PCI_TO_PCI))
 468             {
 469                 /* This should never happen */
 470                 DPRINT1("PCI - PciAddDevice for Non-Root/Non-PCI-PCI bridge,\n"
 471                         "      Class %02x, SubClass %02x, will not add.\n",
 472                         PdoExtension->BaseClass,
 473                         PdoExtension->SubClass);
 474                 ASSERT((PdoExtension->BaseClass == PCI_CLASS_BRIDGE_DEV) &&
 475                        (PdoExtension->SubClass == PCI_SUBCLASS_BR_PCI_TO_PCI));
 476
 477                 /* Enter the failure path */
 478                 Status = STATUS_INVALID_DEVICE_REQUEST;
 479                 break;
 480             }
 481
 482             /* Subordinate bus on the bridge */
 483             DPRINT1("PCI - AddDevice (new bus is child of bus 0x%x).\n",
 484                     ParentExtension->BaseBus);
 485
 486             /* Make sure PCI bus numbers are configured */
 487             if (!PciAreBusNumbersConfigured(PdoExtension))
 488             {
 489                 /* This is a critical failure */
 490                 DPRINT1("PCI - Bus numbers not configured for bridge (0x%x.0x%x.0x%x)\n",
 491                         ParentExtension->BaseBus,
 492                         PdoExtension->Slot.u.bits.DeviceNumber,
 493                         PdoExtension->Slot.u.bits.FunctionNumber);
 494
 495                 /* Enter the failure path */
 496                 Status = STATUS_INVALID_DEVICE_REQUEST;
 497                 break;
 498             }
 499         }
 500
 501         /* Create the FDO for the bus */
 502         Status = IoCreateDevice(DriverObject,
 503                                 sizeof(PCI_FDO_EXTENSION),
 504                                 NULL,
 505                                 FILE_DEVICE_BUS_EXTENDER,
 506                                 0,
 507                                 0,
 508                                 &DeviceObject);
 509         if (!NT_SUCCESS(Status)) break;
 510
 511         /* Initialize the extension for the FDO */
 512         FdoExtension = DeviceObject->DeviceExtension;
 513         PciInitializeFdoExtensionCommonFields(DeviceObject->DeviceExtension,
 514                                               DeviceObject,
 515                                               PhysicalDeviceObject);
 516
 517         /* Attach to the root PDO */
 518         Status = STATUS_NO_SUCH_DEVICE;
 519         AttachedTo = IoAttachDeviceToDeviceStack(DeviceObject,
 520                                                  PhysicalDeviceObject);
 521         ASSERT(AttachedTo != NULL);
 522         if (!AttachedTo) break;
 523         FdoExtension->AttachedDeviceObject = AttachedTo;
 524
 525         /* Check if this is a child bus, or the root */
 526         if (ParentExtension)
 527         {
 528             /* The child inherits root data */
 529             FdoExtension->BaseBus = PdoExtension->Dependent.type1.SecondaryBus;
 530             FdoExtension->BusRootFdoExtension = ParentExtension->BusRootFdoExtension;
 531             PdoExtension->BridgeFdoExtension = FdoExtension;
 532             FdoExtension->ParentFdoExtension = ParentExtension;
 533         }
 534         else
 535         {
 536             /* Query the boot configuration */
 537             Status = PciGetDeviceProperty(PhysicalDeviceObject,
 538                                           DevicePropertyBootConfiguration,
 539                                           (PVOID*)&Descriptor);
 540             if (!NT_SUCCESS(Status))
 541             {
 542                 /* No configuration has been set */
 543                 Descriptor = NULL;
 544             }
 545             else
 546             {
 547                 /* Root PDO in ReactOS does not assign boot resources */
 548                 UNIMPLEMENTED;
 549 //                while (TRUE);
 550                 DPRINT1("Encountered during setup\n");
 551                 Descriptor = NULL;
 552             }
 553
 554             if (Descriptor)
 555             {
 556                 /* Root PDO in ReactOS does not assign boot resources */
 557                 UNIMPLEMENTED;
 558                 while (TRUE);
 559             }
 560             else
 561             {
 562                 /* Default configuration isn't the normal path on Windows */
 563                 if (PciBreakOnDefault)
 564                 {
 565                     /* If a second bus is found and there's still no data, crash */
 566                     KeBugCheckEx(PCI_BUS_DRIVER_INTERNAL,
 567                                  0xDEAD0010u,
 568                                  (ULONG_PTR)DeviceObject,
 569                                  0,
 570                                  0);
 571                 }
 572
 573                 /* Warn that a default configuration will be used, and set bus 0 */
 574                 DPRINT1("PCI   Will use default configuration.\n");
 575                 PciBreakOnDefault = TRUE;
 576                 FdoExtension->BaseBus = 0;
 577             }
 578
 579             /* This is the root bus */
 580             FdoExtension->BusRootFdoExtension = FdoExtension;
 581         }
 582
 583         /* Get the HAL or ACPI Bus Handler Callbacks for Configuration Access */
 584         Status = PciGetConfigHandlers(FdoExtension);
 585         if (!NT_SUCCESS(Status)) break;
 586
 587         /* Initialize all the supported PCI arbiters */
 588         Status = PciInitializeArbiters(FdoExtension);
 589         if (!NT_SUCCESS(Status)) break;
 590
 591         /* This is a real FDO, insert it into the list */
 592         FdoExtension->Fake = FALSE;
 593         PciInsertEntryAtTail(&PciFdoExtensionListHead,
 594                              FdoExtension,
 595                              &PciGlobalLock);
 596
 597         /* Open the device registry key so that we can query the errata flags */
 598         IoOpenDeviceRegistryKey(DeviceObject,
 599                                 PLUGPLAY_REGKEY_DEVICE,
 600                                 KEY_ALL_ACCESS,
 601                                 &KeyHandle),
 602
 603         /* Open the value that contains errata flags for this bus instance */
 604         RtlInitUnicodeString(&ValueName, L"HackFlags");
 605         Status = ZwQueryValueKey(KeyHandle,
 606                                  &ValueName,
 607                                  KeyValuePartialInformation,
 608                                  ValueInfo,
 609                                  sizeof(Buffer),
 610                                  &ResultLength);
 611         ZwClose(KeyHandle);
 612         if (NT_SUCCESS(Status))
 613         {
 614             /* Make sure the data is of expected type and size */
 615             if ((ValueInfo->Type == REG_DWORD) &&
 616                 (ValueInfo->DataLength == sizeof(ULONG)))
 617             {
 618                 /* Read the flags for this bus */
 619                 FdoExtension->BusHackFlags = *(PULONG)&ValueInfo->Data;
 620             }
 621         }
 622
 623         /* Query ACPI for PCI HotPlug Support */
 624         PciGetHotPlugParameters(FdoExtension);
 625
 626         /* The Bus FDO is now initialized */
 627         DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 628         return STATUS_SUCCESS;
 629     } while (FALSE);
 630
 631     /* This is the failure path */
 632     ASSERT(!NT_SUCCESS(Status));
 633
 634     /* Check if the FDO extension exists */
 635     if (FdoExtension) DPRINT1("Should destroy secondaries\n");
 636
 637     /* Delete device objects */
 638     if (AttachedTo) IoDetachDevice(AttachedTo);
 639     if (DeviceObject) IoDeleteDevice(DeviceObject);
 640     return Status;
 641 }
 642
 643 /* EOF */