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