2 * PROJECT: ReactOS USB Port Driver
3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4 * PURPOSE: USBPort main driver functions
5 * COPYRIGHT: Copyright 2017 Vadim Galyant <vgal@rambler.ru>
13 #define NDEBUG_USBPORT_CORE
14 #define NDEBUG_USBPORT_INTERRUPT
15 #define NDEBUG_USBPORT_TIMER
18 LIST_ENTRY USBPORT_MiniPortDrivers
= {NULL
, NULL
};
19 LIST_ENTRY USBPORT_USB1FdoList
= {NULL
, NULL
};
20 LIST_ENTRY USBPORT_USB2FdoList
= {NULL
, NULL
};
22 KSPIN_LOCK USBPORT_SpinLock
;
23 BOOLEAN USBPORT_Initialized
= FALSE
;
27 USBPORT_FindUSB2Controller(IN PDEVICE_OBJECT FdoDevice
)
29 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
30 PUSBPORT_DEVICE_EXTENSION USB2FdoExtension
;
32 PLIST_ENTRY USB2FdoEntry
;
33 PDEVICE_OBJECT USB2FdoDevice
= NULL
;
35 DPRINT("USBPORT_FindUSB2Controller: FdoDevice - %p\n", FdoDevice
);
37 FdoExtension
= FdoDevice
->DeviceExtension
;
39 KeAcquireSpinLock(&USBPORT_SpinLock
, &OldIrql
);
41 USB2FdoEntry
= USBPORT_USB2FdoList
.Flink
;
43 while (USB2FdoEntry
&& USB2FdoEntry
!= &USBPORT_USB2FdoList
)
45 USB2FdoExtension
= CONTAINING_RECORD(USB2FdoEntry
,
46 USBPORT_DEVICE_EXTENSION
,
49 if (USB2FdoExtension
->BusNumber
== FdoExtension
->BusNumber
&&
50 USB2FdoExtension
->PciDeviceNumber
== FdoExtension
->PciDeviceNumber
)
52 USB2FdoDevice
= USB2FdoExtension
->CommonExtension
.SelfDevice
;
56 USB2FdoEntry
= USB2FdoEntry
->Flink
;
59 KeReleaseSpinLock(&USBPORT_SpinLock
, OldIrql
);
66 USBPORT_AddUSB1Fdo(IN PDEVICE_OBJECT FdoDevice
)
68 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
70 DPRINT("USBPORT_AddUSB1Fdo: FdoDevice - %p\n", FdoDevice
);
72 FdoExtension
= FdoDevice
->DeviceExtension
;
73 FdoExtension
->Flags
|= USBPORT_FLAG_REGISTERED_FDO
;
75 ExInterlockedInsertTailList(&USBPORT_USB1FdoList
,
76 &FdoExtension
->ControllerLink
,
82 USBPORT_AddUSB2Fdo(IN PDEVICE_OBJECT FdoDevice
)
84 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
86 DPRINT("USBPORT_AddUSB2Fdo: FdoDevice - %p\n", FdoDevice
);
88 FdoExtension
= FdoDevice
->DeviceExtension
;
89 FdoExtension
->Flags
|= USBPORT_FLAG_REGISTERED_FDO
;
91 ExInterlockedInsertTailList(&USBPORT_USB2FdoList
,
92 &FdoExtension
->ControllerLink
,
98 USBPORT_RemoveUSBxFdo(IN PDEVICE_OBJECT FdoDevice
)
100 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
103 DPRINT("USBPORT_RemoveUSBxFdo: FdoDevice - %p\n", FdoDevice
);
105 FdoExtension
= FdoDevice
->DeviceExtension
;
107 KeAcquireSpinLock(&USBPORT_SpinLock
, &OldIrql
);
108 RemoveEntryList(&FdoExtension
->ControllerLink
);
109 KeReleaseSpinLock(&USBPORT_SpinLock
, OldIrql
);
111 FdoExtension
->Flags
&= ~USBPORT_FLAG_REGISTERED_FDO
;
113 FdoExtension
->ControllerLink
.Flink
= NULL
;
114 FdoExtension
->ControllerLink
.Blink
= NULL
;
119 USBPORT_IsCompanionFdoExtension(IN PDEVICE_OBJECT USB2FdoDevice
,
120 IN PUSBPORT_DEVICE_EXTENSION USB1FdoExtension
)
122 PUSBPORT_DEVICE_EXTENSION USB2FdoExtension
;
124 DPRINT("USBPORT_IsCompanionFdoExtension: USB2Fdo - %p, USB1FdoExtension - %p\n",
128 USB2FdoExtension
= USB2FdoDevice
->DeviceExtension
;
130 return USB2FdoExtension
->BusNumber
== USB1FdoExtension
->BusNumber
&&
131 USB2FdoExtension
->PciDeviceNumber
== USB1FdoExtension
->PciDeviceNumber
;
136 USBPORT_FindCompanionControllers(IN PDEVICE_OBJECT USB2FdoDevice
,
137 IN BOOLEAN IsObRefer
,
138 IN BOOLEAN IsFDOsReturned
)
140 PLIST_ENTRY USB1FdoList
;
141 PUSBPORT_DEVICE_EXTENSION USB1FdoExtension
;
142 ULONG NumControllers
= 0;
143 PDEVICE_OBJECT
* Entry
;
144 PDEVICE_RELATIONS ControllersList
= NULL
;
147 DPRINT("USBPORT_FindCompanionControllers: USB2Fdo - %p, IsObRefer - %x, IsFDOs - %x\n",
152 KeAcquireSpinLock(&USBPORT_SpinLock
, &OldIrql
);
154 USB1FdoList
= USBPORT_USB1FdoList
.Flink
;
156 while (USB1FdoList
&& USB1FdoList
!= &USBPORT_USB1FdoList
)
158 USB1FdoExtension
= CONTAINING_RECORD(USB1FdoList
,
159 USBPORT_DEVICE_EXTENSION
,
162 if (USB1FdoExtension
->Flags
& USBPORT_FLAG_COMPANION_HC
&&
163 USBPORT_IsCompanionFdoExtension(USB2FdoDevice
, USB1FdoExtension
))
168 USB1FdoList
= USB1FdoExtension
->ControllerLink
.Flink
;
171 DPRINT("USBPORT_FindCompanionControllers: NumControllers - %x\n",
179 ControllersList
= ExAllocatePoolWithTag(NonPagedPool
,
180 NumControllers
* sizeof(DEVICE_RELATIONS
),
183 if (!ControllersList
)
188 RtlZeroMemory(ControllersList
, NumControllers
* sizeof(DEVICE_RELATIONS
));
190 ControllersList
->Count
= NumControllers
;
192 USB1FdoList
= USBPORT_USB1FdoList
.Flink
;
194 Entry
= &ControllersList
->Objects
[0];
196 while (USB1FdoList
&& USB1FdoList
!= &USBPORT_USB1FdoList
)
198 USB1FdoExtension
= CONTAINING_RECORD(USB1FdoList
,
199 USBPORT_DEVICE_EXTENSION
,
202 if (USB1FdoExtension
->Flags
& USBPORT_FLAG_COMPANION_HC
&&
203 USBPORT_IsCompanionFdoExtension(USB2FdoDevice
, USB1FdoExtension
))
205 *Entry
= USB1FdoExtension
->CommonExtension
.LowerPdoDevice
;
209 ObReferenceObject(USB1FdoExtension
->CommonExtension
.LowerPdoDevice
);
214 *Entry
= USB1FdoExtension
->CommonExtension
.SelfDevice
;
220 USB1FdoList
= USB1FdoExtension
->ControllerLink
.Flink
;
225 KeReleaseSpinLock(&USBPORT_SpinLock
, OldIrql
);
227 return ControllersList
;
232 USBPORT_NtStatusToMpStatus(NTSTATUS NtStatus
)
234 DPRINT("USBPORT_NtStatusToMpStatus: NtStatus - %x\n", NtStatus
);
236 if (NtStatus
== STATUS_SUCCESS
)
238 return MP_STATUS_SUCCESS
;
242 return MP_STATUS_UNSUCCESSFUL
;
248 USBPORT_SetRegistryKeyValue(IN PDEVICE_OBJECT DeviceObject
,
249 IN BOOL UseDriverKey
,
251 IN PCWSTR ValueNameString
,
255 UNICODE_STRING ValueName
;
259 DPRINT("USBPORT_SetRegistryKeyValue: ValueNameString - %S \n",
264 Status
= IoOpenDeviceRegistryKey(DeviceObject
,
265 PLUGPLAY_REGKEY_DRIVER
,
271 Status
= IoOpenDeviceRegistryKey(DeviceObject
,
272 PLUGPLAY_REGKEY_DEVICE
,
277 if (NT_SUCCESS(Status
))
279 RtlInitUnicodeString(&ValueName
, ValueNameString
);
281 Status
= ZwSetValueKey(KeyHandle
,
296 USBPORT_GetRegistryKeyValueFullInfo(IN PDEVICE_OBJECT FdoDevice
,
297 IN PDEVICE_OBJECT PdoDevice
,
298 IN BOOL UseDriverKey
,
299 IN PCWSTR SourceString
,
302 IN ULONG BufferLength
)
305 PKEY_VALUE_FULL_INFORMATION KeyValue
;
306 UNICODE_STRING ValueName
;
310 DPRINT("USBPORT_GetRegistryKeyValue: UseDriverKey - %x, SourceString - %S, LengthStr - %x, Buffer - %p, BufferLength - %x\n",
319 Status
= IoOpenDeviceRegistryKey(PdoDevice
,
320 PLUGPLAY_REGKEY_DRIVER
,
326 Status
= IoOpenDeviceRegistryKey(PdoDevice
,
327 PLUGPLAY_REGKEY_DEVICE
,
332 if (NT_SUCCESS(Status
))
334 RtlInitUnicodeString(&ValueName
, SourceString
);
336 LengthKey
= sizeof(KEY_VALUE_FULL_INFORMATION
) +
340 KeyValue
= ExAllocatePoolWithTag(PagedPool
,
346 RtlZeroMemory(KeyValue
, LengthKey
);
348 Status
= ZwQueryValueKey(KeyHandle
,
350 KeyValueFullInformation
,
355 if (NT_SUCCESS(Status
))
357 RtlCopyMemory(Buffer
,
358 (PUCHAR
)KeyValue
+ KeyValue
->DataOffset
,
362 ExFreePoolWithTag(KeyValue
, USB_PORT_TAG
);
373 USBPORT_GetMiniportRegistryKeyValue(IN PVOID MiniPortExtension
,
374 IN BOOL UseDriverKey
,
375 IN PCWSTR SourceString
,
378 IN SIZE_T BufferLength
)
380 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
381 PDEVICE_OBJECT FdoDevice
;
384 DPRINT("USBPORT_GetMiniportRegistryKeyValue: MiniPortExtension - %p, UseDriverKey - %x, SourceString - %S, LengthStr - %x, Buffer - %p, BufferLength - %x\n",
392 FdoExtension
= (PUSBPORT_DEVICE_EXTENSION
)((ULONG_PTR
)MiniPortExtension
-
393 sizeof(USBPORT_DEVICE_EXTENSION
));
395 FdoDevice
= FdoExtension
->CommonExtension
.SelfDevice
;
397 Status
= USBPORT_GetRegistryKeyValueFullInfo(FdoDevice
,
398 FdoExtension
->CommonExtension
.LowerPdoDevice
,
405 return USBPORT_NtStatusToMpStatus(Status
);
410 USBPORT_GetSetConfigSpaceData(IN PDEVICE_OBJECT FdoDevice
,
411 IN BOOLEAN IsReadData
,
416 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
417 ULONG BytesReadWrite
;
419 DPRINT("USBPORT_GetSetConfigSpaceData ... \n");
421 FdoExtension
= FdoDevice
->DeviceExtension
;
423 BytesReadWrite
= Length
;
427 RtlZeroMemory(Buffer
, Length
);
429 BytesReadWrite
= (*FdoExtension
->BusInterface
.GetBusData
)
430 (FdoExtension
->BusInterface
.Context
,
431 PCI_WHICHSPACE_CONFIG
,
438 BytesReadWrite
= (*FdoExtension
->BusInterface
.SetBusData
)
439 (FdoExtension
->BusInterface
.Context
,
440 PCI_WHICHSPACE_CONFIG
,
446 if (BytesReadWrite
== Length
)
448 return STATUS_SUCCESS
;
451 return STATUS_UNSUCCESSFUL
;
456 USBPORT_ReadWriteConfigSpace(IN PVOID MiniPortExtension
,
457 IN BOOLEAN IsReadData
,
463 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
464 PDEVICE_OBJECT FdoDevice
;
466 DPRINT("USBPORT_ReadWriteConfigSpace: ... \n");
468 //FdoExtension->MiniPortExt = (PVOID)((ULONG_PTR)FdoExtension + sizeof(USBPORT_DEVICE_EXTENSION));
469 FdoExtension
= (PUSBPORT_DEVICE_EXTENSION
)((ULONG_PTR
)MiniPortExtension
-
470 sizeof(USBPORT_DEVICE_EXTENSION
));
472 FdoDevice
= FdoExtension
->CommonExtension
.SelfDevice
;
474 Status
= USBPORT_GetSetConfigSpaceData(FdoDevice
,
480 return USBPORT_NtStatusToMpStatus(Status
);
485 USBPORT_USBDStatusToNtStatus(IN PURB Urb
,
486 IN USBD_STATUS USBDStatus
)
490 if (USBD_ERROR(USBDStatus
))
492 DPRINT1("USBPORT_USBDStatusToNtStatus: Urb - %p, USBDStatus - %x\n",
498 Urb
->UrbHeader
.Status
= USBDStatus
;
502 case USBD_STATUS_SUCCESS
:
503 Status
= STATUS_SUCCESS
;
506 case USBD_STATUS_INSUFFICIENT_RESOURCES
:
507 Status
= STATUS_INSUFFICIENT_RESOURCES
;
510 case USBD_STATUS_DEVICE_GONE
:
511 Status
= STATUS_DEVICE_NOT_CONNECTED
;
514 case USBD_STATUS_CANCELED
:
515 Status
= STATUS_CANCELLED
;
518 case USBD_STATUS_NOT_SUPPORTED
:
519 Status
= STATUS_NOT_SUPPORTED
;
522 case USBD_STATUS_INVALID_URB_FUNCTION
:
523 case USBD_STATUS_INVALID_PARAMETER
:
524 case USBD_STATUS_INVALID_PIPE_HANDLE
:
525 case USBD_STATUS_BAD_START_FRAME
:
526 Status
= STATUS_INVALID_PARAMETER
;
530 if (USBD_ERROR(USBDStatus
))
531 Status
= STATUS_UNSUCCESSFUL
;
533 Status
= STATUS_SUCCESS
;
543 USBPORT_Wait(IN PVOID MiniPortExtension
,
544 IN ULONG Milliseconds
)
546 LARGE_INTEGER Interval
= {{0, 0}};
548 DPRINT("USBPORT_Wait: Milliseconds - %x\n", Milliseconds
);
549 Interval
.QuadPart
-= 10000 * Milliseconds
+ (KeQueryTimeIncrement() - 1);
550 return KeDelayExecutionThread(KernelMode
, FALSE
, &Interval
);
555 USBPORT_MiniportInterrupts(IN PDEVICE_OBJECT FdoDevice
,
558 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
559 PUSBPORT_REGISTRATION_PACKET Packet
;
563 DPRINT_INT("USBPORT_MiniportInterrupts: IsEnable - %p\n", IsEnable
);
565 FdoExtension
= FdoDevice
->DeviceExtension
;
566 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
568 IsLock
= (Packet
->MiniPortFlags
& USB_MINIPORT_FLAGS_NOT_LOCK_INT
) == 0;
571 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
575 FdoExtension
->Flags
|= USBPORT_FLAG_INTERRUPT_ENABLED
;
576 Packet
->EnableInterrupts(FdoExtension
->MiniPortExt
);
580 Packet
->DisableInterrupts(FdoExtension
->MiniPortExt
);
581 FdoExtension
->Flags
&= ~USBPORT_FLAG_INTERRUPT_ENABLED
;
585 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
590 USBPORT_SoftInterruptDpc(IN PRKDPC Dpc
,
591 IN PVOID DeferredContext
,
592 IN PVOID SystemArgument1
,
593 IN PVOID SystemArgument2
)
595 PDEVICE_OBJECT FdoDevice
;
596 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
598 DPRINT_INT("USBPORT_SoftInterruptDpc: ... \n");
600 FdoDevice
= DeferredContext
;
601 FdoExtension
= FdoDevice
->DeviceExtension
;
603 if (!KeInsertQueueDpc(&FdoExtension
->IsrDpc
, NULL
, (PVOID
)1))
605 InterlockedDecrement(&FdoExtension
->IsrDpcCounter
);
611 USBPORT_SoftInterrupt(IN PDEVICE_OBJECT FdoDevice
)
613 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
614 LARGE_INTEGER DueTime
= {{0, 0}};
616 DPRINT_INT("USBPORT_SoftInterrupt: ... \n");
618 FdoExtension
= FdoDevice
->DeviceExtension
;
620 KeInitializeTimer(&FdoExtension
->TimerSoftInterrupt
);
622 KeInitializeDpc(&FdoExtension
->SoftInterruptDpc
,
623 USBPORT_SoftInterruptDpc
,
626 DueTime
.QuadPart
-= 10000 + (KeQueryTimeIncrement() - 1);
628 KeSetTimer(&FdoExtension
->TimerSoftInterrupt
,
630 &FdoExtension
->SoftInterruptDpc
);
635 USBPORT_InvalidateControllerHandler(IN PDEVICE_OBJECT FdoDevice
,
638 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
640 DPRINT("USBPORT_InvalidateControllerHandler: Invalidate Type - %x\n",
643 FdoExtension
= FdoDevice
->DeviceExtension
;
647 case USBPORT_INVALIDATE_CONTROLLER_RESET
:
648 DPRINT1("USBPORT_InvalidateControllerHandler: INVALIDATE_CONTROLLER_RESET UNIMPLEMENTED. FIXME. \n");
651 case USBPORT_INVALIDATE_CONTROLLER_SURPRISE_REMOVE
:
652 DPRINT1("USBPORT_InvalidateControllerHandler: INVALIDATE_CONTROLLER_SURPRISE_REMOVE UNIMPLEMENTED. FIXME. \n");
655 case USBPORT_INVALIDATE_CONTROLLER_SOFT_INTERRUPT
:
656 if (InterlockedIncrement(&FdoExtension
->IsrDpcCounter
))
658 InterlockedDecrement(&FdoExtension
->IsrDpcCounter
);
662 USBPORT_SoftInterrupt(FdoDevice
);
670 USBPORT_InvalidateController(IN PVOID MiniPortExtension
,
673 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
674 PDEVICE_OBJECT FdoDevice
;
676 DPRINT("USBPORT_InvalidateController: Invalidate Type - %x\n", Type
);
678 //FdoExtension->MiniPortExt = (PVOID)((ULONG_PTR)FdoExtension + sizeof(USBPORT_DEVICE_EXTENSION));
679 FdoExtension
= (PUSBPORT_DEVICE_EXTENSION
)((ULONG_PTR
)MiniPortExtension
-
680 sizeof(USBPORT_DEVICE_EXTENSION
));
681 FdoDevice
= FdoExtension
->CommonExtension
.SelfDevice
;
683 USBPORT_InvalidateControllerHandler(FdoDevice
, Type
);
690 USBPORT_NotifyDoubleBuffer(IN PVOID MiniPortExtension
,
691 IN PVOID MiniPortTransfer
,
695 DPRINT1("USBPORT_NotifyDoubleBuffer: UNIMPLEMENTED. FIXME. \n");
701 USBPORT_WorkerRequestDpc(IN PRKDPC Dpc
,
702 IN PVOID DeferredContext
,
703 IN PVOID SystemArgument1
,
704 IN PVOID SystemArgument2
)
706 PDEVICE_OBJECT FdoDevice
;
707 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
709 DPRINT("USBPORT_WorkerRequestDpc: ... \n");
711 FdoDevice
= DeferredContext
;
712 FdoExtension
= FdoDevice
->DeviceExtension
;
714 if (!InterlockedIncrement(&FdoExtension
->IsrDpcHandlerCounter
))
716 USBPORT_DpcHandler(FdoDevice
);
719 InterlockedDecrement(&FdoExtension
->IsrDpcHandlerCounter
);
724 USBPORT_DoneTransfer(IN PUSBPORT_TRANSFER Transfer
)
726 PUSBPORT_ENDPOINT Endpoint
;
727 PDEVICE_OBJECT FdoDevice
;
728 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
734 DPRINT_CORE("USBPORT_DoneTransfer: Transfer - %p\n", Transfer
);
736 Endpoint
= Transfer
->Endpoint
;
737 FdoDevice
= Endpoint
->FdoDevice
;
738 FdoExtension
= FdoDevice
->DeviceExtension
;
743 KeAcquireSpinLock(&FdoExtension
->FlushTransferSpinLock
, &OldIrql
);
747 IoAcquireCancelSpinLock(&CancelIrql
);
748 IoSetCancelRoutine(Irp
, NULL
);
749 IoReleaseCancelSpinLock(CancelIrql
);
751 USBPORT_RemoveActiveTransferIrp(FdoDevice
, Irp
);
754 KeReleaseSpinLock(&FdoExtension
->FlushTransferSpinLock
, OldIrql
);
756 USBPORT_USBDStatusToNtStatus(Transfer
->Urb
, Transfer
->USBDStatus
);
757 USBPORT_CompleteTransfer(Urb
, Urb
->UrbHeader
.Status
);
759 DPRINT_CORE("USBPORT_DoneTransfer: exit\n");
764 USBPORT_FlushDoneTransfers(IN PDEVICE_OBJECT FdoDevice
)
766 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
767 PLIST_ENTRY DoneTransferList
;
768 PUSBPORT_TRANSFER Transfer
;
769 PUSBPORT_ENDPOINT Endpoint
;
772 BOOLEAN IsHasTransfers
;
774 DPRINT_CORE("USBPORT_FlushDoneTransfers: ... \n");
776 FdoExtension
= FdoDevice
->DeviceExtension
;
777 DoneTransferList
= &FdoExtension
->DoneTransferList
;
781 KeAcquireSpinLock(&FdoExtension
->DoneTransferSpinLock
, &OldIrql
);
783 if (IsListEmpty(DoneTransferList
))
786 Transfer
= CONTAINING_RECORD(DoneTransferList
->Flink
,
790 RemoveHeadList(DoneTransferList
);
791 KeReleaseSpinLock(&FdoExtension
->DoneTransferSpinLock
, OldIrql
);
795 Endpoint
= Transfer
->Endpoint
;
797 if ((Transfer
->Flags
& TRANSFER_FLAG_SPLITED
))
799 USBPORT_DoneSplitTransfer(Transfer
);
803 USBPORT_DoneTransfer(Transfer
);
806 IsHasTransfers
= USBPORT_EndpointHasQueuedTransfers(FdoDevice
,
810 if (IsHasTransfers
&& !TransferCount
)
812 USBPORT_InvalidateEndpointHandler(FdoDevice
,
814 INVALIDATE_ENDPOINT_WORKER_DPC
);
819 KeReleaseSpinLock(&FdoExtension
->DoneTransferSpinLock
, OldIrql
);
825 USBPORT_TransferFlushDpc(IN PRKDPC Dpc
,
826 IN PVOID DeferredContext
,
827 IN PVOID SystemArgument1
,
828 IN PVOID SystemArgument2
)
830 PDEVICE_OBJECT FdoDevice
;
832 DPRINT_CORE("USBPORT_TransferFlushDpc: ... \n");
833 FdoDevice
= DeferredContext
;
834 USBPORT_FlushDoneTransfers(FdoDevice
);
839 USBPORT_QueueDoneTransfer(IN PUSBPORT_TRANSFER Transfer
,
840 IN USBD_STATUS USBDStatus
)
842 PDEVICE_OBJECT FdoDevice
;
843 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
845 DPRINT_CORE("USBPORT_QueueDoneTransfer: Transfer - %p, USBDStatus - %p\n",
849 FdoDevice
= Transfer
->Endpoint
->FdoDevice
;
850 FdoExtension
= FdoDevice
->DeviceExtension
;
852 RemoveEntryList(&Transfer
->TransferLink
);
853 Transfer
->USBDStatus
= USBDStatus
;
855 ExInterlockedInsertTailList(&FdoExtension
->DoneTransferList
,
856 &Transfer
->TransferLink
,
857 &FdoExtension
->DoneTransferSpinLock
);
859 return KeInsertQueueDpc(&FdoExtension
->TransferFlushDpc
, NULL
, NULL
);
864 USBPORT_DpcHandler(IN PDEVICE_OBJECT FdoDevice
)
866 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
867 PUSBPORT_ENDPOINT Endpoint
;
872 DPRINT("USBPORT_DpcHandler: ... \n");
874 FdoExtension
= FdoDevice
->DeviceExtension
;
876 InitializeListHead(&List
);
878 KeAcquireSpinLockAtDpcLevel(&FdoExtension
->EndpointListSpinLock
);
879 Entry
= FdoExtension
->EndpointList
.Flink
;
881 while (Entry
&& Entry
!= &FdoExtension
->EndpointList
)
883 Endpoint
= CONTAINING_RECORD(Entry
,
887 LockCounter
= InterlockedIncrement(&Endpoint
->LockCounter
);
889 if (USBPORT_GetEndpointState(Endpoint
) != USBPORT_ENDPOINT_ACTIVE
||
891 Endpoint
->Flags
& ENDPOINT_FLAG_ROOTHUB_EP0
)
893 InterlockedDecrement(&Endpoint
->LockCounter
);
897 InsertTailList(&List
, &Endpoint
->DispatchLink
);
899 if (Endpoint
->WorkerLink
.Flink
&& Endpoint
->WorkerLink
.Blink
)
901 RemoveEntryList(&Endpoint
->WorkerLink
);
903 Endpoint
->WorkerLink
.Flink
= NULL
;
904 Endpoint
->WorkerLink
.Blink
= NULL
;
908 Entry
= Endpoint
->EndpointLink
.Flink
;
911 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->EndpointListSpinLock
);
913 while (!IsListEmpty(&List
))
915 Endpoint
= CONTAINING_RECORD(List
.Flink
,
919 RemoveEntryList(List
.Flink
);
920 Endpoint
->DispatchLink
.Flink
= NULL
;
921 Endpoint
->DispatchLink
.Blink
= NULL
;
923 USBPORT_EndpointWorker(Endpoint
, TRUE
);
924 USBPORT_FlushPendingTransfers(Endpoint
);
927 KeAcquireSpinLockAtDpcLevel(&FdoExtension
->EndpointListSpinLock
);
929 if (!IsListEmpty(&FdoExtension
->WorkerList
))
931 USBPORT_SignalWorkerThread(FdoDevice
);
934 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->EndpointListSpinLock
);
936 USBPORT_FlushDoneTransfers(FdoDevice
);
941 USBPORT_IsrDpcHandler(IN PDEVICE_OBJECT FdoDevice
,
942 IN BOOLEAN IsDpcHandler
)
944 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
945 PUSBPORT_REGISTRATION_PACKET Packet
;
946 PUSBPORT_ENDPOINT Endpoint
;
950 ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL
);
952 DPRINT_CORE("USBPORT_IsrDpcHandler: IsDpcHandler - %x\n", IsDpcHandler
);
954 FdoExtension
= FdoDevice
->DeviceExtension
;
955 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
957 if (InterlockedIncrement(&FdoExtension
->IsrDpcHandlerCounter
))
959 KeInsertQueueDpc(&FdoExtension
->IsrDpc
, NULL
, NULL
);
960 InterlockedDecrement(&FdoExtension
->IsrDpcHandlerCounter
);
964 for (List
= ExInterlockedRemoveHeadList(&FdoExtension
->EpStateChangeList
,
965 &FdoExtension
->EpStateChangeSpinLock
);
967 List
= ExInterlockedRemoveHeadList(&FdoExtension
->EpStateChangeList
,
968 &FdoExtension
->EpStateChangeSpinLock
))
970 Endpoint
= CONTAINING_RECORD(List
,
974 DPRINT_CORE("USBPORT_IsrDpcHandler: Endpoint - %p\n", Endpoint
);
976 KeAcquireSpinLockAtDpcLevel(&Endpoint
->EndpointSpinLock
);
978 KeAcquireSpinLockAtDpcLevel(&FdoExtension
->MiniportSpinLock
);
979 FrameNumber
= Packet
->Get32BitFrameNumber(FdoExtension
->MiniPortExt
);
980 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->MiniportSpinLock
);
982 if (FrameNumber
<= Endpoint
->FrameNumber
&&
983 !(Endpoint
->Flags
& ENDPOINT_FLAG_NUKE
))
985 KeReleaseSpinLockFromDpcLevel(&Endpoint
->EndpointSpinLock
);
987 ExInterlockedInsertHeadList(&FdoExtension
->EpStateChangeList
,
988 &Endpoint
->StateChangeLink
,
989 &FdoExtension
->EpStateChangeSpinLock
);
991 KeAcquireSpinLockAtDpcLevel(&FdoExtension
->MiniportSpinLock
);
992 Packet
->InterruptNextSOF(FdoExtension
->MiniPortExt
);
993 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->MiniportSpinLock
);
998 KeReleaseSpinLockFromDpcLevel(&Endpoint
->EndpointSpinLock
);
1000 KeAcquireSpinLockAtDpcLevel(&Endpoint
->StateChangeSpinLock
);
1001 Endpoint
->StateLast
= Endpoint
->StateNext
;
1002 KeReleaseSpinLockFromDpcLevel(&Endpoint
->StateChangeSpinLock
);
1004 DPRINT_CORE("USBPORT_IsrDpcHandler: Endpoint->StateLast - %x\n",
1005 Endpoint
->StateLast
);
1009 USBPORT_InvalidateEndpointHandler(FdoDevice
,
1011 INVALIDATE_ENDPOINT_ONLY
);
1015 USBPORT_InvalidateEndpointHandler(FdoDevice
,
1017 INVALIDATE_ENDPOINT_WORKER_THREAD
);
1023 USBPORT_DpcHandler(FdoDevice
);
1026 InterlockedDecrement(&FdoExtension
->IsrDpcHandlerCounter
);
1031 USBPORT_IsrDpc(IN PRKDPC Dpc
,
1032 IN PVOID DeferredContext
,
1033 IN PVOID SystemArgument1
,
1034 IN PVOID SystemArgument2
)
1036 PDEVICE_OBJECT FdoDevice
;
1037 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1038 PUSBPORT_REGISTRATION_PACKET Packet
;
1039 BOOLEAN InterruptEnable
;
1041 DPRINT_INT("USBPORT_IsrDpc: DeferredContext - %p, SystemArgument2 - %p\n",
1045 FdoDevice
= DeferredContext
;
1046 FdoExtension
= FdoDevice
->DeviceExtension
;
1047 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
1049 if (SystemArgument2
)
1051 InterlockedDecrement(&FdoExtension
->IsrDpcCounter
);
1054 KeAcquireSpinLockAtDpcLevel(&FdoExtension
->MiniportInterruptsSpinLock
);
1055 InterruptEnable
= (FdoExtension
->Flags
& USBPORT_FLAG_INTERRUPT_ENABLED
) ==
1056 USBPORT_FLAG_INTERRUPT_ENABLED
;
1058 Packet
->InterruptDpc(FdoExtension
->MiniPortExt
, InterruptEnable
);
1060 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->MiniportInterruptsSpinLock
);
1062 if (FdoExtension
->Flags
& USBPORT_FLAG_HC_SUSPEND
&&
1063 FdoExtension
->TimerFlags
& USBPORT_TMFLAG_WAKE
)
1065 USBPORT_CompletePdoWaitWake(FdoDevice
);
1069 USBPORT_IsrDpcHandler(FdoDevice
, TRUE
);
1072 DPRINT_INT("USBPORT_IsrDpc: exit\n");
1077 USBPORT_InterruptService(IN PKINTERRUPT Interrupt
,
1078 IN PVOID ServiceContext
)
1080 PDEVICE_OBJECT FdoDevice
;
1081 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1082 PUSBPORT_REGISTRATION_PACKET Packet
;
1083 BOOLEAN Result
= FALSE
;
1085 FdoDevice
= ServiceContext
;
1086 FdoExtension
= FdoDevice
->DeviceExtension
;
1087 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
1089 DPRINT_INT("USBPORT_InterruptService: FdoExtension[%p]->Flags - %08X\n",
1091 FdoExtension
->Flags
);
1093 if (FdoExtension
->Flags
& USBPORT_FLAG_INTERRUPT_ENABLED
&&
1094 FdoExtension
->MiniPortFlags
& USBPORT_MPFLAG_INTERRUPTS_ENABLED
)
1096 Result
= Packet
->InterruptService(FdoExtension
->MiniPortExt
);
1100 KeInsertQueueDpc(&FdoExtension
->IsrDpc
, NULL
, NULL
);
1104 DPRINT_INT("USBPORT_InterruptService: return - %x\n", Result
);
1111 USBPORT_SignalWorkerThread(IN PDEVICE_OBJECT FdoDevice
)
1113 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1116 DPRINT_CORE("USBPORT_SignalWorkerThread ... \n");
1118 FdoExtension
= FdoDevice
->DeviceExtension
;
1120 KeAcquireSpinLock(&FdoExtension
->WorkerThreadEventSpinLock
, &OldIrql
);
1121 KeSetEvent(&FdoExtension
->WorkerThreadEvent
, EVENT_INCREMENT
, FALSE
);
1122 KeReleaseSpinLock(&FdoExtension
->WorkerThreadEventSpinLock
, OldIrql
);
1127 USBPORT_WorkerThreadHandler(IN PDEVICE_OBJECT FdoDevice
)
1129 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1130 PUSBPORT_REGISTRATION_PACKET Packet
;
1131 PLIST_ENTRY workerList
;
1133 PUSBPORT_ENDPOINT Endpoint
;
1137 DPRINT_CORE("USBPORT_WorkerThreadHandler: ... \n");
1139 FdoExtension
= FdoDevice
->DeviceExtension
;
1140 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
1142 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
1144 if (!(FdoExtension
->Flags
& USBPORT_FLAG_HC_SUSPEND
))
1146 Packet
->CheckController(FdoExtension
->MiniPortExt
);
1149 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
1151 InitializeListHead(&list
);
1153 USBPORT_FlushAllEndpoints(FdoDevice
);
1157 KeRaiseIrql(DISPATCH_LEVEL
, &OldIrql
);
1158 KeAcquireSpinLockAtDpcLevel(&FdoExtension
->EndpointListSpinLock
);
1160 workerList
= &FdoExtension
->WorkerList
;
1162 if (IsListEmpty(workerList
))
1165 Endpoint
= CONTAINING_RECORD(workerList
->Flink
,
1169 DPRINT_CORE("USBPORT_WorkerThreadHandler: Endpoint - %p\n", Endpoint
);
1171 RemoveHeadList(workerList
);
1172 Endpoint
->WorkerLink
.Blink
= NULL
;
1173 Endpoint
->WorkerLink
.Flink
= NULL
;
1175 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->EndpointListSpinLock
);
1177 Result
= USBPORT_EndpointWorker(Endpoint
, FALSE
);
1178 KeAcquireSpinLockAtDpcLevel(&FdoExtension
->EndpointListSpinLock
);
1182 if (Endpoint
->FlushAbortLink
.Flink
== NULL
||
1183 Endpoint
->FlushAbortLink
.Blink
== NULL
)
1185 InsertTailList(&list
, &Endpoint
->FlushAbortLink
);
1189 while (!IsListEmpty(&list
))
1191 Endpoint
= CONTAINING_RECORD(list
.Flink
,
1195 RemoveHeadList(&list
);
1197 Endpoint
->FlushAbortLink
.Flink
= NULL
;
1198 Endpoint
->FlushAbortLink
.Blink
= NULL
;
1200 if (Endpoint
->WorkerLink
.Flink
== NULL
||
1201 Endpoint
->WorkerLink
.Blink
== NULL
)
1203 InsertTailList(&FdoExtension
->WorkerList
,
1204 &Endpoint
->WorkerLink
);
1206 USBPORT_SignalWorkerThread(FdoDevice
);
1210 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->EndpointListSpinLock
);
1211 KeLowerIrql(OldIrql
);
1214 KeReleaseSpinLockFromDpcLevel(&FdoExtension
->EndpointListSpinLock
);
1215 KeLowerIrql(OldIrql
);
1217 USBPORT_FlushClosedEndpointList(FdoDevice
);
1222 USBPORT_DoRootHubCallback(IN PDEVICE_OBJECT FdoDevice
)
1224 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1225 PDEVICE_OBJECT PdoDevice
;
1226 PUSBPORT_RHDEVICE_EXTENSION PdoExtension
;
1227 PRH_INIT_CALLBACK RootHubInitCallback
;
1228 PVOID RootHubInitContext
;
1230 FdoExtension
= FdoDevice
->DeviceExtension
;
1232 DPRINT("USBPORT_DoRootHubCallback: FdoDevice - %p\n", FdoDevice
);
1234 PdoDevice
= FdoExtension
->RootHubPdo
;
1238 PdoExtension
= PdoDevice
->DeviceExtension
;
1240 RootHubInitContext
= PdoExtension
->RootHubInitContext
;
1241 RootHubInitCallback
= PdoExtension
->RootHubInitCallback
;
1243 PdoExtension
->RootHubInitCallback
= NULL
;
1244 PdoExtension
->RootHubInitContext
= NULL
;
1246 if (RootHubInitCallback
)
1248 RootHubInitCallback(RootHubInitContext
);
1252 DPRINT("USBPORT_DoRootHubCallback: exit\n");
1257 USBPORT_SynchronizeRootHubCallback(IN PDEVICE_OBJECT FdoDevice
,
1258 IN PDEVICE_OBJECT Usb2FdoDevice
)
1260 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1261 PUSBPORT_REGISTRATION_PACKET Packet
;
1262 PUSBPORT_DEVICE_EXTENSION Usb2FdoExtension
;
1263 PDEVICE_RELATIONS CompanionControllersList
;
1264 PUSBPORT_DEVICE_EXTENSION CompanionFdoExtension
;
1265 PDEVICE_OBJECT
* Entry
;
1268 DPRINT("USBPORT_SynchronizeRootHubCallback: FdoDevice - %p, Usb2FdoDevice - %p\n",
1272 FdoExtension
= FdoDevice
->DeviceExtension
;
1273 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
1275 if (Usb2FdoDevice
== NULL
&&
1276 !(Packet
->MiniPortFlags
& USB_MINIPORT_FLAGS_USB2
))
1278 /* Not Companion USB11 Controller */
1279 USBPORT_DoRootHubCallback(FdoDevice
);
1281 FdoExtension
->Flags
&= ~USBPORT_FLAG_RH_INIT_CALLBACK
;
1282 InterlockedCompareExchange(&FdoExtension
->RHInitCallBackLock
, 0, 1);
1284 DPRINT("USBPORT_SynchronizeRootHubCallback: exit \n");
1288 /* USB2 or Companion USB11 */
1290 DPRINT("USBPORT_SynchronizeRootHubCallback: FdoExtension->Flags - %p\n",
1291 FdoExtension
->Flags
);
1293 if (!(FdoExtension
->Flags
& USBPORT_FLAG_COMPANION_HC
))
1295 KeWaitForSingleObject(&FdoExtension
->ControllerSemaphore
,
1301 FdoExtension
->Flags
|= USBPORT_FLAG_PWR_AND_CHIRP_LOCK
;
1303 if (!(FdoExtension
->Flags
& (USBPORT_FLAG_HC_SUSPEND
|
1304 USBPORT_FLAG_POWER_AND_CHIRP_OK
)))
1306 USBPORT_RootHubPowerAndChirpAllCcPorts(FdoDevice
);
1307 FdoExtension
->Flags
|= USBPORT_FLAG_POWER_AND_CHIRP_OK
;
1310 FdoExtension
->Flags
&= ~USBPORT_FLAG_PWR_AND_CHIRP_LOCK
;
1312 KeReleaseSemaphore(&FdoExtension
->ControllerSemaphore
,
1313 LOW_REALTIME_PRIORITY
,
1317 CompanionControllersList
= USBPORT_FindCompanionControllers(FdoDevice
,
1321 if (CompanionControllersList
)
1323 Entry
= &CompanionControllersList
->Objects
[0];
1325 for (ix
= 0; ix
< CompanionControllersList
->Count
; ++ix
)
1327 CompanionFdoExtension
= ((*Entry
)->DeviceExtension
);
1329 InterlockedCompareExchange(&CompanionFdoExtension
->RHInitCallBackLock
,
1336 ExFreePoolWithTag(CompanionControllersList
, USB_PORT_TAG
);
1339 USBPORT_DoRootHubCallback(FdoDevice
);
1341 FdoExtension
->Flags
&= ~USBPORT_FLAG_RH_INIT_CALLBACK
;
1342 InterlockedCompareExchange(&FdoExtension
->RHInitCallBackLock
, 0, 1);
1346 Usb2FdoExtension
= Usb2FdoDevice
->DeviceExtension
;
1348 USBPORT_Wait(FdoDevice
, 50);
1350 while (FdoExtension
->RHInitCallBackLock
)
1352 USBPORT_Wait(FdoDevice
, 10);
1354 Usb2FdoExtension
->Flags
|= USBPORT_FLAG_RH_INIT_CALLBACK
;
1355 USBPORT_SignalWorkerThread(Usb2FdoDevice
);
1358 USBPORT_DoRootHubCallback(FdoDevice
);
1360 FdoExtension
->Flags
&= ~USBPORT_FLAG_RH_INIT_CALLBACK
;
1363 DPRINT("USBPORT_SynchronizeRootHubCallback: exit \n");
1368 USBPORT_WorkerThread(IN PVOID StartContext
)
1370 PDEVICE_OBJECT FdoDevice
;
1371 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1372 LARGE_INTEGER OldTime
;
1373 LARGE_INTEGER NewTime
;
1376 DPRINT_CORE("USBPORT_WorkerThread ... \n");
1378 FdoDevice
= StartContext
;
1379 FdoExtension
= FdoDevice
->DeviceExtension
;
1381 FdoExtension
->WorkerThread
= KeGetCurrentThread();
1385 KeQuerySystemTime(&OldTime
);
1387 KeWaitForSingleObject(&FdoExtension
->WorkerThreadEvent
,
1393 KeQuerySystemTime(&NewTime
);
1395 KeAcquireSpinLock(&FdoExtension
->WorkerThreadEventSpinLock
, &OldIrql
);
1396 KeClearEvent(&FdoExtension
->WorkerThreadEvent
);
1397 KeReleaseSpinLock(&FdoExtension
->WorkerThreadEventSpinLock
, OldIrql
);
1398 DPRINT_CORE("USBPORT_WorkerThread: run \n");
1400 if (FdoExtension
->MiniPortFlags
& USBPORT_MPFLAG_INTERRUPTS_ENABLED
)
1402 USBPORT_DoSetPowerD0(FdoDevice
);
1404 if (FdoExtension
->Flags
& USBPORT_FLAG_RH_INIT_CALLBACK
)
1406 PDEVICE_OBJECT USB2FdoDevice
= NULL
;
1408 USB2FdoDevice
= USBPORT_FindUSB2Controller(FdoDevice
);
1409 USBPORT_SynchronizeRootHubCallback(FdoDevice
, USB2FdoDevice
);
1413 USBPORT_WorkerThreadHandler(FdoDevice
);
1415 while (!(FdoExtension
->Flags
& USBPORT_FLAG_WORKER_THREAD_ON
));
1417 PsTerminateSystemThread(0);
1422 USBPORT_CreateWorkerThread(IN PDEVICE_OBJECT FdoDevice
)
1424 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1427 DPRINT("USBPORT_CreateWorkerThread ... \n");
1429 FdoExtension
= FdoDevice
->DeviceExtension
;
1431 FdoExtension
->Flags
&= ~USBPORT_FLAG_WORKER_THREAD_ON
;
1433 KeInitializeEvent(&FdoExtension
->WorkerThreadEvent
,
1437 Status
= PsCreateSystemThread(&FdoExtension
->WorkerThreadHandle
,
1442 USBPORT_WorkerThread
,
1450 USBPORT_SynchronizeControllersStart(IN PDEVICE_OBJECT FdoDevice
)
1452 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1453 PDEVICE_OBJECT PdoDevice
;
1454 PUSBPORT_RHDEVICE_EXTENSION PdoExtension
;
1455 PDEVICE_OBJECT USB2FdoDevice
= NULL
;
1456 PUSBPORT_DEVICE_EXTENSION USB2FdoExtension
;
1459 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: FdoDevice - %p\n",
1462 FdoExtension
= FdoDevice
->DeviceExtension
;
1464 PdoDevice
= FdoExtension
->RootHubPdo
;
1471 PdoExtension
= PdoDevice
->DeviceExtension
;
1473 if (PdoExtension
->RootHubInitCallback
== NULL
||
1474 FdoExtension
->Flags
& USBPORT_FLAG_RH_INIT_CALLBACK
)
1479 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: Flags - %p\n",
1480 FdoExtension
->Flags
);
1482 if (FdoExtension
->Flags
& USBPORT_FLAG_COMPANION_HC
)
1486 USB2FdoDevice
= USBPORT_FindUSB2Controller(FdoDevice
);
1488 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: USB2FdoDevice - %p\n",
1493 USB2FdoExtension
= USB2FdoDevice
->DeviceExtension
;
1495 if (USB2FdoExtension
->CommonExtension
.PnpStateFlags
&
1496 USBPORT_PNP_STATE_STARTED
)
1502 if (!(FdoExtension
->Flags
& USBPORT_FLAG_NO_HACTION
))
1507 USB2FdoDevice
= NULL
;
1515 !InterlockedCompareExchange(&FdoExtension
->RHInitCallBackLock
, 1, 0))
1517 FdoExtension
->Flags
|= USBPORT_FLAG_RH_INIT_CALLBACK
;
1518 USBPORT_SignalWorkerThread(FdoDevice
);
1522 USB2FdoExtension
= USB2FdoDevice
->DeviceExtension
;
1524 USB2FdoExtension
->Flags
|= USBPORT_FLAG_RH_INIT_CALLBACK
;
1525 USBPORT_SignalWorkerThread(USB2FdoDevice
);
1529 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: exit\n");
1534 USBPORT_TimerDpc(IN PRKDPC Dpc
,
1535 IN PVOID DeferredContext
,
1536 IN PVOID SystemArgument1
,
1537 IN PVOID SystemArgument2
)
1539 PDEVICE_OBJECT FdoDevice
;
1540 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1541 PUSBPORT_REGISTRATION_PACKET Packet
;
1542 LARGE_INTEGER DueTime
= {{0, 0}};
1544 PTIMER_WORK_QUEUE_ITEM IdleQueueItem
;
1548 DPRINT_TIMER("USBPORT_TimerDpc: Dpc - %p, DeferredContext - %p\n",
1552 FdoDevice
= DeferredContext
;
1553 FdoExtension
= FdoDevice
->DeviceExtension
;
1554 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
1556 KeAcquireSpinLock(&FdoExtension
->TimerFlagsSpinLock
, &TimerOldIrql
);
1558 TimerFlags
= FdoExtension
->TimerFlags
;
1560 DPRINT_TIMER("USBPORT_TimerDpc: Flags - %p, TimerFlags - %p\n",
1561 FdoExtension
->Flags
,
1564 if (FdoExtension
->Flags
& USBPORT_FLAG_HC_SUSPEND
&&
1565 FdoExtension
->Flags
& USBPORT_FLAG_HC_WAKE_SUPPORT
&&
1566 !(TimerFlags
& USBPORT_TMFLAG_HC_RESUME
))
1568 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
1569 Packet
->PollController(FdoExtension
->MiniPortExt
);
1570 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
1573 USBPORT_SynchronizeControllersStart(FdoDevice
);
1575 if (TimerFlags
& USBPORT_TMFLAG_HC_SUSPENDED
)
1577 USBPORT_BadRequestFlush(FdoDevice
);
1581 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
1583 if (!(FdoExtension
->Flags
& USBPORT_FLAG_HC_SUSPEND
))
1585 Packet
->CheckController(FdoExtension
->MiniPortExt
);
1588 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
1590 if (FdoExtension
->Flags
& USBPORT_FLAG_HC_POLLING
)
1592 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
1593 Packet
->PollController(FdoExtension
->MiniPortExt
);
1594 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
1597 USBPORT_IsrDpcHandler(FdoDevice
, FALSE
);
1599 DPRINT_TIMER("USBPORT_TimerDpc: USBPORT_TimeoutAllEndpoints UNIMPLEMENTED.\n");
1600 //USBPORT_TimeoutAllEndpoints(FdoDevice);
1601 DPRINT_TIMER("USBPORT_TimerDpc: USBPORT_CheckIdleEndpoints UNIMPLEMENTED.\n");
1602 //USBPORT_CheckIdleEndpoints(FdoDevice);
1604 USBPORT_BadRequestFlush(FdoDevice
);
1606 if (FdoExtension
->IdleLockCounter
> -1 &&
1607 !(TimerFlags
& USBPORT_TMFLAG_IDLE_QUEUEITEM_ON
))
1609 IdleQueueItem
= ExAllocatePoolWithTag(NonPagedPool
,
1610 sizeof(TIMER_WORK_QUEUE_ITEM
),
1613 DPRINT("USBPORT_TimerDpc: IdleLockCounter - %x, IdleQueueItem - %p\n",
1614 FdoExtension
->IdleLockCounter
,
1619 RtlZeroMemory(IdleQueueItem
, sizeof(TIMER_WORK_QUEUE_ITEM
));
1621 IdleQueueItem
->WqItem
.List
.Flink
= NULL
;
1622 IdleQueueItem
->WqItem
.WorkerRoutine
= USBPORT_DoIdleNotificationCallback
;
1623 IdleQueueItem
->WqItem
.Parameter
= IdleQueueItem
;
1625 IdleQueueItem
->FdoDevice
= FdoDevice
;
1626 IdleQueueItem
->Context
= 0;
1628 FdoExtension
->TimerFlags
|= USBPORT_TMFLAG_IDLE_QUEUEITEM_ON
;
1630 ExQueueWorkItem(&IdleQueueItem
->WqItem
, CriticalWorkQueue
);
1636 KeReleaseSpinLock(&FdoExtension
->TimerFlagsSpinLock
, TimerOldIrql
);
1638 if (TimerFlags
& USBPORT_TMFLAG_TIMER_QUEUED
)
1640 DueTime
.QuadPart
-= FdoExtension
->TimerValue
* 10000 +
1641 (KeQueryTimeIncrement() - 1);
1643 KeSetTimer(&FdoExtension
->TimerObject
,
1645 &FdoExtension
->TimerDpc
);
1648 DPRINT_TIMER("USBPORT_TimerDpc: exit\n");
1653 USBPORT_StartTimer(IN PDEVICE_OBJECT FdoDevice
,
1656 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1657 LARGE_INTEGER DueTime
= {{0, 0}};
1658 ULONG TimeIncrement
;
1661 DPRINT_TIMER("USBPORT_StartTimer: FdoDevice - %p, Time - %x\n",
1665 FdoExtension
= FdoDevice
->DeviceExtension
;
1667 TimeIncrement
= KeQueryTimeIncrement();
1669 FdoExtension
->TimerFlags
|= USBPORT_TMFLAG_TIMER_QUEUED
;
1670 FdoExtension
->TimerValue
= Time
;
1672 KeInitializeTimer(&FdoExtension
->TimerObject
);
1673 KeInitializeDpc(&FdoExtension
->TimerDpc
, USBPORT_TimerDpc
, FdoDevice
);
1675 DueTime
.QuadPart
-= 10000 * Time
+ (TimeIncrement
- 1);
1677 Result
= KeSetTimer(&FdoExtension
->TimerObject
,
1679 &FdoExtension
->TimerDpc
);
1684 PUSBPORT_COMMON_BUFFER_HEADER
1686 USBPORT_AllocateCommonBuffer(IN PDEVICE_OBJECT FdoDevice
,
1687 IN SIZE_T BufferLength
)
1689 PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer
= NULL
;
1690 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1691 PDMA_ADAPTER DmaAdapter
;
1692 PDMA_OPERATIONS DmaOperations
;
1696 PHYSICAL_ADDRESS LogicalAddress
;
1698 ULONG_PTR StartBufferVA
;
1699 ULONG_PTR StartBufferPA
;
1701 DPRINT("USBPORT_AllocateCommonBuffer: FdoDevice - %p, BufferLength - %p\n",
1705 if (BufferLength
== 0)
1708 FdoExtension
= FdoDevice
->DeviceExtension
;
1710 DmaAdapter
= FdoExtension
->DmaAdapter
;
1711 DmaOperations
= DmaAdapter
->DmaOperations
;
1713 HeaderSize
= sizeof(USBPORT_COMMON_BUFFER_HEADER
);
1714 Length
= ROUND_TO_PAGES(BufferLength
+ HeaderSize
);
1715 LengthPadded
= Length
- (BufferLength
+ HeaderSize
);
1717 BaseVA
= (ULONG_PTR
)DmaOperations
->AllocateCommonBuffer(DmaAdapter
,
1725 StartBufferVA
= BaseVA
& ~(PAGE_SIZE
- 1);
1726 StartBufferPA
= LogicalAddress
.LowPart
& ~(PAGE_SIZE
- 1);
1728 HeaderBuffer
= (PUSBPORT_COMMON_BUFFER_HEADER
)(StartBufferVA
+
1732 HeaderBuffer
->Length
= Length
;
1733 HeaderBuffer
->BaseVA
= BaseVA
;
1734 HeaderBuffer
->LogicalAddress
= LogicalAddress
;
1736 HeaderBuffer
->BufferLength
= BufferLength
+ LengthPadded
;
1737 HeaderBuffer
->VirtualAddress
= StartBufferVA
;
1738 HeaderBuffer
->PhysicalAddress
= StartBufferPA
;
1740 RtlZeroMemory((PVOID
)StartBufferVA
, BufferLength
+ LengthPadded
);
1743 return HeaderBuffer
;
1748 USBPORT_FreeCommonBuffer(IN PDEVICE_OBJECT FdoDevice
,
1749 IN PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer
)
1751 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1752 PDMA_ADAPTER DmaAdapter
;
1753 PDMA_OPERATIONS DmaOperations
;
1755 DPRINT("USBPORT_FreeCommonBuffer: ... \n");
1757 FdoExtension
= FdoDevice
->DeviceExtension
;
1759 DmaAdapter
= FdoExtension
->DmaAdapter
;
1760 DmaOperations
= DmaAdapter
->DmaOperations
;
1762 DmaOperations
->FreeCommonBuffer(FdoExtension
->DmaAdapter
,
1763 HeaderBuffer
->Length
,
1764 HeaderBuffer
->LogicalAddress
,
1765 (PVOID
)HeaderBuffer
->VirtualAddress
,
1769 PUSBPORT_MINIPORT_INTERFACE
1771 USBPORT_FindMiniPort(IN PDRIVER_OBJECT DriverObject
)
1775 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
1776 BOOLEAN IsFound
= FALSE
;
1778 DPRINT("USBPORT_FindMiniPort: ... \n");
1780 KeAcquireSpinLock(&USBPORT_SpinLock
, &OldIrql
);
1782 for (List
= USBPORT_MiniPortDrivers
.Flink
;
1783 List
!= &USBPORT_MiniPortDrivers
;
1786 MiniPortInterface
= CONTAINING_RECORD(List
,
1787 USBPORT_MINIPORT_INTERFACE
,
1790 if (MiniPortInterface
->DriverObject
== DriverObject
)
1792 DPRINT("USBPORT_FindMiniPort: find MiniPortInterface - %p\n",
1800 KeReleaseSpinLock(&USBPORT_SpinLock
, OldIrql
);
1803 return MiniPortInterface
;
1811 USBPORT_AddDevice(IN PDRIVER_OBJECT DriverObject
,
1812 IN PDEVICE_OBJECT PhysicalDeviceObject
)
1815 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
1816 ULONG DeviceNumber
= 0;
1817 WCHAR CharDeviceName
[64];
1818 UNICODE_STRING DeviceName
;
1819 PDEVICE_OBJECT DeviceObject
;
1820 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1821 PUSBPORT_COMMON_DEVICE_EXTENSION FdoCommonExtension
;
1822 PDEVICE_OBJECT LowerDevice
;
1825 DPRINT("USBPORT_AddDevice: DriverObject - %p, PhysicalDeviceObject - %p\n",
1827 PhysicalDeviceObject
);
1829 MiniPortInterface
= USBPORT_FindMiniPort(DriverObject
);
1831 if (!MiniPortInterface
)
1833 DPRINT("USBPORT_AddDevice: USBPORT_FindMiniPort not found MiniPortInterface\n");
1834 return STATUS_UNSUCCESSFUL
;
1839 /* Construct device name */
1840 RtlStringCbPrintfW(CharDeviceName
,
1841 sizeof(CharDeviceName
),
1842 L
"\\Device\\USBFDO-%d",
1845 RtlInitUnicodeString(&DeviceName
, CharDeviceName
);
1847 Length
= sizeof(USBPORT_DEVICE_EXTENSION
) +
1848 MiniPortInterface
->Packet
.MiniPortExtensionSize
+
1849 sizeof(USB2_HC_EXTENSION
);
1852 Status
= IoCreateDevice(DriverObject
,
1855 FILE_DEVICE_CONTROLLER
,
1860 /* Check for success */
1861 if (NT_SUCCESS(Status
)) break;
1863 /* Is there a device object with that same name */
1864 if ((Status
== STATUS_OBJECT_NAME_EXISTS
) ||
1865 (Status
== STATUS_OBJECT_NAME_COLLISION
))
1867 /* Try the next name */
1872 /* Bail out on other errors */
1873 if (!NT_SUCCESS(Status
))
1875 DPRINT1("USBPORT_AddDevice: failed to create %wZ, Status %x\n",
1883 DPRINT("USBPORT_AddDevice: created device %p <%wZ>, Status %x\n",
1888 FdoExtension
= DeviceObject
->DeviceExtension
;
1889 FdoCommonExtension
= &FdoExtension
->CommonExtension
;
1891 RtlZeroMemory(FdoExtension
, sizeof(USBPORT_DEVICE_EXTENSION
));
1893 FdoCommonExtension
->SelfDevice
= DeviceObject
;
1894 FdoCommonExtension
->LowerPdoDevice
= PhysicalDeviceObject
;
1895 FdoCommonExtension
->IsPDO
= FALSE
;
1897 LowerDevice
= IoAttachDeviceToDeviceStack(DeviceObject
,
1898 PhysicalDeviceObject
);
1900 FdoCommonExtension
->LowerDevice
= LowerDevice
;
1902 FdoCommonExtension
->DevicePowerState
= PowerDeviceD3
;
1904 FdoExtension
->MiniPortExt
= (PVOID
)((ULONG_PTR
)FdoExtension
+
1905 sizeof(USBPORT_DEVICE_EXTENSION
));
1907 if (MiniPortInterface
->Packet
.MiniPortFlags
& USB_MINIPORT_FLAGS_USB2
)
1909 FdoExtension
->Usb2Extension
=
1910 (PUSB2_HC_EXTENSION
)((ULONG_PTR
)FdoExtension
->MiniPortExt
+
1911 MiniPortInterface
->Packet
.MiniPortExtensionSize
);
1913 DPRINT("USBPORT_AddDevice: Usb2Extension - %p\n",
1914 FdoExtension
->Usb2Extension
);
1916 USB2_InitController(FdoExtension
->Usb2Extension
);
1920 FdoExtension
->Usb2Extension
= NULL
;
1923 FdoExtension
->MiniPortInterface
= MiniPortInterface
;
1924 FdoExtension
->FdoNameNumber
= DeviceNumber
;
1926 KeInitializeSemaphore(&FdoExtension
->DeviceSemaphore
, 1, 1);
1927 KeInitializeSemaphore(&FdoExtension
->ControllerSemaphore
, 1, 1);
1929 InitializeListHead(&FdoExtension
->EndpointList
);
1930 InitializeListHead(&FdoExtension
->DoneTransferList
);
1931 InitializeListHead(&FdoExtension
->WorkerList
);
1932 InitializeListHead(&FdoExtension
->EpStateChangeList
);
1933 InitializeListHead(&FdoExtension
->MapTransferList
);
1934 InitializeListHead(&FdoExtension
->DeviceHandleList
);
1935 InitializeListHead(&FdoExtension
->IdleIrpList
);
1936 InitializeListHead(&FdoExtension
->BadRequestList
);
1937 InitializeListHead(&FdoExtension
->EndpointClosedList
);
1939 DeviceObject
->Flags
&= ~DO_DEVICE_INITIALIZING
;
1946 USBPORT_Unload(IN PDRIVER_OBJECT DriverObject
)
1948 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
1950 DPRINT1("USBPORT_Unload: FIXME!\n");
1952 MiniPortInterface
= USBPORT_FindMiniPort(DriverObject
);
1954 if (!MiniPortInterface
)
1956 DPRINT("USBPORT_Unload: CRITICAL ERROR!!! USBPORT_FindMiniPort not found MiniPortInterface\n");
1957 KeBugCheckEx(BUGCODE_USB_DRIVER
, 1, 0, 0, 0);
1960 DPRINT1("USBPORT_Unload: UNIMPLEMENTED. FIXME. \n");
1961 //MiniPortInterface->DriverUnload(DriverObject); // Call MiniPort _HCI_Unload
1966 USBPORT_MiniportCompleteTransfer(IN PVOID MiniPortExtension
,
1967 IN PVOID MiniPortEndpoint
,
1968 IN PVOID TransferParameters
,
1969 IN USBD_STATUS USBDStatus
,
1970 IN ULONG TransferLength
)
1972 PUSBPORT_TRANSFER Transfer
;
1973 PUSBPORT_TRANSFER ParentTransfer
;
1974 PUSBPORT_TRANSFER SplitTransfer
;
1975 PLIST_ENTRY SplitHead
;
1979 DPRINT_CORE("USBPORT_MiniportCompleteTransfer: USBDStatus - %x, TransferLength - %x\n",
1983 Transfer
= CONTAINING_RECORD(TransferParameters
,
1985 TransferParameters
);
1987 Transfer
->Flags
|= TRANSFER_FLAG_COMPLETED
;
1988 Transfer
->CompletedTransferLen
= TransferLength
;
1990 if (((Transfer
->Flags
& TRANSFER_FLAG_SPLITED
) == 0) ||
1991 TransferLength
>= Transfer
->TransferParameters
.TransferBufferLength
)
1996 ParentTransfer
= Transfer
->ParentTransfer
;
1998 KeAcquireSpinLock(&ParentTransfer
->TransferSpinLock
, &OldIrql
);
2000 if (IsListEmpty(&ParentTransfer
->SplitTransfersList
))
2005 SplitHead
= &ParentTransfer
->SplitTransfersList
;
2006 Entry
= SplitHead
->Flink
;
2008 while (Entry
&& !IsListEmpty(SplitHead
))
2010 SplitTransfer
= CONTAINING_RECORD(Entry
,
2014 if (!(SplitTransfer
->Flags
& TRANSFER_FLAG_SUBMITED
))
2016 DPRINT1("USBPORT_MiniportCompleteTransfer: SplitTransfer->Flags - %X\n",
2017 SplitTransfer
->Flags
);
2018 //Add TRANSFER_FLAG_xxx
2021 Entry
= Entry
->Flink
;
2024 KeReleaseSpinLock(&ParentTransfer
->TransferSpinLock
, OldIrql
);
2027 USBPORT_QueueDoneTransfer(Transfer
, USBDStatus
);
2032 USBPORT_AsyncTimerDpc(IN PRKDPC Dpc
,
2033 IN PVOID DeferredContext
,
2034 IN PVOID SystemArgument1
,
2035 IN PVOID SystemArgument2
)
2037 PDEVICE_OBJECT FdoDevice
;
2038 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2039 PUSBPORT_ASYNC_CALLBACK_DATA AsyncCallbackData
;
2041 DPRINT("USBPORT_AsyncTimerDpc: ... \n");
2043 AsyncCallbackData
= DeferredContext
;
2044 FdoDevice
= AsyncCallbackData
->FdoDevice
;
2045 FdoExtension
= FdoDevice
->DeviceExtension
;
2047 (*AsyncCallbackData
->CallbackFunction
)(FdoExtension
->MiniPortExt
,
2048 &AsyncCallbackData
->CallbackContext
);
2050 ExFreePoolWithTag(AsyncCallbackData
, USB_PORT_TAG
);
2055 USBPORT_RequestAsyncCallback(IN PVOID MiniPortExtension
,
2056 IN ULONG TimerValue
,
2059 IN ASYNC_TIMER_CALLBACK
* Callback
)
2061 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2062 PDEVICE_OBJECT FdoDevice
;
2063 PUSBPORT_ASYNC_CALLBACK_DATA AsyncCallbackData
;
2064 LARGE_INTEGER DueTime
= {{0, 0}};
2066 DPRINT("USBPORT_RequestAsyncCallback: ... \n");
2068 FdoExtension
= (PUSBPORT_DEVICE_EXTENSION
)((ULONG_PTR
)MiniPortExtension
-
2069 sizeof(USBPORT_DEVICE_EXTENSION
));
2071 FdoDevice
= FdoExtension
->CommonExtension
.SelfDevice
;
2073 AsyncCallbackData
= ExAllocatePoolWithTag(NonPagedPool
,
2074 sizeof(USBPORT_ASYNC_CALLBACK_DATA
) + Length
,
2077 if (!AsyncCallbackData
)
2079 DPRINT1("USBPORT_RequestAsyncCallback: Not allocated AsyncCallbackData!\n");
2083 RtlZeroMemory(AsyncCallbackData
,
2084 sizeof(USBPORT_ASYNC_CALLBACK_DATA
) + Length
);
2088 RtlCopyMemory(&AsyncCallbackData
->CallbackContext
, Buffer
, Length
);
2091 AsyncCallbackData
->FdoDevice
= FdoDevice
;
2092 AsyncCallbackData
->CallbackFunction
= Callback
;
2094 KeInitializeTimer(&AsyncCallbackData
->AsyncTimer
);
2096 KeInitializeDpc(&AsyncCallbackData
->AsyncTimerDpc
,
2097 USBPORT_AsyncTimerDpc
,
2100 DueTime
.QuadPart
-= (KeQueryTimeIncrement() - 1) + 10000 * TimerValue
;
2102 KeSetTimer(&AsyncCallbackData
->AsyncTimer
,
2104 &AsyncCallbackData
->AsyncTimerDpc
);
2111 USBPORT_GetMappedVirtualAddress(IN PVOID PhysicalAddress
,
2112 IN PVOID MiniPortExtension
,
2113 IN PVOID MiniPortEndpoint
)
2115 PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer
;
2116 PUSBPORT_ENDPOINT Endpoint
;
2118 ULONG_PTR VirtualAddress
;
2120 DPRINT_CORE("USBPORT_GetMappedVirtualAddress ... \n");
2122 Endpoint
= (PUSBPORT_ENDPOINT
)((ULONG_PTR
)MiniPortEndpoint
-
2123 sizeof(USBPORT_ENDPOINT
));
2130 HeaderBuffer
= Endpoint
->HeaderBuffer
;
2132 Offset
= (ULONG_PTR
)PhysicalAddress
- HeaderBuffer
->PhysicalAddress
;
2133 VirtualAddress
= HeaderBuffer
->VirtualAddress
+ Offset
;
2135 return (PVOID
)VirtualAddress
;
2140 USBPORT_InvalidateEndpoint(IN PVOID MiniPortExtension
,
2141 IN PVOID MiniPortEndpoint
)
2143 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2144 PDEVICE_OBJECT FdoDevice
;
2145 PUSBPORT_ENDPOINT Endpoint
;
2147 DPRINT_CORE("USBPORT_InvalidateEndpoint: ... \n");
2149 FdoExtension
= (PUSBPORT_DEVICE_EXTENSION
)((ULONG_PTR
)MiniPortExtension
-
2150 sizeof(USBPORT_DEVICE_EXTENSION
));
2152 FdoDevice
= FdoExtension
->CommonExtension
.SelfDevice
;
2154 if (!MiniPortEndpoint
)
2156 USBPORT_InvalidateEndpointHandler(FdoDevice
,
2158 INVALIDATE_ENDPOINT_ONLY
);
2162 Endpoint
= (PUSBPORT_ENDPOINT
)((ULONG_PTR
)MiniPortEndpoint
-
2163 sizeof(USBPORT_ENDPOINT
));
2165 USBPORT_InvalidateEndpointHandler(FdoDevice
,
2167 INVALIDATE_ENDPOINT_ONLY
);
2174 USBPORT_CompleteTransfer(IN PURB Urb
,
2175 IN USBD_STATUS TransferStatus
)
2177 struct _URB_CONTROL_TRANSFER
*UrbTransfer
;
2178 PUSBPORT_TRANSFER Transfer
;
2183 BOOLEAN WriteToDevice
;
2184 BOOLEAN IsFlushSuccess
;
2186 ULONG_PTR CurrentVa
;
2187 SIZE_T TransferLength
;
2188 PUSBPORT_ENDPOINT Endpoint
;
2189 PDEVICE_OBJECT FdoDevice
;
2190 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2191 PDMA_OPERATIONS DmaOperations
;
2193 DPRINT("USBPORT_CompleteTransfer: Urb - %p, TransferStatus - %X\n",
2197 UrbTransfer
= &Urb
->UrbControlTransfer
;
2198 Transfer
= UrbTransfer
->hca
.Reserved8
[0];
2200 Transfer
->USBDStatus
= TransferStatus
;
2201 Status
= USBPORT_USBDStatusToNtStatus(Urb
, TransferStatus
);
2203 UrbTransfer
->TransferBufferLength
= Transfer
->CompletedTransferLen
;
2205 if (Transfer
->Flags
& TRANSFER_FLAG_DMA_MAPPED
)
2207 Endpoint
= Transfer
->Endpoint
;
2208 FdoDevice
= Endpoint
->FdoDevice
;
2209 FdoExtension
= FdoDevice
->DeviceExtension
;
2210 DmaOperations
= FdoExtension
->DmaAdapter
->DmaOperations
;
2212 WriteToDevice
= Transfer
->Direction
== USBPORT_DMA_DIRECTION_TO_DEVICE
;
2213 Mdl
= UrbTransfer
->TransferBufferMDL
;
2214 CurrentVa
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2215 TransferLength
= UrbTransfer
->TransferBufferLength
;
2217 IsFlushSuccess
= DmaOperations
->FlushAdapterBuffers(FdoExtension
->DmaAdapter
,
2219 Transfer
->MapRegisterBase
,
2224 if (!IsFlushSuccess
)
2226 DPRINT("USBPORT_CompleteTransfer: no FlushAdapterBuffers !!!\n");
2230 KeRaiseIrql(DISPATCH_LEVEL
, &OldIrql
);
2232 DmaOperations
->FreeMapRegisters(FdoExtension
->DmaAdapter
,
2233 Transfer
->MapRegisterBase
,
2234 Transfer
->NumberOfMapRegisters
);
2236 KeLowerIrql(OldIrql
);
2239 if (Urb
->UrbHeader
.UsbdFlags
& USBD_FLAG_ALLOCATED_MDL
)
2241 IoFreeMdl(Transfer
->TransferBufferMDL
);
2242 Urb
->UrbHeader
.UsbdFlags
|= ~USBD_FLAG_ALLOCATED_MDL
;
2245 Urb
->UrbControlTransfer
.hca
.Reserved8
[0] = NULL
;
2246 Urb
->UrbHeader
.UsbdFlags
|= ~USBD_FLAG_ALLOCATED_TRANSFER
;
2248 Irp
= Transfer
->Irp
;
2252 if (!NT_SUCCESS(Status
))
2255 DPRINT1("USBPORT_CompleteTransfer: Irp - %p complete with Status - %lx\n",
2259 USBPORT_DumpingURB(Urb
);
2262 Irp
->IoStatus
.Status
= Status
;
2263 Irp
->IoStatus
.Information
= 0;
2265 KeRaiseIrql(DISPATCH_LEVEL
, &OldIrql
);
2266 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2267 KeLowerIrql(OldIrql
);
2270 Event
= Transfer
->Event
;
2274 KeSetEvent(Event
, EVENT_INCREMENT
, FALSE
);
2277 ExFreePoolWithTag(Transfer
, USB_PORT_TAG
);
2279 DPRINT_CORE("USBPORT_CompleteTransfer: exit\n");
2282 IO_ALLOCATION_ACTION
2284 USBPORT_MapTransfer(IN PDEVICE_OBJECT FdoDevice
,
2286 IN PVOID MapRegisterBase
,
2289 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2290 PDMA_ADAPTER DmaAdapter
;
2291 PUSBPORT_TRANSFER Transfer
;
2293 PUSBPORT_ENDPOINT Endpoint
;
2295 ULONG_PTR CurrentVa
;
2296 PUSBPORT_SCATTER_GATHER_LIST sgList
;
2297 SIZE_T CurrentLength
;
2299 BOOLEAN WriteToDevice
;
2300 PHYSICAL_ADDRESS PhAddr
= {{0, 0}};
2301 PHYSICAL_ADDRESS PhAddress
= {{0, 0}};
2302 SIZE_T TransferLength
;
2303 SIZE_T SgCurrentLength
;
2304 SIZE_T ElementLength
;
2305 PUSBPORT_DEVICE_HANDLE DeviceHandle
;
2306 PDMA_OPERATIONS DmaOperations
;
2307 USBD_STATUS USBDStatus
;
2309 PUSBPORT_TRANSFER transfer
;
2311 DPRINT_CORE("USBPORT_MapTransfer: ... \n");
2313 FdoExtension
= FdoDevice
->DeviceExtension
;
2314 DmaAdapter
= FdoExtension
->DmaAdapter
;
2315 DmaOperations
= DmaAdapter
->DmaOperations
;
2319 Urb
= Transfer
->Urb
;
2320 Endpoint
= Transfer
->Endpoint
;
2321 TransferLength
= Transfer
->TransferParameters
.TransferBufferLength
;
2323 Mdl
= Urb
->UrbControlTransfer
.TransferBufferMDL
;
2324 CurrentVa
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2326 sgList
= &Transfer
->SgList
;
2329 sgList
->CurrentVa
= CurrentVa
;
2330 sgList
->MappedSystemVa
= MmGetSystemAddressForMdlSafe(Mdl
,
2331 NormalPagePriority
);
2332 Transfer
->MapRegisterBase
= MapRegisterBase
;
2339 WriteToDevice
= Transfer
->Direction
== USBPORT_DMA_DIRECTION_TO_DEVICE
;
2340 ASSERT(Transfer
->Direction
!= 0);
2342 PhAddress
= DmaOperations
->MapTransfer(DmaAdapter
,
2349 DPRINT_CORE("USBPORT_MapTransfer: PhAddress.LowPart - %p, PhAddress.HighPart - %x, TransferLength - %x\n",
2354 PhAddress
.HighPart
= 0;
2355 SgCurrentLength
= TransferLength
;
2359 ElementLength
= PAGE_SIZE
- (PhAddress
.LowPart
& (PAGE_SIZE
- 1));
2361 if (ElementLength
> SgCurrentLength
)
2362 ElementLength
= SgCurrentLength
;
2364 DPRINT_CORE("USBPORT_MapTransfer: PhAddress.LowPart - %p, HighPart - %x, ElementLength - %x\n",
2369 sgList
->SgElement
[ix
].SgPhysicalAddress
= PhAddress
;
2370 sgList
->SgElement
[ix
].SgTransferLength
= ElementLength
;
2371 sgList
->SgElement
[ix
].SgOffset
= CurrentLength
+
2372 (TransferLength
- SgCurrentLength
);
2374 PhAddress
.LowPart
+= ElementLength
;
2375 SgCurrentLength
-= ElementLength
;
2379 while (SgCurrentLength
);
2381 if (PhAddr
.QuadPart
== PhAddress
.QuadPart
)
2383 DPRINT1("USBPORT_MapTransfer: PhAddr == PhAddress\n");
2389 CurrentLength
+= TransferLength
;
2390 CurrentVa
+= TransferLength
;
2392 TransferLength
= Transfer
->TransferParameters
.TransferBufferLength
-
2395 while (CurrentLength
!= Transfer
->TransferParameters
.TransferBufferLength
);
2397 sgList
->SgElementCount
= ix
;
2399 if (Endpoint
->EndpointProperties
.DeviceSpeed
== UsbHighSpeed
)
2401 Transfer
->Flags
|= TRANSFER_FLAG_HIGH_SPEED
;
2404 Transfer
->Flags
|= TRANSFER_FLAG_DMA_MAPPED
;
2406 if ((Transfer
->Flags
& TRANSFER_FLAG_ISO
) == 0)
2408 KeAcquireSpinLock(&Endpoint
->EndpointSpinLock
,
2409 &Endpoint
->EndpointOldIrql
);
2411 USBPORT_SplitTransfer(FdoDevice
, Endpoint
, Transfer
, &List
);
2413 while (!IsListEmpty(&List
))
2415 transfer
= CONTAINING_RECORD(List
.Flink
,
2419 RemoveHeadList(&List
);
2420 InsertTailList(&Endpoint
->TransferList
, &transfer
->TransferLink
);
2423 KeReleaseSpinLock(&Endpoint
->EndpointSpinLock
,
2424 Endpoint
->EndpointOldIrql
);
2428 USBDStatus
= USBPORT_InitializeIsoTransfer(FdoDevice
,
2429 &Urb
->UrbIsochronousTransfer
,
2432 if (USBDStatus
!= USBD_STATUS_SUCCESS
)
2434 KeAcquireSpinLock(&Endpoint
->EndpointSpinLock
,
2435 &Endpoint
->EndpointOldIrql
);
2437 USBPORT_QueueDoneTransfer(Transfer
, USBDStatus
);
2439 KeReleaseSpinLock(&Endpoint
->EndpointSpinLock
,
2440 Endpoint
->EndpointOldIrql
);
2444 DeviceHandle
= Urb
->UrbHeader
.UsbdDeviceHandle
;
2445 InterlockedDecrement(&DeviceHandle
->DeviceHandleLock
);
2447 if (USBPORT_EndpointWorker(Endpoint
, 0))
2449 USBPORT_InvalidateEndpointHandler(FdoDevice
,
2451 INVALIDATE_ENDPOINT_WORKER_THREAD
);
2454 return DeallocateObjectKeepRegisters
;
2459 USBPORT_FlushMapTransfers(IN PDEVICE_OBJECT FdoDevice
)
2461 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2462 PLIST_ENTRY MapTransferList
;
2463 PUSBPORT_TRANSFER Transfer
;
2464 ULONG NumMapRegisters
;
2466 SIZE_T TransferBufferLength
;
2467 ULONG_PTR VirtualAddr
;
2470 PDMA_OPERATIONS DmaOperations
;
2472 DPRINT_CORE("USBPORT_FlushMapTransfers: ... \n");
2474 FdoExtension
= FdoDevice
->DeviceExtension
;
2475 DmaOperations
= FdoExtension
->DmaAdapter
->DmaOperations
;
2477 KeRaiseIrql(DISPATCH_LEVEL
, &OldIrql
);
2481 MapTransferList
= &FdoExtension
->MapTransferList
;
2483 if (IsListEmpty(&FdoExtension
->MapTransferList
))
2485 KeLowerIrql(OldIrql
);
2489 Transfer
= CONTAINING_RECORD(MapTransferList
->Flink
,
2493 RemoveHeadList(MapTransferList
);
2495 Mdl
= Transfer
->Urb
->UrbControlTransfer
.TransferBufferMDL
;
2496 TransferBufferLength
= Transfer
->TransferParameters
.TransferBufferLength
;
2497 VirtualAddr
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2499 NumMapRegisters
= ADDRESS_AND_SIZE_TO_SPAN_PAGES(VirtualAddr
,
2500 TransferBufferLength
);
2502 Transfer
->NumberOfMapRegisters
= NumMapRegisters
;
2504 Status
= DmaOperations
->AllocateAdapterChannel(FdoExtension
->DmaAdapter
,
2507 USBPORT_MapTransfer
,
2510 if (!NT_SUCCESS(Status
))
2514 KeLowerIrql(OldIrql
);
2519 USBPORT_AllocateTransfer(IN PDEVICE_OBJECT FdoDevice
,
2521 IN PUSBPORT_DEVICE_HANDLE DeviceHandle
,
2525 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2526 SIZE_T TransferLength
;
2528 ULONG_PTR VirtualAddr
;
2529 ULONG PagesNeed
= 0;
2530 SIZE_T PortTransferLength
;
2531 SIZE_T FullTransferLength
;
2532 PUSBPORT_TRANSFER Transfer
;
2533 PUSBPORT_PIPE_HANDLE PipeHandle
;
2534 USBD_STATUS USBDStatus
;
2535 SIZE_T IsoBlockLen
= 0;
2537 DPRINT_CORE("USBPORT_AllocateTransfer: FdoDevice - %p, Urb - %p, DeviceHandle - %p, Irp - %p, Event - %p\n",
2544 FdoExtension
= FdoDevice
->DeviceExtension
;
2546 TransferLength
= Urb
->UrbControlTransfer
.TransferBufferLength
;
2547 PipeHandle
= Urb
->UrbControlTransfer
.PipeHandle
;
2551 Mdl
= Urb
->UrbControlTransfer
.TransferBufferMDL
;
2552 VirtualAddr
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2554 PagesNeed
= ADDRESS_AND_SIZE_TO_SPAN_PAGES(VirtualAddr
,
2562 if (Urb
->UrbHeader
.Function
== URB_FUNCTION_ISOCH_TRANSFER
)
2564 DPRINT1("USBPORT_AllocateTransfer: ISOCH_TRANSFER UNIMPLEMENTED. FIXME\n");
2566 //IsoBlockLen = sizeof(USBPORT_ISO_BLOCK) +
2567 // Urb->UrbIsochronousTransfer.NumberOfPackets *
2568 // sizeof(USBPORT_ISO_BLOCK_PACKET);
2571 PortTransferLength
= sizeof(USBPORT_TRANSFER
) +
2572 PagesNeed
* sizeof(USBPORT_SCATTER_GATHER_ELEMENT
) +
2575 FullTransferLength
= PortTransferLength
+
2576 FdoExtension
->MiniPortInterface
->Packet
.MiniPortTransferSize
;
2578 Transfer
= ExAllocatePoolWithTag(NonPagedPool
,
2584 DPRINT1("USBPORT_AllocateTransfer: Transfer not allocated!\n");
2585 return USBD_STATUS_INSUFFICIENT_RESOURCES
;
2588 RtlZeroMemory(Transfer
, FullTransferLength
);
2590 Transfer
->Irp
= Irp
;
2591 Transfer
->Urb
= Urb
;
2592 Transfer
->Endpoint
= PipeHandle
->Endpoint
;
2593 Transfer
->Event
= Event
;
2594 Transfer
->PortTransferLength
= PortTransferLength
;
2595 Transfer
->FullTransferLength
= FullTransferLength
;
2596 Transfer
->IsoBlockPtr
= NULL
;
2597 Transfer
->Period
= 0;
2598 Transfer
->ParentTransfer
= Transfer
;
2602 Transfer
->IsoBlockPtr
= (PVOID
)((ULONG_PTR
)Transfer
+
2603 PortTransferLength
- IsoBlockLen
);
2605 Transfer
->Period
= PipeHandle
->Endpoint
->EndpointProperties
.Period
;
2606 Transfer
->Flags
|= TRANSFER_FLAG_ISO
;
2609 Transfer
->MiniportTransfer
= (PVOID
)((ULONG_PTR
)Transfer
+
2610 PortTransferLength
);
2612 KeInitializeSpinLock(&Transfer
->TransferSpinLock
);
2614 Urb
->UrbControlTransfer
.hca
.Reserved8
[0] = Transfer
;
2615 Urb
->UrbHeader
.UsbdFlags
|= USBD_FLAG_ALLOCATED_TRANSFER
;
2617 USBDStatus
= USBD_STATUS_SUCCESS
;
2619 DPRINT_CORE("USBPORT_AllocateTransfer: return USBDStatus - %x\n",
2627 USBPORT_Dispatch(IN PDEVICE_OBJECT DeviceObject
,
2630 PUSBPORT_COMMON_DEVICE_EXTENSION DeviceExtension
;
2631 PIO_STACK_LOCATION IoStack
;
2632 NTSTATUS Status
= STATUS_SUCCESS
;
2634 DeviceExtension
= DeviceObject
->DeviceExtension
;
2635 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
2637 if (DeviceExtension
->PnpStateFlags
& USBPORT_PNP_STATE_FAILED
)
2639 DPRINT1("USBPORT_Dispatch: USBPORT_PNP_STATE_FAILED\n");
2643 switch (IoStack
->MajorFunction
)
2645 case IRP_MJ_DEVICE_CONTROL
:
2646 if (DeviceExtension
->IsPDO
)
2648 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2649 IoStack
->MajorFunction
,
2650 IoStack
->MinorFunction
);
2652 Status
= USBPORT_PdoDeviceControl(DeviceObject
, Irp
);
2656 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2657 IoStack
->MajorFunction
,
2658 IoStack
->MinorFunction
);
2660 Status
= USBPORT_FdoDeviceControl(DeviceObject
, Irp
);
2665 case IRP_MJ_INTERNAL_DEVICE_CONTROL
:
2666 if (DeviceExtension
->IsPDO
)
2668 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_INTERNAL_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2669 IoStack
->MajorFunction
,
2670 IoStack
->MinorFunction
);
2672 Status
= USBPORT_PdoInternalDeviceControl(DeviceObject
, Irp
);
2676 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_INTERNAL_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2677 IoStack
->MajorFunction
,
2678 IoStack
->MinorFunction
);
2680 Status
= USBPORT_FdoInternalDeviceControl(DeviceObject
, Irp
);
2686 if (DeviceExtension
->IsPDO
)
2688 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_POWER. Major - %d, Minor - %d\n",
2689 IoStack
->MajorFunction
,
2690 IoStack
->MinorFunction
);
2692 Status
= USBPORT_PdoPower(DeviceObject
, Irp
);
2696 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_POWER. Major - %d, Minor - %d\n",
2697 IoStack
->MajorFunction
,
2698 IoStack
->MinorFunction
);
2700 Status
= USBPORT_FdoPower(DeviceObject
, Irp
);
2705 case IRP_MJ_SYSTEM_CONTROL
:
2706 if (DeviceExtension
->IsPDO
)
2708 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_SYSTEM_CONTROL. Major - %d, Minor - %d\n",
2709 IoStack
->MajorFunction
,
2710 IoStack
->MinorFunction
);
2712 Irp
->IoStatus
.Status
= Status
;
2713 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2717 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_SYSTEM_CONTROL. Major - %d, Minor - %d\n",
2718 IoStack
->MajorFunction
,
2719 IoStack
->MinorFunction
);
2721 IoSkipCurrentIrpStackLocation(Irp
);
2722 Status
= IoCallDriver(DeviceExtension
->LowerDevice
, Irp
);
2728 if (DeviceExtension
->IsPDO
)
2730 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_PNP. Major - %d, Minor - %d\n",
2731 IoStack
->MajorFunction
,
2732 IoStack
->MinorFunction
);
2734 Status
= USBPORT_PdoPnP(DeviceObject
, Irp
);
2738 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_PNP. Major - %d, Minor - %d\n",
2739 IoStack
->MajorFunction
,
2740 IoStack
->MinorFunction
);
2742 Status
= USBPORT_FdoPnP(DeviceObject
, Irp
);
2749 DPRINT("USBPORT_Dispatch: IRP_MJ_CREATE | IRP_MJ_CLOSE\n");
2750 Irp
->IoStatus
.Status
= Status
;
2751 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2755 if (DeviceExtension
->IsPDO
)
2757 DPRINT("USBPORT_Dispatch: PDO unhandled IRP_MJ_???. Major - %d, Minor - %d\n",
2758 IoStack
->MajorFunction
,
2759 IoStack
->MinorFunction
);
2763 DPRINT("USBPORT_Dispatch: FDO unhandled IRP_MJ_???. Major - %d, Minor - %d\n",
2764 IoStack
->MajorFunction
,
2765 IoStack
->MinorFunction
);
2768 Status
= STATUS_INVALID_DEVICE_REQUEST
;
2769 Irp
->IoStatus
.Status
= Status
;
2770 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2774 DPRINT("USBPORT_Dispatch: Status - %x\n", Status
);
2780 USBPORT_GetHciMn(VOID
)
2782 return USBPORT_HCI_MN
;
2787 USBPORT_RegisterUSBPortDriver(IN PDRIVER_OBJECT DriverObject
,
2789 IN PUSBPORT_REGISTRATION_PACKET RegPacket
)
2791 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
2793 DPRINT("USBPORT_RegisterUSBPortDriver: DriverObject - %p, Version - %p, RegPacket - %p\n",
2798 DPRINT("USBPORT_RegisterUSBPortDriver: sizeof(USBPORT_MINIPORT_INTERFACE) - %x\n",
2799 sizeof(USBPORT_MINIPORT_INTERFACE
));
2801 DPRINT("USBPORT_RegisterUSBPortDriver: sizeof(USBPORT_DEVICE_EXTENSION) - %x\n",
2802 sizeof(USBPORT_DEVICE_EXTENSION
));
2804 if (Version
< USB10_MINIPORT_INTERFACE_VERSION
)
2806 return STATUS_UNSUCCESSFUL
;
2809 if (!USBPORT_Initialized
)
2811 InitializeListHead(&USBPORT_MiniPortDrivers
);
2812 InitializeListHead(&USBPORT_USB1FdoList
);
2813 InitializeListHead(&USBPORT_USB2FdoList
);
2815 KeInitializeSpinLock(&USBPORT_SpinLock
);
2816 USBPORT_Initialized
= TRUE
;
2819 MiniPortInterface
= ExAllocatePoolWithTag(NonPagedPool
,
2820 sizeof(USBPORT_MINIPORT_INTERFACE
),
2822 if (!MiniPortInterface
)
2824 return STATUS_INSUFFICIENT_RESOURCES
;
2827 RtlZeroMemory(MiniPortInterface
, sizeof(USBPORT_MINIPORT_INTERFACE
));
2829 MiniPortInterface
->DriverObject
= DriverObject
;
2830 MiniPortInterface
->DriverUnload
= DriverObject
->DriverUnload
;
2831 MiniPortInterface
->Version
= Version
;
2833 ExInterlockedInsertTailList(&USBPORT_MiniPortDrivers
,
2834 &MiniPortInterface
->DriverLink
,
2837 DriverObject
->DriverExtension
->AddDevice
= USBPORT_AddDevice
;
2838 DriverObject
->DriverUnload
= USBPORT_Unload
;
2840 DriverObject
->MajorFunction
[IRP_MJ_CREATE
] = USBPORT_Dispatch
;
2841 DriverObject
->MajorFunction
[IRP_MJ_CLOSE
] = USBPORT_Dispatch
;
2842 DriverObject
->MajorFunction
[IRP_MJ_DEVICE_CONTROL
] = USBPORT_Dispatch
;
2843 DriverObject
->MajorFunction
[IRP_MJ_INTERNAL_DEVICE_CONTROL
] = USBPORT_Dispatch
;
2844 DriverObject
->MajorFunction
[IRP_MJ_PNP
] = USBPORT_Dispatch
;
2845 DriverObject
->MajorFunction
[IRP_MJ_POWER
] = USBPORT_Dispatch
;
2846 DriverObject
->MajorFunction
[IRP_MJ_SYSTEM_CONTROL
] = USBPORT_Dispatch
;
2848 RegPacket
->UsbPortDbgPrint
= USBPORT_DbgPrint
;
2849 RegPacket
->UsbPortTestDebugBreak
= USBPORT_TestDebugBreak
;
2850 RegPacket
->UsbPortAssertFailure
= USBPORT_AssertFailure
;
2851 RegPacket
->UsbPortGetMiniportRegistryKeyValue
= USBPORT_GetMiniportRegistryKeyValue
;
2852 RegPacket
->UsbPortInvalidateRootHub
= USBPORT_InvalidateRootHub
;
2853 RegPacket
->UsbPortInvalidateEndpoint
= USBPORT_InvalidateEndpoint
;
2854 RegPacket
->UsbPortCompleteTransfer
= USBPORT_MiniportCompleteTransfer
;
2855 RegPacket
->UsbPortCompleteIsoTransfer
= USBPORT_CompleteIsoTransfer
;
2856 RegPacket
->UsbPortLogEntry
= USBPORT_LogEntry
;
2857 RegPacket
->UsbPortGetMappedVirtualAddress
= USBPORT_GetMappedVirtualAddress
;
2858 RegPacket
->UsbPortRequestAsyncCallback
= USBPORT_RequestAsyncCallback
;
2859 RegPacket
->UsbPortReadWriteConfigSpace
= USBPORT_ReadWriteConfigSpace
;
2860 RegPacket
->UsbPortWait
= USBPORT_Wait
;
2861 RegPacket
->UsbPortInvalidateController
= USBPORT_InvalidateController
;
2862 RegPacket
->UsbPortBugCheck
= USBPORT_BugCheck
;
2863 RegPacket
->UsbPortNotifyDoubleBuffer
= USBPORT_NotifyDoubleBuffer
;
2865 RtlCopyMemory(&MiniPortInterface
->Packet
,
2867 sizeof(USBPORT_REGISTRATION_PACKET
));
2869 return STATUS_SUCCESS
;
2874 DriverEntry(IN PDRIVER_OBJECT DriverObject
,
2875 IN PUNICODE_STRING RegistryPath
)
2877 return STATUS_SUCCESS
;