[HAL]: Use Bus Handlers for HalpAssignSlotResources. Warn that current PCI Slot assig...
[reactos.git] / reactos / hal / halx86 / generic / legacy / bus / pcibus.c
1 /*
2 * PROJECT: ReactOS HAL
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: hal/halx86/generic/bus/pcibus.c
5 * PURPOSE: PCI Bus Support (Configuration Space, Resource Allocation)
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include <hal.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* GLOBALS *******************************************************************/
16
17 ULONG HalpBusType;
18
19 PCI_TYPE1_CFG_CYCLE_BITS HalpPciDebuggingDevice[2] = {{{{0}}}};
20
21 BOOLEAN HalpPCIConfigInitialized;
22 ULONG HalpMinPciBus, HalpMaxPciBus;
23 KSPIN_LOCK HalpPCIConfigLock;
24 PCI_CONFIG_HANDLER PCIConfigHandler;
25
26 /* PCI Operation Matrix */
27 UCHAR PCIDeref[4][4] =
28 {
29 {0, 1, 2, 2}, // ULONG-aligned offset
30 {1, 1, 1, 1}, // UCHAR-aligned offset
31 {2, 1, 2, 2}, // USHORT-aligned offset
32 {1, 1, 1, 1} // UCHAR-aligned offset
33 };
34
35 /* Type 1 PCI Bus */
36 PCI_CONFIG_HANDLER PCIConfigHandlerType1 =
37 {
38 /* Synchronization */
39 (FncSync)HalpPCISynchronizeType1,
40 (FncReleaseSync)HalpPCIReleaseSynchronzationType1,
41
42 /* Read */
43 {
44 (FncConfigIO)HalpPCIReadUlongType1,
45 (FncConfigIO)HalpPCIReadUcharType1,
46 (FncConfigIO)HalpPCIReadUshortType1
47 },
48
49 /* Write */
50 {
51 (FncConfigIO)HalpPCIWriteUlongType1,
52 (FncConfigIO)HalpPCIWriteUcharType1,
53 (FncConfigIO)HalpPCIWriteUshortType1
54 }
55 };
56
57 /* Type 2 PCI Bus */
58 PCI_CONFIG_HANDLER PCIConfigHandlerType2 =
59 {
60 /* Synchronization */
61 (FncSync)HalpPCISynchronizeType2,
62 (FncReleaseSync)HalpPCIReleaseSynchronizationType2,
63
64 /* Read */
65 {
66 (FncConfigIO)HalpPCIReadUlongType2,
67 (FncConfigIO)HalpPCIReadUcharType2,
68 (FncConfigIO)HalpPCIReadUshortType2
69 },
70
71 /* Write */
72 {
73 (FncConfigIO)HalpPCIWriteUlongType2,
74 (FncConfigIO)HalpPCIWriteUcharType2,
75 (FncConfigIO)HalpPCIWriteUshortType2
76 }
77 };
78
79 PCIPBUSDATA HalpFakePciBusData =
80 {
81 {
82 PCI_DATA_TAG,
83 PCI_DATA_VERSION,
84 HalpReadPCIConfig,
85 HalpWritePCIConfig,
86 NULL,
87 NULL,
88 {{{0, 0, 0}}},
89 {0, 0, 0, 0}
90 },
91 {{0, 0}},
92 32,
93 };
94
95 BUS_HANDLER HalpFakePciBusHandler =
96 {
97 1,
98 PCIBus,
99 PCIConfiguration,
100 0,
101 NULL,
102 NULL,
103 &HalpFakePciBusData,
104 0,
105 NULL,
106 {0, 0, 0, 0},
107 (PGETSETBUSDATA)HalpGetPCIData,
108 (PGETSETBUSDATA)HalpSetPCIData,
109 NULL,
110 HalpAssignPCISlotResources,
111 NULL,
112 NULL
113 };
114
115 /* TYPE 1 FUNCTIONS **********************************************************/
116
117 VOID
118 NTAPI
119 HalpPCISynchronizeType1(IN PBUS_HANDLER BusHandler,
120 IN PCI_SLOT_NUMBER Slot,
121 IN PKIRQL Irql,
122 IN PPCI_TYPE1_CFG_BITS PciCfg1)
123 {
124 /* Setup the PCI Configuration Register */
125 PciCfg1->u.AsULONG = 0;
126 PciCfg1->u.bits.BusNumber = BusHandler->BusNumber;
127 PciCfg1->u.bits.DeviceNumber = Slot.u.bits.DeviceNumber;
128 PciCfg1->u.bits.FunctionNumber = Slot.u.bits.FunctionNumber;
129 PciCfg1->u.bits.Enable = TRUE;
130
131 /* Acquire the lock */
132 KeRaiseIrql(HIGH_LEVEL, Irql);
133 KiAcquireSpinLock(&HalpPCIConfigLock);
134 }
135
136 VOID
137 NTAPI
138 HalpPCIReleaseSynchronzationType1(IN PBUS_HANDLER BusHandler,
139 IN KIRQL Irql)
140 {
141 PCI_TYPE1_CFG_BITS PciCfg1;
142
143 /* Clear the PCI Configuration Register */
144 PciCfg1.u.AsULONG = 0;
145 WRITE_PORT_ULONG(((PPCIPBUSDATA)BusHandler->BusData)->Config.Type1.Address,
146 PciCfg1.u.AsULONG);
147
148 /* Release the lock */
149 KiReleaseSpinLock(&HalpPCIConfigLock);
150 KeLowerIrql(Irql);
151 }
152
153 TYPE1_READ(HalpPCIReadUcharType1, UCHAR)
154 TYPE1_READ(HalpPCIReadUshortType1, USHORT)
155 TYPE1_READ(HalpPCIReadUlongType1, ULONG)
156 TYPE1_WRITE(HalpPCIWriteUcharType1, UCHAR)
157 TYPE1_WRITE(HalpPCIWriteUshortType1, USHORT)
158 TYPE1_WRITE(HalpPCIWriteUlongType1, ULONG)
159
160 /* TYPE 2 FUNCTIONS **********************************************************/
161
162 VOID
163 NTAPI
164 HalpPCISynchronizeType2(IN PBUS_HANDLER BusHandler,
165 IN PCI_SLOT_NUMBER Slot,
166 IN PKIRQL Irql,
167 IN PPCI_TYPE2_ADDRESS_BITS PciCfg)
168 {
169 PCI_TYPE2_CSE_BITS PciCfg2Cse;
170 PPCIPBUSDATA BusData = (PPCIPBUSDATA)BusHandler->BusData;
171
172 /* Setup the configuration register */
173 PciCfg->u.AsUSHORT = 0;
174 PciCfg->u.bits.Agent = (USHORT)Slot.u.bits.DeviceNumber;
175 PciCfg->u.bits.AddressBase = (USHORT)BusData->Config.Type2.Base;
176
177 /* Acquire the lock */
178 KeRaiseIrql(HIGH_LEVEL, Irql);
179 KiAcquireSpinLock(&HalpPCIConfigLock);
180
181 /* Setup the CSE Register */
182 PciCfg2Cse.u.AsUCHAR = 0;
183 PciCfg2Cse.u.bits.Enable = TRUE;
184 PciCfg2Cse.u.bits.FunctionNumber = (UCHAR)Slot.u.bits.FunctionNumber;
185 PciCfg2Cse.u.bits.Key = -1;
186
187 /* Write the bus number and CSE */
188 WRITE_PORT_UCHAR(BusData->Config.Type2.Forward,
189 (UCHAR)BusHandler->BusNumber);
190 WRITE_PORT_UCHAR(BusData->Config.Type2.CSE, PciCfg2Cse.u.AsUCHAR);
191 }
192
193 VOID
194 NTAPI
195 HalpPCIReleaseSynchronizationType2(IN PBUS_HANDLER BusHandler,
196 IN KIRQL Irql)
197 {
198 PCI_TYPE2_CSE_BITS PciCfg2Cse;
199 PPCIPBUSDATA BusData = (PPCIPBUSDATA)BusHandler->BusData;
200
201 /* Clear CSE and bus number */
202 PciCfg2Cse.u.AsUCHAR = 0;
203 WRITE_PORT_UCHAR(BusData->Config.Type2.CSE, PciCfg2Cse.u.AsUCHAR);
204 WRITE_PORT_UCHAR(BusData->Config.Type2.Forward, 0);
205
206 /* Release the lock */
207 KiReleaseSpinLock(&HalpPCIConfigLock);
208 KeLowerIrql(Irql);
209 }
210
211 TYPE2_READ(HalpPCIReadUcharType2, UCHAR)
212 TYPE2_READ(HalpPCIReadUshortType2, USHORT)
213 TYPE2_READ(HalpPCIReadUlongType2, ULONG)
214 TYPE2_WRITE(HalpPCIWriteUcharType2, UCHAR)
215 TYPE2_WRITE(HalpPCIWriteUshortType2, USHORT)
216 TYPE2_WRITE(HalpPCIWriteUlongType2, ULONG)
217
218 /* PCI CONFIGURATION SPACE ***************************************************/
219
220 VOID
221 NTAPI
222 HalpPCIConfig(IN PBUS_HANDLER BusHandler,
223 IN PCI_SLOT_NUMBER Slot,
224 IN PUCHAR Buffer,
225 IN ULONG Offset,
226 IN ULONG Length,
227 IN FncConfigIO *ConfigIO)
228 {
229 KIRQL OldIrql;
230 ULONG i;
231 UCHAR State[20];
232
233 /* Synchronize the operation */
234 PCIConfigHandler.Synchronize(BusHandler, Slot, &OldIrql, State);
235
236 /* Loop every increment */
237 while (Length)
238 {
239 /* Find out the type of read/write we need to do */
240 i = PCIDeref[Offset % sizeof(ULONG)][Length % sizeof(ULONG)];
241
242 /* Do the read/write and return the number of bytes */
243 i = ConfigIO[i]((PPCIPBUSDATA)BusHandler->BusData,
244 State,
245 Buffer,
246 Offset);
247
248 /* Increment the buffer position and offset, and decrease the length */
249 Offset += i;
250 Buffer += i;
251 Length -= i;
252 }
253
254 /* Release the lock and PCI bus */
255 PCIConfigHandler.ReleaseSynchronzation(BusHandler, OldIrql);
256 }
257
258 VOID
259 NTAPI
260 HalpReadPCIConfig(IN PBUS_HANDLER BusHandler,
261 IN PCI_SLOT_NUMBER Slot,
262 IN PVOID Buffer,
263 IN ULONG Offset,
264 IN ULONG Length)
265 {
266 /* Validate the PCI Slot */
267 if (!HalpValidPCISlot(BusHandler, Slot))
268 {
269 /* Fill the buffer with invalid data */
270 RtlFillMemory(Buffer, Length, -1);
271 }
272 else
273 {
274 /* Send the request */
275 HalpPCIConfig(BusHandler,
276 Slot,
277 Buffer,
278 Offset,
279 Length,
280 PCIConfigHandler.ConfigRead);
281 }
282 }
283
284 VOID
285 NTAPI
286 HalpWritePCIConfig(IN PBUS_HANDLER BusHandler,
287 IN PCI_SLOT_NUMBER Slot,
288 IN PVOID Buffer,
289 IN ULONG Offset,
290 IN ULONG Length)
291 {
292 /* Validate the PCI Slot */
293 if (HalpValidPCISlot(BusHandler, Slot))
294 {
295 /* Send the request */
296 HalpPCIConfig(BusHandler,
297 Slot,
298 Buffer,
299 Offset,
300 Length,
301 PCIConfigHandler.ConfigWrite);
302 }
303 }
304
305 BOOLEAN
306 NTAPI
307 HalpValidPCISlot(IN PBUS_HANDLER BusHandler,
308 IN PCI_SLOT_NUMBER Slot)
309 {
310 PCI_SLOT_NUMBER MultiSlot;
311 PPCIPBUSDATA BusData = (PPCIPBUSDATA)BusHandler->BusData;
312 UCHAR HeaderType;
313 ULONG Device;
314
315 /* Simple validation */
316 if (Slot.u.bits.Reserved) return FALSE;
317 if (Slot.u.bits.DeviceNumber >= BusData->MaxDevice) return FALSE;
318
319 /* Function 0 doesn't need checking */
320 if (!Slot.u.bits.FunctionNumber) return TRUE;
321
322 /* Functions 0+ need Multi-Function support, so check the slot */
323 Device = Slot.u.bits.DeviceNumber;
324 MultiSlot = Slot;
325 MultiSlot.u.bits.FunctionNumber = 0;
326
327 /* Send function 0 request to get the header back */
328 HalpReadPCIConfig(BusHandler,
329 MultiSlot,
330 &HeaderType,
331 FIELD_OFFSET(PCI_COMMON_CONFIG, HeaderType),
332 sizeof(UCHAR));
333
334 /* Now make sure the header is multi-function */
335 if (!(HeaderType & PCI_MULTIFUNCTION) || (HeaderType == 0xFF)) return FALSE;
336 return TRUE;
337 }
338
339 /* HAL PCI CALLBACKS *********************************************************/
340
341 ULONG
342 NTAPI
343 HalpGetPCIData(IN PBUS_HANDLER BusHandler,
344 IN PBUS_HANDLER RootHandler,
345 IN PCI_SLOT_NUMBER Slot,
346 IN PVOID Buffer,
347 IN ULONG Offset,
348 IN ULONG Length)
349 {
350 UCHAR PciBuffer[PCI_COMMON_HDR_LENGTH];
351 PPCI_COMMON_CONFIG PciConfig = (PPCI_COMMON_CONFIG)PciBuffer;
352 ULONG Len = 0;
353
354 #ifdef SARCH_XBOX
355 /* Trying to get PCI config data from devices 0:0:1 and 0:0:2 will completely
356 * hang the Xbox. Also, the device number doesn't seem to be decoded for the
357 * video card, so it appears to be present on 1:0:0 - 1:31:0.
358 * We hack around these problems by indicating "device not present" for devices
359 * 0:0:1, 0:0:2, 1:1:0, 1:2:0, 1:3:0, ...., 1:31:0 */
360 if ((0 == BusHandler->BusNumber && 0 == Slot.u.bits.DeviceNumber &&
361 (1 == Slot.u.bits.FunctionNumber || 2 == Slot.u.bits.FunctionNumber)) ||
362 (1 == BusHandler->BusNumber && 0 != Slot.u.bits.DeviceNumber))
363 {
364 DPRINT("Blacklisted PCI slot\n");
365 if (0 == Offset && sizeof(USHORT) <= Length)
366 {
367 *(PUSHORT)Buffer = PCI_INVALID_VENDORID;
368 return sizeof(USHORT);
369 }
370 return 0;
371 }
372 #endif
373
374 /* Normalize the length */
375 if (Length > sizeof(PCI_COMMON_CONFIG)) Length = sizeof(PCI_COMMON_CONFIG);
376
377 /* Check if this is a vendor-specific read */
378 if (Offset >= PCI_COMMON_HDR_LENGTH)
379 {
380 /* Read the header */
381 HalpReadPCIConfig(BusHandler, Slot, PciConfig, 0, sizeof(ULONG));
382
383 /* Make sure the vendor is valid */
384 if (PciConfig->VendorID == PCI_INVALID_VENDORID) return 0;
385 }
386 else
387 {
388 /* Read the entire header */
389 Len = PCI_COMMON_HDR_LENGTH;
390 HalpReadPCIConfig(BusHandler, Slot, PciConfig, 0, Len);
391
392 /* Validate the vendor ID */
393 if (PciConfig->VendorID == PCI_INVALID_VENDORID)
394 {
395 /* It's invalid, but we want to return this much */
396 Len = sizeof(USHORT);
397 }
398
399 /* Now check if there's space left */
400 if (Len < Offset) return 0;
401
402 /* There is, so return what's after the offset and normalize */
403 Len -= Offset;
404 if (Len > Length) Len = Length;
405
406 /* Copy the data into the caller's buffer */
407 RtlMoveMemory(Buffer, PciBuffer + Offset, Len);
408
409 /* Update buffer and offset, decrement total length */
410 Offset += Len;
411 Buffer = (PVOID)((ULONG_PTR)Buffer + Len);
412 Length -= Len;
413 }
414
415 /* Now we still have something to copy */
416 if (Length)
417 {
418 /* Check if it's vendor-specific data */
419 if (Offset >= PCI_COMMON_HDR_LENGTH)
420 {
421 /* Read it now */
422 HalpReadPCIConfig(BusHandler, Slot, Buffer, Offset, Length);
423 Len += Length;
424 }
425 }
426
427 /* Update the total length read */
428 return Len;
429 }
430
431 ULONG
432 NTAPI
433 HalpSetPCIData(IN PBUS_HANDLER BusHandler,
434 IN PBUS_HANDLER RootHandler,
435 IN PCI_SLOT_NUMBER Slot,
436 IN PVOID Buffer,
437 IN ULONG Offset,
438 IN ULONG Length)
439 {
440 UCHAR PciBuffer[PCI_COMMON_HDR_LENGTH];
441 PPCI_COMMON_CONFIG PciConfig = (PPCI_COMMON_CONFIG)PciBuffer;
442 ULONG Len = 0;
443
444 #ifdef SARCH_XBOX
445 /* Trying to get PCI config data from devices 0:0:1 and 0:0:2 will completely
446 * hang the Xbox. Also, the device number doesn't seem to be decoded for the
447 * video card, so it appears to be present on 1:0:0 - 1:31:0.
448 * We hack around these problems by indicating "device not present" for devices
449 * 0:0:1, 0:0:2, 1:1:0, 1:2:0, 1:3:0, ...., 1:31:0 */
450 if ((0 == BusHandler->BusNumber && 0 == Slot.u.bits.DeviceNumber &&
451 (1 == Slot.u.bits.FunctionNumber || 2 == Slot.u.bits.FunctionNumber)) ||
452 (1 == BusHandler->BusNumber && 0 != Slot.u.bits.DeviceNumber))
453 {
454 DPRINT1("Trying to set data on blacklisted PCI slot\n");
455 return 0;
456 }
457 #endif
458
459 /* Normalize the length */
460 if (Length > sizeof(PCI_COMMON_CONFIG)) Length = sizeof(PCI_COMMON_CONFIG);
461
462 /* Check if this is a vendor-specific read */
463 if (Offset >= PCI_COMMON_HDR_LENGTH)
464 {
465 /* Read the header */
466 HalpReadPCIConfig(BusHandler, Slot, PciConfig, 0, sizeof(ULONG));
467
468 /* Make sure the vendor is valid */
469 if (PciConfig->VendorID == PCI_INVALID_VENDORID) return 0;
470 }
471 else
472 {
473 /* Read the entire header and validate the vendor ID */
474 Len = PCI_COMMON_HDR_LENGTH;
475 HalpReadPCIConfig(BusHandler, Slot, PciConfig, 0, Len);
476 if (PciConfig->VendorID == PCI_INVALID_VENDORID) return 0;
477
478 /* Return what's after the offset and normalize */
479 Len -= Offset;
480 if (Len > Length) Len = Length;
481
482 /* Copy the specific caller data */
483 RtlMoveMemory(PciBuffer + Offset, Buffer, Len);
484
485 /* Write the actual configuration data */
486 HalpWritePCIConfig(BusHandler, Slot, PciBuffer + Offset, Offset, Len);
487
488 /* Update buffer and offset, decrement total length */
489 Offset += Len;
490 Buffer = (PVOID)((ULONG_PTR)Buffer + Len);
491 Length -= Len;
492 }
493
494 /* Now we still have something to copy */
495 if (Length)
496 {
497 /* Check if it's vendor-specific data */
498 if (Offset >= PCI_COMMON_HDR_LENGTH)
499 {
500 /* Read it now */
501 HalpWritePCIConfig(BusHandler, Slot, Buffer, Offset, Length);
502 Len += Length;
503 }
504 }
505
506 /* Update the total length read */
507 return Len;
508 }
509
510 ULONG
511 NTAPI
512 HalpGetPCIIntOnISABus(IN PBUS_HANDLER BusHandler,
513 IN PBUS_HANDLER RootHandler,
514 IN ULONG BusInterruptLevel,
515 IN ULONG BusInterruptVector,
516 OUT PKIRQL Irql,
517 OUT PKAFFINITY Affinity)
518 {
519 /* Validate the level first */
520 if (BusInterruptLevel < 1) return 0;
521
522 /* PCI has its IRQs on top of ISA IRQs, so pass it on to the ISA handler */
523 return HalGetInterruptVector(Isa,
524 0,
525 BusInterruptLevel,
526 0,
527 Irql,
528 Affinity);
529 }
530
531 VOID
532 NTAPI
533 HalpPCIPin2ISALine(IN PBUS_HANDLER BusHandler,
534 IN PBUS_HANDLER RootHandler,
535 IN PCI_SLOT_NUMBER SlotNumber,
536 IN PPCI_COMMON_CONFIG PciData)
537 {
538 UNIMPLEMENTED;
539 while (TRUE);
540 }
541
542 VOID
543 NTAPI
544 HalpPCIISALine2Pin(IN PBUS_HANDLER BusHandler,
545 IN PBUS_HANDLER RootHandler,
546 IN PCI_SLOT_NUMBER SlotNumber,
547 IN PPCI_COMMON_CONFIG PciNewData,
548 IN PPCI_COMMON_CONFIG PciOldData)
549 {
550 UNIMPLEMENTED;
551 while (TRUE);
552 }
553
554 NTSTATUS
555 NTAPI
556 HalpGetISAFixedPCIIrq(IN PBUS_HANDLER BusHandler,
557 IN PBUS_HANDLER RootHandler,
558 IN PCI_SLOT_NUMBER PciSlot,
559 OUT PSUPPORTED_RANGE *Range)
560 {
561 UNIMPLEMENTED;
562 while (TRUE);
563 return STATUS_SUCCESS;
564 }
565
566 NTSTATUS
567 NTAPI
568 HalpSetupPciDeviceForDebugging(IN PVOID LoaderBlock,
569 IN OUT PDEBUG_DEVICE_DESCRIPTOR PciDevice)
570 {
571 DPRINT1("Unimplemented!\n");
572 return STATUS_NOT_IMPLEMENTED;
573 }
574
575 NTSTATUS
576 NTAPI
577 HalpReleasePciDeviceForDebugging(IN OUT PDEBUG_DEVICE_DESCRIPTOR PciDevice)
578 {
579 DPRINT1("Unimplemented!\n");
580 return STATUS_NOT_IMPLEMENTED;
581 }
582
583 VOID
584 NTAPI
585 HalpRegisterPciDebuggingDeviceInfo(VOID)
586 {
587 BOOLEAN Found = FALSE;
588 ULONG i;
589 PAGED_CODE();
590
591 /* Loop PCI debugging devices */
592 for (i = 0; i < 2; i++)
593 {
594 /* Reserved bit is set if we found one */
595 if (HalpPciDebuggingDevice[i].u.bits.Reserved1)
596 {
597 Found = TRUE;
598 break;
599 }
600 }
601
602 /* Bail out if there aren't any */
603 if (!Found) return;
604
605 /* FIXME: TODO */
606 DPRINT1("You have implemented the KD routines for searching PCI debugger"
607 "devices, but you have forgotten to implement this routine\n");
608 while (TRUE);
609 }
610
611 static ULONG NTAPI
612 PciSize(ULONG Base, ULONG Mask)
613 {
614 ULONG Size = Mask & Base; /* Find the significant bits */
615 Size = Size & ~(Size - 1); /* Get the lowest of them to find the decode size */
616 return Size;
617 }
618
619 NTSTATUS
620 NTAPI
621 HalpAdjustPCIResourceList(IN PBUS_HANDLER BusHandler,
622 IN PBUS_HANDLER RootHandler,
623 IN OUT PIO_RESOURCE_REQUIREMENTS_LIST *pResourceList)
624 {
625 /* Not yet supported */
626 DbgPrint("HAL: PCI Resource List Adjustment not implemented!");
627 while (TRUE);
628 return STATUS_UNSUCCESSFUL;
629 }
630
631 NTSTATUS
632 NTAPI
633 HalpAssignPCISlotResources(IN PBUS_HANDLER BusHandler,
634 IN PBUS_HANDLER RootHandler,
635 IN PUNICODE_STRING RegistryPath,
636 IN PUNICODE_STRING DriverClassName OPTIONAL,
637 IN PDRIVER_OBJECT DriverObject,
638 IN PDEVICE_OBJECT DeviceObject OPTIONAL,
639 IN ULONG Slot,
640 IN OUT PCM_RESOURCE_LIST *AllocatedResources)
641 {
642 PCI_COMMON_CONFIG PciConfig;
643 SIZE_T Address;
644 SIZE_T ResourceCount;
645 ULONG Size[PCI_TYPE0_ADDRESSES];
646 NTSTATUS Status = STATUS_SUCCESS;
647 UCHAR Offset;
648 PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
649 PCI_SLOT_NUMBER SlotNumber;
650 ULONG WriteBuffer;
651 DPRINT1("WARNING: PCI Slot Resource Assignment is FOOBAR\n");
652
653 /* FIXME: Should handle 64-bit addresses */
654
655 /* Read configuration data */
656 SlotNumber.u.AsULONG = Slot;
657 HalpReadPCIConfig(BusHandler, SlotNumber, &PciConfig, 0, PCI_COMMON_HDR_LENGTH);
658
659 /* Check if we read it correctly */
660 if (PciConfig.VendorID == PCI_INVALID_VENDORID)
661 return STATUS_NO_SUCH_DEVICE;
662
663 /* Read the PCI configuration space for the device and store base address and
664 size information in temporary storage. Count the number of valid base addresses */
665 ResourceCount = 0;
666 for (Address = 0; Address < PCI_TYPE0_ADDRESSES; Address++)
667 {
668 if (0xffffffff == PciConfig.u.type0.BaseAddresses[Address])
669 PciConfig.u.type0.BaseAddresses[Address] = 0;
670
671 /* Memory resource */
672 if (0 != PciConfig.u.type0.BaseAddresses[Address])
673 {
674 ResourceCount++;
675
676 Offset = (UCHAR)FIELD_OFFSET(PCI_COMMON_CONFIG, u.type0.BaseAddresses[Address]);
677
678 /* Write 0xFFFFFFFF there */
679 WriteBuffer = 0xffffffff;
680 HalpWritePCIConfig(BusHandler, SlotNumber, &WriteBuffer, Offset, sizeof(ULONG));
681
682 /* Read that figure back from the config space */
683 HalpReadPCIConfig(BusHandler, SlotNumber, &Size[Address], Offset, sizeof(ULONG));
684
685 /* Write back initial value */
686 HalpWritePCIConfig(BusHandler, SlotNumber, &PciConfig.u.type0.BaseAddresses[Address], Offset, sizeof(ULONG));
687 }
688 }
689
690 /* Interrupt resource */
691 if (0 != PciConfig.u.type0.InterruptLine)
692 ResourceCount++;
693
694 /* Allocate output buffer and initialize */
695 *AllocatedResources = ExAllocatePoolWithTag(
696 PagedPool,
697 sizeof(CM_RESOURCE_LIST) +
698 (ResourceCount - 1) * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR),
699 ' laH');
700
701 if (NULL == *AllocatedResources)
702 return STATUS_NO_MEMORY;
703
704 (*AllocatedResources)->Count = 1;
705 (*AllocatedResources)->List[0].InterfaceType = PCIBus;
706 (*AllocatedResources)->List[0].BusNumber = BusHandler->BusNumber;
707 (*AllocatedResources)->List[0].PartialResourceList.Version = 1;
708 (*AllocatedResources)->List[0].PartialResourceList.Revision = 1;
709 (*AllocatedResources)->List[0].PartialResourceList.Count = ResourceCount;
710 Descriptor = (*AllocatedResources)->List[0].PartialResourceList.PartialDescriptors;
711
712 /* Store configuration information */
713 for (Address = 0; Address < PCI_TYPE0_ADDRESSES; Address++)
714 {
715 if (0 != PciConfig.u.type0.BaseAddresses[Address])
716 {
717 if (PCI_ADDRESS_MEMORY_SPACE ==
718 (PciConfig.u.type0.BaseAddresses[Address] & 0x1))
719 {
720 Descriptor->Type = CmResourceTypeMemory;
721 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive; /* FIXME I have no idea... */
722 Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE; /* FIXME Just a guess */
723 Descriptor->u.Memory.Start.QuadPart = (PciConfig.u.type0.BaseAddresses[Address] & PCI_ADDRESS_MEMORY_ADDRESS_MASK);
724 Descriptor->u.Memory.Length = PciSize(Size[Address], PCI_ADDRESS_MEMORY_ADDRESS_MASK);
725 }
726 else if (PCI_ADDRESS_IO_SPACE ==
727 (PciConfig.u.type0.BaseAddresses[Address] & 0x1))
728 {
729 Descriptor->Type = CmResourceTypePort;
730 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive; /* FIXME I have no idea... */
731 Descriptor->Flags = CM_RESOURCE_PORT_IO; /* FIXME Just a guess */
732 Descriptor->u.Port.Start.QuadPart = PciConfig.u.type0.BaseAddresses[Address] &= PCI_ADDRESS_IO_ADDRESS_MASK;
733 Descriptor->u.Port.Length = PciSize(Size[Address], PCI_ADDRESS_IO_ADDRESS_MASK & 0xffff);
734 }
735 else
736 {
737 ASSERT(FALSE);
738 return STATUS_UNSUCCESSFUL;
739 }
740 Descriptor++;
741 }
742 }
743
744 if (0 != PciConfig.u.type0.InterruptLine)
745 {
746 Descriptor->Type = CmResourceTypeInterrupt;
747 Descriptor->ShareDisposition = CmResourceShareShared; /* FIXME Just a guess */
748 Descriptor->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE; /* FIXME Just a guess */
749 Descriptor->u.Interrupt.Level = PciConfig.u.type0.InterruptLine;
750 Descriptor->u.Interrupt.Vector = PciConfig.u.type0.InterruptLine;
751 Descriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
752
753 Descriptor++;
754 }
755
756 ASSERT(Descriptor == (*AllocatedResources)->List[0].PartialResourceList.PartialDescriptors + ResourceCount);
757
758 /* FIXME: Should store the resources in the registry resource map */
759
760 return Status;
761 }
762
763 ULONG
764 NTAPI
765 HaliPciInterfaceReadConfig(IN PBUS_HANDLER RootBusHandler,
766 IN ULONG BusNumber,
767 IN PCI_SLOT_NUMBER SlotNumber,
768 IN PVOID Buffer,
769 IN ULONG Offset,
770 IN ULONG Length)
771 {
772 BUS_HANDLER BusHandler;
773
774 /* Setup fake PCI Bus handler */
775 RtlCopyMemory(&BusHandler, &HalpFakePciBusHandler, sizeof(BUS_HANDLER));
776 BusHandler.BusNumber = BusNumber;
777
778 /* Read configuration data */
779 HalpReadPCIConfig(&BusHandler, SlotNumber, Buffer, Offset, Length);
780
781 /* Return length */
782 return Length;
783 }
784
785 PPCI_REGISTRY_INFO_INTERNAL
786 NTAPI
787 HalpQueryPciRegistryInfo(VOID)
788 {
789 #ifndef _MINIHAL_
790 WCHAR NameBuffer[8];
791 OBJECT_ATTRIBUTES ObjectAttributes;
792 UNICODE_STRING KeyName, ConfigName, IdentName;
793 HANDLE KeyHandle, BusKeyHandle, CardListHandle;
794 NTSTATUS Status;
795 UCHAR KeyBuffer[sizeof(CM_FULL_RESOURCE_DESCRIPTOR) + 100];
796 PKEY_VALUE_FULL_INFORMATION ValueInfo = (PVOID)KeyBuffer;
797 UCHAR PartialKeyBuffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
798 sizeof(PCI_CARD_DESCRIPTOR)];
799 PKEY_VALUE_PARTIAL_INFORMATION PartialValueInfo = (PVOID)PartialKeyBuffer;
800 KEY_FULL_INFORMATION KeyInformation;
801 ULONG ResultLength;
802 PWSTR Tag;
803 ULONG i, ElementCount;
804 PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
805 PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
806 PPCI_REGISTRY_INFO PciRegInfo;
807 PPCI_REGISTRY_INFO_INTERNAL PciRegistryInfo;
808 PPCI_CARD_DESCRIPTOR CardDescriptor;
809
810 /* Setup the object attributes for the key */
811 RtlInitUnicodeString(&KeyName,
812 L"\\Registry\\Machine\\Hardware\\Description\\"
813 L"System\\MultiFunctionAdapter");
814 InitializeObjectAttributes(&ObjectAttributes,
815 &KeyName,
816 OBJ_CASE_INSENSITIVE,
817 NULL,
818 NULL);
819
820 /* Open the key */
821 Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
822 if (!NT_SUCCESS(Status)) return NULL;
823
824 /* Setup the receiving string */
825 KeyName.Buffer = NameBuffer;
826 KeyName.MaximumLength = sizeof(NameBuffer);
827
828 /* Setup the configuration and identifier key names */
829 RtlInitUnicodeString(&ConfigName, L"Configuration Data");
830 RtlInitUnicodeString(&IdentName, L"Identifier");
831
832 /* Keep looping for each ID */
833 for (i = 0; TRUE; i++)
834 {
835 /* Setup the key name */
836 RtlIntegerToUnicodeString(i, 10, &KeyName);
837 InitializeObjectAttributes(&ObjectAttributes,
838 &KeyName,
839 OBJ_CASE_INSENSITIVE,
840 KeyHandle,
841 NULL);
842
843 /* Open it */
844 Status = ZwOpenKey(&BusKeyHandle, KEY_READ, &ObjectAttributes);
845 if (!NT_SUCCESS(Status))
846 {
847 /* None left, fail */
848 ZwClose(KeyHandle);
849 return NULL;
850 }
851
852 /* Read the registry data */
853 Status = ZwQueryValueKey(BusKeyHandle,
854 &IdentName,
855 KeyValueFullInformation,
856 ValueInfo,
857 sizeof(KeyBuffer),
858 &ResultLength);
859 if (!NT_SUCCESS(Status))
860 {
861 /* Failed, try the next one */
862 ZwClose(BusKeyHandle);
863 continue;
864 }
865
866 /* Get the PCI Tag and validate it */
867 Tag = (PWSTR)((ULONG_PTR)ValueInfo + ValueInfo->DataOffset);
868 if ((Tag[0] != L'P') ||
869 (Tag[1] != L'C') ||
870 (Tag[2] != L'I') ||
871 (Tag[3]))
872 {
873 /* Not a valid PCI entry, skip it */
874 ZwClose(BusKeyHandle);
875 continue;
876 }
877
878 /* Now read our PCI structure */
879 Status = ZwQueryValueKey(BusKeyHandle,
880 &ConfigName,
881 KeyValueFullInformation,
882 ValueInfo,
883 sizeof(KeyBuffer),
884 &ResultLength);
885 ZwClose(BusKeyHandle);
886 if (!NT_SUCCESS(Status)) continue;
887
888 /* We read it OK! Get the actual resource descriptors */
889 FullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR)
890 ((ULONG_PTR)ValueInfo + ValueInfo->DataOffset);
891 PartialDescriptor = (PCM_PARTIAL_RESOURCE_DESCRIPTOR)
892 ((ULONG_PTR)FullDescriptor->
893 PartialResourceList.PartialDescriptors);
894
895 /* Check if this is our PCI Registry Information */
896 if (PartialDescriptor->Type == CmResourceTypeDeviceSpecific)
897 {
898 /* It is, stop searching */
899 break;
900 }
901 }
902
903 /* Close the key */
904 ZwClose(KeyHandle);
905
906 /* Save the PCI information for later */
907 PciRegInfo = (PPCI_REGISTRY_INFO)(PartialDescriptor + 1);
908
909 /* Assume no Card List entries */
910 ElementCount = 0;
911
912 /* Set up for checking the PCI Card List key */
913 RtlInitUnicodeString(&KeyName,
914 L"\\Registry\\Machine\\System\\CurrentControlSet\\"
915 L"Control\\PnP\\PCI\\CardList");
916 InitializeObjectAttributes(&ObjectAttributes,
917 &KeyName,
918 OBJ_CASE_INSENSITIVE,
919 NULL,
920 NULL);
921
922 /* Attempt to open it */
923 Status = ZwOpenKey(&CardListHandle, KEY_READ, &ObjectAttributes);
924 if (NT_SUCCESS(Status))
925 {
926 /* It exists, so let's query it */
927 Status = ZwQueryKey(CardListHandle,
928 KeyFullInformation,
929 &KeyInformation,
930 sizeof(KEY_FULL_INFORMATION),
931 &ResultLength);
932 if (!NT_SUCCESS(Status))
933 {
934 /* Failed to query, so no info */
935 PciRegistryInfo = NULL;
936 }
937 else
938 {
939 /* Allocate the full structure */
940 PciRegistryInfo =
941 ExAllocatePoolWithTag(NonPagedPool,
942 sizeof(PCI_REGISTRY_INFO_INTERNAL) +
943 (KeyInformation.Values *
944 sizeof(PCI_CARD_DESCRIPTOR)),
945 ' laH');
946 if (PciRegistryInfo)
947 {
948 /* Get the first card descriptor entry */
949 CardDescriptor = (PPCI_CARD_DESCRIPTOR)(PciRegistryInfo + 1);
950
951 /* Loop all the values */
952 for (i = 0; i < KeyInformation.Values; i++)
953 {
954 /* Attempt to get the value */
955 Status = ZwEnumerateValueKey(CardListHandle,
956 i,
957 KeyValuePartialInformation,
958 PartialValueInfo,
959 sizeof(PartialKeyBuffer),
960 &ResultLength);
961 if (!NT_SUCCESS(Status))
962 {
963 /* Something went wrong, stop the search */
964 break;
965 }
966
967 /* Make sure it is correctly sized */
968 if (PartialValueInfo->DataLength == sizeof(PCI_CARD_DESCRIPTOR))
969 {
970 /* Sure is, copy it over */
971 *CardDescriptor = *(PPCI_CARD_DESCRIPTOR)
972 PartialValueInfo->Data;
973
974 /* One more Card List entry */
975 ElementCount++;
976
977 /* Move to the next descriptor */
978 CardDescriptor = (CardDescriptor + 1);
979 }
980 }
981 }
982 }
983
984 /* Close the Card List key */
985 ZwClose(CardListHandle);
986 }
987 else
988 {
989 /* No key, no Card List */
990 PciRegistryInfo = NULL;
991 }
992
993 /* Check if we failed to get the full structure */
994 if (!PciRegistryInfo)
995 {
996 /* Just allocate the basic structure then */
997 PciRegistryInfo = ExAllocatePoolWithTag(NonPagedPool,
998 sizeof(PCI_REGISTRY_INFO_INTERNAL),
999 ' laH');
1000 if (!PciRegistryInfo) return NULL;
1001 }
1002
1003 /* Save the info we got */
1004 PciRegistryInfo->MajorRevision = PciRegInfo->MajorRevision;
1005 PciRegistryInfo->MinorRevision = PciRegInfo->MinorRevision;
1006 PciRegistryInfo->NoBuses = PciRegInfo->NoBuses;
1007 PciRegistryInfo->HardwareMechanism = PciRegInfo->HardwareMechanism;
1008 PciRegistryInfo->ElementCount = ElementCount;
1009
1010 /* Return it */
1011 return PciRegistryInfo;
1012 #else
1013 return NULL;
1014 #endif
1015 }
1016
1017 VOID
1018 NTAPI
1019 HalpInitializePciStubs(VOID)
1020 {
1021 PPCI_REGISTRY_INFO_INTERNAL PciRegistryInfo;
1022 UCHAR PciType;
1023 PPCIPBUSDATA BusData = (PPCIPBUSDATA)HalpFakePciBusHandler.BusData;
1024 ULONG i;
1025 PCI_SLOT_NUMBER j;
1026 ULONG VendorId = 0;
1027 ULONG MaxPciBusNumber;
1028
1029 /* Query registry information */
1030 PciRegistryInfo = HalpQueryPciRegistryInfo();
1031 if (!PciRegistryInfo)
1032 {
1033 /* Assume type 1 */
1034 PciType = 1;
1035
1036 /* Force a manual bus scan later */
1037 MaxPciBusNumber = MAXULONG;
1038 }
1039 else
1040 {
1041 /* Get the PCI type */
1042 PciType = PciRegistryInfo->HardwareMechanism & 0xF;
1043
1044 /* Get MaxPciBusNumber and make it 0-based */
1045 MaxPciBusNumber = PciRegistryInfo->NoBuses - 1;
1046
1047 /* Free the info structure */
1048 ExFreePool(PciRegistryInfo);
1049 }
1050
1051 /* Initialize the PCI lock */
1052 KeInitializeSpinLock(&HalpPCIConfigLock);
1053
1054 /* Check the type of PCI bus */
1055 switch (PciType)
1056 {
1057 /* Type 1 PCI Bus */
1058 case 1:
1059
1060 /* Copy the Type 1 handler data */
1061 RtlCopyMemory(&PCIConfigHandler,
1062 &PCIConfigHandlerType1,
1063 sizeof(PCIConfigHandler));
1064
1065 /* Set correct I/O Ports */
1066 BusData->Config.Type1.Address = PCI_TYPE1_ADDRESS_PORT;
1067 BusData->Config.Type1.Data = PCI_TYPE1_DATA_PORT;
1068 break;
1069
1070 /* Type 2 PCI Bus */
1071 case 2:
1072
1073 /* Copy the Type 2 handler data */
1074 RtlCopyMemory(&PCIConfigHandler,
1075 &PCIConfigHandlerType2,
1076 sizeof (PCIConfigHandler));
1077
1078 /* Set correct I/O Ports */
1079 BusData->Config.Type2.CSE = PCI_TYPE2_CSE_PORT;
1080 BusData->Config.Type2.Forward = PCI_TYPE2_FORWARD_PORT;
1081 BusData->Config.Type2.Base = PCI_TYPE2_ADDRESS_BASE;
1082
1083 /* Only 16 devices supported, not 32 */
1084 BusData->MaxDevice = 16;
1085 break;
1086
1087 default:
1088
1089 /* Invalid type */
1090 DbgPrint("HAL: Unknown PCI type\n");
1091 }
1092
1093 /* Run a forced bus scan if needed */
1094 if (MaxPciBusNumber == MAXULONG)
1095 {
1096 /* Initialize the max bus number to 0xFF */
1097 HalpMaxPciBus = 0xFF;
1098
1099 /* Initialize the counter */
1100 MaxPciBusNumber = 0;
1101
1102 /* Loop all possible buses */
1103 for (i = 0; i < HalpMaxPciBus; i++)
1104 {
1105 /* Loop all devices */
1106 for (j.u.AsULONG = 0; j.u.AsULONG < BusData->MaxDevice; j.u.AsULONG++)
1107 {
1108 /* Query the interface */
1109 if (HaliPciInterfaceReadConfig(NULL,
1110 i,
1111 j,
1112 &VendorId,
1113 0,
1114 sizeof(ULONG)))
1115 {
1116 /* Validate the vendor ID */
1117 if ((USHORT)VendorId != PCI_INVALID_VENDORID)
1118 {
1119 /* Set this as the maximum ID */
1120 MaxPciBusNumber = i;
1121 break;
1122 }
1123 }
1124 }
1125 }
1126 }
1127
1128 /* Set the real max bus number */
1129 HalpMaxPciBus = MaxPciBusNumber;
1130
1131 /* We're done */
1132 HalpPCIConfigInitialized = TRUE;
1133 }
1134
1135 /* EOF */
1136