Visual C++ backend for rbuild (for now just a hacked mingw backend) and related compi...
[reactos.git] / drivers / bus / pci / fdo.c
1 /*
2 * PROJECT: ReactOS PCI bus driver
3 * FILE: fdo.c
4 * PURPOSE: PCI 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 FdoLocateChildDevice(
21 PPCI_DEVICE *Device,
22 PFDO_DEVICE_EXTENSION DeviceExtension,
23 PCI_SLOT_NUMBER SlotNumber,
24 PPCI_COMMON_CONFIG PciConfig)
25 {
26 PLIST_ENTRY CurrentEntry;
27 PPCI_DEVICE CurrentDevice;
28
29 DPRINT("Called\n");
30
31 CurrentEntry = DeviceExtension->DeviceListHead.Flink;
32 while (CurrentEntry != &DeviceExtension->DeviceListHead) {
33 CurrentDevice = CONTAINING_RECORD(CurrentEntry, PCI_DEVICE, ListEntry);
34
35 /* If both vendor ID and device ID match, it is the same device */
36 if ((PciConfig->VendorID == CurrentDevice->PciConfig.VendorID) &&
37 (PciConfig->DeviceID == CurrentDevice->PciConfig.DeviceID) &&
38 (SlotNumber.u.AsULONG == CurrentDevice->SlotNumber.u.AsULONG)) {
39 *Device = CurrentDevice;
40 DPRINT("Done\n");
41 return STATUS_SUCCESS;
42 }
43
44 CurrentEntry = CurrentEntry->Flink;
45 }
46
47 *Device = NULL;
48 DPRINT("Done\n");
49 return STATUS_UNSUCCESSFUL;
50 }
51
52
53 static NTSTATUS
54 FdoEnumerateDevices(
55 PDEVICE_OBJECT DeviceObject)
56 {
57 PFDO_DEVICE_EXTENSION DeviceExtension;
58 PCI_COMMON_CONFIG PciConfig;
59 PLIST_ENTRY CurrentEntry;
60 PPCI_DEVICE Device;
61 PCI_SLOT_NUMBER SlotNumber;
62 ULONG DeviceNumber;
63 ULONG FunctionNumber;
64 ULONG Size;
65 NTSTATUS Status;
66
67 DPRINT("Called\n");
68
69 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
70
71 /* Mark all devices to be removed. If we don't discover them again during
72 enumeration, assume that they have been surprise removed */
73 CurrentEntry = DeviceExtension->DeviceListHead.Flink;
74 while (CurrentEntry != &DeviceExtension->DeviceListHead) {
75 Device = CONTAINING_RECORD(CurrentEntry, PCI_DEVICE, ListEntry);
76 Device->RemovePending = TRUE;
77 CurrentEntry = CurrentEntry->Flink;
78 }
79
80 DeviceExtension->DeviceListCount = 0;
81
82 /* Enumerate devices on the PCI bus */
83 SlotNumber.u.AsULONG = 0;
84 for (DeviceNumber = 0; DeviceNumber < PCI_MAX_DEVICES; DeviceNumber++)
85 {
86 SlotNumber.u.bits.DeviceNumber = DeviceNumber;
87 for (FunctionNumber = 0; FunctionNumber < PCI_MAX_FUNCTION; FunctionNumber++)
88 {
89 SlotNumber.u.bits.FunctionNumber = FunctionNumber;
90
91 DPRINT("Bus %1lu Device %2lu Func %1lu\n",
92 DeviceExtension->BusNumber,
93 DeviceNumber,
94 FunctionNumber);
95
96 RtlZeroMemory(&PciConfig,
97 sizeof(PCI_COMMON_CONFIG));
98
99 Size = HalGetBusData(PCIConfiguration,
100 DeviceExtension->BusNumber,
101 SlotNumber.u.AsULONG,
102 &PciConfig,
103 PCI_COMMON_HDR_LENGTH);
104 DPRINT("Size %lu\n", Size);
105 if (Size < PCI_COMMON_HDR_LENGTH)
106 {
107 if (FunctionNumber == 0)
108 {
109 break;
110 }
111 else
112 {
113 continue;
114 }
115 }
116
117 DPRINT("Bus %1lu Device %2lu Func %1lu VenID 0x%04hx DevID 0x%04hx\n",
118 DeviceExtension->BusNumber,
119 DeviceNumber,
120 FunctionNumber,
121 PciConfig.VendorID,
122 PciConfig.DeviceID);
123
124 Status = FdoLocateChildDevice(&Device, DeviceExtension, SlotNumber, &PciConfig);
125 if (!NT_SUCCESS(Status))
126 {
127 Device = (PPCI_DEVICE)ExAllocatePoolWithTag(NonPagedPool, sizeof(PCI_DEVICE),TAG_PCI);
128 if (!Device)
129 {
130 /* FIXME: Cleanup resources for already discovered devices */
131 return STATUS_INSUFFICIENT_RESOURCES;
132 }
133
134 RtlZeroMemory(Device,
135 sizeof(PCI_DEVICE));
136
137 Device->BusNumber = DeviceExtension->BusNumber;
138
139 RtlCopyMemory(&Device->SlotNumber,
140 &SlotNumber,
141 sizeof(PCI_SLOT_NUMBER));
142
143 RtlCopyMemory(&Device->PciConfig,
144 &PciConfig,
145 sizeof(PCI_COMMON_CONFIG));
146
147 ExInterlockedInsertTailList(
148 &DeviceExtension->DeviceListHead,
149 &Device->ListEntry,
150 &DeviceExtension->DeviceListLock);
151 }
152
153 /* Don't remove this device */
154 Device->RemovePending = FALSE;
155
156 DeviceExtension->DeviceListCount++;
157
158 /* Skip to next device if the current one is not a multifunction device */
159 if ((FunctionNumber == 0) &&
160 ((PciConfig.HeaderType & 0x80) == 0))
161 {
162 break;
163 }
164 }
165 }
166
167 DPRINT("Done\n");
168
169 return STATUS_SUCCESS;
170 }
171
172
173 static NTSTATUS
174 FdoQueryBusRelations(
175 IN PDEVICE_OBJECT DeviceObject,
176 IN PIRP Irp,
177 PIO_STACK_LOCATION IrpSp)
178 {
179 PPDO_DEVICE_EXTENSION PdoDeviceExtension;
180 PFDO_DEVICE_EXTENSION DeviceExtension;
181 PDEVICE_RELATIONS Relations;
182 PLIST_ENTRY CurrentEntry;
183 PPCI_DEVICE Device;
184 NTSTATUS Status;
185 BOOLEAN ErrorOccurred;
186 NTSTATUS ErrorStatus;
187 ULONG Size;
188 ULONG i;
189
190 DPRINT("Called\n");
191
192 ErrorStatus = STATUS_INSUFFICIENT_RESOURCES;
193
194 Status = STATUS_SUCCESS;
195
196 ErrorOccurred = FALSE;
197
198 FdoEnumerateDevices(DeviceObject);
199
200 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
201
202 if (Irp->IoStatus.Information) {
203 /* FIXME: Another bus driver has already created a DEVICE_RELATIONS
204 structure so we must merge this structure with our own */
205 }
206
207 Size = sizeof(DEVICE_RELATIONS) + sizeof(Relations->Objects) *
208 (DeviceExtension->DeviceListCount - 1);
209 Relations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, Size);
210 if (!Relations)
211 return STATUS_INSUFFICIENT_RESOURCES;
212
213 Relations->Count = DeviceExtension->DeviceListCount;
214
215 i = 0;
216 CurrentEntry = DeviceExtension->DeviceListHead.Flink;
217 while (CurrentEntry != &DeviceExtension->DeviceListHead) {
218 Device = CONTAINING_RECORD(CurrentEntry, PCI_DEVICE, ListEntry);
219
220 PdoDeviceExtension = NULL;
221
222 if (!Device->Pdo) {
223 /* Create a physical device object for the
224 device as it does not already have one */
225 Status = IoCreateDevice(
226 DeviceObject->DriverObject,
227 sizeof(PDO_DEVICE_EXTENSION),
228 NULL,
229 FILE_DEVICE_CONTROLLER,
230 FILE_AUTOGENERATED_DEVICE_NAME,
231 FALSE,
232 &Device->Pdo);
233 if (!NT_SUCCESS(Status)) {
234 DPRINT("IoCreateDevice() failed with status 0x%X\n", Status);
235 ErrorStatus = Status;
236 ErrorOccurred = TRUE;
237 break;
238 }
239
240 Device->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
241
242 Device->Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
243
244 //Device->Pdo->Flags |= DO_POWER_PAGABLE;
245
246 PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)Device->Pdo->DeviceExtension;
247
248 RtlZeroMemory(PdoDeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
249
250 PdoDeviceExtension->Common.IsFDO = FALSE;
251
252 PdoDeviceExtension->Common.DeviceObject = Device->Pdo;
253
254 PdoDeviceExtension->Common.DevicePowerState = PowerDeviceD0;
255
256 PdoDeviceExtension->Fdo = DeviceObject;
257
258 PdoDeviceExtension->PciDevice = Device;
259
260 /* Add Device ID string */
261 Status = PciCreateDeviceIDString(&PdoDeviceExtension->DeviceID, Device);
262 if (!NT_SUCCESS(Status))
263 {
264 ErrorStatus = Status;
265 ErrorOccurred = TRUE;
266 break;
267 }
268
269 DPRINT("DeviceID: %S\n", PdoDeviceExtension->DeviceID.Buffer);
270
271 /* Add Instance ID string */
272 Status = PciCreateInstanceIDString(&PdoDeviceExtension->InstanceID, Device);
273 if (!NT_SUCCESS(Status))
274 {
275 ErrorStatus = Status;
276 ErrorOccurred = TRUE;
277 break;
278 }
279
280 /* Add Hardware IDs string */
281 Status = PciCreateHardwareIDsString(&PdoDeviceExtension->HardwareIDs, Device);
282 if (!NT_SUCCESS(Status))
283 {
284 ErrorStatus = Status;
285 ErrorOccurred = TRUE;
286 break;
287 }
288
289 /* Add Compatible IDs string */
290 Status = PciCreateCompatibleIDsString(&PdoDeviceExtension->CompatibleIDs, Device);
291 if (!NT_SUCCESS(Status))
292 {
293 ErrorStatus = Status;
294 ErrorOccurred = TRUE;
295 break;
296 }
297
298 /* Add device description string */
299 Status = PciCreateDeviceDescriptionString(&PdoDeviceExtension->DeviceDescription, Device);
300 if (!NT_SUCCESS(Status))
301 {
302 ErrorStatus = Status;
303 ErrorOccurred = TRUE;
304 break;
305 }
306
307 /* Add device location string */
308 Status = PciCreateDeviceLocationString(&PdoDeviceExtension->DeviceLocation, Device);
309 if (!NT_SUCCESS(Status))
310 {
311 ErrorStatus = Status;
312 ErrorOccurred = TRUE;
313 break;
314 }
315 }
316
317 if (!Device->RemovePending) {
318 /* Reference the physical device object. The PnP manager
319 will dereference it again when it is no longer needed */
320 ObReferenceObject(Device->Pdo);
321
322 Relations->Objects[i] = Device->Pdo;
323
324 i++;
325 }
326
327 CurrentEntry = CurrentEntry->Flink;
328 }
329
330 if (ErrorOccurred) {
331 /* FIXME: Cleanup all new PDOs created in this call. Please give me SEH!!! ;-) */
332 /* FIXME: Should IoAttachDeviceToDeviceStack() be undone? */
333 if (PdoDeviceExtension) {
334 RtlFreeUnicodeString(&PdoDeviceExtension->DeviceID);
335 RtlFreeUnicodeString(&PdoDeviceExtension->InstanceID);
336 RtlFreeUnicodeString(&PdoDeviceExtension->HardwareIDs);
337 RtlFreeUnicodeString(&PdoDeviceExtension->CompatibleIDs);
338 RtlFreeUnicodeString(&PdoDeviceExtension->DeviceDescription);
339 RtlFreeUnicodeString(&PdoDeviceExtension->DeviceLocation);
340 }
341
342 ExFreePool(Relations);
343 return ErrorStatus;
344 }
345
346 Irp->IoStatus.Information = (ULONG_PTR)Relations;
347
348 DPRINT("Done\n");
349
350 return Status;
351 }
352
353
354 static NTSTATUS
355 FdoStartDevice(
356 IN PDEVICE_OBJECT DeviceObject,
357 IN PIRP Irp)
358 {
359 PFDO_DEVICE_EXTENSION DeviceExtension;
360 PCM_RESOURCE_LIST AllocatedResources;
361 PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor;
362 ULONG FoundBusNumber = FALSE;
363 ULONG i;
364
365 DPRINT("Called\n");
366
367 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
368
369 AllocatedResources = IoGetCurrentIrpStackLocation(Irp)->Parameters.StartDevice.AllocatedResources;
370 if (!AllocatedResources)
371 {
372 DPRINT("No allocated resources sent to driver\n");
373 return STATUS_INSUFFICIENT_RESOURCES;
374 }
375 if (AllocatedResources->Count < 1)
376 {
377 DPRINT("Not enough allocated resources sent to driver\n");
378 return STATUS_INSUFFICIENT_RESOURCES;
379 }
380 if (AllocatedResources->List[0].PartialResourceList.Version != 1
381 || AllocatedResources->List[0].PartialResourceList.Revision != 1)
382 return STATUS_REVISION_MISMATCH;
383
384 ASSERT(DeviceExtension->State == dsStopped);
385
386 /* By default, use the bus number in the resource list header */
387 DeviceExtension->BusNumber = AllocatedResources->List[0].BusNumber;
388
389 for (i = 0; i < AllocatedResources->List[0].PartialResourceList.Count; i++)
390 {
391 ResourceDescriptor = &AllocatedResources->List[0].PartialResourceList.PartialDescriptors[i];
392 switch (ResourceDescriptor->Type)
393 {
394 case CmResourceTypeBusNumber:
395 {
396 if (FoundBusNumber || ResourceDescriptor->u.BusNumber.Length != 1)
397 return STATUS_INVALID_PARAMETER;
398 /* Use this one instead */
399 ASSERT(AllocatedResources->List[0].BusNumber == ResourceDescriptor->u.BusNumber.Start);
400 DeviceExtension->BusNumber = ResourceDescriptor->u.BusNumber.Start;
401 DPRINT("Found bus number resource: %lu\n", DeviceExtension->BusNumber);
402 FoundBusNumber = TRUE;
403 break;
404 }
405 default:
406 DPRINT("Unknown resource descriptor type 0x%x\n", ResourceDescriptor->Type);
407 }
408 }
409
410 InitializeListHead(&DeviceExtension->DeviceListHead);
411 KeInitializeSpinLock(&DeviceExtension->DeviceListLock);
412 DeviceExtension->DeviceListCount = 0;
413 DeviceExtension->State = dsStarted;
414
415 ExInterlockedInsertTailList(
416 &DriverExtension->BusListHead,
417 &DeviceExtension->ListEntry,
418 &DriverExtension->BusListLock);
419
420 Irp->IoStatus.Information = 0;
421
422 return STATUS_SUCCESS;
423 }
424
425
426 static NTSTATUS
427 FdoSetPower(
428 IN PDEVICE_OBJECT DeviceObject,
429 IN PIRP Irp,
430 PIO_STACK_LOCATION IrpSp)
431 {
432 PFDO_DEVICE_EXTENSION DeviceExtension;
433 NTSTATUS Status;
434
435 DPRINT("Called\n");
436
437 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
438
439 if (IrpSp->Parameters.Power.Type == DevicePowerState) {
440 /* FIXME: Set device power state for the device */
441 Status = STATUS_UNSUCCESSFUL;
442 } else {
443 Status = STATUS_UNSUCCESSFUL;
444 }
445
446 return Status;
447 }
448
449
450 /*** PUBLIC ******************************************************************/
451
452 NTSTATUS
453 FdoPnpControl(
454 PDEVICE_OBJECT DeviceObject,
455 PIRP Irp)
456 /*
457 * FUNCTION: Handle Plug and Play IRPs for the PCI device object
458 * ARGUMENTS:
459 * DeviceObject = Pointer to functional device object of the PCI driver
460 * Irp = Pointer to IRP that should be handled
461 * RETURNS:
462 * Status
463 */
464 {
465 PFDO_DEVICE_EXTENSION DeviceExtension;
466 PIO_STACK_LOCATION IrpSp;
467 NTSTATUS Status;
468
469 DPRINT("Called\n");
470
471 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
472
473 IrpSp = IoGetCurrentIrpStackLocation(Irp);
474 switch (IrpSp->MinorFunction) {
475 #if 0
476 case IRP_MN_CANCEL_REMOVE_DEVICE:
477 Status = STATUS_NOT_IMPLEMENTED;
478 break;
479
480 case IRP_MN_CANCEL_STOP_DEVICE:
481 Status = STATUS_NOT_IMPLEMENTED;
482 break;
483
484 case IRP_MN_DEVICE_USAGE_NOTIFICATION:
485 Status = STATUS_NOT_IMPLEMENTED;
486 break;
487
488 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
489 Status = STATUS_NOT_IMPLEMENTED;
490 break;
491 #endif
492 case IRP_MN_QUERY_DEVICE_RELATIONS:
493 Status = FdoQueryBusRelations(DeviceObject, Irp, IrpSp);
494 break;
495 #if 0
496 case IRP_MN_QUERY_PNP_DEVICE_STATE:
497 Status = STATUS_NOT_IMPLEMENTED;
498 break;
499
500 case IRP_MN_QUERY_REMOVE_DEVICE:
501 Status = STATUS_NOT_IMPLEMENTED;
502 break;
503
504 case IRP_MN_QUERY_STOP_DEVICE:
505 Status = STATUS_NOT_IMPLEMENTED;
506 break;
507
508 case IRP_MN_REMOVE_DEVICE:
509 Status = STATUS_NOT_IMPLEMENTED;
510 break;
511 #endif
512 case IRP_MN_START_DEVICE:
513 DPRINT("IRP_MN_START_DEVICE received\n");
514 Status = FdoStartDevice(DeviceObject, Irp);
515 break;
516 case IRP_MN_STOP_DEVICE:
517 /* Currently not supported */
518 Status = STATUS_UNSUCCESSFUL;
519 break;
520 #if 0
521 case IRP_MN_SURPRISE_REMOVAL:
522 Status = STATUS_NOT_IMPLEMENTED;
523 break;
524 #endif
525 default:
526 DPRINT1("Unknown IOCTL 0x%lx\n", IrpSp->MinorFunction);
527 /* fall through */
528
529 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
530 /*
531 * Do NOT complete the IRP as it will be processed by the lower
532 * device object, which will complete the IRP
533 */
534 IoSkipCurrentIrpStackLocation(Irp);
535 Status = IoCallDriver(DeviceExtension->Ldo, Irp);
536 return Status;
537 break;
538 }
539
540
541 if (Status != STATUS_PENDING) {
542 if (Status != STATUS_NOT_IMPLEMENTED)
543 Irp->IoStatus.Status = Status;
544 IoCompleteRequest(Irp, IO_NO_INCREMENT);
545 }
546
547 DPRINT("Leaving. Status 0x%X\n", Status);
548
549 return Status;
550 }
551
552
553 NTSTATUS
554 FdoPowerControl(
555 PDEVICE_OBJECT DeviceObject,
556 PIRP Irp)
557 /*
558 * FUNCTION: Handle power management IRPs for the PCI device object
559 * ARGUMENTS:
560 * DeviceObject = Pointer to functional device object of the PCI driver
561 * Irp = Pointer to IRP that should be handled
562 * RETURNS:
563 * Status
564 */
565 {
566 PIO_STACK_LOCATION IrpSp;
567 NTSTATUS Status;
568
569 DPRINT("Called\n");
570
571 IrpSp = IoGetCurrentIrpStackLocation(Irp);
572
573 switch (IrpSp->MinorFunction) {
574 case IRP_MN_SET_POWER:
575 Status = FdoSetPower(DeviceObject, Irp, IrpSp);
576 break;
577
578 default:
579 DPRINT("Unknown IOCTL 0x%X\n", IrpSp->MinorFunction);
580 Status = STATUS_NOT_IMPLEMENTED;
581 break;
582 }
583
584 if (Status != STATUS_PENDING) {
585 Irp->IoStatus.Status = Status;
586 IoCompleteRequest(Irp, IO_NO_INCREMENT);
587 }
588
589 DPRINT("Leaving. Status 0x%X\n", Status);
590
591 return Status;
592 }
593
594 /* EOF */