Sunc with trunk revision 58971.
[reactos.git] / drivers / bluetooth / fbtusb / fbtpnp.c
1 // Copyright (c) 2004, Antony C. Roberts
2
3 // Use of this file is subject to the terms
4 // described in the LICENSE.TXT file that
5 // accompanies this file.
6 //
7 // Your use of this file indicates your
8 // acceptance of the terms described in
9 // LICENSE.TXT.
10 //
11 // http://www.freebt.net
12
13 #include "stdio.h"
14 #include "fbtusb.h"
15 #include "fbtpnp.h"
16 #include "fbtpwr.h"
17 #include "fbtdev.h"
18 #include "fbtrwr.h"
19 #include "fbtwmi.h"
20
21 #include "fbtusr.h"
22
23 // Handle PNP events
24 NTSTATUS NTAPI FreeBT_DispatchPnP(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
25 {
26 PIO_STACK_LOCATION irpStack;
27 PDEVICE_EXTENSION deviceExtension;
28 //KEVENT startDeviceEvent;
29 NTSTATUS ntStatus;
30
31 irpStack = IoGetCurrentIrpStackLocation(Irp);
32 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
33
34 // since the device is removed, fail the Irp.
35 if (Removed == deviceExtension->DeviceState)
36 {
37 ntStatus = STATUS_DELETE_PENDING;
38 Irp->IoStatus.Status = ntStatus;
39 Irp->IoStatus.Information = 0;
40 IoCompleteRequest(Irp, IO_NO_INCREMENT);
41 return ntStatus;
42
43 }
44
45 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchPnP::"));
46 FreeBT_IoIncrement(deviceExtension);
47 if (irpStack->MinorFunction == IRP_MN_START_DEVICE)
48 {
49 ASSERT(deviceExtension->IdleReqPend == 0);
50
51 }
52
53 else
54 {
55 if (deviceExtension->SSEnable)
56 {
57 CancelSelectSuspend(deviceExtension);
58
59 }
60
61 }
62
63 FreeBT_DbgPrint(3, ("FBTUSB: ///////////////////////////////////////////\n"));
64 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchPnP::"));
65 FreeBT_DbgPrint(2, (PnPMinorFunctionString(irpStack->MinorFunction)));
66 switch (irpStack->MinorFunction)
67 {
68 case IRP_MN_START_DEVICE:
69 ntStatus = HandleStartDevice(DeviceObject, Irp);
70 break;
71
72 case IRP_MN_QUERY_STOP_DEVICE:
73 // if we cannot stop the device, we fail the query stop irp
74 ntStatus = CanStopDevice(DeviceObject, Irp);
75 if(NT_SUCCESS(ntStatus))
76 {
77 ntStatus = HandleQueryStopDevice(DeviceObject, Irp);
78 return ntStatus;
79
80 }
81
82 break;
83
84 case IRP_MN_CANCEL_STOP_DEVICE:
85 ntStatus = HandleCancelStopDevice(DeviceObject, Irp);
86 break;
87
88 case IRP_MN_STOP_DEVICE:
89 ntStatus = HandleStopDevice(DeviceObject, Irp);
90 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchPnP::IRP_MN_STOP_DEVICE::"));
91 FreeBT_IoDecrement(deviceExtension);
92
93 return ntStatus;
94
95 case IRP_MN_QUERY_REMOVE_DEVICE:
96 // if we cannot remove the device, we fail the query remove irp
97 ntStatus = HandleQueryRemoveDevice(DeviceObject, Irp);
98
99 return ntStatus;
100
101 case IRP_MN_CANCEL_REMOVE_DEVICE:
102 ntStatus = HandleCancelRemoveDevice(DeviceObject, Irp);
103 break;
104
105 case IRP_MN_SURPRISE_REMOVAL:
106 ntStatus = HandleSurpriseRemoval(DeviceObject, Irp);
107 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchPnP::IRP_MN_SURPRISE_REMOVAL::"));
108 FreeBT_IoDecrement(deviceExtension);
109 return ntStatus;
110
111 case IRP_MN_REMOVE_DEVICE:
112 ntStatus = HandleRemoveDevice(DeviceObject, Irp);
113 return ntStatus;
114
115 case IRP_MN_QUERY_CAPABILITIES:
116 ntStatus = HandleQueryCapabilities(DeviceObject, Irp);
117 break;
118
119 default:
120 IoSkipCurrentIrpStackLocation(Irp);
121
122 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
123
124 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchPnP::default::"));
125 FreeBT_IoDecrement(deviceExtension);
126
127 return ntStatus;
128
129 }
130
131 Irp->IoStatus.Status = ntStatus;
132 Irp->IoStatus.Information = 0;
133 IoCompleteRequest(Irp, IO_NO_INCREMENT);
134
135 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchPnP::"));
136 FreeBT_IoDecrement(deviceExtension);
137
138 return ntStatus;
139
140 }
141
142 NTSTATUS NTAPI HandleStartDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
143 {
144 KIRQL oldIrql;
145 KEVENT startDeviceEvent;
146 NTSTATUS ntStatus;
147 PDEVICE_EXTENSION deviceExtension;
148 LARGE_INTEGER dueTime;
149
150 FreeBT_DbgPrint(3, ("FBTUSB: HandleStartDevice: Entered\n"));
151
152 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
153 deviceExtension->UsbConfigurationDescriptor = NULL;
154 deviceExtension->UsbInterface = NULL;
155 deviceExtension->PipeContext = NULL;
156
157 // We cannot touch the device (send it any non pnp irps) until a
158 // start device has been passed down to the lower drivers.
159 // first pass the Irp down
160 KeInitializeEvent(&startDeviceEvent, NotificationEvent, FALSE);
161 IoCopyCurrentIrpStackLocationToNext(Irp);
162 IoSetCompletionRoutine(Irp,
163 (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine,
164 (PVOID)&startDeviceEvent,
165 TRUE,
166 TRUE,
167 TRUE);
168
169 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
170 if (ntStatus == STATUS_PENDING)
171 {
172 KeWaitForSingleObject(&startDeviceEvent, Executive, KernelMode, FALSE, NULL);
173 ntStatus = Irp->IoStatus.Status;
174
175 }
176
177 if (!NT_SUCCESS(ntStatus))
178 {
179 FreeBT_DbgPrint(1, ("FBTUSB: HandleStartDevice: Lower drivers failed this Irp (0x%08x)\n", ntStatus));
180 return ntStatus;
181
182 }
183
184 // Read the device descriptor, configuration descriptor
185 // and select the interface descriptors
186 ntStatus = ReadandSelectDescriptors(DeviceObject);
187 if (!NT_SUCCESS(ntStatus))
188 {
189 FreeBT_DbgPrint(1, ("FBTUSB: HandleStartDevice: ReadandSelectDescriptors failed (0x%08x)\n", ntStatus));
190 return ntStatus;
191
192 }
193
194 // enable the symbolic links for system components to open
195 // handles to the device
196 ntStatus = IoSetDeviceInterfaceState(&deviceExtension->InterfaceName, TRUE);
197 if (!NT_SUCCESS(ntStatus))
198 {
199 FreeBT_DbgPrint(1, ("FBTUSB: HandleStartDevice: IoSetDeviceInterfaceState failed (0x%08x)\n", ntStatus));
200 return ntStatus;
201
202 }
203
204 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
205
206 SET_NEW_PNP_STATE(deviceExtension, Working);
207 deviceExtension->QueueState = AllowRequests;
208
209 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
210
211 deviceExtension->FlagWWOutstanding = 0;
212 deviceExtension->FlagWWCancel = 0;
213 deviceExtension->WaitWakeIrp = NULL;
214
215 if (deviceExtension->WaitWakeEnable)
216 {
217 IssueWaitWake(deviceExtension);
218
219 }
220
221 ProcessQueuedRequests(deviceExtension);
222 if (WinXpOrBetter == deviceExtension->WdmVersion)
223 {
224 deviceExtension->SSEnable = deviceExtension->SSRegistryEnable;
225
226 // set timer.for selective suspend requests
227 if (deviceExtension->SSEnable)
228 {
229 dueTime.QuadPart = -10000 * IDLE_INTERVAL; // 5000 ms
230 KeSetTimerEx(&deviceExtension->Timer, dueTime, IDLE_INTERVAL, &deviceExtension->DeferredProcCall);
231 deviceExtension->FreeIdleIrpCount = 0;
232
233 }
234
235 }
236
237 FreeBT_DbgPrint(3, ("FBTUSB: HandleStartDevice: Leaving\n"));
238
239 return ntStatus;
240
241 }
242
243
244 NTSTATUS NTAPI ReadandSelectDescriptors(IN PDEVICE_OBJECT DeviceObject)
245 {
246 PURB urb;
247 ULONG siz;
248 NTSTATUS ntStatus;
249 PUSB_DEVICE_DESCRIPTOR deviceDescriptor;
250
251 urb = NULL;
252 deviceDescriptor = NULL;
253
254 // 1. Read the device descriptor
255 urb = (PURB) ExAllocatePool(NonPagedPool, sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
256 if(urb)
257 {
258 siz = sizeof(USB_DEVICE_DESCRIPTOR);
259 deviceDescriptor = (PUSB_DEVICE_DESCRIPTOR) ExAllocatePool(NonPagedPool, siz);
260 if (deviceDescriptor)
261 {
262 UsbBuildGetDescriptorRequest(
263 urb,
264 (USHORT) sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
265 USB_DEVICE_DESCRIPTOR_TYPE,
266 0,
267 0,
268 deviceDescriptor,
269 NULL,
270 siz,
271 NULL);
272
273 ntStatus = CallUSBD(DeviceObject, urb);
274 if (NT_SUCCESS(ntStatus))
275 {
276 ASSERT(deviceDescriptor->bNumConfigurations);
277 ntStatus = ConfigureDevice(DeviceObject);
278
279 }
280
281 ExFreePool(urb);
282 ExFreePool(deviceDescriptor);
283
284 }
285
286 else
287 {
288 FreeBT_DbgPrint(1, ("FBTUSB: ReadandSelectDescriptors: Failed to allocate memory for deviceDescriptor"));
289 ExFreePool(urb);
290 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
291
292 }
293
294 }
295
296 else
297 {
298 FreeBT_DbgPrint(1, ("FBTUSB: ReadandSelectDescriptors: Failed to allocate memory for urb"));
299 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
300
301 }
302
303
304 return ntStatus;
305
306 }
307
308 NTSTATUS NTAPI ConfigureDevice(IN PDEVICE_OBJECT DeviceObject)
309 {
310 PURB urb;
311 ULONG siz;
312 NTSTATUS ntStatus;
313 PDEVICE_EXTENSION deviceExtension;
314 PUSB_CONFIGURATION_DESCRIPTOR configurationDescriptor;
315
316 urb = NULL;
317 configurationDescriptor = NULL;
318 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
319
320 // Read the first configuration descriptor
321 // This requires two steps:
322 // 1. Read the fixed sized configuration desciptor (CD)
323 // 2. Read the CD with all embedded interface and endpoint descriptors
324 urb = (PURB) ExAllocatePool(NonPagedPool, sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
325 if (urb)
326 {
327 siz = sizeof(USB_CONFIGURATION_DESCRIPTOR);
328 configurationDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR) ExAllocatePool(NonPagedPool, siz);
329
330 if(configurationDescriptor)
331 {
332 UsbBuildGetDescriptorRequest(
333 urb,
334 (USHORT) sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
335 USB_CONFIGURATION_DESCRIPTOR_TYPE,
336 0,
337 0,
338 configurationDescriptor,
339 NULL,
340 sizeof(USB_CONFIGURATION_DESCRIPTOR),
341 NULL);
342
343 ntStatus = CallUSBD(DeviceObject, urb);
344 if(!NT_SUCCESS(ntStatus))
345 {
346 FreeBT_DbgPrint(1, ("FBTUSB: ConfigureDevice: UsbBuildGetDescriptorRequest failed\n"));
347 goto ConfigureDevice_Exit;
348
349 }
350
351 }
352
353 else
354 {
355 FreeBT_DbgPrint(1, ("FBTUSB: ConfigureDevice: Failed to allocate mem for config Descriptor\n"));
356 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
357 goto ConfigureDevice_Exit;
358
359 }
360
361 siz = configurationDescriptor->wTotalLength;
362 ExFreePool(configurationDescriptor);
363
364 configurationDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR) ExAllocatePool(NonPagedPool, siz);
365 if (configurationDescriptor)
366 {
367 UsbBuildGetDescriptorRequest(
368 urb,
369 (USHORT)sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
370 USB_CONFIGURATION_DESCRIPTOR_TYPE,
371 0,
372 0,
373 configurationDescriptor,
374 NULL,
375 siz,
376 NULL);
377
378 ntStatus = CallUSBD(DeviceObject, urb);
379 if (!NT_SUCCESS(ntStatus))
380 {
381 FreeBT_DbgPrint(1,("FBTUSB: ConfigureDevice: Failed to read configuration descriptor"));
382 goto ConfigureDevice_Exit;
383
384 }
385
386 }
387
388 else
389 {
390 FreeBT_DbgPrint(1, ("FBTUSB: ConfigureDevice: Failed to alloc mem for config Descriptor\n"));
391 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
392 goto ConfigureDevice_Exit;
393
394 }
395
396 }
397
398 else
399 {
400 FreeBT_DbgPrint(1, ("FBTUSB: ConfigureDevice: Failed to allocate memory for urb\n"));
401 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
402 goto ConfigureDevice_Exit;
403
404 }
405
406 if (configurationDescriptor)
407 {
408 // save a copy of configurationDescriptor in deviceExtension
409 // remember to free it later.
410 deviceExtension->UsbConfigurationDescriptor = configurationDescriptor;
411
412 if (configurationDescriptor->bmAttributes & REMOTE_WAKEUP_MASK)
413 {
414 // this configuration supports remote wakeup
415 deviceExtension->WaitWakeEnable = 1;
416
417 }
418
419 else
420 {
421 deviceExtension->WaitWakeEnable = 0;
422
423 }
424
425 ntStatus = SelectInterfaces(DeviceObject, configurationDescriptor);
426
427 }
428
429 else
430 {
431 deviceExtension->UsbConfigurationDescriptor = NULL;
432
433 }
434
435 ConfigureDevice_Exit:
436 if (urb)
437 {
438 ExFreePool(urb);
439
440 }
441
442 return ntStatus;
443
444 }
445
446 NTSTATUS NTAPI SelectInterfaces(IN PDEVICE_OBJECT DeviceObject, IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor)
447 {
448 LONG numberOfInterfaces, interfaceNumber, interfaceindex;
449 ULONG i;
450 PURB urb;
451 //PUCHAR pInf;
452 NTSTATUS ntStatus;
453 PDEVICE_EXTENSION deviceExtension;
454 PUSB_INTERFACE_DESCRIPTOR interfaceDescriptor;
455 PUSBD_INTERFACE_LIST_ENTRY interfaceList,
456 tmp;
457 PUSBD_INTERFACE_INFORMATION Interface;
458
459 urb = NULL;
460 Interface = NULL;
461 interfaceDescriptor = NULL;
462 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
463 numberOfInterfaces = ConfigurationDescriptor->bNumInterfaces;
464 interfaceindex = interfaceNumber = 0;
465
466 // Parse the configuration descriptor for the interface;
467 tmp = interfaceList = (PUSBD_INTERFACE_LIST_ENTRY)
468 ExAllocatePool(NonPagedPool, sizeof(USBD_INTERFACE_LIST_ENTRY) * (numberOfInterfaces + 1));
469
470 if (!tmp)
471 {
472
473 FreeBT_DbgPrint(1, ("FBTUSB: SelectInterfaces: Failed to allocate mem for interfaceList\n"));
474 return STATUS_INSUFFICIENT_RESOURCES;
475
476 }
477
478
479 FreeBT_DbgPrint(3, ("FBTUSB: -------------\n"));
480 FreeBT_DbgPrint(3, ("FBTUSB: Number of interfaces %d\n", numberOfInterfaces));
481
482 while (interfaceNumber < numberOfInterfaces)
483 {
484 interfaceDescriptor = USBD_ParseConfigurationDescriptorEx(
485 ConfigurationDescriptor,
486 ConfigurationDescriptor,
487 interfaceindex,
488 0, -1, -1, -1);
489
490 if (interfaceDescriptor)
491 {
492 interfaceList->InterfaceDescriptor = interfaceDescriptor;
493 interfaceList->Interface = NULL;
494 interfaceList++;
495 interfaceNumber++;
496
497 }
498
499 interfaceindex++;
500
501 }
502
503 interfaceList->InterfaceDescriptor = NULL;
504 interfaceList->Interface = NULL;
505 urb = USBD_CreateConfigurationRequestEx(ConfigurationDescriptor, tmp);
506
507 if (urb)
508 {
509 Interface = &urb->UrbSelectConfiguration.Interface;
510 for (i=0; i<Interface->NumberOfPipes; i++)
511 {
512 // perform pipe initialization here
513 // set the transfer size and any pipe flags we use
514 // USBD sets the rest of the Interface struct members
515 Interface->Pipes[i].MaximumTransferSize = USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE;
516
517 }
518
519 ntStatus = CallUSBD(DeviceObject, urb);
520 if (NT_SUCCESS(ntStatus))
521 {
522 // save a copy of interface information in the device extension.
523 deviceExtension->UsbInterface = (PUSBD_INTERFACE_INFORMATION) ExAllocatePool(NonPagedPool, Interface->Length);
524 if (deviceExtension->UsbInterface)
525 {
526 RtlCopyMemory(deviceExtension->UsbInterface, Interface, Interface->Length);
527
528 }
529
530 else
531 {
532 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
533 FreeBT_DbgPrint(1, ("FBTUSB: SelectInterfaces: Memory alloc for UsbInterface failed\n"));
534
535 }
536
537 // Dump the interface to the debugger
538 Interface = &urb->UrbSelectConfiguration.Interface;
539
540 FreeBT_DbgPrint(3, ("FBTUSB: ---------\n"));
541 FreeBT_DbgPrint(3, ("FBTUSB: NumberOfPipes 0x%x\n", Interface->NumberOfPipes));
542 FreeBT_DbgPrint(3, ("FBTUSB: Length 0x%x\n", Interface->Length));
543 FreeBT_DbgPrint(3, ("FBTUSB: Alt Setting 0x%x\n", Interface->AlternateSetting));
544 FreeBT_DbgPrint(3, ("FBTUSB: Interface Number 0x%x\n", Interface->InterfaceNumber));
545 FreeBT_DbgPrint(3, ("FBTUSB: Class, subclass, protocol 0x%x 0x%x 0x%x\n",
546 Interface->Class,
547 Interface->SubClass,
548 Interface->Protocol));
549
550 if (Interface->Class==FREEBT_USB_STDCLASS && Interface->SubClass==FREEBT_USB_STDSUBCLASS &&
551 Interface->Protocol==FREEBT_USB_STDPROTOCOL)
552 {
553 FreeBT_DbgPrint(3, ("FBTUSB: This is a standard USB Bluetooth device\n"));
554
555 }
556
557 else
558 {
559 FreeBT_DbgPrint(3, ("FBTUSB: WARNING: This device does not report itself as a standard USB Bluetooth device\n"));
560
561 }
562
563 // Initialize the PipeContext
564 // Dump the pipe info
565 deviceExtension->PipeContext = (PFREEBT_PIPE_CONTEXT) ExAllocatePool(
566 NonPagedPool,
567 Interface->NumberOfPipes *
568 sizeof(FREEBT_PIPE_CONTEXT));
569
570 if (!deviceExtension->PipeContext)
571 {
572 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
573 FreeBT_DbgPrint(1, ("FBTUSB: Memory alloc for UsbInterface failed\n"));
574
575 }
576
577 else
578 {
579 FreeBT_DbgPrint(3, ("FBTUSB: SelectInterfaces: Allocated PipeContext %p\n", deviceExtension->PipeContext));
580 for (i=0; i<Interface->NumberOfPipes; i++)
581 {
582 deviceExtension->PipeContext[i].PipeOpen = FALSE;
583
584 FreeBT_DbgPrint(3, ("FBTUSB: ---------\n"));
585 FreeBT_DbgPrint(3, ("FBTUSB: PipeType 0x%x\n", Interface->Pipes[i].PipeType));
586 FreeBT_DbgPrint(3, ("FBTUSB: EndpointAddress 0x%x\n", Interface->Pipes[i].EndpointAddress));
587 FreeBT_DbgPrint(3, ("FBTUSB: MaxPacketSize 0x%x\n", Interface->Pipes[i].MaximumPacketSize));
588 FreeBT_DbgPrint(3, ("FBTUSB: Interval 0x%x\n", Interface->Pipes[i].Interval));
589 FreeBT_DbgPrint(3, ("FBTUSB: Handle 0x%x\n", Interface->Pipes[i].PipeHandle));
590 FreeBT_DbgPrint(3, ("FBTUSB: MaximumTransferSize 0x%x\n", Interface->Pipes[i].MaximumTransferSize));
591
592 // Log the pipes
593 // Note the HCI Command endpoint won't appear here, because the Default Control Pipe
594 // is used for this. The Default Control Pipe is always present at EndPointAddress 0x0
595 switch (Interface->Pipes[i].EndpointAddress)
596 {
597 case FREEBT_STDENDPOINT_HCIEVENT:
598 deviceExtension->PipeContext[i].PipeType=HciEventPipe;
599 deviceExtension->EventPipe=Interface->Pipes[i];
600 FreeBT_DbgPrint(3, ("FBTUSB: HCI Event Endpoint\n"));
601 break;
602
603 case FREEBT_STDENDPOINT_ACLIN:
604 deviceExtension->PipeContext[i].PipeType=AclDataIn;
605 deviceExtension->DataInPipe=Interface->Pipes[i];
606 FreeBT_DbgPrint(3, ("FBTUSB: ACL Data In Endpoint\n"));
607 break;
608
609 case FREEBT_STDENDPOINT_ACLOUT:
610 deviceExtension->PipeContext[i].PipeType=AclDataOut;
611 deviceExtension->DataOutPipe=Interface->Pipes[i];
612 FreeBT_DbgPrint(3, ("FBTUSB: ACL Data Out Endpoint\n"));
613 break;
614
615 case FREEBT_STDENDPOINT_AUDIOIN:
616 deviceExtension->PipeContext[i].PipeType=SCODataIn;
617 deviceExtension->AudioInPipe=Interface->Pipes[i];
618 FreeBT_DbgPrint(3, ("FBTUSB: ACL Data Out Endpoint\n"));
619 break;
620
621 case FREEBT_STDENDPOINT_AUDIOOUT:
622 deviceExtension->PipeContext[i].PipeType=SCODataOut;
623 deviceExtension->AudioOutPipe=Interface->Pipes[i];
624 FreeBT_DbgPrint(3, ("FBTUSB: ACL Data Out Endpoint\n"));
625 break;
626
627 }
628
629 }
630
631 }
632
633 FreeBT_DbgPrint(3, ("FBTUSB: ---------\n"));
634
635 }
636
637 else
638 {
639 FreeBT_DbgPrint(1, ("FBTUSB: SelectInterfaces: Failed to select an interface\n"));
640
641 }
642
643 }
644
645 else
646 {
647 FreeBT_DbgPrint(1, ("FBTUSB: SelectInterfaces: USBD_CreateConfigurationRequestEx failed\n"));
648 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
649
650 }
651
652 if (tmp)
653 {
654 ExFreePool(tmp);
655
656 }
657
658 if (urb)
659 {
660 ExFreePool(urb);
661
662 }
663
664 return ntStatus;
665 }
666
667
668 NTSTATUS NTAPI DeconfigureDevice(IN PDEVICE_OBJECT DeviceObject)
669 {
670 PURB urb;
671 ULONG siz;
672 NTSTATUS ntStatus;
673
674 siz = sizeof(struct _URB_SELECT_CONFIGURATION);
675 urb = (PURB) ExAllocatePool(NonPagedPool, siz);
676 if (urb)
677 {
678 UsbBuildSelectConfigurationRequest(urb, (USHORT)siz, NULL);
679 ntStatus = CallUSBD(DeviceObject, urb);
680 if(!NT_SUCCESS(ntStatus))
681 {
682 FreeBT_DbgPrint(3, ("FBTUSB: DeconfigureDevice: Failed to deconfigure device\n"));
683
684 }
685
686 ExFreePool(urb);
687
688 }
689
690 else
691 {
692 FreeBT_DbgPrint(1, ("FBTUSB: DeconfigureDevice: Failed to allocate urb\n"));
693 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
694
695 }
696
697 return ntStatus;
698
699 }
700
701 NTSTATUS NTAPI CallUSBD(IN PDEVICE_OBJECT DeviceObject, IN PURB Urb)
702 {
703 PIRP irp;
704 KEVENT event;
705 NTSTATUS ntStatus;
706 IO_STATUS_BLOCK ioStatus;
707 PIO_STACK_LOCATION nextStack;
708 PDEVICE_EXTENSION deviceExtension;
709
710 irp = NULL;
711 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
712
713 KeInitializeEvent(&event, NotificationEvent, FALSE);
714 irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_USB_SUBMIT_URB,
715 deviceExtension->TopOfStackDeviceObject,
716 NULL,
717 0,
718 NULL,
719 0,
720 TRUE,
721 &event,
722 &ioStatus);
723
724 if (!irp)
725 {
726 FreeBT_DbgPrint(1, ("FBTUSB: CallUSBD: IoBuildDeviceIoControlRequest failed\n"));
727 return STATUS_INSUFFICIENT_RESOURCES;
728
729 }
730
731 nextStack = IoGetNextIrpStackLocation(irp);
732 ASSERT(nextStack != NULL);
733 nextStack->Parameters.Others.Argument1 = Urb;
734
735 FreeBT_DbgPrint(3, ("FBTUSB: CallUSBD::"));
736 FreeBT_IoIncrement(deviceExtension);
737
738 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, irp);
739 if (ntStatus == STATUS_PENDING)
740 {
741 KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
742 ntStatus = ioStatus.Status;
743
744 }
745
746 FreeBT_DbgPrint(3, ("FBTUSB: CallUSBD::"));
747 FreeBT_IoDecrement(deviceExtension);
748 return ntStatus;
749
750 }
751
752 NTSTATUS NTAPI HandleQueryStopDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
753 {
754 KIRQL oldIrql;
755 NTSTATUS ntStatus;
756 PDEVICE_EXTENSION deviceExtension;
757
758 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryStopDevice: Entered\n"));
759
760 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
761
762 // If we can stop the device, we need to set the QueueState to
763 // HoldRequests so further requests will be queued.
764 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
765
766 SET_NEW_PNP_STATE(deviceExtension, PendingStop);
767 deviceExtension->QueueState = HoldRequests;
768
769 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
770
771 // wait for the existing ones to be finished.
772 // first, decrement this operation
773 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryStopDevice::"));
774 FreeBT_IoDecrement(deviceExtension);
775
776 KeWaitForSingleObject(&deviceExtension->StopEvent, Executive, KernelMode, FALSE, NULL);
777
778 Irp->IoStatus.Status = STATUS_SUCCESS;
779 Irp->IoStatus.Information = 0;
780
781 IoSkipCurrentIrpStackLocation(Irp);
782
783 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
784
785 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryStopDevice: Leaving\n"));
786
787 return ntStatus;
788
789 }
790
791 NTSTATUS NTAPI HandleCancelStopDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
792 {
793 KIRQL oldIrql;
794 KEVENT event;
795 NTSTATUS ntStatus;
796 PDEVICE_EXTENSION deviceExtension;
797
798 FreeBT_DbgPrint(3, ("FBTUSB: HandleCancelStopDevice: Entered\n"));
799
800 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
801
802 // Send this IRP down and wait for it to come back.
803 // Set the QueueState flag to AllowRequests,
804 // and process all the previously queued up IRPs.
805
806 // First check to see whether you have received cancel-stop
807 // without first receiving a query-stop. This could happen if someone
808 // above us fails a query-stop and passes down the subsequent
809 // cancel-stop.
810 if(PendingStop == deviceExtension->DeviceState)
811 {
812 KeInitializeEvent(&event, NotificationEvent, FALSE);
813
814 IoCopyCurrentIrpStackLocationToNext(Irp);
815 IoSetCompletionRoutine(Irp,
816 (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine,
817 (PVOID)&event,
818 TRUE,
819 TRUE,
820 TRUE);
821
822 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
823 if(ntStatus == STATUS_PENDING)
824 {
825 KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
826 ntStatus = Irp->IoStatus.Status;
827
828 }
829
830 if(NT_SUCCESS(ntStatus))
831 {
832 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
833
834 RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
835 deviceExtension->QueueState = AllowRequests;
836 ASSERT(deviceExtension->DeviceState == Working);
837
838 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
839
840 ProcessQueuedRequests(deviceExtension);
841
842 }
843
844 }
845
846 else
847 {
848 // spurious Irp
849 ntStatus = STATUS_SUCCESS;
850
851 }
852
853 FreeBT_DbgPrint(3, ("FBTUSB: HandleCancelStopDevice: Leaving\n"));
854
855 return ntStatus;
856
857 }
858
859 NTSTATUS NTAPI HandleStopDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
860 {
861 KIRQL oldIrql;
862 NTSTATUS ntStatus;
863 PDEVICE_EXTENSION deviceExtension;
864
865 FreeBT_DbgPrint(3, ("FBTUSB: HandleStopDevice: Entered\n"));
866
867 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
868 if(WinXpOrBetter == deviceExtension->WdmVersion)
869 {
870 if(deviceExtension->SSEnable)
871 {
872 // Cancel the timer so that the DPCs are no longer fired.
873 // Thus, we are making judicious usage of our resources.
874 // we do not need DPCs because the device is stopping.
875 // The timers are re-initialized while handling the start
876 // device irp.
877 KeCancelTimer(&deviceExtension->Timer);
878
879 // after the device is stopped, it can be surprise removed.
880 // we set this to 0, so that we do not attempt to cancel
881 // the timer while handling surprise remove or remove irps.
882 // when we get the start device request, this flag will be
883 // reinitialized.
884 deviceExtension->SSEnable = 0;
885
886 // make sure that if a DPC was fired before we called cancel timer,
887 // then the DPC and work-time have run to their completion
888 KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, Executive, KernelMode, FALSE, NULL);
889
890 // make sure that the selective suspend request has been completed.
891 KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, Executive, KernelMode, FALSE, NULL);
892
893 }
894
895 }
896
897 // after the stop Irp is sent to the lower driver object,
898 // the driver must not send any more Irps down that touch
899 // the device until another Start has occurred.
900 if (deviceExtension->WaitWakeEnable)
901 {
902 CancelWaitWake(deviceExtension);
903
904 }
905
906 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
907
908 SET_NEW_PNP_STATE(deviceExtension, Stopped);
909
910 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
911
912 // This is the right place to actually give up all the resources used
913 // This might include calls to IoDisconnectInterrupt, MmUnmapIoSpace,
914 // etc.
915 ReleaseMemory(DeviceObject);
916
917 ntStatus = DeconfigureDevice(DeviceObject);
918
919 Irp->IoStatus.Status = ntStatus;
920 Irp->IoStatus.Information = 0;
921
922 IoSkipCurrentIrpStackLocation(Irp);
923 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
924
925 FreeBT_DbgPrint(3, ("FBTUSB: HandleStopDevice: Leaving\n"));
926
927 return ntStatus;
928
929 }
930
931 NTSTATUS NTAPI HandleQueryRemoveDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
932 {
933 KIRQL oldIrql;
934 NTSTATUS ntStatus;
935 PDEVICE_EXTENSION deviceExtension;
936
937 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryRemoveDevice: Entered\n"));
938
939 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
940
941 // If we can allow removal of the device, we should set the QueueState
942 // to HoldRequests so further requests will be queued. This is required
943 // so that we can process queued up requests in cancel-remove just in
944 // case somebody else in the stack fails the query-remove.
945 ntStatus = CanRemoveDevice(DeviceObject, Irp);
946
947 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
948
949 deviceExtension->QueueState = HoldRequests;
950 SET_NEW_PNP_STATE(deviceExtension, PendingRemove);
951
952 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
953
954 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryRemoveDevice::"));
955 FreeBT_IoDecrement(deviceExtension);
956
957 // Wait for all the requests to be completed
958 KeWaitForSingleObject(&deviceExtension->StopEvent, Executive, KernelMode, FALSE, NULL);
959
960 Irp->IoStatus.Status = STATUS_SUCCESS;
961 Irp->IoStatus.Information = 0;
962
963 IoSkipCurrentIrpStackLocation(Irp);
964 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
965
966 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryRemoveDevice: Leaving\n"));
967
968 return ntStatus;
969
970 }
971
972 NTSTATUS NTAPI HandleCancelRemoveDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
973 {
974 KIRQL oldIrql;
975 KEVENT event;
976 NTSTATUS ntStatus;
977 PDEVICE_EXTENSION deviceExtension;
978
979 FreeBT_DbgPrint(3, ("FBTUSB: HandleCancelRemoveDevice: Entered\n"));
980
981 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
982
983 // We need to reset the QueueState flag to ProcessRequest,
984 // since the device resume its normal activities.
985
986 // First check to see whether you have received cancel-remove
987 // without first receiving a query-remove. This could happen if
988 // someone above us fails a query-remove and passes down the
989 // subsequent cancel-remove.
990 if(PendingRemove == deviceExtension->DeviceState)
991 {
992
993 KeInitializeEvent(&event, NotificationEvent, FALSE);
994
995 IoCopyCurrentIrpStackLocationToNext(Irp);
996 IoSetCompletionRoutine(Irp,
997 (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine,
998 (PVOID)&event,
999 TRUE,
1000 TRUE,
1001 TRUE);
1002
1003 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
1004 if(ntStatus == STATUS_PENDING)
1005 {
1006 KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
1007 ntStatus = Irp->IoStatus.Status;
1008
1009 }
1010
1011 if (NT_SUCCESS(ntStatus))
1012 {
1013 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
1014
1015 deviceExtension->QueueState = AllowRequests;
1016 RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
1017
1018 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
1019
1020 // process the queued requests that arrive between
1021 // QUERY_REMOVE and CANCEL_REMOVE
1022 ProcessQueuedRequests(deviceExtension);
1023
1024 }
1025
1026 }
1027
1028 else
1029 {
1030 // spurious cancel-remove
1031 ntStatus = STATUS_SUCCESS;
1032
1033 }
1034
1035 FreeBT_DbgPrint(3, ("FBTUSB: HandleCancelRemoveDevice: Leaving\n"));
1036
1037 return ntStatus;
1038
1039 }
1040
1041 NTSTATUS NTAPI HandleSurpriseRemoval(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
1042 {
1043 KIRQL oldIrql;
1044 NTSTATUS ntStatus;
1045 PDEVICE_EXTENSION deviceExtension;
1046
1047 FreeBT_DbgPrint(3, ("FBTUSB: HandleSurpriseRemoval: Entered\n"));
1048
1049 // initialize variables
1050 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1051
1052 // 1. fail pending requests
1053 // 2. return device and memory resources
1054 // 3. disable interfaces
1055 if(deviceExtension->WaitWakeEnable)
1056 {
1057 CancelWaitWake(deviceExtension);
1058
1059 }
1060
1061
1062 if (WinXpOrBetter == deviceExtension->WdmVersion)
1063 {
1064 if (deviceExtension->SSEnable)
1065 {
1066 // Cancel the timer so that the DPCs are no longer fired.
1067 // we do not need DPCs because the device has been surprise
1068 // removed
1069 KeCancelTimer(&deviceExtension->Timer);
1070
1071 deviceExtension->SSEnable = 0;
1072
1073 // make sure that if a DPC was fired before we called cancel timer,
1074 // then the DPC and work-time have run to their completion
1075 KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, Executive, KernelMode, FALSE, NULL);
1076
1077 // make sure that the selective suspend request has been completed.
1078 KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, Executive, KernelMode, FALSE, NULL);
1079
1080 }
1081
1082 }
1083
1084 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
1085 deviceExtension->QueueState = FailRequests;
1086 SET_NEW_PNP_STATE(deviceExtension, SurpriseRemoved);
1087 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
1088
1089 ProcessQueuedRequests(deviceExtension);
1090
1091 ntStatus = IoSetDeviceInterfaceState(&deviceExtension->InterfaceName, FALSE);
1092 if(!NT_SUCCESS(ntStatus))
1093 {
1094 FreeBT_DbgPrint(1, ("FBTUSB: HandleSurpriseRemoval: IoSetDeviceInterfaceState::disable:failed\n"));
1095
1096 }
1097
1098 FreeBT_AbortPipes(DeviceObject);
1099
1100 Irp->IoStatus.Status = STATUS_SUCCESS;
1101 Irp->IoStatus.Information = 0;
1102
1103 IoSkipCurrentIrpStackLocation(Irp);
1104 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
1105
1106 FreeBT_DbgPrint(3, ("FBTUSB: HandleSurpriseRemoval: Leaving\n"));
1107
1108 return ntStatus;
1109
1110 }
1111
1112 NTSTATUS NTAPI HandleRemoveDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
1113 {
1114 KIRQL oldIrql;
1115 //KEVENT event;
1116 ULONG requestCount;
1117 NTSTATUS ntStatus;
1118 PDEVICE_EXTENSION deviceExtension;
1119
1120 FreeBT_DbgPrint(3, ("FBTUSB: HandleRemoveDevice: Entered\n"));
1121
1122 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1123
1124 // The Plug & Play system has dictated the removal of this device. We
1125 // have no choice but to detach and delete the device object.
1126 // (If we wanted to express an interest in preventing this removal,
1127 // we should have failed the query remove IRP).
1128 if(SurpriseRemoved != deviceExtension->DeviceState)
1129 {
1130
1131 // we are here after QUERY_REMOVE
1132 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
1133 deviceExtension->QueueState = FailRequests;
1134 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
1135
1136 if(deviceExtension->WaitWakeEnable)
1137 {
1138 CancelWaitWake(deviceExtension);
1139
1140 }
1141
1142 if(WinXpOrBetter == deviceExtension->WdmVersion)
1143 {
1144 if (deviceExtension->SSEnable)
1145 {
1146 // Cancel the timer so that the DPCs are no longer fired.
1147 // we do not need DPCs because the device has been removed
1148 KeCancelTimer(&deviceExtension->Timer);
1149
1150 deviceExtension->SSEnable = 0;
1151
1152 // make sure that if a DPC was fired before we called cancel timer,
1153 // then the DPC and work-time have run to their completion
1154 KeWaitForSingleObject(&deviceExtension->NoDpcWorkItemPendingEvent, Executive, KernelMode, FALSE, NULL);
1155
1156 // make sure that the selective suspend request has been completed.
1157 KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, Executive, KernelMode, FALSE, NULL);
1158
1159 }
1160
1161 }
1162
1163 ProcessQueuedRequests(deviceExtension);
1164
1165 ntStatus = IoSetDeviceInterfaceState(&deviceExtension->InterfaceName, FALSE);
1166 if(!NT_SUCCESS(ntStatus))
1167 {
1168 FreeBT_DbgPrint(1, ("FBTUSB: HandleRemoveDevice: IoSetDeviceInterfaceState::disable:failed\n"));
1169
1170 }
1171
1172 FreeBT_AbortPipes(DeviceObject);
1173
1174 }
1175
1176 KeAcquireSpinLock(&deviceExtension->DevStateLock, &oldIrql);
1177 SET_NEW_PNP_STATE(deviceExtension, Removed);
1178 KeReleaseSpinLock(&deviceExtension->DevStateLock, oldIrql);
1179 #ifdef ENABLE_WMI
1180 FreeBT_WmiDeRegistration(deviceExtension);
1181 #endif
1182
1183 // Need 2 decrements
1184 FreeBT_DbgPrint(3, ("FBTUSB: HandleRemoveDevice::"));
1185 requestCount = FreeBT_IoDecrement(deviceExtension);
1186
1187 ASSERT(requestCount > 0);
1188
1189 FreeBT_DbgPrint(3, ("FBTUSB: HandleRemoveDevice::"));
1190 requestCount = FreeBT_IoDecrement(deviceExtension);
1191
1192 KeWaitForSingleObject(&deviceExtension->RemoveEvent,
1193 Executive,
1194 KernelMode,
1195 FALSE,
1196 NULL);
1197
1198 ReleaseMemory(DeviceObject);
1199
1200 // We need to send the remove down the stack before we detach,
1201 // but we don't need to wait for the completion of this operation
1202 // (and to register a completion routine).
1203 Irp->IoStatus.Status = STATUS_SUCCESS;
1204 Irp->IoStatus.Information = 0;
1205
1206 IoSkipCurrentIrpStackLocation(Irp);
1207 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
1208
1209 IoDetachDevice(deviceExtension->TopOfStackDeviceObject);
1210 IoDeleteDevice(DeviceObject);
1211
1212 FreeBT_DbgPrint(3, ("FBTUSB: HandleRemoveDevice: Leaving\n"));
1213
1214 return ntStatus;
1215
1216 }
1217
1218 NTSTATUS NTAPI HandleQueryCapabilities(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
1219 {
1220 ULONG i;
1221 KEVENT event;
1222 NTSTATUS ntStatus;
1223 PDEVICE_EXTENSION deviceExtension;
1224 PDEVICE_CAPABILITIES pdc;
1225 PIO_STACK_LOCATION irpStack;
1226
1227 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryCapabilities: Entered\n"));
1228
1229 irpStack = IoGetCurrentIrpStackLocation(Irp);
1230 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1231 pdc = irpStack->Parameters.DeviceCapabilities.Capabilities;
1232
1233 if(pdc->Version < 1 || pdc->Size < sizeof(DEVICE_CAPABILITIES))
1234 {
1235
1236 FreeBT_DbgPrint(1, ("FBTUSB: HandleQueryCapabilities::request failed\n"));
1237 ntStatus = STATUS_UNSUCCESSFUL;
1238 return ntStatus;
1239
1240 }
1241
1242 // Add in the SurpriseRemovalOK bit before passing it down.
1243 pdc->SurpriseRemovalOK = TRUE;
1244 Irp->IoStatus.Status = STATUS_SUCCESS;
1245
1246 KeInitializeEvent(&event, NotificationEvent, FALSE);
1247
1248 IoCopyCurrentIrpStackLocationToNext(Irp);
1249 IoSetCompletionRoutine(Irp,
1250 (PIO_COMPLETION_ROUTINE)IrpCompletionRoutine,
1251 (PVOID)&event,
1252 TRUE,
1253 TRUE,
1254 TRUE);
1255 ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
1256 if(ntStatus == STATUS_PENDING)
1257 {
1258 KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
1259 ntStatus = Irp->IoStatus.Status;
1260
1261 }
1262
1263 // initialize PowerDownLevel to disabled
1264 deviceExtension->PowerDownLevel = PowerDeviceUnspecified;
1265 if(NT_SUCCESS(ntStatus))
1266 {
1267 deviceExtension->DeviceCapabilities = *pdc;
1268 for(i = PowerSystemSleeping1; i <= PowerSystemSleeping3; i++)
1269 {
1270 if(deviceExtension->DeviceCapabilities.DeviceState[i] < PowerDeviceD3)
1271 {
1272 deviceExtension->PowerDownLevel = deviceExtension->DeviceCapabilities.DeviceState[i];
1273
1274 }
1275
1276 }
1277
1278 // since its safe to surprise-remove this device, we shall
1279 // set the SurpriseRemoveOK flag to supress any dialog to
1280 // user.
1281 pdc->SurpriseRemovalOK = 1;
1282
1283 }
1284
1285 if(deviceExtension->PowerDownLevel == PowerDeviceUnspecified ||
1286 deviceExtension->PowerDownLevel <= PowerDeviceD0)
1287 {
1288 deviceExtension->PowerDownLevel = PowerDeviceD2;
1289
1290 }
1291
1292 FreeBT_DbgPrint(3, ("FBTUSB: HandleQueryCapabilities: Leaving\n"));
1293
1294 return ntStatus;
1295 }
1296
1297
1298 VOID NTAPI DpcRoutine(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
1299 /*++
1300
1301 DPC routine triggered by the timer to check the idle state
1302 of the device and submit an idle request for the device.
1303
1304 --*/
1305 {
1306 NTSTATUS ntStatus;
1307 PDEVICE_OBJECT deviceObject;
1308 PDEVICE_EXTENSION deviceExtension;
1309 PIO_WORKITEM item;
1310
1311 FreeBT_DbgPrint(3, ("FBTUSB: DpcRoutine: Entered\n"));
1312
1313 deviceObject = (PDEVICE_OBJECT)DeferredContext;
1314 deviceExtension = (PDEVICE_EXTENSION)deviceObject->DeviceExtension;
1315
1316 // Clear this event since a DPC has been fired!
1317 KeClearEvent(&deviceExtension->NoDpcWorkItemPendingEvent);
1318
1319 if(CanDeviceSuspend(deviceExtension))
1320 {
1321 FreeBT_DbgPrint(3, ("FBTUSB: DpcRoutine: Device is Idle\n"));
1322 item = IoAllocateWorkItem(deviceObject);
1323
1324 if (item)
1325 {
1326 IoQueueWorkItem(item, IdleRequestWorkerRoutine, DelayedWorkQueue, item);
1327 ntStatus = STATUS_PENDING;
1328
1329 }
1330
1331 else
1332 {
1333 FreeBT_DbgPrint(3, ("FBTUSB: DpcRoutine: Cannot alloc memory for work item\n"));
1334 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
1335 KeSetEvent(&deviceExtension->NoDpcWorkItemPendingEvent, IO_NO_INCREMENT, FALSE);
1336
1337 }
1338
1339 }
1340
1341 else
1342 {
1343 FreeBT_DbgPrint(3, ("FBTUSB: DpcRoutine: Idle event not signaled\n"));
1344 KeSetEvent(&deviceExtension->NoDpcWorkItemPendingEvent, IO_NO_INCREMENT, FALSE);
1345
1346 }
1347
1348 FreeBT_DbgPrint(3, ("FBTUSB: DpcRoutine: Leaving\n"));
1349 }
1350
1351
1352 VOID NTAPI IdleRequestWorkerRoutine(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
1353 {
1354 //PIRP irp;
1355 NTSTATUS ntStatus;
1356 PDEVICE_EXTENSION deviceExtension;
1357 PIO_WORKITEM workItem;
1358
1359 FreeBT_DbgPrint(3, ("FBTUSB: IdleRequestWorkerRoutine: Entered\n"));
1360
1361 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1362 workItem = (PIO_WORKITEM) Context;
1363
1364 if(CanDeviceSuspend(deviceExtension))
1365 {
1366 FreeBT_DbgPrint(3, ("FBTUSB: IdleRequestWorkerRoutine: Device is idle\n"));
1367 ntStatus = SubmitIdleRequestIrp(deviceExtension);
1368 if(!NT_SUCCESS(ntStatus))
1369 {
1370 FreeBT_DbgPrint(1, ("FBTUSB: IdleRequestWorkerRoutine: SubmitIdleRequestIrp failed\n"));
1371
1372 }
1373
1374 }
1375
1376 else
1377 {
1378 FreeBT_DbgPrint(3, ("FBTUSB: IdleRequestWorkerRoutine: Device is not idle\n"));
1379
1380 }
1381
1382 IoFreeWorkItem(workItem);
1383
1384 KeSetEvent(&deviceExtension->NoDpcWorkItemPendingEvent, IO_NO_INCREMENT, FALSE);
1385
1386 FreeBT_DbgPrint(3, ("FBTUSB: IdleRequestsWorkerRoutine: Leaving\n"));
1387
1388 }
1389
1390
1391 VOID NTAPI ProcessQueuedRequests(IN OUT PDEVICE_EXTENSION DeviceExtension)
1392 /*++
1393
1394 Routine Description:
1395
1396 Remove and process the entries in the queue. If this routine is called
1397 when processing IRP_MN_CANCEL_STOP_DEVICE, IRP_MN_CANCEL_REMOVE_DEVICE
1398 or IRP_MN_START_DEVICE, the requests are passed to the next lower driver.
1399 If the routine is called when IRP_MN_REMOVE_DEVICE is received, the IRPs
1400 are complete with STATUS_DELETE_PENDING
1401
1402 Arguments:
1403
1404 DeviceExtension - pointer to device extension
1405
1406 Return Value:
1407
1408 None
1409
1410 --*/
1411 {
1412 KIRQL oldIrql;
1413 PIRP nextIrp,
1414 cancelledIrp;
1415 PVOID cancelRoutine;
1416 LIST_ENTRY cancelledIrpList;
1417 PLIST_ENTRY listEntry;
1418
1419 FreeBT_DbgPrint(3, ("FBTUSB: ProcessQueuedRequests: Entered\n"));
1420
1421 cancelRoutine = NULL;
1422 InitializeListHead(&cancelledIrpList);
1423
1424 // 1. dequeue the entries in the queue
1425 // 2. reset the cancel routine
1426 // 3. process them
1427 // 3a. if the device is active, send them down
1428 // 3b. else complete with STATUS_DELETE_PENDING
1429 while(1)
1430 {
1431 KeAcquireSpinLock(&DeviceExtension->QueueLock, &oldIrql);
1432 if(IsListEmpty(&DeviceExtension->NewRequestsQueue))
1433 {
1434 KeReleaseSpinLock(&DeviceExtension->QueueLock, oldIrql);
1435 break;
1436
1437 }
1438
1439 listEntry = RemoveHeadList(&DeviceExtension->NewRequestsQueue);
1440 nextIrp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry);
1441
1442 cancelRoutine = IoSetCancelRoutine(nextIrp, NULL);
1443
1444 // check if its already cancelled
1445 if (nextIrp->Cancel)
1446 {
1447 if(cancelRoutine)
1448 {
1449 // the cancel routine for this IRP hasnt been called yet
1450 // so queue the IRP in the cancelledIrp list and complete
1451 // after releasing the lock
1452 InsertTailList(&cancelledIrpList, listEntry);
1453
1454 }
1455
1456 else
1457 {
1458 // the cancel routine has run
1459 // it must be waiting to hold the queue lock
1460 // so initialize the IRPs listEntry
1461 InitializeListHead(listEntry);
1462
1463 }
1464
1465 KeReleaseSpinLock(&DeviceExtension->QueueLock, oldIrql);
1466
1467 }
1468
1469 else
1470 {
1471 KeReleaseSpinLock(&DeviceExtension->QueueLock, oldIrql);
1472 if(FailRequests == DeviceExtension->QueueState)
1473 {
1474 nextIrp->IoStatus.Information = 0;
1475 nextIrp->IoStatus.Status = STATUS_DELETE_PENDING;
1476 IoCompleteRequest(nextIrp, IO_NO_INCREMENT);
1477
1478 }
1479
1480 else
1481 {
1482 //PIO_STACK_LOCATION irpStack;
1483
1484 FreeBT_DbgPrint(3, ("FBTUSB: ProcessQueuedRequests::"));
1485 FreeBT_IoIncrement(DeviceExtension);
1486
1487 IoSkipCurrentIrpStackLocation(nextIrp);
1488 IoCallDriver(DeviceExtension->TopOfStackDeviceObject, nextIrp);
1489
1490 FreeBT_DbgPrint(3, ("FBTUSB: ProcessQueuedRequests::"));
1491 FreeBT_IoDecrement(DeviceExtension);
1492
1493 }
1494
1495 }
1496
1497 }
1498
1499 while(!IsListEmpty(&cancelledIrpList))
1500 {
1501 PLIST_ENTRY cancelEntry = RemoveHeadList(&cancelledIrpList);
1502
1503 cancelledIrp = CONTAINING_RECORD(cancelEntry, IRP, Tail.Overlay.ListEntry);
1504 cancelledIrp->IoStatus.Status = STATUS_CANCELLED;
1505 cancelledIrp->IoStatus.Information = 0;
1506
1507 IoCompleteRequest(cancelledIrp, IO_NO_INCREMENT);
1508
1509 }
1510
1511 FreeBT_DbgPrint(3, ("FBTUSB: ProcessQueuedRequests: Leaving\n"));
1512
1513 return;
1514
1515 }
1516
1517 NTSTATUS NTAPI FreeBT_GetRegistryDword(IN PWCHAR RegPath, IN PWCHAR ValueName, IN OUT PULONG Value)
1518 {
1519 ULONG defaultData;
1520 WCHAR buffer[MAXIMUM_FILENAME_LENGTH];
1521 NTSTATUS ntStatus;
1522 UNICODE_STRING regPath;
1523 RTL_QUERY_REGISTRY_TABLE paramTable[2];
1524
1525 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetRegistryDword: Entered\n"));
1526
1527 regPath.Length = 0;
1528 regPath.MaximumLength = MAXIMUM_FILENAME_LENGTH * sizeof(WCHAR);
1529 regPath.Buffer = buffer;
1530
1531 RtlZeroMemory(regPath.Buffer, regPath.MaximumLength);
1532 RtlMoveMemory(regPath.Buffer, RegPath, wcslen(RegPath) * sizeof(WCHAR));
1533 RtlZeroMemory(paramTable, sizeof(paramTable));
1534
1535 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
1536 paramTable[0].Name = ValueName;
1537 paramTable[0].EntryContext = Value;
1538 paramTable[0].DefaultType = REG_DWORD;
1539 paramTable[0].DefaultData = &defaultData;
1540 paramTable[0].DefaultLength = sizeof(ULONG);
1541
1542 ntStatus = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE |
1543 RTL_REGISTRY_OPTIONAL,
1544 regPath.Buffer,
1545 paramTable,
1546 NULL,
1547 NULL);
1548
1549 if (NT_SUCCESS(ntStatus))
1550 {
1551 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetRegistryDword: Success, Value = %X\n", *Value));
1552 return STATUS_SUCCESS;
1553 }
1554
1555 else
1556 {
1557 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_GetRegistryDword: Failed\n"));
1558 *Value = 0;
1559 return STATUS_UNSUCCESSFUL;
1560
1561 }
1562 }
1563
1564
1565 NTSTATUS NTAPI FreeBT_DispatchClean(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
1566 {
1567 PDEVICE_EXTENSION deviceExtension;
1568 KIRQL oldIrql;
1569 LIST_ENTRY cleanupList;
1570 PLIST_ENTRY thisEntry,
1571 nextEntry,
1572 listHead;
1573 PIRP pendingIrp;
1574 PIO_STACK_LOCATION pendingIrpStack,
1575 irpStack;
1576 //NTSTATUS ntStatus;
1577
1578 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1579 irpStack = IoGetCurrentIrpStackLocation(Irp);
1580 InitializeListHead(&cleanupList);
1581
1582 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchClean::"));
1583 FreeBT_IoIncrement(deviceExtension);
1584
1585 KeAcquireSpinLock(&deviceExtension->QueueLock, &oldIrql);
1586
1587 listHead = &deviceExtension->NewRequestsQueue;
1588 for(thisEntry = listHead->Flink, nextEntry = thisEntry->Flink;
1589 thisEntry != listHead;
1590 thisEntry = nextEntry, nextEntry = thisEntry->Flink)
1591 {
1592 pendingIrp = CONTAINING_RECORD(thisEntry, IRP, Tail.Overlay.ListEntry);
1593 pendingIrpStack = IoGetCurrentIrpStackLocation(pendingIrp);
1594 if (irpStack->FileObject == pendingIrpStack->FileObject)
1595 {
1596 RemoveEntryList(thisEntry);
1597
1598 if (NULL == IoSetCancelRoutine(pendingIrp, NULL))
1599 {
1600 InitializeListHead(thisEntry);
1601
1602 }
1603
1604 else
1605 {
1606 InsertTailList(&cleanupList, thisEntry);
1607
1608 }
1609
1610 }
1611
1612 }
1613
1614 KeReleaseSpinLock(&deviceExtension->QueueLock, oldIrql);
1615
1616 while(!IsListEmpty(&cleanupList))
1617 {
1618 thisEntry = RemoveHeadList(&cleanupList);
1619 pendingIrp = CONTAINING_RECORD(thisEntry, IRP, Tail.Overlay.ListEntry);
1620
1621 pendingIrp->IoStatus.Information = 0;
1622 pendingIrp->IoStatus.Status = STATUS_CANCELLED;
1623 IoCompleteRequest(pendingIrp, IO_NO_INCREMENT);
1624
1625 }
1626
1627 Irp->IoStatus.Information = 0;
1628 Irp->IoStatus.Status = STATUS_SUCCESS;
1629
1630 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1631
1632 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_DispatchClean::"));
1633 FreeBT_IoDecrement(deviceExtension);
1634
1635 return STATUS_SUCCESS;
1636
1637 }
1638
1639
1640 BOOLEAN NTAPI CanDeviceSuspend(IN PDEVICE_EXTENSION DeviceExtension)
1641 {
1642 FreeBT_DbgPrint(3, ("FBTUSB: CanDeviceSuspend: Entered\n"));
1643
1644 if ((DeviceExtension->OpenHandleCount == 0) && (DeviceExtension->OutStandingIO == 1))
1645 return TRUE;
1646
1647 return FALSE;
1648
1649 }
1650
1651 NTSTATUS NTAPI FreeBT_AbortPipes(IN PDEVICE_OBJECT DeviceObject)
1652 {
1653 PURB urb;
1654 ULONG i;
1655 NTSTATUS ntStatus;
1656 PDEVICE_EXTENSION deviceExtension;
1657 PFREEBT_PIPE_CONTEXT pipeContext;
1658 //PUSBD_PIPE_INFORMATION pipeInformation;
1659 PUSBD_INTERFACE_INFORMATION interfaceInfo;
1660
1661 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1662 pipeContext = deviceExtension->PipeContext;
1663 interfaceInfo = deviceExtension->UsbInterface;
1664
1665 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_AbortPipes: Entered\n"));
1666
1667 if(interfaceInfo == NULL || pipeContext == NULL)
1668 return STATUS_SUCCESS;
1669
1670 for(i=0; i<interfaceInfo->NumberOfPipes; i++)
1671 {
1672 if(pipeContext[i].PipeOpen)
1673 {
1674 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_AbortPipes: Aborting open pipe %d\n", i));
1675
1676 urb = (PURB) ExAllocatePool(NonPagedPool, sizeof(struct _URB_PIPE_REQUEST));
1677 if (urb)
1678 {
1679 urb->UrbHeader.Length = sizeof(struct _URB_PIPE_REQUEST);
1680 urb->UrbHeader.Function = URB_FUNCTION_ABORT_PIPE;
1681 urb->UrbPipeRequest.PipeHandle = interfaceInfo->Pipes[i].PipeHandle;
1682
1683 ntStatus = CallUSBD(DeviceObject, urb);
1684
1685 ExFreePool(urb);
1686
1687 }
1688
1689 else
1690 {
1691 FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_AbortPipes: Failed to alloc memory for urb\n"));
1692 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
1693 return ntStatus;
1694
1695 }
1696
1697 if(NT_SUCCESS(ntStatus))
1698 pipeContext[i].PipeOpen = FALSE;
1699
1700
1701 }
1702
1703 }
1704
1705 FreeBT_DbgPrint(3, ("FBTUSB: FreeBT_AbortPipes: Leaving\n"));
1706
1707 return STATUS_SUCCESS;
1708
1709 }
1710
1711 // Completion routine for PNP IRPs
1712 NTSTATUS NTAPI IrpCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
1713 {
1714 PKEVENT event = (PKEVENT) Context;
1715 KeSetEvent(event, 0, FALSE);
1716
1717 return STATUS_MORE_PROCESSING_REQUIRED;
1718
1719 }
1720
1721
1722 LONG NTAPI FreeBT_IoIncrement(IN OUT PDEVICE_EXTENSION DeviceExtension)
1723 {
1724 LONG result = 0;
1725 KIRQL oldIrql;
1726
1727 KeAcquireSpinLock(&DeviceExtension->IOCountLock, &oldIrql);
1728 result = InterlockedIncrement((PLONG)(&DeviceExtension->OutStandingIO));
1729
1730 // When OutStandingIO bumps from 1 to 2, clear the StopEvent
1731 if (result == 2)
1732 KeClearEvent(&DeviceExtension->StopEvent);
1733
1734 KeReleaseSpinLock(&DeviceExtension->IOCountLock, oldIrql);
1735
1736 FreeBT_DbgPrint(3, ("FreeBT_IoIncrement::%d\n", result));
1737
1738 return result;
1739
1740 }
1741
1742 LONG NTAPI FreeBT_IoDecrement(IN OUT PDEVICE_EXTENSION DeviceExtension)
1743 {
1744 LONG result = 0;
1745 KIRQL oldIrql;
1746
1747 KeAcquireSpinLock(&DeviceExtension->IOCountLock, &oldIrql);
1748
1749 result = InterlockedDecrement((PLONG)(&DeviceExtension->OutStandingIO));
1750
1751 if (result == 1)
1752 KeSetEvent(&DeviceExtension->StopEvent, IO_NO_INCREMENT, FALSE);
1753
1754 if(result == 0)
1755 {
1756 ASSERT(Removed == DeviceExtension->DeviceState);
1757 KeSetEvent(&DeviceExtension->RemoveEvent, IO_NO_INCREMENT, FALSE);
1758
1759 }
1760
1761 KeReleaseSpinLock(&DeviceExtension->IOCountLock, oldIrql);
1762
1763 FreeBT_DbgPrint(3, ("FreeBT_IoDecrement::%d\n", result));
1764
1765 return result;
1766
1767 }
1768
1769 NTSTATUS NTAPI CanStopDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
1770 {
1771 // For the time being, just allow it to be stopped
1772 UNREFERENCED_PARAMETER(DeviceObject);
1773 UNREFERENCED_PARAMETER(Irp);
1774
1775 return STATUS_SUCCESS;
1776
1777 }
1778
1779 NTSTATUS NTAPI CanRemoveDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
1780
1781 {
1782 // For the time being, just allow it to be removed
1783 UNREFERENCED_PARAMETER(DeviceObject);
1784 UNREFERENCED_PARAMETER(Irp);
1785
1786 return STATUS_SUCCESS;
1787
1788 }
1789
1790 NTSTATUS NTAPI ReleaseMemory(IN PDEVICE_OBJECT DeviceObject)
1791 {
1792 // Disconnect from the interrupt and unmap any I/O ports
1793 PDEVICE_EXTENSION deviceExtension;
1794 UNICODE_STRING uniDeviceName;
1795 NTSTATUS ntStatus;
1796
1797 deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1798 if (deviceExtension->UsbConfigurationDescriptor)
1799 {
1800 FreeBT_DbgPrint(3, ("FBTUSB: ReleaseMemory: Freeing UsbConfigurationDescriptor\n"));
1801 ExFreePool(deviceExtension->UsbConfigurationDescriptor);
1802 deviceExtension->UsbConfigurationDescriptor = NULL;
1803
1804 }
1805
1806 if(deviceExtension->UsbInterface)
1807 {
1808 FreeBT_DbgPrint(3, ("FBTUSB: ReleaseMemory: Freeing UsbInterface\n"));
1809 ExFreePool(deviceExtension->UsbInterface);
1810 deviceExtension->UsbInterface = NULL;
1811
1812 }
1813
1814 if(deviceExtension->PipeContext)
1815 {
1816 RtlInitUnicodeString(&uniDeviceName, deviceExtension->wszDosDeviceName);
1817 ntStatus = IoDeleteSymbolicLink(&uniDeviceName);
1818 if (!NT_SUCCESS(ntStatus))
1819 FreeBT_DbgPrint(3, ("FBTUSB: Failed to delete symbolic link %ws\n", deviceExtension->wszDosDeviceName));
1820
1821 FreeBT_DbgPrint(3, ("FBTUSB: ReleaseMemory: Freeing PipeContext %p\n", deviceExtension->PipeContext));
1822 ExFreePool(deviceExtension->PipeContext);
1823 deviceExtension->PipeContext = NULL;
1824
1825 }
1826
1827 return STATUS_SUCCESS;
1828
1829 }
1830
1831 PCHAR NTAPI PnPMinorFunctionString (UCHAR MinorFunction)
1832 {
1833 switch (MinorFunction)
1834 {
1835 case IRP_MN_START_DEVICE:
1836 return "IRP_MN_START_DEVICE\n";
1837
1838 case IRP_MN_QUERY_REMOVE_DEVICE:
1839 return "IRP_MN_QUERY_REMOVE_DEVICE\n";
1840
1841 case IRP_MN_REMOVE_DEVICE:
1842 return "IRP_MN_REMOVE_DEVICE\n";
1843
1844 case IRP_MN_CANCEL_REMOVE_DEVICE:
1845 return "IRP_MN_CANCEL_REMOVE_DEVICE\n";
1846
1847 case IRP_MN_STOP_DEVICE:
1848 return "IRP_MN_STOP_DEVICE\n";
1849
1850 case IRP_MN_QUERY_STOP_DEVICE:
1851 return "IRP_MN_QUERY_STOP_DEVICE\n";
1852
1853 case IRP_MN_CANCEL_STOP_DEVICE:
1854 return "IRP_MN_CANCEL_STOP_DEVICE\n";
1855
1856 case IRP_MN_QUERY_DEVICE_RELATIONS:
1857 return "IRP_MN_QUERY_DEVICE_RELATIONS\n";
1858
1859 case IRP_MN_QUERY_INTERFACE:
1860 return "IRP_MN_QUERY_INTERFACE\n";
1861
1862 case IRP_MN_QUERY_CAPABILITIES:
1863 return "IRP_MN_QUERY_CAPABILITIES\n";
1864
1865 case IRP_MN_QUERY_RESOURCES:
1866 return "IRP_MN_QUERY_RESOURCES\n";
1867
1868 case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
1869 return "IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n";
1870
1871 case IRP_MN_QUERY_DEVICE_TEXT:
1872 return "IRP_MN_QUERY_DEVICE_TEXT\n";
1873
1874 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
1875 return "IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n";
1876
1877 case IRP_MN_READ_CONFIG:
1878 return "IRP_MN_READ_CONFIG\n";
1879
1880 case IRP_MN_WRITE_CONFIG:
1881 return "IRP_MN_WRITE_CONFIG\n";
1882
1883 case IRP_MN_EJECT:
1884 return "IRP_MN_EJECT\n";
1885
1886 case IRP_MN_SET_LOCK:
1887 return "IRP_MN_SET_LOCK\n";
1888
1889 case IRP_MN_QUERY_ID:
1890 return "IRP_MN_QUERY_ID\n";
1891
1892 case IRP_MN_QUERY_PNP_DEVICE_STATE:
1893 return "IRP_MN_QUERY_PNP_DEVICE_STATE\n";
1894
1895 case IRP_MN_QUERY_BUS_INFORMATION:
1896 return "IRP_MN_QUERY_BUS_INFORMATION\n";
1897
1898 case IRP_MN_DEVICE_USAGE_NOTIFICATION:
1899 return "IRP_MN_DEVICE_USAGE_NOTIFICATION\n";
1900
1901 case IRP_MN_SURPRISE_REMOVAL:
1902 return "IRP_MN_SURPRISE_REMOVAL\n";
1903
1904 default:
1905 return "IRP_MN_?????\n";
1906
1907 }
1908
1909 }
1910