[BTRFS] Fix booting with runtime checks
[reactos.git] / drivers / hid / hidclass / pdo.c
1 /*
2 * PROJECT: ReactOS Universal Serial Bus Human Interface Device Driver
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: drivers/hid/hidclass/fdo.c
5 * PURPOSE: HID Class Driver
6 * PROGRAMMERS:
7 * Michael Martin (michael.martin@reactos.org)
8 * Johannes Anderwald (johannes.anderwald@reactos.org)
9 */
10
11 #include "precomp.h"
12
13 #include <wdmguid.h>
14
15 #define NDEBUG
16 #include <debug.h>
17
18 PHIDP_COLLECTION_DESC
19 HidClassPDO_GetCollectionDescription(
20 PHIDP_DEVICE_DESC DeviceDescription,
21 ULONG CollectionNumber)
22 {
23 ULONG Index;
24
25 for(Index = 0; Index < DeviceDescription->CollectionDescLength; Index++)
26 {
27 if (DeviceDescription->CollectionDesc[Index].CollectionNumber == CollectionNumber)
28 {
29 //
30 // found collection
31 //
32 return &DeviceDescription->CollectionDesc[Index];
33 }
34 }
35
36 //
37 // failed to find collection
38 //
39 DPRINT1("[HIDCLASS] GetCollectionDescription CollectionNumber %x not found\n", CollectionNumber);
40 ASSERT(FALSE);
41 return NULL;
42 }
43
44 PHIDP_REPORT_IDS
45 HidClassPDO_GetReportDescription(
46 PHIDP_DEVICE_DESC DeviceDescription,
47 ULONG CollectionNumber)
48 {
49 ULONG Index;
50
51 for (Index = 0; Index < DeviceDescription->ReportIDsLength; Index++)
52 {
53 if (DeviceDescription->ReportIDs[Index].CollectionNumber == CollectionNumber)
54 {
55 //
56 // found collection
57 //
58 return &DeviceDescription->ReportIDs[Index];
59 }
60 }
61
62 //
63 // failed to find collection
64 //
65 DPRINT1("[HIDCLASS] GetReportDescription CollectionNumber %x not found\n", CollectionNumber);
66 ASSERT(FALSE);
67 return NULL;
68 }
69
70 NTSTATUS
71 HidClassPDO_HandleQueryDeviceId(
72 IN PDEVICE_OBJECT DeviceObject,
73 IN PIRP Irp)
74 {
75 NTSTATUS Status;
76 LPWSTR Buffer;
77 LPWSTR NewBuffer, Ptr;
78 ULONG Length;
79
80 //
81 // copy current stack location
82 //
83 IoCopyCurrentIrpStackLocationToNext(Irp);
84
85 //
86 // call mini-driver
87 //
88 Status = HidClassFDO_DispatchRequestSynchronous(DeviceObject, Irp);
89 if (!NT_SUCCESS(Status))
90 {
91 //
92 // failed
93 //
94 return Status;
95 }
96
97 //
98 // get buffer
99 //
100 Buffer = (LPWSTR)Irp->IoStatus.Information;
101 Length = wcslen(Buffer);
102
103 //
104 // allocate new buffer
105 //
106 NewBuffer = ExAllocatePoolWithTag(NonPagedPool, (Length + 1) * sizeof(WCHAR), HIDCLASS_TAG);
107 if (!NewBuffer)
108 {
109 //
110 // failed to allocate buffer
111 //
112 return STATUS_INSUFFICIENT_RESOURCES;
113 }
114
115 //
116 // replace bus
117 //
118 wcscpy(NewBuffer, L"HID\\");
119
120 //
121 // get offset to first '\\'
122 //
123 Ptr = wcschr(Buffer, L'\\');
124 if (Ptr)
125 {
126 //
127 // append result
128 //
129 wcscat(NewBuffer, Ptr + 1);
130 }
131
132 //
133 // free old buffer
134 //
135 ExFreePoolWithTag(Buffer, 0);
136
137 //
138 // store result
139 //
140 DPRINT("NewBuffer %S\n", NewBuffer);
141 Irp->IoStatus.Information = (ULONG_PTR)NewBuffer;
142 return STATUS_SUCCESS;
143 }
144
145 NTSTATUS
146 HidClassPDO_HandleQueryHardwareId(
147 IN PDEVICE_OBJECT DeviceObject,
148 IN PIRP Irp)
149 {
150 NTSTATUS Status;
151 PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
152 WCHAR Buffer[200];
153 ULONG Offset = 0;
154 LPWSTR Ptr;
155 PHIDP_COLLECTION_DESC CollectionDescription;
156
157 //
158 // get device extension
159 //
160 PDODeviceExtension = DeviceObject->DeviceExtension;
161 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
162
163 //
164 // copy current stack location
165 //
166 IoCopyCurrentIrpStackLocationToNext(Irp);
167
168 //
169 // call mini-driver
170 //
171 Status = HidClassFDO_DispatchRequestSynchronous(DeviceObject, Irp);
172 if (!NT_SUCCESS(Status))
173 {
174 //
175 // failed
176 //
177 return Status;
178 }
179
180 if (PDODeviceExtension->Common.DeviceDescription.CollectionDescLength > 1)
181 {
182 //
183 // multi-tlc device
184 //
185 Offset = swprintf(&Buffer[Offset], L"HID\\Vid_%04x&Pid_%04x&Rev_%04x&Col%02x", PDODeviceExtension->Common.Attributes.VendorID, PDODeviceExtension->Common.Attributes.ProductID, PDODeviceExtension->Common.Attributes.VersionNumber, PDODeviceExtension->CollectionNumber) + 1;
186 Offset += swprintf(&Buffer[Offset], L"HID\\Vid_%04x&Pid_%04x&Col%02x", PDODeviceExtension->Common.Attributes.VendorID, PDODeviceExtension->Common.Attributes.ProductID, PDODeviceExtension->CollectionNumber) + 1;
187 }
188 else
189 {
190 //
191 // single tlc device
192 //
193 Offset = swprintf(&Buffer[Offset], L"HID\\Vid_%04x&Pid_%04x&Rev_%04x", PDODeviceExtension->Common.Attributes.VendorID, PDODeviceExtension->Common.Attributes.ProductID, PDODeviceExtension->Common.Attributes.VersionNumber) + 1;
194 Offset += swprintf(&Buffer[Offset], L"HID\\Vid_%04x&Pid_%04x", PDODeviceExtension->Common.Attributes.VendorID, PDODeviceExtension->Common.Attributes.ProductID) + 1;
195 }
196
197 //
198 // get collection description
199 //
200 CollectionDescription = HidClassPDO_GetCollectionDescription(&PDODeviceExtension->Common.DeviceDescription, PDODeviceExtension->CollectionNumber);
201 ASSERT(CollectionDescription);
202
203 if (CollectionDescription->UsagePage == HID_USAGE_PAGE_GENERIC)
204 {
205 switch (CollectionDescription->Usage)
206 {
207 case HID_USAGE_GENERIC_POINTER:
208 case HID_USAGE_GENERIC_MOUSE:
209 //
210 // Pointer / Mouse
211 //
212 Offset += swprintf(&Buffer[Offset], L"HID_DEVICE_SYSTEM_MOUSE") + 1;
213 break;
214 case HID_USAGE_GENERIC_GAMEPAD:
215 case HID_USAGE_GENERIC_JOYSTICK:
216 //
217 // Joystick / Gamepad
218 //
219 Offset += swprintf(&Buffer[Offset], L"HID_DEVICE_SYSTEM_GAME") + 1;
220 break;
221 case HID_USAGE_GENERIC_KEYBOARD:
222 case HID_USAGE_GENERIC_KEYPAD:
223 //
224 // Keyboard / Keypad
225 //
226 Offset += swprintf(&Buffer[Offset], L"HID_DEVICE_SYSTEM_KEYBOARD") + 1;
227 break;
228 case HID_USAGE_GENERIC_SYSTEM_CTL:
229 //
230 // System Control
231 //
232 Offset += swprintf(&Buffer[Offset], L"HID_DEVICE_SYSTEM_CONTROL") + 1;
233 break;
234 }
235 }
236 else if (CollectionDescription->UsagePage == HID_USAGE_PAGE_CONSUMER && CollectionDescription->Usage == HID_USAGE_CONSUMERCTRL)
237 {
238 //
239 // Consumer Audio Control
240 //
241 Offset += swprintf(&Buffer[Offset], L"HID_DEVICE_SYSTEM_CONSUMER") + 1;
242 }
243
244 //
245 // add HID_DEVICE_UP:0001_U:0002'
246 //
247 Offset += swprintf(&Buffer[Offset], L"HID_DEVICE_UP:%04x_U:%04x", CollectionDescription->UsagePage, CollectionDescription->Usage) + 1;
248
249 //
250 // add HID
251 //
252 Offset +=swprintf(&Buffer[Offset], L"HID_DEVICE") + 1;
253
254 //
255 // free old buffer
256 //
257 ExFreePoolWithTag((PVOID)Irp->IoStatus.Information, 0);
258
259 //
260 // allocate buffer
261 //
262 Ptr = ExAllocatePoolWithTag(NonPagedPool, (Offset + 1) * sizeof(WCHAR), HIDCLASS_TAG);
263 if (!Ptr)
264 {
265 //
266 // no memory
267 //
268 Irp->IoStatus.Information = 0;
269 return STATUS_INSUFFICIENT_RESOURCES;
270 }
271
272 //
273 // copy buffer
274 //
275 RtlCopyMemory(Ptr, Buffer, Offset * sizeof(WCHAR));
276 Ptr[Offset] = UNICODE_NULL;
277
278 //
279 // store result
280 //
281 Irp->IoStatus.Information = (ULONG_PTR)Ptr;
282 return STATUS_SUCCESS;
283 }
284
285 NTSTATUS
286 HidClassPDO_HandleQueryInstanceId(
287 IN PDEVICE_OBJECT DeviceObject,
288 IN PIRP Irp)
289 {
290 LPWSTR Buffer;
291 PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
292
293 //
294 // get device extension
295 //
296 PDODeviceExtension = DeviceObject->DeviceExtension;
297 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
298
299 //
300 // allocate buffer
301 //
302 Buffer = ExAllocatePoolWithTag(NonPagedPool, 5 * sizeof(WCHAR), HIDCLASS_TAG);
303 if (!Buffer)
304 {
305 //
306 // failed
307 //
308 return STATUS_INSUFFICIENT_RESOURCES;
309 }
310
311 //
312 // write device id
313 //
314 swprintf(Buffer, L"%04x", PDODeviceExtension->CollectionNumber);
315 Irp->IoStatus.Information = (ULONG_PTR)Buffer;
316
317 //
318 // done
319 //
320 return STATUS_SUCCESS;
321 }
322
323 NTSTATUS
324 HidClassPDO_HandleQueryCompatibleId(
325 IN PDEVICE_OBJECT DeviceObject,
326 IN PIRP Irp)
327 {
328 LPWSTR Buffer;
329
330 Buffer = ExAllocatePoolWithTag(NonPagedPool, 2 * sizeof(WCHAR), HIDCLASS_TAG);
331 if (!Buffer)
332 {
333 //
334 // no memory
335 //
336 return STATUS_INSUFFICIENT_RESOURCES;
337 }
338
339 //
340 // zero buffer
341 //
342 Buffer[0] = 0;
343 Buffer[1] = 0;
344
345 //
346 // store result
347 //
348 Irp->IoStatus.Information = (ULONG_PTR)Buffer;
349 return STATUS_SUCCESS;
350 }
351
352 NTSTATUS
353 HidClassPDO_PnP(
354 IN PDEVICE_OBJECT DeviceObject,
355 IN PIRP Irp)
356 {
357 PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
358 PIO_STACK_LOCATION IoStack;
359 NTSTATUS Status;
360 PPNP_BUS_INFORMATION BusInformation;
361 PDEVICE_RELATIONS DeviceRelation;
362 ULONG Index, bFound;
363
364 //
365 // get device extension
366 //
367 PDODeviceExtension = DeviceObject->DeviceExtension;
368 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
369
370 //
371 // get current irp stack location
372 //
373 IoStack = IoGetCurrentIrpStackLocation(Irp);
374
375 //
376 // handle request
377 //
378 switch (IoStack->MinorFunction)
379 {
380 case IRP_MN_QUERY_ID:
381 {
382 if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
383 {
384 //
385 // handle query device id
386 //
387 Status = HidClassPDO_HandleQueryDeviceId(DeviceObject, Irp);
388 break;
389 }
390 else if (IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
391 {
392 //
393 // handle instance id
394 //
395 Status = HidClassPDO_HandleQueryHardwareId(DeviceObject, Irp);
396 break;
397 }
398 else if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
399 {
400 //
401 // handle instance id
402 //
403 Status = HidClassPDO_HandleQueryInstanceId(DeviceObject, Irp);
404 break;
405 }
406 else if (IoStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
407 {
408 //
409 // handle instance id
410 //
411 Status = HidClassPDO_HandleQueryCompatibleId(DeviceObject, Irp);
412 break;
413 }
414
415 DPRINT1("[HIDCLASS]: IRP_MN_QUERY_ID IdType %x unimplemented\n", IoStack->Parameters.QueryId.IdType);
416 Status = STATUS_NOT_SUPPORTED;
417 Irp->IoStatus.Information = 0;
418 break;
419 }
420 case IRP_MN_QUERY_CAPABILITIES:
421 {
422 if (IoStack->Parameters.DeviceCapabilities.Capabilities == NULL)
423 {
424 //
425 // invalid request
426 //
427 Status = STATUS_DEVICE_CONFIGURATION_ERROR;
428 break;
429 }
430
431 //
432 // copy capabilities
433 //
434 RtlCopyMemory(IoStack->Parameters.DeviceCapabilities.Capabilities,
435 &PDODeviceExtension->Capabilities,
436 sizeof(DEVICE_CAPABILITIES));
437 Status = STATUS_SUCCESS;
438 break;
439 }
440 case IRP_MN_QUERY_BUS_INFORMATION:
441 {
442 //
443 //
444 //
445 BusInformation = ExAllocatePoolWithTag(NonPagedPool, sizeof(PNP_BUS_INFORMATION), HIDCLASS_TAG);
446
447 //
448 // fill in result
449 //
450 RtlCopyMemory(&BusInformation->BusTypeGuid, &GUID_BUS_TYPE_HID, sizeof(GUID));
451 BusInformation->LegacyBusType = PNPBus;
452 BusInformation->BusNumber = 0; //FIXME
453
454 //
455 // store result
456 //
457 Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
458 Status = STATUS_SUCCESS;
459 break;
460 }
461 case IRP_MN_QUERY_PNP_DEVICE_STATE:
462 {
463 //
464 // FIXME set flags when driver fails / disabled
465 //
466 Status = STATUS_SUCCESS;
467 break;
468 }
469 case IRP_MN_QUERY_DEVICE_RELATIONS:
470 {
471 //
472 // only target relations are supported
473 //
474 if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
475 {
476 //
477 // not supported
478 //
479 Status = Irp->IoStatus.Status;
480 break;
481 }
482
483 //
484 // allocate device relations
485 //
486 DeviceRelation = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_RELATIONS), HIDCLASS_TAG);
487 if (!DeviceRelation)
488 {
489 //
490 // no memory
491 //
492 Status = STATUS_INSUFFICIENT_RESOURCES;
493 break;
494 }
495
496 //
497 // init device relation
498 //
499 DeviceRelation->Count = 1;
500 DeviceRelation->Objects[0] = DeviceObject;
501 ObReferenceObject(DeviceRelation->Objects[0]);
502
503 //
504 // store result
505 //
506 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
507 Status = STATUS_SUCCESS;
508 break;
509 }
510 case IRP_MN_START_DEVICE:
511 {
512 //
513 // FIXME: support polled devices
514 //
515 ASSERT(PDODeviceExtension->Common.DriverExtension->DevicesArePolled == FALSE);
516
517 //
518 // now register the device interface
519 //
520 Status = IoRegisterDeviceInterface(PDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject,
521 &GUID_DEVINTERFACE_HID,
522 NULL,
523 &PDODeviceExtension->DeviceInterface);
524 DPRINT("[HIDCLASS] IoRegisterDeviceInterfaceState Status %x\n", Status);
525 if (NT_SUCCESS(Status))
526 {
527 //
528 // enable device interface
529 //
530 Status = IoSetDeviceInterfaceState(&PDODeviceExtension->DeviceInterface, TRUE);
531 DPRINT("[HIDCLASS] IoSetDeviceInterFaceState %x\n", Status);
532 }
533
534 //
535 // done
536 //
537 Status = STATUS_SUCCESS;
538 break;
539 }
540 case IRP_MN_REMOVE_DEVICE:
541 {
542 /* Disable the device interface */
543 if (PDODeviceExtension->DeviceInterface.Length != 0)
544 IoSetDeviceInterfaceState(&PDODeviceExtension->DeviceInterface, FALSE);
545
546 //
547 // remove us from the fdo's pdo list
548 //
549 bFound = FALSE;
550 for (Index = 0; Index < PDODeviceExtension->FDODeviceExtension->DeviceRelations->Count; Index++)
551 {
552 if (PDODeviceExtension->FDODeviceExtension->DeviceRelations->Objects[Index] == DeviceObject)
553 {
554 //
555 // remove us
556 //
557 bFound = TRUE;
558 PDODeviceExtension->FDODeviceExtension->DeviceRelations->Objects[Index] = NULL;
559 break;
560 }
561 }
562
563 /* Complete the IRP */
564 Irp->IoStatus.Status = STATUS_SUCCESS;
565 IoCompleteRequest(Irp, IO_NO_INCREMENT);
566
567 if (bFound)
568 {
569 /* Delete our device object*/
570 IoDeleteDevice(DeviceObject);
571 }
572
573 return STATUS_SUCCESS;
574 }
575 case IRP_MN_QUERY_INTERFACE:
576 {
577 DPRINT1("[HIDCLASS] PDO IRP_MN_QUERY_INTERFACE not implemented\n");
578
579 //
580 // do nothing
581 //
582 Status = Irp->IoStatus.Status;
583 break;
584 }
585 case IRP_MN_QUERY_REMOVE_DEVICE:
586 case IRP_MN_CANCEL_STOP_DEVICE:
587 case IRP_MN_QUERY_STOP_DEVICE:
588 case IRP_MN_CANCEL_REMOVE_DEVICE:
589 {
590 //
591 // no/op
592 //
593 #if 0
594 Status = STATUS_SUCCESS;
595 #else
596 DPRINT1("Denying removal of HID device due to IRP cancellation bugs\n");
597 Status = STATUS_UNSUCCESSFUL;
598 #endif
599 break;
600 }
601 default:
602 {
603 //
604 // do nothing
605 //
606 Status = Irp->IoStatus.Status;
607 break;
608 }
609 }
610
611 //
612 // complete request
613 //
614 if (Status != STATUS_PENDING)
615 {
616 //
617 // store result
618 //
619 Irp->IoStatus.Status = Status;
620
621 //
622 // complete request
623 //
624 IoCompleteRequest(Irp, IO_NO_INCREMENT);
625 }
626
627 //
628 // done processing
629 //
630 return Status;
631 }
632
633 NTSTATUS
634 HidClassPDO_CreatePDO(
635 IN PDEVICE_OBJECT DeviceObject,
636 OUT PDEVICE_RELATIONS *OutDeviceRelations)
637 {
638 PHIDCLASS_FDO_EXTENSION FDODeviceExtension;
639 NTSTATUS Status = STATUS_SUCCESS;
640 PDEVICE_OBJECT PDODeviceObject;
641 PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
642 ULONG Index;
643 PDEVICE_RELATIONS DeviceRelations;
644 ULONG Length;
645
646 //
647 // get device extension
648 //
649 FDODeviceExtension = DeviceObject->DeviceExtension;
650 ASSERT(FDODeviceExtension->Common.IsFDO);
651
652 //
653 // first allocate device relations
654 //
655 Length = FIELD_OFFSET(DEVICE_RELATIONS, Objects) + sizeof(PDEVICE_OBJECT) * FDODeviceExtension->Common.DeviceDescription.CollectionDescLength;
656 DeviceRelations = ExAllocatePoolWithTag(PagedPool, Length, HIDCLASS_TAG);
657 if (!DeviceRelations)
658 {
659 //
660 // no memory
661 //
662 return STATUS_INSUFFICIENT_RESOURCES;
663 }
664
665 //
666 // zero device relations
667 //
668 RtlZeroMemory(DeviceRelations, Length);
669
670 //
671 // let's create a PDO for top level collection
672 //
673 Index = 0;
674 while (Index < FDODeviceExtension->Common.DeviceDescription.CollectionDescLength)
675 {
676 //
677 // let's create the device object
678 //
679 Status = IoCreateDevice(FDODeviceExtension->Common.DriverExtension->DriverObject,
680 sizeof(HIDCLASS_PDO_DEVICE_EXTENSION),
681 NULL,
682 FILE_DEVICE_UNKNOWN,
683 FILE_AUTOGENERATED_DEVICE_NAME,
684 FALSE,
685 &PDODeviceObject);
686 if (!NT_SUCCESS(Status))
687 {
688 //
689 // failed to create device
690 //
691 DPRINT1("[HIDCLASS] Failed to create PDO %x\n", Status);
692 break;
693 }
694
695 //
696 // patch stack size
697 //
698 PDODeviceObject->StackSize = DeviceObject->StackSize + 1;
699
700 //
701 // get device extension
702 //
703 PDODeviceExtension = PDODeviceObject->DeviceExtension;
704
705 //
706 // init device extension
707 //
708 PDODeviceExtension->Common.HidDeviceExtension.MiniDeviceExtension = FDODeviceExtension->Common.HidDeviceExtension.MiniDeviceExtension;
709 PDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject = FDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject;
710 PDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject = FDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject;
711 PDODeviceExtension->Common.IsFDO = FALSE;
712 PDODeviceExtension->FDODeviceExtension = FDODeviceExtension;
713 PDODeviceExtension->FDODeviceObject = DeviceObject;
714 PDODeviceExtension->Common.DriverExtension = FDODeviceExtension->Common.DriverExtension;
715 PDODeviceExtension->CollectionNumber = FDODeviceExtension->Common.DeviceDescription.CollectionDesc[Index].CollectionNumber;
716
717 //
718 // copy device data
719 //
720 RtlCopyMemory(&PDODeviceExtension->Common.Attributes, &FDODeviceExtension->Common.Attributes, sizeof(HID_DEVICE_ATTRIBUTES));
721 RtlCopyMemory(&PDODeviceExtension->Common.DeviceDescription, &FDODeviceExtension->Common.DeviceDescription, sizeof(HIDP_DEVICE_DESC));
722 RtlCopyMemory(&PDODeviceExtension->Capabilities, &FDODeviceExtension->Capabilities, sizeof(DEVICE_CAPABILITIES));
723
724 //
725 // set device flags
726 //
727 PDODeviceObject->Flags |= DO_MAP_IO_BUFFER;
728
729 //
730 // device is initialized
731 //
732 PDODeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
733
734 //
735 // store device object in device relations
736 //
737 DeviceRelations->Objects[Index] = PDODeviceObject;
738 DeviceRelations->Count++;
739
740 //
741 // move to next
742 //
743 Index++;
744
745 }
746
747
748 //
749 // check if creating succeeded
750 //
751 if (!NT_SUCCESS(Status))
752 {
753 //
754 // failed
755 //
756 for (Index = 0; Index < DeviceRelations->Count; Index++)
757 {
758 //
759 // delete device
760 //
761 IoDeleteDevice(DeviceRelations->Objects[Index]);
762 }
763
764 //
765 // free device relations
766 //
767 ExFreePoolWithTag(DeviceRelations, HIDCLASS_TAG);
768 return Status;
769 }
770
771 //
772 // store device relations
773 //
774 *OutDeviceRelations = DeviceRelations;
775
776 //
777 // done
778 //
779 return STATUS_SUCCESS;
780 }