Sync with trunk r62529.
[reactos.git] / drivers / bus / pci / pdo.c
1 /*
2 * PROJECT: ReactOS PCI bus driver
3 * FILE: pdo.c
4 * PURPOSE: Child device object dispatch routines
5 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
6 * UPDATE HISTORY:
7 * 10-09-2001 CSH Created
8 */
9
10 #include "pci.h"
11
12 #include <initguid.h>
13 #include <wdmguid.h>
14
15 #define NDEBUG
16 #include <debug.h>
17
18 /*** PRIVATE *****************************************************************/
19
20 static NTSTATUS
21 PdoQueryDeviceText(
22 IN PDEVICE_OBJECT DeviceObject,
23 IN PIRP Irp,
24 PIO_STACK_LOCATION IrpSp)
25 {
26 PPDO_DEVICE_EXTENSION DeviceExtension;
27 UNICODE_STRING String;
28 NTSTATUS Status;
29
30 DPRINT("Called\n");
31
32 DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
33
34 switch (IrpSp->Parameters.QueryDeviceText.DeviceTextType)
35 {
36 case DeviceTextDescription:
37 Status = PciDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
38 &DeviceExtension->DeviceDescription,
39 &String);
40
41 DPRINT("DeviceTextDescription\n");
42 Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
43 break;
44
45 case DeviceTextLocationInformation:
46 Status = PciDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
47 &DeviceExtension->DeviceLocation,
48 &String);
49
50 DPRINT("DeviceTextLocationInformation\n");
51 Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
52 break;
53
54 default:
55 Irp->IoStatus.Information = 0;
56 Status = STATUS_INVALID_PARAMETER;
57 break;
58 }
59
60 return Status;
61 }
62
63
64 static NTSTATUS
65 PdoQueryId(
66 IN PDEVICE_OBJECT DeviceObject,
67 IN PIRP Irp,
68 PIO_STACK_LOCATION IrpSp)
69 {
70 PPDO_DEVICE_EXTENSION DeviceExtension;
71 UNICODE_STRING String;
72 NTSTATUS Status;
73
74 DPRINT("Called\n");
75
76 DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
77
78 // Irp->IoStatus.Information = 0;
79
80 Status = STATUS_SUCCESS;
81
82 RtlInitUnicodeString(&String, NULL);
83
84 switch (IrpSp->Parameters.QueryId.IdType)
85 {
86 case BusQueryDeviceID:
87 Status = PciDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
88 &DeviceExtension->DeviceID,
89 &String);
90
91 DPRINT("DeviceID: %S\n", String.Buffer);
92
93 Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
94 break;
95
96 case BusQueryHardwareIDs:
97 Status = PciDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
98 &DeviceExtension->HardwareIDs,
99 &String);
100
101 Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
102 break;
103
104 case BusQueryCompatibleIDs:
105 Status = PciDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
106 &DeviceExtension->CompatibleIDs,
107 &String);
108
109 Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
110 break;
111
112 case BusQueryInstanceID:
113 Status = PciDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
114 &DeviceExtension->InstanceID,
115 &String);
116
117 DPRINT("InstanceID: %S\n", String.Buffer);
118
119 Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
120 break;
121
122 case BusQueryDeviceSerialNumber:
123 default:
124 Status = STATUS_NOT_IMPLEMENTED;
125 }
126
127 return Status;
128 }
129
130
131 static NTSTATUS
132 PdoQueryBusInformation(
133 IN PDEVICE_OBJECT DeviceObject,
134 IN PIRP Irp,
135 PIO_STACK_LOCATION IrpSp)
136 {
137 PPDO_DEVICE_EXTENSION DeviceExtension;
138 PPNP_BUS_INFORMATION BusInformation;
139
140 UNREFERENCED_PARAMETER(IrpSp);
141 DPRINT("Called\n");
142
143 DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
144 BusInformation = ExAllocatePool(PagedPool, sizeof(PNP_BUS_INFORMATION));
145 Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
146 if (BusInformation != NULL)
147 {
148 BusInformation->BusTypeGuid = GUID_BUS_TYPE_PCI;
149 BusInformation->LegacyBusType = PCIBus;
150 BusInformation->BusNumber = DeviceExtension->PciDevice->BusNumber;
151
152 return STATUS_SUCCESS;
153 }
154
155 return STATUS_INSUFFICIENT_RESOURCES;
156 }
157
158
159 static NTSTATUS
160 PdoQueryCapabilities(
161 IN PDEVICE_OBJECT DeviceObject,
162 IN PIRP Irp,
163 PIO_STACK_LOCATION IrpSp)
164 {
165 PPDO_DEVICE_EXTENSION DeviceExtension;
166 PDEVICE_CAPABILITIES DeviceCapabilities;
167 ULONG DeviceNumber, FunctionNumber;
168
169 UNREFERENCED_PARAMETER(Irp);
170 DPRINT("Called\n");
171
172 DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
173 DeviceCapabilities = IrpSp->Parameters.DeviceCapabilities.Capabilities;
174
175 if (DeviceCapabilities->Version != 1)
176 return STATUS_UNSUCCESSFUL;
177
178 DeviceNumber = DeviceExtension->PciDevice->SlotNumber.u.bits.DeviceNumber;
179 FunctionNumber = DeviceExtension->PciDevice->SlotNumber.u.bits.FunctionNumber;
180
181 DeviceCapabilities->UniqueID = FALSE;
182 DeviceCapabilities->Address = ((DeviceNumber << 16) & 0xFFFF0000) + (FunctionNumber & 0xFFFF);
183 DeviceCapabilities->UINumber = MAXULONG; /* FIXME */
184
185 return STATUS_SUCCESS;
186 }
187
188
189 static BOOLEAN
190 PdoGetRangeLength(PPDO_DEVICE_EXTENSION DeviceExtension,
191 ULONG Offset,
192 PULONG Base,
193 PULONG Length,
194 PULONG Flags)
195 {
196 ULONG OrigValue;
197 ULONG BaseValue;
198 ULONG NewValue;
199 ULONG Size;
200 ULONG XLength;
201
202 /* Save original value */
203 Size= HalGetBusDataByOffset(PCIConfiguration,
204 DeviceExtension->PciDevice->BusNumber,
205 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
206 &OrigValue,
207 Offset,
208 sizeof(ULONG));
209 if (Size != sizeof(ULONG))
210 {
211 DPRINT1("Wrong size %lu\n", Size);
212 return FALSE;
213 }
214
215 BaseValue = (OrigValue & PCI_ADDRESS_IO_SPACE)
216 ? (OrigValue & PCI_ADDRESS_IO_ADDRESS_MASK)
217 : (OrigValue & PCI_ADDRESS_MEMORY_ADDRESS_MASK);
218
219 *Base = BaseValue;
220
221 /* Set magic value */
222 NewValue = MAXULONG;
223 Size= HalSetBusDataByOffset(PCIConfiguration,
224 DeviceExtension->PciDevice->BusNumber,
225 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
226 &NewValue,
227 Offset,
228 sizeof(ULONG));
229 if (Size != sizeof(ULONG))
230 {
231 DPRINT1("Wrong size %lu\n", Size);
232 return FALSE;
233 }
234
235 /* Get the range length */
236 Size= HalGetBusDataByOffset(PCIConfiguration,
237 DeviceExtension->PciDevice->BusNumber,
238 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
239 &NewValue,
240 Offset,
241 sizeof(ULONG));
242 if (Size != sizeof(ULONG))
243 {
244 DPRINT1("Wrong size %lu\n", Size);
245 return FALSE;
246 }
247
248 /* Restore original value */
249 Size= HalSetBusDataByOffset(PCIConfiguration,
250 DeviceExtension->PciDevice->BusNumber,
251 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
252 &OrigValue,
253 Offset,
254 sizeof(ULONG));
255 if (Size != sizeof(ULONG))
256 {
257 DPRINT1("Wrong size %lu\n", Size);
258 return FALSE;
259 }
260
261 if (NewValue == 0)
262 {
263 DPRINT("Unused address register\n");
264 *Base = 0;
265 *Length = 0;
266 *Flags = 0;
267 return TRUE;
268 }
269
270 XLength = ~((NewValue & PCI_ADDRESS_IO_SPACE)
271 ? (NewValue & PCI_ADDRESS_IO_ADDRESS_MASK)
272 : (NewValue & PCI_ADDRESS_MEMORY_ADDRESS_MASK)) + 1;
273
274 #if 0
275 DbgPrint("BaseAddress 0x%08lx Length 0x%08lx",
276 BaseValue, XLength);
277
278 if (NewValue & PCI_ADDRESS_IO_SPACE)
279 {
280 DbgPrint(" IO range");
281 }
282 else
283 {
284 DbgPrint(" Memory range");
285 if ((NewValue & PCI_ADDRESS_MEMORY_TYPE_MASK) == 0)
286 {
287 DbgPrint(" in 32-Bit address space");
288 }
289 else if ((NewValue & PCI_ADDRESS_MEMORY_TYPE_MASK) == 2)
290 {
291 DbgPrint(" below 1BM ");
292 }
293 else if ((NewValue & PCI_ADDRESS_MEMORY_TYPE_MASK) == 4)
294 {
295 DbgPrint(" in 64-Bit address space");
296 }
297
298 if (NewValue & PCI_ADDRESS_MEMORY_PREFETCHABLE)
299 {
300 DbgPrint(" prefetchable");
301 }
302 }
303
304 DbgPrint("\n");
305 #endif
306
307 *Length = XLength;
308 *Flags = (NewValue & PCI_ADDRESS_IO_SPACE)
309 ? (NewValue & ~PCI_ADDRESS_IO_ADDRESS_MASK)
310 : (NewValue & ~PCI_ADDRESS_MEMORY_ADDRESS_MASK);
311
312 return TRUE;
313 }
314
315
316 static NTSTATUS
317 PdoQueryResourceRequirements(
318 IN PDEVICE_OBJECT DeviceObject,
319 IN PIRP Irp,
320 PIO_STACK_LOCATION IrpSp)
321 {
322 PPDO_DEVICE_EXTENSION DeviceExtension;
323 PCI_COMMON_CONFIG PciConfig;
324 PIO_RESOURCE_REQUIREMENTS_LIST ResourceList;
325 PIO_RESOURCE_DESCRIPTOR Descriptor;
326 ULONG Size;
327 ULONG ResCount = 0;
328 ULONG ListSize;
329 ULONG i;
330 ULONG Base;
331 ULONG Length;
332 ULONG Flags;
333
334 UNREFERENCED_PARAMETER(IrpSp);
335 DPRINT("PdoQueryResourceRequirements() called\n");
336
337 DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
338
339 /* Get PCI configuration space */
340 Size= HalGetBusData(PCIConfiguration,
341 DeviceExtension->PciDevice->BusNumber,
342 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
343 &PciConfig,
344 PCI_COMMON_HDR_LENGTH);
345 DPRINT("Size %lu\n", Size);
346 if (Size < PCI_COMMON_HDR_LENGTH)
347 {
348 Irp->IoStatus.Information = 0;
349 return STATUS_UNSUCCESSFUL;
350 }
351
352 DPRINT("Command register: 0x%04hx\n", PciConfig.Command);
353
354 /* Count required resource descriptors */
355 ResCount = 0;
356 if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_DEVICE_TYPE)
357 {
358 for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
359 {
360 if (!PdoGetRangeLength(DeviceExtension,
361 0x10 + i * 4,
362 &Base,
363 &Length,
364 &Flags))
365 break;
366
367 if (Length != 0)
368 ResCount += 2;
369 }
370
371 /* FIXME: Check ROM address */
372
373 if (PciConfig.u.type0.InterruptPin != 0)
374 ResCount++;
375 }
376 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_BRIDGE_TYPE)
377 {
378 for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
379 {
380 if (!PdoGetRangeLength(DeviceExtension,
381 0x10 + i * 4,
382 &Base,
383 &Length,
384 &Flags))
385 break;
386
387 if (Length != 0)
388 ResCount += 2;
389 }
390
391 if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
392 ResCount++;
393 }
394 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
395 {
396 /* FIXME: Count Cardbus bridge resources */
397 }
398 else
399 {
400 DPRINT1("Unsupported header type %d\n", PCI_CONFIGURATION_TYPE(&PciConfig));
401 }
402
403 if (ResCount == 0)
404 {
405 Irp->IoStatus.Information = 0;
406 return STATUS_SUCCESS;
407 }
408
409 /* Calculate the resource list size */
410 ListSize = FIELD_OFFSET(IO_RESOURCE_REQUIREMENTS_LIST, List[0].Descriptors) +
411 ResCount * sizeof(IO_RESOURCE_DESCRIPTOR);
412
413 DPRINT("ListSize %lu (0x%lx)\n", ListSize, ListSize);
414
415 /* Allocate the resource requirements list */
416 ResourceList = ExAllocatePoolWithTag(PagedPool,
417 ListSize,
418 TAG_PCI);
419 if (ResourceList == NULL)
420 {
421 Irp->IoStatus.Information = 0;
422 return STATUS_INSUFFICIENT_RESOURCES;
423 }
424
425 RtlZeroMemory(ResourceList, ListSize);
426 ResourceList->ListSize = ListSize;
427 ResourceList->InterfaceType = PCIBus;
428 ResourceList->BusNumber = DeviceExtension->PciDevice->BusNumber;
429 ResourceList->SlotNumber = DeviceExtension->PciDevice->SlotNumber.u.AsULONG;
430 ResourceList->AlternativeLists = 1;
431
432 ResourceList->List[0].Version = 1;
433 ResourceList->List[0].Revision = 1;
434 ResourceList->List[0].Count = ResCount;
435
436 Descriptor = &ResourceList->List[0].Descriptors[0];
437 if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_DEVICE_TYPE)
438 {
439 for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
440 {
441 if (!PdoGetRangeLength(DeviceExtension,
442 0x10 + i * 4,
443 &Base,
444 &Length,
445 &Flags))
446 {
447 DPRINT1("PdoGetRangeLength() failed\n");
448 break;
449 }
450
451 if (Length == 0)
452 {
453 DPRINT("Unused address register\n");
454 continue;
455 }
456
457 /* Set preferred descriptor */
458 Descriptor->Option = IO_RESOURCE_PREFERRED;
459 if (Flags & PCI_ADDRESS_IO_SPACE)
460 {
461 Descriptor->Type = CmResourceTypePort;
462 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
463 Descriptor->Flags = CM_RESOURCE_PORT_IO |
464 CM_RESOURCE_PORT_16_BIT_DECODE |
465 CM_RESOURCE_PORT_POSITIVE_DECODE;
466
467 Descriptor->u.Port.Length = Length;
468 Descriptor->u.Port.Alignment = 1;
469 Descriptor->u.Port.MinimumAddress.QuadPart = (ULONGLONG)Base;
470 Descriptor->u.Port.MaximumAddress.QuadPart = (ULONGLONG)(Base + Length - 1);
471 }
472 else
473 {
474 Descriptor->Type = CmResourceTypeMemory;
475 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
476 Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
477
478 Descriptor->u.Memory.Length = Length;
479 Descriptor->u.Memory.Alignment = 1;
480 Descriptor->u.Memory.MinimumAddress.QuadPart = (ULONGLONG)Base;
481 Descriptor->u.Memory.MaximumAddress.QuadPart = (ULONGLONG)(Base + Length - 1);
482 }
483 Descriptor++;
484
485 /* Set alternative descriptor */
486 Descriptor->Option = IO_RESOURCE_ALTERNATIVE;
487 if (Flags & PCI_ADDRESS_IO_SPACE)
488 {
489 Descriptor->Type = CmResourceTypePort;
490 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
491 Descriptor->Flags = CM_RESOURCE_PORT_IO |
492 CM_RESOURCE_PORT_16_BIT_DECODE |
493 CM_RESOURCE_PORT_POSITIVE_DECODE;
494
495 Descriptor->u.Port.Length = Length;
496 Descriptor->u.Port.Alignment = Length;
497 Descriptor->u.Port.MinimumAddress.QuadPart = (ULONGLONG)0;
498 Descriptor->u.Port.MaximumAddress.QuadPart = (ULONGLONG)0x00000000FFFFFFFF;
499 }
500 else
501 {
502 Descriptor->Type = CmResourceTypeMemory;
503 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
504 Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
505
506 Descriptor->u.Memory.Length = Length;
507 Descriptor->u.Memory.Alignment = Length;
508 Descriptor->u.Port.MinimumAddress.QuadPart = (ULONGLONG)0;
509 Descriptor->u.Port.MaximumAddress.QuadPart = (ULONGLONG)0x00000000FFFFFFFF;
510 }
511 Descriptor++;
512 }
513
514 /* FIXME: Check ROM address */
515
516 if (PciConfig.u.type0.InterruptPin != 0)
517 {
518 Descriptor->Option = 0; /* Required */
519 Descriptor->Type = CmResourceTypeInterrupt;
520 Descriptor->ShareDisposition = CmResourceShareShared;
521 Descriptor->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
522
523 Descriptor->u.Interrupt.MinimumVector = 0;
524 Descriptor->u.Interrupt.MaximumVector = 0xFF;
525 }
526 }
527 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_BRIDGE_TYPE)
528 {
529 for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
530 {
531 if (!PdoGetRangeLength(DeviceExtension,
532 0x10 + i * 4,
533 &Base,
534 &Length,
535 &Flags))
536 {
537 DPRINT1("PdoGetRangeLength() failed\n");
538 break;
539 }
540
541 if (Length == 0)
542 {
543 DPRINT("Unused address register\n");
544 continue;
545 }
546
547 /* Set preferred descriptor */
548 Descriptor->Option = IO_RESOURCE_PREFERRED;
549 if (Flags & PCI_ADDRESS_IO_SPACE)
550 {
551 Descriptor->Type = CmResourceTypePort;
552 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
553 Descriptor->Flags = CM_RESOURCE_PORT_IO |
554 CM_RESOURCE_PORT_16_BIT_DECODE |
555 CM_RESOURCE_PORT_POSITIVE_DECODE;
556
557 Descriptor->u.Port.Length = Length;
558 Descriptor->u.Port.Alignment = 1;
559 Descriptor->u.Port.MinimumAddress.QuadPart = (ULONGLONG)Base;
560 Descriptor->u.Port.MaximumAddress.QuadPart = (ULONGLONG)(Base + Length - 1);
561 }
562 else
563 {
564 Descriptor->Type = CmResourceTypeMemory;
565 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
566 Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
567
568 Descriptor->u.Memory.Length = Length;
569 Descriptor->u.Memory.Alignment = 1;
570 Descriptor->u.Memory.MinimumAddress.QuadPart = (ULONGLONG)Base;
571 Descriptor->u.Memory.MaximumAddress.QuadPart = (ULONGLONG)(Base + Length - 1);
572 }
573 Descriptor++;
574
575 /* Set alternative descriptor */
576 Descriptor->Option = IO_RESOURCE_ALTERNATIVE;
577 if (Flags & PCI_ADDRESS_IO_SPACE)
578 {
579 Descriptor->Type = CmResourceTypePort;
580 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
581 Descriptor->Flags = CM_RESOURCE_PORT_IO |
582 CM_RESOURCE_PORT_16_BIT_DECODE |
583 CM_RESOURCE_PORT_POSITIVE_DECODE;
584
585 Descriptor->u.Port.Length = Length;
586 Descriptor->u.Port.Alignment = Length;
587 Descriptor->u.Port.MinimumAddress.QuadPart = (ULONGLONG)0;
588 Descriptor->u.Port.MaximumAddress.QuadPart = (ULONGLONG)0x00000000FFFFFFFF;
589 }
590 else
591 {
592 Descriptor->Type = CmResourceTypeMemory;
593 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
594 Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
595
596 Descriptor->u.Memory.Length = Length;
597 Descriptor->u.Memory.Alignment = Length;
598 Descriptor->u.Port.MinimumAddress.QuadPart = (ULONGLONG)0;
599 Descriptor->u.Port.MaximumAddress.QuadPart = (ULONGLONG)0x00000000FFFFFFFF;
600 }
601 Descriptor++;
602 }
603
604 if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
605 {
606 Descriptor->Option = 0; /* Required */
607 Descriptor->Type = CmResourceTypeBusNumber;
608 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
609
610 ResourceList->BusNumber =
611 Descriptor->u.BusNumber.MinBusNumber =
612 Descriptor->u.BusNumber.MaxBusNumber = DeviceExtension->PciDevice->PciConfig.u.type1.SecondaryBus;
613 Descriptor->u.BusNumber.Length = 1;
614 Descriptor->u.BusNumber.Reserved = 0;
615 }
616 }
617 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
618 {
619 /* FIXME: Add Cardbus bridge resources */
620 }
621
622 Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
623
624 return STATUS_SUCCESS;
625 }
626
627
628 static NTSTATUS
629 PdoQueryResources(
630 IN PDEVICE_OBJECT DeviceObject,
631 IN PIRP Irp,
632 PIO_STACK_LOCATION IrpSp)
633 {
634 PPDO_DEVICE_EXTENSION DeviceExtension;
635 PCI_COMMON_CONFIG PciConfig;
636 PCM_RESOURCE_LIST ResourceList;
637 PCM_PARTIAL_RESOURCE_LIST PartialList;
638 PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
639 ULONG Size;
640 ULONG ResCount = 0;
641 ULONG ListSize;
642 ULONG i;
643 ULONG Base;
644 ULONG Length;
645 ULONG Flags;
646
647 DPRINT("PdoQueryResources() called\n");
648
649 UNREFERENCED_PARAMETER(IrpSp);
650 DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
651
652 /* Get PCI configuration space */
653 Size= HalGetBusData(PCIConfiguration,
654 DeviceExtension->PciDevice->BusNumber,
655 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
656 &PciConfig,
657 PCI_COMMON_HDR_LENGTH);
658 DPRINT("Size %lu\n", Size);
659 if (Size < PCI_COMMON_HDR_LENGTH)
660 {
661 Irp->IoStatus.Information = 0;
662 return STATUS_UNSUCCESSFUL;
663 }
664
665 DPRINT("Command register: 0x%04hx\n", PciConfig.Command);
666
667 /* Count required resource descriptors */
668 ResCount = 0;
669 if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_DEVICE_TYPE)
670 {
671 for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
672 {
673 if (!PdoGetRangeLength(DeviceExtension,
674 0x10 + i * 4,
675 &Base,
676 &Length,
677 &Flags))
678 break;
679
680 if (Length)
681 ResCount++;
682 }
683
684 if ((PciConfig.u.type0.InterruptPin != 0) &&
685 (PciConfig.u.type0.InterruptLine != 0) &&
686 (PciConfig.u.type0.InterruptLine != 0xFF))
687 ResCount++;
688 }
689 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_BRIDGE_TYPE)
690 {
691 for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
692 {
693 if (!PdoGetRangeLength(DeviceExtension,
694 0x10 + i * 4,
695 &Base,
696 &Length,
697 &Flags))
698 break;
699
700 if (Length != 0)
701 ResCount++;
702 }
703
704 if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
705 ResCount++;
706 }
707 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
708 {
709 /* FIXME: Count Cardbus bridge resources */
710 }
711 else
712 {
713 DPRINT1("Unsupported header type %d\n", PCI_CONFIGURATION_TYPE(&PciConfig));
714 }
715
716 if (ResCount == 0)
717 {
718 Irp->IoStatus.Information = 0;
719 return STATUS_SUCCESS;
720 }
721
722 /* Calculate the resource list size */
723 ListSize = FIELD_OFFSET(CM_RESOURCE_LIST, List[0].PartialResourceList.PartialDescriptors) +
724 ResCount * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
725
726 /* Allocate the resource list */
727 ResourceList = ExAllocatePoolWithTag(PagedPool,
728 ListSize,
729 TAG_PCI);
730 if (ResourceList == NULL)
731 return STATUS_INSUFFICIENT_RESOURCES;
732
733 RtlZeroMemory(ResourceList, ListSize);
734 ResourceList->Count = 1;
735 ResourceList->List[0].InterfaceType = PCIBus;
736 ResourceList->List[0].BusNumber = DeviceExtension->PciDevice->BusNumber;
737
738 PartialList = &ResourceList->List[0].PartialResourceList;
739 PartialList->Version = 1;
740 PartialList->Revision = 1;
741 PartialList->Count = ResCount;
742
743 Descriptor = &PartialList->PartialDescriptors[0];
744 if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_DEVICE_TYPE)
745 {
746 for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
747 {
748 if (!PdoGetRangeLength(DeviceExtension,
749 0x10 + i * 4,
750 &Base,
751 &Length,
752 &Flags))
753 {
754 DPRINT1("PdoGetRangeLength() failed\n");
755 break;
756 }
757
758 if (Length == 0)
759 {
760 DPRINT("Unused address register\n");
761 continue;
762 }
763
764 if (Flags & PCI_ADDRESS_IO_SPACE)
765 {
766 Descriptor->Type = CmResourceTypePort;
767 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
768 Descriptor->Flags = CM_RESOURCE_PORT_IO;
769 Descriptor->u.Port.Start.QuadPart = (ULONGLONG)Base;
770 Descriptor->u.Port.Length = Length;
771
772 /* Enable IO space access */
773 DeviceExtension->PciDevice->EnableIoSpace = TRUE;
774 }
775 else
776 {
777 Descriptor->Type = CmResourceTypeMemory;
778 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
779 Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
780 Descriptor->u.Memory.Start.QuadPart = (ULONGLONG)Base;
781 Descriptor->u.Memory.Length = Length;
782
783 /* Enable memory space access */
784 DeviceExtension->PciDevice->EnableMemorySpace = TRUE;
785 }
786
787 Descriptor++;
788 }
789
790 /* Add interrupt resource */
791 if ((PciConfig.u.type0.InterruptPin != 0) &&
792 (PciConfig.u.type0.InterruptLine != 0) &&
793 (PciConfig.u.type0.InterruptLine != 0xFF))
794 {
795 Descriptor->Type = CmResourceTypeInterrupt;
796 Descriptor->ShareDisposition = CmResourceShareShared;
797 Descriptor->Flags = CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
798 Descriptor->u.Interrupt.Level = PciConfig.u.type0.InterruptLine;
799 Descriptor->u.Interrupt.Vector = PciConfig.u.type0.InterruptLine;
800 Descriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
801 }
802
803 /* Allow bus master mode */
804 DeviceExtension->PciDevice->EnableBusMaster = TRUE;
805 }
806 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_BRIDGE_TYPE)
807 {
808 for (i = 0; i < PCI_TYPE1_ADDRESSES; i++)
809 {
810 if (!PdoGetRangeLength(DeviceExtension,
811 0x10 + i * 4,
812 &Base,
813 &Length,
814 &Flags))
815 {
816 DPRINT1("PdoGetRangeLength() failed\n");
817 break;
818 }
819
820 if (Length == 0)
821 {
822 DPRINT("Unused address register\n");
823 continue;
824 }
825
826 if (Flags & PCI_ADDRESS_IO_SPACE)
827 {
828 Descriptor->Type = CmResourceTypePort;
829 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
830 Descriptor->Flags = CM_RESOURCE_PORT_IO;
831 Descriptor->u.Port.Start.QuadPart = (ULONGLONG)Base;
832 Descriptor->u.Port.Length = Length;
833
834 /* Enable IO space access */
835 DeviceExtension->PciDevice->EnableIoSpace = TRUE;
836 }
837 else
838 {
839 Descriptor->Type = CmResourceTypeMemory;
840 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
841 Descriptor->Flags = CM_RESOURCE_MEMORY_READ_WRITE;
842 Descriptor->u.Memory.Start.QuadPart = (ULONGLONG)Base;
843 Descriptor->u.Memory.Length = Length;
844
845 /* Enable memory space access */
846 DeviceExtension->PciDevice->EnableMemorySpace = TRUE;
847 }
848
849 Descriptor++;
850 }
851
852 if (DeviceExtension->PciDevice->PciConfig.BaseClass == PCI_CLASS_BRIDGE_DEV)
853 {
854 Descriptor->Type = CmResourceTypeBusNumber;
855 Descriptor->ShareDisposition = CmResourceShareDeviceExclusive;
856
857 ResourceList->List[0].BusNumber =
858 Descriptor->u.BusNumber.Start = DeviceExtension->PciDevice->PciConfig.u.type1.SecondaryBus;
859 Descriptor->u.BusNumber.Length = 1;
860 Descriptor->u.BusNumber.Reserved = 0;
861 }
862 }
863 else if (PCI_CONFIGURATION_TYPE(&PciConfig) == PCI_CARDBUS_BRIDGE_TYPE)
864 {
865 /* FIXME: Add Cardbus bridge resources */
866 }
867
868 Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
869
870 return STATUS_SUCCESS;
871 }
872
873
874 static VOID NTAPI
875 InterfaceReference(
876 IN PVOID Context)
877 {
878 PPDO_DEVICE_EXTENSION DeviceExtension;
879
880 DPRINT("InterfaceReference(%p)\n", Context);
881
882 DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
883 InterlockedIncrement(&DeviceExtension->References);
884 }
885
886
887 static VOID NTAPI
888 InterfaceDereference(
889 IN PVOID Context)
890 {
891 PPDO_DEVICE_EXTENSION DeviceExtension;
892
893 DPRINT("InterfaceDereference(%p)\n", Context);
894
895 DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
896 InterlockedDecrement(&DeviceExtension->References);
897 }
898
899 static TRANSLATE_BUS_ADDRESS InterfaceBusTranslateBusAddress;
900
901 static
902 BOOLEAN
903 NTAPI
904 InterfaceBusTranslateBusAddress(
905 IN PVOID Context,
906 IN PHYSICAL_ADDRESS BusAddress,
907 IN ULONG Length,
908 IN OUT PULONG AddressSpace,
909 OUT PPHYSICAL_ADDRESS TranslatedAddress)
910 {
911 PPDO_DEVICE_EXTENSION DeviceExtension;
912
913 DPRINT("InterfaceBusTranslateBusAddress(%p %p 0x%lx %p %p)\n",
914 Context, BusAddress, Length, AddressSpace, TranslatedAddress);
915
916 DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
917
918 return HalTranslateBusAddress(PCIBus,
919 DeviceExtension->PciDevice->BusNumber,
920 BusAddress,
921 AddressSpace,
922 TranslatedAddress);
923 }
924
925 static GET_DMA_ADAPTER InterfaceBusGetDmaAdapter;
926
927 static
928 PDMA_ADAPTER
929 NTAPI
930 InterfaceBusGetDmaAdapter(
931 IN PVOID Context,
932 IN PDEVICE_DESCRIPTION DeviceDescription,
933 OUT PULONG NumberOfMapRegisters)
934 {
935 DPRINT("InterfaceBusGetDmaAdapter(%p %p %p)\n",
936 Context, DeviceDescription, NumberOfMapRegisters);
937 return (PDMA_ADAPTER)HalGetAdapter(DeviceDescription, NumberOfMapRegisters);
938 }
939
940 static GET_SET_DEVICE_DATA InterfaceBusSetBusData;
941
942 static
943 ULONG
944 NTAPI
945 InterfaceBusSetBusData(
946 IN PVOID Context,
947 IN ULONG DataType,
948 IN PVOID Buffer,
949 IN ULONG Offset,
950 IN ULONG Length)
951 {
952 PPDO_DEVICE_EXTENSION DeviceExtension;
953 ULONG Size;
954
955 DPRINT("InterfaceBusSetBusData(%p 0x%lx %p 0x%lx 0x%lx)\n",
956 Context, DataType, Buffer, Offset, Length);
957
958 if (DataType != PCI_WHICHSPACE_CONFIG)
959 {
960 DPRINT("Unknown DataType %lu\n", DataType);
961 return 0;
962 }
963
964 DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
965
966 /* Get PCI configuration space */
967 Size = HalSetBusDataByOffset(PCIConfiguration,
968 DeviceExtension->PciDevice->BusNumber,
969 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
970 Buffer,
971 Offset,
972 Length);
973 return Size;
974 }
975
976 static GET_SET_DEVICE_DATA InterfaceBusGetBusData;
977
978 static
979 ULONG
980 NTAPI
981 InterfaceBusGetBusData(
982 IN PVOID Context,
983 IN ULONG DataType,
984 IN PVOID Buffer,
985 IN ULONG Offset,
986 IN ULONG Length)
987 {
988 PPDO_DEVICE_EXTENSION DeviceExtension;
989 ULONG Size;
990
991 DPRINT("InterfaceBusGetBusData(%p 0x%lx %p 0x%lx 0x%lx) called\n",
992 Context, DataType, Buffer, Offset, Length);
993
994 if (DataType != PCI_WHICHSPACE_CONFIG)
995 {
996 DPRINT("Unknown DataType %lu\n", DataType);
997 return 0;
998 }
999
1000 DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
1001
1002 /* Get PCI configuration space */
1003 Size = HalGetBusDataByOffset(PCIConfiguration,
1004 DeviceExtension->PciDevice->BusNumber,
1005 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
1006 Buffer,
1007 Offset,
1008 Length);
1009 return Size;
1010 }
1011
1012
1013 static BOOLEAN NTAPI
1014 InterfacePciDevicePresent(
1015 IN USHORT VendorID,
1016 IN USHORT DeviceID,
1017 IN UCHAR RevisionID,
1018 IN USHORT SubVendorID,
1019 IN USHORT SubSystemID,
1020 IN ULONG Flags)
1021 {
1022 PFDO_DEVICE_EXTENSION FdoDeviceExtension;
1023 PPCI_DEVICE PciDevice;
1024 PLIST_ENTRY CurrentBus, CurrentEntry;
1025 KIRQL OldIrql;
1026 BOOLEAN Found = FALSE;
1027
1028 KeAcquireSpinLock(&DriverExtension->BusListLock, &OldIrql);
1029 CurrentBus = DriverExtension->BusListHead.Flink;
1030 while (!Found && CurrentBus != &DriverExtension->BusListHead)
1031 {
1032 FdoDeviceExtension = CONTAINING_RECORD(CurrentBus, FDO_DEVICE_EXTENSION, ListEntry);
1033
1034 KeAcquireSpinLockAtDpcLevel(&FdoDeviceExtension->DeviceListLock);
1035 CurrentEntry = FdoDeviceExtension->DeviceListHead.Flink;
1036 while (!Found && CurrentEntry != &FdoDeviceExtension->DeviceListHead)
1037 {
1038 PciDevice = CONTAINING_RECORD(CurrentEntry, PCI_DEVICE, ListEntry);
1039 if (PciDevice->PciConfig.VendorID == VendorID &&
1040 PciDevice->PciConfig.DeviceID == DeviceID)
1041 {
1042 if (!(Flags & PCI_USE_SUBSYSTEM_IDS) ||
1043 (PciDevice->PciConfig.u.type0.SubVendorID == SubVendorID &&
1044 PciDevice->PciConfig.u.type0.SubSystemID == SubSystemID))
1045 {
1046 if (!(Flags & PCI_USE_REVISION) ||
1047 PciDevice->PciConfig.RevisionID == RevisionID)
1048 {
1049 DPRINT("Found the PCI device\n");
1050 Found = TRUE;
1051 }
1052 }
1053 }
1054
1055 CurrentEntry = CurrentEntry->Flink;
1056 }
1057
1058 KeReleaseSpinLockFromDpcLevel(&FdoDeviceExtension->DeviceListLock);
1059 CurrentBus = CurrentBus->Flink;
1060 }
1061 KeReleaseSpinLock(&DriverExtension->BusListLock, OldIrql);
1062
1063 return Found;
1064 }
1065
1066
1067 static BOOLEAN
1068 CheckPciDevice(
1069 IN PPCI_COMMON_CONFIG PciConfig,
1070 IN PPCI_DEVICE_PRESENCE_PARAMETERS Parameters)
1071 {
1072 if ((Parameters->Flags & PCI_USE_VENDEV_IDS) &&
1073 (PciConfig->VendorID != Parameters->VendorID ||
1074 PciConfig->DeviceID != Parameters->DeviceID))
1075 {
1076 return FALSE;
1077 }
1078
1079 if ((Parameters->Flags & PCI_USE_CLASS_SUBCLASS) &&
1080 (PciConfig->BaseClass != Parameters->BaseClass ||
1081 PciConfig->SubClass != Parameters->SubClass))
1082 {
1083 return FALSE;
1084 }
1085
1086 if ((Parameters->Flags & PCI_USE_PROGIF) &&
1087 PciConfig->ProgIf != Parameters->ProgIf)
1088 {
1089 return FALSE;
1090 }
1091
1092 if ((Parameters->Flags & PCI_USE_SUBSYSTEM_IDS) &&
1093 (PciConfig->u.type0.SubVendorID != Parameters->SubVendorID ||
1094 PciConfig->u.type0.SubSystemID != Parameters->SubSystemID))
1095 {
1096 return FALSE;
1097 }
1098
1099 if ((Parameters->Flags & PCI_USE_REVISION) &&
1100 PciConfig->RevisionID != Parameters->RevisionID)
1101 {
1102 return FALSE;
1103 }
1104
1105 return TRUE;
1106 }
1107
1108
1109 static BOOLEAN NTAPI
1110 InterfacePciDevicePresentEx(
1111 IN PVOID Context,
1112 IN PPCI_DEVICE_PRESENCE_PARAMETERS Parameters)
1113 {
1114 PPDO_DEVICE_EXTENSION DeviceExtension;
1115 PFDO_DEVICE_EXTENSION MyFdoDeviceExtension;
1116 PFDO_DEVICE_EXTENSION FdoDeviceExtension;
1117 PPCI_DEVICE PciDevice;
1118 PLIST_ENTRY CurrentBus, CurrentEntry;
1119 KIRQL OldIrql;
1120 BOOLEAN Found = FALSE;
1121
1122 DPRINT("InterfacePciDevicePresentEx(%p %p) called\n",
1123 Context, Parameters);
1124
1125 if (!Parameters || Parameters->Size != sizeof(PCI_DEVICE_PRESENCE_PARAMETERS))
1126 return FALSE;
1127
1128 DeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
1129 MyFdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceExtension->Fdo->DeviceExtension;
1130
1131 if (Parameters->Flags & PCI_USE_LOCAL_DEVICE)
1132 {
1133 return CheckPciDevice(&DeviceExtension->PciDevice->PciConfig, Parameters);
1134 }
1135
1136 KeAcquireSpinLock(&DriverExtension->BusListLock, &OldIrql);
1137 CurrentBus = DriverExtension->BusListHead.Flink;
1138 while (!Found && CurrentBus != &DriverExtension->BusListHead)
1139 {
1140 FdoDeviceExtension = CONTAINING_RECORD(CurrentBus, FDO_DEVICE_EXTENSION, ListEntry);
1141 if (!(Parameters->Flags & PCI_USE_LOCAL_BUS) || FdoDeviceExtension == MyFdoDeviceExtension)
1142 {
1143 KeAcquireSpinLockAtDpcLevel(&FdoDeviceExtension->DeviceListLock);
1144 CurrentEntry = FdoDeviceExtension->DeviceListHead.Flink;
1145 while (!Found && CurrentEntry != &FdoDeviceExtension->DeviceListHead)
1146 {
1147 PciDevice = CONTAINING_RECORD(CurrentEntry, PCI_DEVICE, ListEntry);
1148
1149 if (CheckPciDevice(&PciDevice->PciConfig, Parameters))
1150 {
1151 DPRINT("Found the PCI device\n");
1152 Found = TRUE;
1153 }
1154
1155 CurrentEntry = CurrentEntry->Flink;
1156 }
1157
1158 KeReleaseSpinLockFromDpcLevel(&FdoDeviceExtension->DeviceListLock);
1159 }
1160 CurrentBus = CurrentBus->Flink;
1161 }
1162 KeReleaseSpinLock(&DriverExtension->BusListLock, OldIrql);
1163
1164 return Found;
1165 }
1166
1167
1168 static NTSTATUS
1169 PdoQueryInterface(
1170 IN PDEVICE_OBJECT DeviceObject,
1171 IN PIRP Irp,
1172 PIO_STACK_LOCATION IrpSp)
1173 {
1174 NTSTATUS Status;
1175
1176 UNREFERENCED_PARAMETER(Irp);
1177
1178 if (RtlCompareMemory(IrpSp->Parameters.QueryInterface.InterfaceType,
1179 &GUID_BUS_INTERFACE_STANDARD, sizeof(GUID)) == sizeof(GUID))
1180 {
1181 /* BUS_INTERFACE_STANDARD */
1182 if (IrpSp->Parameters.QueryInterface.Version < 1)
1183 Status = STATUS_NOT_SUPPORTED;
1184 else if (IrpSp->Parameters.QueryInterface.Size < sizeof(BUS_INTERFACE_STANDARD))
1185 Status = STATUS_BUFFER_TOO_SMALL;
1186 else
1187 {
1188 PBUS_INTERFACE_STANDARD BusInterface;
1189 BusInterface = (PBUS_INTERFACE_STANDARD)IrpSp->Parameters.QueryInterface.Interface;
1190 BusInterface->Size = sizeof(BUS_INTERFACE_STANDARD);
1191 BusInterface->Version = 1;
1192 BusInterface->TranslateBusAddress = InterfaceBusTranslateBusAddress;
1193 BusInterface->GetDmaAdapter = InterfaceBusGetDmaAdapter;
1194 BusInterface->SetBusData = InterfaceBusSetBusData;
1195 BusInterface->GetBusData = InterfaceBusGetBusData;
1196 Status = STATUS_SUCCESS;
1197 }
1198 }
1199 else if (RtlCompareMemory(IrpSp->Parameters.QueryInterface.InterfaceType,
1200 &GUID_PCI_DEVICE_PRESENT_INTERFACE, sizeof(GUID)) == sizeof(GUID))
1201 {
1202 /* PCI_DEVICE_PRESENT_INTERFACE */
1203 if (IrpSp->Parameters.QueryInterface.Version < 1)
1204 Status = STATUS_NOT_SUPPORTED;
1205 else if (IrpSp->Parameters.QueryInterface.Size < sizeof(PCI_DEVICE_PRESENT_INTERFACE))
1206 Status = STATUS_BUFFER_TOO_SMALL;
1207 else
1208 {
1209 PPCI_DEVICE_PRESENT_INTERFACE PciDevicePresentInterface;
1210 PciDevicePresentInterface = (PPCI_DEVICE_PRESENT_INTERFACE)IrpSp->Parameters.QueryInterface.Interface;
1211 PciDevicePresentInterface->Size = sizeof(PCI_DEVICE_PRESENT_INTERFACE);
1212 PciDevicePresentInterface->Version = 1;
1213 PciDevicePresentInterface->IsDevicePresent = InterfacePciDevicePresent;
1214 PciDevicePresentInterface->IsDevicePresentEx = InterfacePciDevicePresentEx;
1215 Status = STATUS_SUCCESS;
1216 }
1217 }
1218 else
1219 {
1220 /* Not a supported interface */
1221 return STATUS_NOT_SUPPORTED;
1222 }
1223
1224 if (NT_SUCCESS(Status))
1225 {
1226 /* Add a reference for the returned interface */
1227 PINTERFACE Interface;
1228 Interface = (PINTERFACE)IrpSp->Parameters.QueryInterface.Interface;
1229 Interface->Context = DeviceObject;
1230 Interface->InterfaceReference = InterfaceReference;
1231 Interface->InterfaceDereference = InterfaceDereference;
1232 Interface->InterfaceReference(Interface->Context);
1233 }
1234
1235 return Status;
1236 }
1237
1238 static NTSTATUS
1239 PdoStartDevice(
1240 IN PDEVICE_OBJECT DeviceObject,
1241 IN PIRP Irp,
1242 PIO_STACK_LOCATION IrpSp)
1243 {
1244 PCM_RESOURCE_LIST RawResList = IrpSp->Parameters.StartDevice.AllocatedResources;
1245 PCM_FULL_RESOURCE_DESCRIPTOR RawFullDesc;
1246 PCM_PARTIAL_RESOURCE_DESCRIPTOR RawPartialDesc;
1247 ULONG i, ii;
1248 PPDO_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
1249 UCHAR Irq;
1250 USHORT Command;
1251
1252 UNREFERENCED_PARAMETER(Irp);
1253
1254 if (!RawResList)
1255 return STATUS_SUCCESS;
1256
1257 /* TODO: Assign the other resources we get to the card */
1258
1259 for (i = 0; i < RawResList->Count; i++)
1260 {
1261 RawFullDesc = &RawResList->List[i];
1262
1263 for (ii = 0; ii < RawFullDesc->PartialResourceList.Count; ii++)
1264 {
1265 RawPartialDesc = &RawFullDesc->PartialResourceList.PartialDescriptors[ii];
1266
1267 if (RawPartialDesc->Type == CmResourceTypeInterrupt)
1268 {
1269 DPRINT1("Assigning IRQ %u to PCI device 0x%x on bus 0x%x\n",
1270 RawPartialDesc->u.Interrupt.Vector,
1271 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
1272 DeviceExtension->PciDevice->BusNumber);
1273
1274 Irq = (UCHAR)RawPartialDesc->u.Interrupt.Vector;
1275 HalSetBusDataByOffset(PCIConfiguration,
1276 DeviceExtension->PciDevice->BusNumber,
1277 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
1278 &Irq,
1279 0x3c /* PCI_INTERRUPT_LINE */,
1280 sizeof(UCHAR));
1281 }
1282 }
1283 }
1284
1285 Command = 0;
1286
1287 DPRINT1("Enabling command flags for PCI device 0x%x on bus 0x%x: ",
1288 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
1289 DeviceExtension->PciDevice->BusNumber);
1290 if (DeviceExtension->PciDevice->EnableBusMaster)
1291 {
1292 Command |= PCI_ENABLE_BUS_MASTER;
1293 DbgPrint("[Bus master] ");
1294 }
1295
1296 if (DeviceExtension->PciDevice->EnableMemorySpace)
1297 {
1298 Command |= PCI_ENABLE_MEMORY_SPACE;
1299 DbgPrint("[Memory space enable] ");
1300 }
1301
1302 if (DeviceExtension->PciDevice->EnableIoSpace)
1303 {
1304 Command |= PCI_ENABLE_IO_SPACE;
1305 DbgPrint("[I/O space enable] ");
1306 }
1307
1308 if (Command != 0)
1309 {
1310 DbgPrint("\n");
1311
1312 /* OR with the previous value */
1313 Command |= DeviceExtension->PciDevice->PciConfig.Command;
1314
1315 HalSetBusDataByOffset(PCIConfiguration,
1316 DeviceExtension->PciDevice->BusNumber,
1317 DeviceExtension->PciDevice->SlotNumber.u.AsULONG,
1318 &Command,
1319 FIELD_OFFSET(PCI_COMMON_CONFIG, Command),
1320 sizeof(USHORT));
1321 }
1322 else
1323 {
1324 DbgPrint("None\n");
1325 }
1326
1327 return STATUS_SUCCESS;
1328 }
1329
1330 static NTSTATUS
1331 PdoReadConfig(
1332 IN PDEVICE_OBJECT DeviceObject,
1333 IN PIRP Irp,
1334 PIO_STACK_LOCATION IrpSp)
1335 {
1336 ULONG Size;
1337
1338 DPRINT("PdoReadConfig() called\n");
1339
1340 Size = InterfaceBusGetBusData(DeviceObject,
1341 IrpSp->Parameters.ReadWriteConfig.WhichSpace,
1342 IrpSp->Parameters.ReadWriteConfig.Buffer,
1343 IrpSp->Parameters.ReadWriteConfig.Offset,
1344 IrpSp->Parameters.ReadWriteConfig.Length);
1345
1346 if (Size != IrpSp->Parameters.ReadWriteConfig.Length)
1347 {
1348 DPRINT1("Size %lu Length %lu\n", Size, IrpSp->Parameters.ReadWriteConfig.Length);
1349 Irp->IoStatus.Information = 0;
1350 return STATUS_UNSUCCESSFUL;
1351 }
1352
1353 Irp->IoStatus.Information = Size;
1354
1355 return STATUS_SUCCESS;
1356 }
1357
1358
1359 static NTSTATUS
1360 PdoWriteConfig(
1361 IN PDEVICE_OBJECT DeviceObject,
1362 IN PIRP Irp,
1363 PIO_STACK_LOCATION IrpSp)
1364 {
1365 ULONG Size;
1366
1367 DPRINT1("PdoWriteConfig() called\n");
1368
1369 /* Get PCI configuration space */
1370 Size = InterfaceBusSetBusData(DeviceObject,
1371 IrpSp->Parameters.ReadWriteConfig.WhichSpace,
1372 IrpSp->Parameters.ReadWriteConfig.Buffer,
1373 IrpSp->Parameters.ReadWriteConfig.Offset,
1374 IrpSp->Parameters.ReadWriteConfig.Length);
1375
1376 if (Size != IrpSp->Parameters.ReadWriteConfig.Length)
1377 {
1378 DPRINT1("Size %lu Length %lu\n", Size, IrpSp->Parameters.ReadWriteConfig.Length);
1379 Irp->IoStatus.Information = 0;
1380 return STATUS_UNSUCCESSFUL;
1381 }
1382
1383 Irp->IoStatus.Information = Size;
1384
1385 return STATUS_SUCCESS;
1386 }
1387
1388 static NTSTATUS
1389 PdoQueryDeviceRelations(
1390 IN PDEVICE_OBJECT DeviceObject,
1391 IN PIRP Irp,
1392 PIO_STACK_LOCATION IrpSp)
1393 {
1394 PDEVICE_RELATIONS DeviceRelations;
1395
1396 /* We only support TargetDeviceRelation for child PDOs */
1397 if (IrpSp->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
1398 return Irp->IoStatus.Status;
1399
1400 /* We can do this because we only return 1 PDO for TargetDeviceRelation */
1401 DeviceRelations = ExAllocatePool(PagedPool, sizeof(*DeviceRelations));
1402 if (!DeviceRelations)
1403 return STATUS_INSUFFICIENT_RESOURCES;
1404
1405 DeviceRelations->Count = 1;
1406 DeviceRelations->Objects[0] = DeviceObject;
1407
1408 /* The PnP manager will remove this when it is done with the PDO */
1409 ObReferenceObject(DeviceObject);
1410
1411 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
1412
1413 return STATUS_SUCCESS;
1414 }
1415
1416 static NTSTATUS
1417 PdoSetPower(
1418 IN PDEVICE_OBJECT DeviceObject,
1419 IN PIRP Irp,
1420 PIO_STACK_LOCATION IrpSp)
1421 {
1422 NTSTATUS Status;
1423
1424 UNREFERENCED_PARAMETER(DeviceObject);
1425 UNREFERENCED_PARAMETER(Irp);
1426 DPRINT("Called\n");
1427
1428 if (IrpSp->Parameters.Power.Type == DevicePowerState)
1429 {
1430 Status = STATUS_SUCCESS;
1431
1432 switch (IrpSp->Parameters.Power.State.SystemState)
1433 {
1434 default:
1435 Status = STATUS_UNSUCCESSFUL;
1436 }
1437 }
1438 else
1439 {
1440 Status = STATUS_UNSUCCESSFUL;
1441 }
1442
1443 return Status;
1444 }
1445
1446
1447 /*** PUBLIC ******************************************************************/
1448
1449 NTSTATUS
1450 PdoPnpControl(
1451 PDEVICE_OBJECT DeviceObject,
1452 PIRP Irp)
1453 /*
1454 * FUNCTION: Handle Plug and Play IRPs for the child device
1455 * ARGUMENTS:
1456 * DeviceObject = Pointer to physical device object of the child device
1457 * Irp = Pointer to IRP that should be handled
1458 * RETURNS:
1459 * Status
1460 */
1461 {
1462 PIO_STACK_LOCATION IrpSp;
1463 NTSTATUS Status;
1464
1465 DPRINT("Called\n");
1466
1467 Status = Irp->IoStatus.Status;
1468
1469 IrpSp = IoGetCurrentIrpStackLocation(Irp);
1470
1471 switch (IrpSp->MinorFunction)
1472 {
1473 case IRP_MN_DEVICE_USAGE_NOTIFICATION:
1474 DPRINT("Unimplemented IRP_MN_DEVICE_USAGE_NOTIFICATION received\n");
1475 break;
1476
1477 case IRP_MN_EJECT:
1478 DPRINT("Unimplemented IRP_MN_EJECT received\n");
1479 break;
1480
1481 case IRP_MN_QUERY_BUS_INFORMATION:
1482 Status = PdoQueryBusInformation(DeviceObject, Irp, IrpSp);
1483 break;
1484
1485 case IRP_MN_QUERY_CAPABILITIES:
1486 Status = PdoQueryCapabilities(DeviceObject, Irp, IrpSp);
1487 break;
1488
1489 case IRP_MN_QUERY_DEVICE_RELATIONS:
1490 Status = PdoQueryDeviceRelations(DeviceObject, Irp, IrpSp);
1491 break;
1492
1493 case IRP_MN_QUERY_DEVICE_TEXT:
1494 DPRINT("IRP_MN_QUERY_DEVICE_TEXT received\n");
1495 Status = PdoQueryDeviceText(DeviceObject, Irp, IrpSp);
1496 break;
1497
1498 case IRP_MN_QUERY_ID:
1499 DPRINT("IRP_MN_QUERY_ID received\n");
1500 Status = PdoQueryId(DeviceObject, Irp, IrpSp);
1501 break;
1502
1503 case IRP_MN_QUERY_PNP_DEVICE_STATE:
1504 DPRINT("Unimplemented IRP_MN_QUERY_ID received\n");
1505 break;
1506
1507 case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
1508 DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS received\n");
1509 Status = PdoQueryResourceRequirements(DeviceObject, Irp, IrpSp);
1510 break;
1511
1512 case IRP_MN_QUERY_RESOURCES:
1513 DPRINT("IRP_MN_QUERY_RESOURCES received\n");
1514 Status = PdoQueryResources(DeviceObject, Irp, IrpSp);
1515 break;
1516
1517 case IRP_MN_SET_LOCK:
1518 DPRINT("Unimplemented IRP_MN_SET_LOCK received\n");
1519 break;
1520
1521 case IRP_MN_START_DEVICE:
1522 Status = PdoStartDevice(DeviceObject, Irp, IrpSp);
1523 break;
1524
1525 case IRP_MN_QUERY_STOP_DEVICE:
1526 case IRP_MN_CANCEL_STOP_DEVICE:
1527 case IRP_MN_STOP_DEVICE:
1528 case IRP_MN_QUERY_REMOVE_DEVICE:
1529 case IRP_MN_CANCEL_REMOVE_DEVICE:
1530 case IRP_MN_SURPRISE_REMOVAL:
1531 Status = STATUS_SUCCESS;
1532 break;
1533
1534 case IRP_MN_REMOVE_DEVICE:
1535 {
1536 PPDO_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
1537 PFDO_DEVICE_EXTENSION FdoDeviceExtension = DeviceExtension->Fdo->DeviceExtension;
1538 KIRQL OldIrql;
1539
1540 /* Remove it from the device list */
1541 KeAcquireSpinLock(&FdoDeviceExtension->DeviceListLock, &OldIrql);
1542 RemoveEntryList(&DeviceExtension->PciDevice->ListEntry);
1543 FdoDeviceExtension->DeviceListCount--;
1544 KeReleaseSpinLock(&FdoDeviceExtension->DeviceListLock, OldIrql);
1545
1546 /* Free the device */
1547 ExFreePool(DeviceExtension->PciDevice);
1548
1549 /* Complete the IRP */
1550 Irp->IoStatus.Status = STATUS_SUCCESS;
1551 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1552
1553 /* Delete the DO */
1554 IoDeleteDevice(DeviceObject);
1555 return STATUS_SUCCESS;
1556 }
1557
1558 case IRP_MN_QUERY_INTERFACE:
1559 DPRINT("IRP_MN_QUERY_INTERFACE received\n");
1560 Status = PdoQueryInterface(DeviceObject, Irp, IrpSp);
1561 break;
1562
1563 case IRP_MN_READ_CONFIG:
1564 DPRINT("IRP_MN_READ_CONFIG received\n");
1565 Status = PdoReadConfig(DeviceObject, Irp, IrpSp);
1566 break;
1567
1568 case IRP_MN_WRITE_CONFIG:
1569 DPRINT("IRP_MN_WRITE_CONFIG received\n");
1570 Status = PdoWriteConfig(DeviceObject, Irp, IrpSp);
1571 break;
1572
1573 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
1574 DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS received\n");
1575 /* Nothing to do */
1576 Irp->IoStatus.Status = Status;
1577 break;
1578
1579 default:
1580 DPRINT1("Unknown IOCTL 0x%lx\n", IrpSp->MinorFunction);
1581 break;
1582 }
1583
1584 if (Status != STATUS_PENDING)
1585 {
1586 Irp->IoStatus.Status = Status;
1587 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1588 }
1589
1590 DPRINT("Leaving. Status 0x%X\n", Status);
1591
1592 return Status;
1593 }
1594
1595 NTSTATUS
1596 PdoPowerControl(
1597 PDEVICE_OBJECT DeviceObject,
1598 PIRP Irp)
1599 /*
1600 * FUNCTION: Handle power management IRPs for the child device
1601 * ARGUMENTS:
1602 * DeviceObject = Pointer to physical device object of the child device
1603 * Irp = Pointer to IRP that should be handled
1604 * RETURNS:
1605 * Status
1606 */
1607 {
1608 PIO_STACK_LOCATION IrpSp;
1609 NTSTATUS Status;
1610
1611 DPRINT("Called\n");
1612
1613 IrpSp = IoGetCurrentIrpStackLocation(Irp);
1614
1615 switch (IrpSp->MinorFunction)
1616 {
1617 case IRP_MN_SET_POWER:
1618 Status = PdoSetPower(DeviceObject, Irp, IrpSp);
1619 break;
1620
1621 default:
1622 DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
1623 Status = STATUS_NOT_IMPLEMENTED;
1624 break;
1625 }
1626
1627 if (Status != STATUS_PENDING)
1628 {
1629 Irp->IoStatus.Status = Status;
1630 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1631 }
1632
1633 DPRINT("Leaving. Status 0x%X\n", Status);
1634
1635 return Status;
1636 }
1637
1638 /* EOF */