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