xref: /reactos/drivers/usb/usbccgp/fdo.c (revision ede7a20a) 
1 /*
2  * PROJECT:     ReactOS Universal Serial Bus Bulk Enhanced Host Controller Interface
3  * LICENSE:     GPL - See COPYING in the top level directory
4  * FILE:        drivers/usb/usbccgp/fdo.c
5  * PURPOSE:     USB  device driver.
6  * PROGRAMMERS:
7  *              Michael Martin (michael.martin@reactos.org)
8  *              Johannes Anderwald (johannes.anderwald@reactos.org)
9  *              Cameron Gutman
10  */
11 
12 #include "usbccgp.h"
13 
14 #define NDEBUG
15 #include <debug.h>
16 
17 NTSTATUS
18 NTAPI
19 FDO_QueryCapabilitiesCompletionRoutine(
20     IN PDEVICE_OBJECT DeviceObject,
21     IN PIRP Irp,
22     IN PVOID Context)
23 {
24     /* Set event */
25     KeSetEvent((PRKEVENT)Context, 0, FALSE);
26 
27     /* Completion is done in the HidClassFDO_QueryCapabilities routine */
28     return STATUS_MORE_PROCESSING_REQUIRED;
29 }
30 
31 NTSTATUS
32 FDO_QueryCapabilities(
33     IN PDEVICE_OBJECT DeviceObject,
34     IN OUT PDEVICE_CAPABILITIES Capabilities)
35 {
36     PIRP Irp;
37     KEVENT Event;
38     NTSTATUS Status;
39     PIO_STACK_LOCATION IoStack;
40     PFDO_DEVICE_EXTENSION FDODeviceExtension;
41 
42     /* Get device extension */
43     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
44     ASSERT(FDODeviceExtension->Common.IsFDO);
45 
46     /* Init event */
47     KeInitializeEvent(&Event, NotificationEvent, FALSE);
48 
49     /* Now allocate the irp */
50     Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
51     if (!Irp)
52     {
53         /* No memory */
54         return STATUS_INSUFFICIENT_RESOURCES;
55     }
56 
57     /* Get next stack location */
58     IoStack = IoGetNextIrpStackLocation(Irp);
59 
60     /* Init stack location */
61     IoStack->MajorFunction = IRP_MJ_PNP;
62     IoStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
63     IoStack->Parameters.DeviceCapabilities.Capabilities = Capabilities;
64 
65     /* Set completion routine */
66     IoSetCompletionRoutine(Irp,
67                            FDO_QueryCapabilitiesCompletionRoutine,
68                            (PVOID)&Event,
69                            TRUE,
70                            TRUE,
71                            TRUE);
72 
73     /* Init capabilities */
74     RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES));
75     Capabilities->Size = sizeof(DEVICE_CAPABILITIES);
76     Capabilities->Version = 1; // FIXME hardcoded constant
77     Capabilities->Address = MAXULONG;
78     Capabilities->UINumber = MAXULONG;
79 
80     /* Pnp irps have default completion code */
81     Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
82 
83     /* Call lower device */
84     Status = IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
85     if (Status == STATUS_PENDING)
86     {
87         /* Wait for completion */
88         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
89     }
90 
91     /* Get status */
92     Status = Irp->IoStatus.Status;
93 
94     /* Complete request */
95     IoFreeIrp(Irp);
96 
97     /* Done */
98     return Status;
99 }
100 
101 NTSTATUS
102 FDO_DeviceRelations(
103     PDEVICE_OBJECT DeviceObject,
104     PIRP Irp)
105 {
106     ULONG DeviceCount = 0;
107     ULONG Index;
108     PDEVICE_RELATIONS DeviceRelations;
109     PIO_STACK_LOCATION IoStack;
110     PFDO_DEVICE_EXTENSION FDODeviceExtension;
111 
112     /* Get device extension */
113     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
114 
115     /* Get current irp stack location */
116     IoStack = IoGetCurrentIrpStackLocation(Irp);
117 
118     /* Check if relation type is BusRelations */
119     if (IoStack->Parameters.QueryDeviceRelations.Type != BusRelations)
120     {
121         /* FDO always only handles bus relations */
122         return STATUS_SUCCESS;
123     }
124 
125     /* Go through array and count device objects */
126     for(Index = 0; Index < FDODeviceExtension->FunctionDescriptorCount; Index++)
127     {
128         if (FDODeviceExtension->ChildPDO[Index])
129         {
130             /* Child pdo */
131             DeviceCount++;
132         }
133     }
134 
135     /* Allocate device relations */
136     DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(PagedPool,
137                                                       sizeof(DEVICE_RELATIONS) + (DeviceCount > 1 ? (DeviceCount-1) * sizeof(PDEVICE_OBJECT) : 0));
138     if (!DeviceRelations)
139     {
140         /* No memory */
141         return STATUS_INSUFFICIENT_RESOURCES;
142     }
143 
144     /* Add device objects */
145     for(Index = 0; Index < FDODeviceExtension->FunctionDescriptorCount; Index++)
146     {
147         if (FDODeviceExtension->ChildPDO[Index])
148         {
149             /* Store child pdo */
150             DeviceRelations->Objects[DeviceRelations->Count] = FDODeviceExtension->ChildPDO[Index];
151 
152             /* Add reference */
153             ObReferenceObject(FDODeviceExtension->ChildPDO[Index]);
154 
155             /* Increment count */
156             DeviceRelations->Count++;
157         }
158     }
159 
160     /* Store result */
161     Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
162     Irp->IoStatus.Status = STATUS_SUCCESS;
163 
164     /* Request completed successfully */
165     return STATUS_SUCCESS;
166 }
167 
168 NTSTATUS
169 FDO_CreateChildPdo(
170     IN PDEVICE_OBJECT DeviceObject)
171 {
172     NTSTATUS Status;
173     PDEVICE_OBJECT PDODeviceObject;
174     PPDO_DEVICE_EXTENSION PDODeviceExtension;
175     PFDO_DEVICE_EXTENSION FDODeviceExtension;
176     ULONG Index;
177 
178     /* Get device extension */
179     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
180     ASSERT(FDODeviceExtension->Common.IsFDO);
181 
182     /* Lets create array for the child PDO */
183     FDODeviceExtension->ChildPDO = AllocateItem(NonPagedPool,
184                                                 sizeof(PDEVICE_OBJECT) * FDODeviceExtension->FunctionDescriptorCount);
185     if (!FDODeviceExtension->ChildPDO)
186     {
187         /* No memory */
188         return STATUS_INSUFFICIENT_RESOURCES;
189     }
190 
191     /* Create pdo for each function */
192     for(Index = 0; Index < FDODeviceExtension->FunctionDescriptorCount; Index++)
193     {
194         /* Create the PDO */
195         Status = IoCreateDevice(FDODeviceExtension->DriverObject,
196                                 sizeof(PDO_DEVICE_EXTENSION),
197                                 NULL,
198                                 FILE_DEVICE_USB,
199                                 FILE_AUTOGENERATED_DEVICE_NAME,
200                                 FALSE,
201                                 &PDODeviceObject);
202         if (!NT_SUCCESS(Status))
203         {
204             /* Failed to create device object */
205             DPRINT1("IoCreateDevice failed with %x\n", Status);
206             return Status;
207         }
208 
209         /* Store in array */
210         FDODeviceExtension->ChildPDO[Index] = PDODeviceObject;
211 
212         /* Get device extension */
213         PDODeviceExtension = (PPDO_DEVICE_EXTENSION)PDODeviceObject->DeviceExtension;
214         RtlZeroMemory(PDODeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
215 
216         /* Init device extension */
217         PDODeviceExtension->Common.IsFDO = FALSE;
218         PDODeviceExtension->FunctionDescriptor = &FDODeviceExtension->FunctionDescriptor[Index];
219         PDODeviceExtension->NextDeviceObject = DeviceObject;
220         PDODeviceExtension->FunctionIndex = Index;
221         PDODeviceExtension->FDODeviceExtension = FDODeviceExtension;
222         PDODeviceExtension->InterfaceList = FDODeviceExtension->InterfaceList;
223         PDODeviceExtension->InterfaceListCount = FDODeviceExtension->InterfaceListCount;
224         PDODeviceExtension->ConfigurationHandle = FDODeviceExtension->ConfigurationHandle;
225         PDODeviceExtension->ConfigurationDescriptor = FDODeviceExtension->ConfigurationDescriptor;
226         RtlCopyMemory(&PDODeviceExtension->Capabilities, &FDODeviceExtension->Capabilities, sizeof(DEVICE_CAPABILITIES));
227         RtlCopyMemory(&PDODeviceExtension->DeviceDescriptor, FDODeviceExtension->DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
228 
229         /* Patch the stack size */
230         PDODeviceObject->StackSize = DeviceObject->StackSize + 1;
231 
232         /* Set device flags */
233         PDODeviceObject->Flags |= DO_DIRECT_IO | DO_MAP_IO_BUFFER;
234 
235         /* Device is initialized */
236         PDODeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
237     }
238 
239     /* Done */
240     return STATUS_SUCCESS;
241 }
242 
243 NTSTATUS
244 FDO_StartDevice(
245     PDEVICE_OBJECT DeviceObject,
246     PIRP Irp)
247 {
248     NTSTATUS Status;
249     PFDO_DEVICE_EXTENSION FDODeviceExtension;
250 
251     /* Get device extension */
252     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
253     ASSERT(FDODeviceExtension->Common.IsFDO);
254 
255     /* First start lower device */
256     Status = USBCCGP_SyncForwardIrp(FDODeviceExtension->NextDeviceObject, Irp);
257 
258     if (!NT_SUCCESS(Status))
259     {
260         /* Failed to start lower device */
261         DPRINT1("FDO_StartDevice lower device failed to start with %x\n", Status);
262         return Status;
263     }
264 
265     /* Get descriptors */
266     Status = USBCCGP_GetDescriptors(DeviceObject);
267     if (!NT_SUCCESS(Status))
268     {
269         /* Failed to start lower device */
270         DPRINT1("FDO_StartDevice failed to get descriptors with %x\n", Status);
271         return Status;
272     }
273 
274     /* Get capabilities */
275     Status = FDO_QueryCapabilities(DeviceObject,
276                                    &FDODeviceExtension->Capabilities);
277     if (!NT_SUCCESS(Status))
278     {
279         /* Failed to start lower device */
280         DPRINT1("FDO_StartDevice failed to get capabilities with %x\n", Status);
281         return Status;
282     }
283 
284     /* Now select the configuration */
285     Status = USBCCGP_SelectConfiguration(DeviceObject, FDODeviceExtension);
286     if (!NT_SUCCESS(Status))
287     {
288         /* Failed to select interface */
289         DPRINT1("FDO_StartDevice failed to get capabilities with %x\n", Status);
290         return Status;
291     }
292 
293     /* Query bus interface */
294     USBCCGP_QueryInterface(FDODeviceExtension->NextDeviceObject,
295                            &FDODeviceExtension->BusInterface);
296 
297     /* Now enumerate the functions */
298     Status = USBCCGP_EnumerateFunctions(DeviceObject);
299     if (!NT_SUCCESS(Status))
300     {
301         /* Failed to enumerate functions */
302         DPRINT1("Failed to enumerate functions with %x\n", Status);
303         return Status;
304     }
305 
306     /* Sanity checks */
307     ASSERT(FDODeviceExtension->FunctionDescriptorCount);
308     ASSERT(FDODeviceExtension->FunctionDescriptor);
309     DumpFunctionDescriptor(FDODeviceExtension->FunctionDescriptor,
310                            FDODeviceExtension->FunctionDescriptorCount);
311 
312     /* Now create the pdo */
313     Status = FDO_CreateChildPdo(DeviceObject);
314     if (!NT_SUCCESS(Status))
315     {
316         /* Failed */
317         DPRINT1("FDO_CreateChildPdo failed with %x\n", Status);
318         return Status;
319     }
320 
321     /* Inform pnp manager of new device objects */
322     IoInvalidateDeviceRelations(FDODeviceExtension->PhysicalDeviceObject,
323                                 BusRelations);
324 
325     /* Done */
326     DPRINT("[USBCCGP] FDO initialized successfully\n");
327     return Status;
328 }
329 
330 NTSTATUS
331 FDO_CloseConfiguration(
332     IN PDEVICE_OBJECT DeviceObject)
333 {
334     NTSTATUS Status;
335     PURB Urb;
336     PFDO_DEVICE_EXTENSION FDODeviceExtension;
337 
338     /* Get device extension */
339     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
340     ASSERT(FDODeviceExtension->Common.IsFDO);
341 
342     /* Nothing to do if we're not configured */
343     if (FDODeviceExtension->ConfigurationDescriptor == NULL ||
344         FDODeviceExtension->InterfaceList == NULL)
345     {
346         return STATUS_SUCCESS;
347     }
348 
349     /* Now allocate the urb */
350     Urb = USBD_CreateConfigurationRequestEx(FDODeviceExtension->ConfigurationDescriptor,
351                                             FDODeviceExtension->InterfaceList);
352     if (!Urb)
353     {
354         /* No memory */
355         return STATUS_INSUFFICIENT_RESOURCES;
356     }
357 
358     /* Clear configuration descriptor to make it an unconfigure request */
359     Urb->UrbSelectConfiguration.ConfigurationDescriptor = NULL;
360 
361     /* Submit urb */
362     Status = USBCCGP_SyncUrbRequest(FDODeviceExtension->NextDeviceObject, Urb);
363     if (!NT_SUCCESS(Status))
364     {
365         /* Failed to set configuration */
366         DPRINT1("USBCCGP_SyncUrbRequest failed to unconfigure device\n", Status);
367     }
368 
369     ExFreePool(Urb);
370     return Status;
371 }
372 
373 
374 NTSTATUS
375 FDO_HandlePnp(
376     PDEVICE_OBJECT DeviceObject,
377     PIRP Irp)
378 {
379     PIO_STACK_LOCATION IoStack;
380     NTSTATUS Status;
381     PFDO_DEVICE_EXTENSION FDODeviceExtension;
382 
383     /* Get device extension */
384     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
385     ASSERT(FDODeviceExtension->Common.IsFDO);
386 
387 
388     /* Get stack location */
389     IoStack = IoGetCurrentIrpStackLocation(Irp);
390     DPRINT("[USBCCGP] PnP Minor %x\n", IoStack->MinorFunction);
391     switch(IoStack->MinorFunction)
392     {
393         case IRP_MN_REMOVE_DEVICE:
394         {
395             // Unconfigure device */
396             DPRINT1("[USBCCGP] FDO IRP_MN_REMOVE\n");
397             FDO_CloseConfiguration(DeviceObject);
398 
399             /* Send the IRP down the stack */
400             Irp->IoStatus.Status = STATUS_SUCCESS;
401             IoSkipCurrentIrpStackLocation(Irp);
402             Status = IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
403 
404             /* Detach from the device stack */
405             IoDetachDevice(FDODeviceExtension->NextDeviceObject);
406 
407             /* Delete the device object */
408             IoDeleteDevice(DeviceObject);
409 
410             /* Request completed */
411             break;
412         }
413         case IRP_MN_START_DEVICE:
414         {
415             /* Start the device */
416             Status = FDO_StartDevice(DeviceObject, Irp);
417             break;
418         }
419         case IRP_MN_QUERY_DEVICE_RELATIONS:
420         {
421             /* Handle device relations */
422             Status = FDO_DeviceRelations(DeviceObject, Irp);
423             if (!NT_SUCCESS(Status))
424             {
425                 break;
426             }
427 
428             /* Forward irp to next device object */
429             IoSkipCurrentIrpStackLocation(Irp);
430             return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
431         }
432         case IRP_MN_QUERY_CAPABILITIES:
433         {
434             /* Copy capabilities */
435             RtlCopyMemory(IoStack->Parameters.DeviceCapabilities.Capabilities,
436                           &FDODeviceExtension->Capabilities,
437                           sizeof(DEVICE_CAPABILITIES));
438             Status = USBCCGP_SyncForwardIrp(FDODeviceExtension->NextDeviceObject, Irp);
439             if (NT_SUCCESS(Status))
440             {
441                 /* Surprise removal ok */
442                 IoStack->Parameters.DeviceCapabilities.Capabilities->SurpriseRemovalOK = TRUE;
443             }
444             break;
445        }
446         case IRP_MN_QUERY_REMOVE_DEVICE:
447         case IRP_MN_QUERY_STOP_DEVICE:
448         {
449             /* Sure */
450             Irp->IoStatus.Status = STATUS_SUCCESS;
451 
452             /* Forward irp to next device object */
453             IoSkipCurrentIrpStackLocation(Irp);
454             return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
455         }
456        default:
457        {
458             /* Forward irp to next device object */
459             IoSkipCurrentIrpStackLocation(Irp);
460             return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
461        }
462 
463     }
464 
465     /* Complete request */
466     Irp->IoStatus.Status = Status;
467     IoCompleteRequest(Irp, IO_NO_INCREMENT);
468     return Status;
469 }
470 
471 NTSTATUS
472 FDO_HandleResetCyclePort(
473     PDEVICE_OBJECT DeviceObject,
474     PIRP Irp)
475 {
476     PIO_STACK_LOCATION IoStack;
477     NTSTATUS Status;
478     PFDO_DEVICE_EXTENSION FDODeviceExtension;
479     PLIST_ENTRY ListHead, Entry;
480     LIST_ENTRY TempList;
481     PUCHAR ResetActive;
482     PIRP ListIrp;
483     KIRQL OldLevel;
484 
485     /* Get device extension */
486     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
487     ASSERT(FDODeviceExtension->Common.IsFDO);
488 
489     /* Get stack location */
490     IoStack = IoGetCurrentIrpStackLocation(Irp);
491     DPRINT("FDO_HandleResetCyclePort IOCTL %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
492 
493     if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_RESET_PORT)
494     {
495         /* Use reset port list */
496         ListHead = &FDODeviceExtension->ResetPortListHead;
497         ResetActive = &FDODeviceExtension->ResetPortActive;
498     }
499     else
500     {
501         /* Use cycle port list */
502         ListHead = &FDODeviceExtension->CyclePortListHead;
503         ResetActive = &FDODeviceExtension->CyclePortActive;
504     }
505 
506     /* Acquire lock */
507     KeAcquireSpinLock(&FDODeviceExtension->Lock, &OldLevel);
508 
509     if (*ResetActive)
510     {
511         /* Insert into pending list */
512         InsertTailList(ListHead, &Irp->Tail.Overlay.ListEntry);
513 
514         /* Mark irp pending */
515         IoMarkIrpPending(Irp);
516         Status = STATUS_PENDING;
517 
518         /* Release lock */
519         KeReleaseSpinLock(&FDODeviceExtension->Lock, OldLevel);
520     }
521     else
522     {
523         /* Mark reset active */
524         *ResetActive = TRUE;
525 
526         /* Release lock */
527         KeReleaseSpinLock(&FDODeviceExtension->Lock, OldLevel);
528 
529         /* Forward request synchronized */
530         USBCCGP_SyncForwardIrp(FDODeviceExtension->NextDeviceObject, Irp);
531 
532         /* Reacquire lock */
533         KeAcquireSpinLock(&FDODeviceExtension->Lock, &OldLevel);
534 
535         /* Mark reset as completed */
536         *ResetActive = FALSE;
537 
538         /* Move all requests into temporary list */
539         InitializeListHead(&TempList);
540         while(!IsListEmpty(ListHead))
541         {
542             Entry = RemoveHeadList(ListHead);
543             InsertTailList(&TempList, Entry);
544         }
545 
546         /* Release lock */
547         KeReleaseSpinLock(&FDODeviceExtension->Lock, OldLevel);
548 
549         /* Complete pending irps */
550         while(!IsListEmpty(&TempList))
551         {
552             Entry = RemoveHeadList(&TempList);
553             ListIrp = (PIRP)CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
554 
555             /* Complete request with status success */
556             ListIrp->IoStatus.Status = STATUS_SUCCESS;
557             IoCompleteRequest(ListIrp, IO_NO_INCREMENT);
558         }
559 
560         /* Status success */
561         Status = STATUS_SUCCESS;
562     }
563 
564     return Status;
565 }
566 
567 
568 
569 NTSTATUS
570 FDO_HandleInternalDeviceControl(
571     PDEVICE_OBJECT DeviceObject,
572     PIRP Irp)
573 {
574     PIO_STACK_LOCATION IoStack;
575     NTSTATUS Status;
576     PFDO_DEVICE_EXTENSION FDODeviceExtension;
577 
578     /* Get device extension */
579     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
580     ASSERT(FDODeviceExtension->Common.IsFDO);
581 
582     /* Get stack location */
583     IoStack = IoGetCurrentIrpStackLocation(Irp);
584 
585     if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_RESET_PORT ||
586         IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_CYCLE_PORT)
587     {
588         /* Handle reset / cycle ports */
589         Status = FDO_HandleResetCyclePort(DeviceObject, Irp);
590         DPRINT("FDO_HandleResetCyclePort Status %x\n", Status);
591         if (Status != STATUS_PENDING)
592         {
593             /* Complete request */
594             Irp->IoStatus.Status = Status;
595             IoCompleteRequest(Irp, IO_NO_INCREMENT);
596         }
597         return Status;
598     }
599 
600     /* Forward and forget request */
601     IoSkipCurrentIrpStackLocation(Irp);
602     return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
603 }
604 
605 NTSTATUS
606 FDO_HandleSystemControl(
607     PDEVICE_OBJECT DeviceObject,
608     PIRP Irp)
609 {
610     PFDO_DEVICE_EXTENSION FDODeviceExtension;
611 
612     /* Get device extension */
613     FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
614     ASSERT(FDODeviceExtension->Common.IsFDO);
615 
616     /* Forward and forget request */
617     IoSkipCurrentIrpStackLocation(Irp);
618     return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
619 }
620 
621 NTSTATUS
622 FDO_Dispatch(
623     PDEVICE_OBJECT DeviceObject,
624     PIRP Irp)
625 {
626     PIO_STACK_LOCATION IoStack;
627     NTSTATUS Status;
628     PFDO_DEVICE_EXTENSION FDODeviceExtension;
629 
630     /* Get device extension */
631     FDODeviceExtension = DeviceObject->DeviceExtension;
632     ASSERT(FDODeviceExtension->Common.IsFDO);
633 
634     /* Get stack location */
635     IoStack = IoGetCurrentIrpStackLocation(Irp);
636 
637     switch(IoStack->MajorFunction)
638     {
639         case IRP_MJ_PNP:
640             return FDO_HandlePnp(DeviceObject, Irp);
641         case IRP_MJ_INTERNAL_DEVICE_CONTROL:
642             return FDO_HandleInternalDeviceControl(DeviceObject, Irp);
643         case IRP_MJ_POWER:
644             PoStartNextPowerIrp(Irp);
645             IoSkipCurrentIrpStackLocation(Irp);
646             return PoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
647         case IRP_MJ_SYSTEM_CONTROL:
648             return FDO_HandleSystemControl(DeviceObject, Irp);
649         default:
650             DPRINT1("FDO_Dispatch Function %x not implemented\n", IoStack->MajorFunction);
651             ASSERT(FALSE);
652             Status = Irp->IoStatus.Status;
653             IoCompleteRequest(Irp, IO_NO_INCREMENT);
654             return Status;
655     }
656 
657 }
658