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_CORE("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_CORE("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 if (FdoExtension
->Flags
& USBPORT_FLAG_WORKER_THREAD_EXIT
)
1398 KeQuerySystemTime(&NewTime
);
1400 KeAcquireSpinLock(&FdoExtension
->WorkerThreadEventSpinLock
, &OldIrql
);
1401 KeClearEvent(&FdoExtension
->WorkerThreadEvent
);
1402 KeReleaseSpinLock(&FdoExtension
->WorkerThreadEventSpinLock
, OldIrql
);
1403 DPRINT_CORE("USBPORT_WorkerThread: run\n");
1405 if (FdoExtension
->MiniPortFlags
& USBPORT_MPFLAG_INTERRUPTS_ENABLED
)
1407 USBPORT_DoSetPowerD0(FdoDevice
);
1409 if (FdoExtension
->Flags
& USBPORT_FLAG_RH_INIT_CALLBACK
)
1411 PDEVICE_OBJECT USB2FdoDevice
= NULL
;
1413 USB2FdoDevice
= USBPORT_FindUSB2Controller(FdoDevice
);
1414 USBPORT_SynchronizeRootHubCallback(FdoDevice
, USB2FdoDevice
);
1418 USBPORT_WorkerThreadHandler(FdoDevice
);
1420 while (!(FdoExtension
->Flags
& USBPORT_FLAG_WORKER_THREAD_ON
));
1422 PsTerminateSystemThread(0);
1427 USBPORT_CreateWorkerThread(IN PDEVICE_OBJECT FdoDevice
)
1429 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1432 DPRINT("USBPORT_CreateWorkerThread ...\n");
1434 FdoExtension
= FdoDevice
->DeviceExtension
;
1436 FdoExtension
->Flags
&= ~USBPORT_FLAG_WORKER_THREAD_ON
;
1438 KeInitializeEvent(&FdoExtension
->WorkerThreadEvent
,
1442 Status
= PsCreateSystemThread(&FdoExtension
->WorkerThreadHandle
,
1447 USBPORT_WorkerThread
,
1455 USBPORT_StopWorkerThread(IN PDEVICE_OBJECT FdoDevice
)
1457 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1460 DPRINT("USBPORT_StopWorkerThread ...\n");
1462 FdoExtension
= FdoDevice
->DeviceExtension
;
1464 FdoExtension
->Flags
|= USBPORT_FLAG_WORKER_THREAD_EXIT
;
1465 USBPORT_SignalWorkerThread(FdoDevice
);
1466 Status
= ZwWaitForSingleObject(FdoExtension
->WorkerThreadHandle
, FALSE
, NULL
);
1467 NT_ASSERT(Status
== STATUS_SUCCESS
);
1472 USBPORT_SynchronizeControllersStart(IN PDEVICE_OBJECT FdoDevice
)
1474 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1475 PDEVICE_OBJECT PdoDevice
;
1476 PUSBPORT_RHDEVICE_EXTENSION PdoExtension
;
1477 PDEVICE_OBJECT USB2FdoDevice
= NULL
;
1478 PUSBPORT_DEVICE_EXTENSION USB2FdoExtension
;
1481 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: FdoDevice - %p\n",
1484 FdoExtension
= FdoDevice
->DeviceExtension
;
1486 PdoDevice
= FdoExtension
->RootHubPdo
;
1493 PdoExtension
= PdoDevice
->DeviceExtension
;
1495 if (PdoExtension
->RootHubInitCallback
== NULL
||
1496 FdoExtension
->Flags
& USBPORT_FLAG_RH_INIT_CALLBACK
)
1501 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: Flags - %p\n",
1502 FdoExtension
->Flags
);
1504 if (FdoExtension
->Flags
& USBPORT_FLAG_COMPANION_HC
)
1508 USB2FdoDevice
= USBPORT_FindUSB2Controller(FdoDevice
);
1510 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: USB2FdoDevice - %p\n",
1515 USB2FdoExtension
= USB2FdoDevice
->DeviceExtension
;
1517 if (USB2FdoExtension
->CommonExtension
.PnpStateFlags
&
1518 USBPORT_PNP_STATE_STARTED
)
1524 if (!(FdoExtension
->Flags
& USBPORT_FLAG_NO_HACTION
))
1529 USB2FdoDevice
= NULL
;
1537 !InterlockedCompareExchange(&FdoExtension
->RHInitCallBackLock
, 1, 0))
1539 FdoExtension
->Flags
|= USBPORT_FLAG_RH_INIT_CALLBACK
;
1540 USBPORT_SignalWorkerThread(FdoDevice
);
1544 USB2FdoExtension
= USB2FdoDevice
->DeviceExtension
;
1546 USB2FdoExtension
->Flags
|= USBPORT_FLAG_RH_INIT_CALLBACK
;
1547 USBPORT_SignalWorkerThread(USB2FdoDevice
);
1551 DPRINT_TIMER("USBPORT_SynchronizeControllersStart: exit\n");
1556 USBPORT_TimerDpc(IN PRKDPC Dpc
,
1557 IN PVOID DeferredContext
,
1558 IN PVOID SystemArgument1
,
1559 IN PVOID SystemArgument2
)
1561 PDEVICE_OBJECT FdoDevice
;
1562 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1563 PUSBPORT_REGISTRATION_PACKET Packet
;
1564 LARGE_INTEGER DueTime
= {{0, 0}};
1566 PTIMER_WORK_QUEUE_ITEM IdleQueueItem
;
1570 DPRINT_TIMER("USBPORT_TimerDpc: Dpc - %p, DeferredContext - %p\n",
1574 FdoDevice
= DeferredContext
;
1575 FdoExtension
= FdoDevice
->DeviceExtension
;
1576 Packet
= &FdoExtension
->MiniPortInterface
->Packet
;
1578 KeAcquireSpinLock(&FdoExtension
->TimerFlagsSpinLock
, &TimerOldIrql
);
1580 TimerFlags
= FdoExtension
->TimerFlags
;
1582 DPRINT_TIMER("USBPORT_TimerDpc: Flags - %p, TimerFlags - %p\n",
1583 FdoExtension
->Flags
,
1586 if (FdoExtension
->Flags
& USBPORT_FLAG_HC_SUSPEND
&&
1587 FdoExtension
->Flags
& USBPORT_FLAG_HC_WAKE_SUPPORT
&&
1588 !(TimerFlags
& USBPORT_TMFLAG_HC_RESUME
))
1590 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
1591 Packet
->PollController(FdoExtension
->MiniPortExt
);
1592 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
1595 USBPORT_SynchronizeControllersStart(FdoDevice
);
1597 if (TimerFlags
& USBPORT_TMFLAG_HC_SUSPENDED
)
1599 USBPORT_BadRequestFlush(FdoDevice
);
1603 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
1605 if (!(FdoExtension
->Flags
& USBPORT_FLAG_HC_SUSPEND
))
1607 Packet
->CheckController(FdoExtension
->MiniPortExt
);
1610 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
1612 if (FdoExtension
->Flags
& USBPORT_FLAG_HC_POLLING
)
1614 KeAcquireSpinLock(&FdoExtension
->MiniportSpinLock
, &OldIrql
);
1615 Packet
->PollController(FdoExtension
->MiniPortExt
);
1616 KeReleaseSpinLock(&FdoExtension
->MiniportSpinLock
, OldIrql
);
1619 USBPORT_IsrDpcHandler(FdoDevice
, FALSE
);
1621 DPRINT_TIMER("USBPORT_TimerDpc: USBPORT_TimeoutAllEndpoints UNIMPLEMENTED.\n");
1622 //USBPORT_TimeoutAllEndpoints(FdoDevice);
1623 DPRINT_TIMER("USBPORT_TimerDpc: USBPORT_CheckIdleEndpoints UNIMPLEMENTED.\n");
1624 //USBPORT_CheckIdleEndpoints(FdoDevice);
1626 USBPORT_BadRequestFlush(FdoDevice
);
1628 if (FdoExtension
->IdleLockCounter
> -1 &&
1629 !(TimerFlags
& USBPORT_TMFLAG_IDLE_QUEUEITEM_ON
))
1631 IdleQueueItem
= ExAllocatePoolWithTag(NonPagedPool
,
1632 sizeof(TIMER_WORK_QUEUE_ITEM
),
1635 DPRINT("USBPORT_TimerDpc: IdleLockCounter - %x, IdleQueueItem - %p\n",
1636 FdoExtension
->IdleLockCounter
,
1641 RtlZeroMemory(IdleQueueItem
, sizeof(TIMER_WORK_QUEUE_ITEM
));
1643 IdleQueueItem
->WqItem
.List
.Flink
= NULL
;
1644 IdleQueueItem
->WqItem
.WorkerRoutine
= USBPORT_DoIdleNotificationCallback
;
1645 IdleQueueItem
->WqItem
.Parameter
= IdleQueueItem
;
1647 IdleQueueItem
->FdoDevice
= FdoDevice
;
1648 IdleQueueItem
->Context
= 0;
1650 FdoExtension
->TimerFlags
|= USBPORT_TMFLAG_IDLE_QUEUEITEM_ON
;
1652 ExQueueWorkItem(&IdleQueueItem
->WqItem
, CriticalWorkQueue
);
1658 KeReleaseSpinLock(&FdoExtension
->TimerFlagsSpinLock
, TimerOldIrql
);
1660 if (TimerFlags
& USBPORT_TMFLAG_TIMER_QUEUED
)
1662 DueTime
.QuadPart
-= FdoExtension
->TimerValue
* 10000 +
1663 (KeQueryTimeIncrement() - 1);
1665 KeSetTimer(&FdoExtension
->TimerObject
,
1667 &FdoExtension
->TimerDpc
);
1670 DPRINT_TIMER("USBPORT_TimerDpc: exit\n");
1675 USBPORT_StartTimer(IN PDEVICE_OBJECT FdoDevice
,
1678 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1679 LARGE_INTEGER DueTime
= {{0, 0}};
1680 ULONG TimeIncrement
;
1683 DPRINT_TIMER("USBPORT_StartTimer: FdoDevice - %p, Time - %x\n",
1687 FdoExtension
= FdoDevice
->DeviceExtension
;
1689 TimeIncrement
= KeQueryTimeIncrement();
1691 FdoExtension
->TimerFlags
|= USBPORT_TMFLAG_TIMER_QUEUED
;
1692 FdoExtension
->TimerValue
= Time
;
1694 KeInitializeTimer(&FdoExtension
->TimerObject
);
1695 KeInitializeDpc(&FdoExtension
->TimerDpc
, USBPORT_TimerDpc
, FdoDevice
);
1697 DueTime
.QuadPart
-= 10000 * Time
+ (TimeIncrement
- 1);
1699 Result
= KeSetTimer(&FdoExtension
->TimerObject
,
1701 &FdoExtension
->TimerDpc
);
1706 PUSBPORT_COMMON_BUFFER_HEADER
1708 USBPORT_AllocateCommonBuffer(IN PDEVICE_OBJECT FdoDevice
,
1709 IN SIZE_T BufferLength
)
1711 PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer
= NULL
;
1712 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1713 PDMA_ADAPTER DmaAdapter
;
1714 PDMA_OPERATIONS DmaOperations
;
1718 PHYSICAL_ADDRESS LogicalAddress
;
1720 ULONG_PTR StartBufferVA
;
1721 ULONG StartBufferPA
;
1723 DPRINT("USBPORT_AllocateCommonBuffer: FdoDevice - %p, BufferLength - %p\n",
1727 if (BufferLength
== 0)
1730 FdoExtension
= FdoDevice
->DeviceExtension
;
1732 DmaAdapter
= FdoExtension
->DmaAdapter
;
1733 DmaOperations
= DmaAdapter
->DmaOperations
;
1735 HeaderSize
= sizeof(USBPORT_COMMON_BUFFER_HEADER
);
1736 Length
= ROUND_TO_PAGES(BufferLength
+ HeaderSize
);
1737 LengthPadded
= Length
- (BufferLength
+ HeaderSize
);
1739 BaseVA
= (ULONG_PTR
)DmaOperations
->AllocateCommonBuffer(DmaAdapter
,
1747 StartBufferVA
= BaseVA
& ~(PAGE_SIZE
- 1);
1748 StartBufferPA
= LogicalAddress
.LowPart
& ~(PAGE_SIZE
- 1);
1750 HeaderBuffer
= (PUSBPORT_COMMON_BUFFER_HEADER
)(StartBufferVA
+
1754 HeaderBuffer
->Length
= Length
;
1755 HeaderBuffer
->BaseVA
= BaseVA
;
1756 HeaderBuffer
->LogicalAddress
= LogicalAddress
;
1758 HeaderBuffer
->BufferLength
= BufferLength
+ LengthPadded
;
1759 HeaderBuffer
->VirtualAddress
= StartBufferVA
;
1760 HeaderBuffer
->PhysicalAddress
= StartBufferPA
;
1762 RtlZeroMemory((PVOID
)StartBufferVA
, BufferLength
+ LengthPadded
);
1765 return HeaderBuffer
;
1770 USBPORT_FreeCommonBuffer(IN PDEVICE_OBJECT FdoDevice
,
1771 IN PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer
)
1773 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1774 PDMA_ADAPTER DmaAdapter
;
1775 PDMA_OPERATIONS DmaOperations
;
1777 DPRINT("USBPORT_FreeCommonBuffer: ...\n");
1779 FdoExtension
= FdoDevice
->DeviceExtension
;
1781 DmaAdapter
= FdoExtension
->DmaAdapter
;
1782 DmaOperations
= DmaAdapter
->DmaOperations
;
1784 DmaOperations
->FreeCommonBuffer(FdoExtension
->DmaAdapter
,
1785 HeaderBuffer
->Length
,
1786 HeaderBuffer
->LogicalAddress
,
1787 (PVOID
)HeaderBuffer
->VirtualAddress
,
1791 PUSBPORT_MINIPORT_INTERFACE
1793 USBPORT_FindMiniPort(IN PDRIVER_OBJECT DriverObject
)
1797 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
1798 BOOLEAN IsFound
= FALSE
;
1800 DPRINT("USBPORT_FindMiniPort: ...\n");
1802 KeAcquireSpinLock(&USBPORT_SpinLock
, &OldIrql
);
1804 for (List
= USBPORT_MiniPortDrivers
.Flink
;
1805 List
!= &USBPORT_MiniPortDrivers
;
1808 MiniPortInterface
= CONTAINING_RECORD(List
,
1809 USBPORT_MINIPORT_INTERFACE
,
1812 if (MiniPortInterface
->DriverObject
== DriverObject
)
1814 DPRINT("USBPORT_FindMiniPort: find MiniPortInterface - %p\n",
1822 KeReleaseSpinLock(&USBPORT_SpinLock
, OldIrql
);
1825 return MiniPortInterface
;
1833 USBPORT_AddDevice(IN PDRIVER_OBJECT DriverObject
,
1834 IN PDEVICE_OBJECT PhysicalDeviceObject
)
1837 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
1838 ULONG DeviceNumber
= 0;
1839 WCHAR CharDeviceName
[64];
1840 UNICODE_STRING DeviceName
;
1841 PDEVICE_OBJECT DeviceObject
;
1842 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
1843 PUSBPORT_COMMON_DEVICE_EXTENSION FdoCommonExtension
;
1844 PDEVICE_OBJECT LowerDevice
;
1847 DPRINT("USBPORT_AddDevice: DriverObject - %p, PhysicalDeviceObject - %p\n",
1849 PhysicalDeviceObject
);
1851 MiniPortInterface
= USBPORT_FindMiniPort(DriverObject
);
1853 if (!MiniPortInterface
)
1855 DPRINT("USBPORT_AddDevice: USBPORT_FindMiniPort not found MiniPortInterface\n");
1856 return STATUS_UNSUCCESSFUL
;
1861 /* Construct device name */
1862 RtlStringCbPrintfW(CharDeviceName
,
1863 sizeof(CharDeviceName
),
1864 L
"\\Device\\USBFDO-%d",
1867 RtlInitUnicodeString(&DeviceName
, CharDeviceName
);
1869 ASSERT(MiniPortInterface
->Packet
.MiniPortExtensionSize
<=
1870 MAXULONG
- sizeof(USBPORT_DEVICE_EXTENSION
) - sizeof(USB2_HC_EXTENSION
));
1871 Length
= (ULONG
)(sizeof(USBPORT_DEVICE_EXTENSION
) +
1872 MiniPortInterface
->Packet
.MiniPortExtensionSize
+
1873 sizeof(USB2_HC_EXTENSION
));
1876 Status
= IoCreateDevice(DriverObject
,
1879 FILE_DEVICE_CONTROLLER
,
1884 /* Check for success */
1885 if (NT_SUCCESS(Status
)) break;
1887 /* Is there a device object with that same name */
1888 if ((Status
== STATUS_OBJECT_NAME_EXISTS
) ||
1889 (Status
== STATUS_OBJECT_NAME_COLLISION
))
1891 /* Try the next name */
1896 /* Bail out on other errors */
1897 if (!NT_SUCCESS(Status
))
1899 DPRINT1("USBPORT_AddDevice: failed to create %wZ, Status %x\n",
1907 DPRINT("USBPORT_AddDevice: created device %p <%wZ>, Status %x\n",
1912 FdoExtension
= DeviceObject
->DeviceExtension
;
1913 FdoCommonExtension
= &FdoExtension
->CommonExtension
;
1915 RtlZeroMemory(FdoExtension
, sizeof(USBPORT_DEVICE_EXTENSION
));
1917 FdoCommonExtension
->SelfDevice
= DeviceObject
;
1918 FdoCommonExtension
->LowerPdoDevice
= PhysicalDeviceObject
;
1919 FdoCommonExtension
->IsPDO
= FALSE
;
1921 LowerDevice
= IoAttachDeviceToDeviceStack(DeviceObject
,
1922 PhysicalDeviceObject
);
1924 FdoCommonExtension
->LowerDevice
= LowerDevice
;
1926 FdoCommonExtension
->DevicePowerState
= PowerDeviceD3
;
1928 FdoExtension
->MiniPortExt
= (PVOID
)((ULONG_PTR
)FdoExtension
+
1929 sizeof(USBPORT_DEVICE_EXTENSION
));
1931 if (MiniPortInterface
->Packet
.MiniPortFlags
& USB_MINIPORT_FLAGS_USB2
)
1933 FdoExtension
->Usb2Extension
=
1934 (PUSB2_HC_EXTENSION
)((ULONG_PTR
)FdoExtension
->MiniPortExt
+
1935 MiniPortInterface
->Packet
.MiniPortExtensionSize
);
1937 DPRINT("USBPORT_AddDevice: Usb2Extension - %p\n",
1938 FdoExtension
->Usb2Extension
);
1940 USB2_InitController(FdoExtension
->Usb2Extension
);
1944 FdoExtension
->Usb2Extension
= NULL
;
1947 FdoExtension
->MiniPortInterface
= MiniPortInterface
;
1948 FdoExtension
->FdoNameNumber
= DeviceNumber
;
1950 KeInitializeSemaphore(&FdoExtension
->DeviceSemaphore
, 1, 1);
1951 KeInitializeSemaphore(&FdoExtension
->ControllerSemaphore
, 1, 1);
1953 InitializeListHead(&FdoExtension
->EndpointList
);
1954 InitializeListHead(&FdoExtension
->DoneTransferList
);
1955 InitializeListHead(&FdoExtension
->WorkerList
);
1956 InitializeListHead(&FdoExtension
->EpStateChangeList
);
1957 InitializeListHead(&FdoExtension
->MapTransferList
);
1958 InitializeListHead(&FdoExtension
->DeviceHandleList
);
1959 InitializeListHead(&FdoExtension
->IdleIrpList
);
1960 InitializeListHead(&FdoExtension
->BadRequestList
);
1961 InitializeListHead(&FdoExtension
->EndpointClosedList
);
1963 DeviceObject
->Flags
&= ~DO_DEVICE_INITIALIZING
;
1970 USBPORT_Unload(IN PDRIVER_OBJECT DriverObject
)
1972 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
1974 DPRINT1("USBPORT_Unload: FIXME!\n");
1976 MiniPortInterface
= USBPORT_FindMiniPort(DriverObject
);
1978 if (!MiniPortInterface
)
1980 DPRINT("USBPORT_Unload: CRITICAL ERROR!!! Not found MiniPortInterface\n");
1981 KeBugCheckEx(BUGCODE_USB_DRIVER
, 1, 0, 0, 0);
1984 DPRINT1("USBPORT_Unload: UNIMPLEMENTED. FIXME.\n");
1985 //MiniPortInterface->DriverUnload(DriverObject); // Call MiniPort _HCI_Unload
1990 USBPORT_MiniportCompleteTransfer(IN PVOID MiniPortExtension
,
1991 IN PVOID MiniPortEndpoint
,
1992 IN PVOID TransferParameters
,
1993 IN USBD_STATUS USBDStatus
,
1994 IN ULONG TransferLength
)
1996 PUSBPORT_TRANSFER Transfer
;
1997 PUSBPORT_TRANSFER ParentTransfer
;
1998 PUSBPORT_TRANSFER SplitTransfer
;
1999 PLIST_ENTRY SplitHead
;
2003 DPRINT_CORE("USBPORT_MiniportCompleteTransfer: USBDStatus - %x, TransferLength - %x\n",
2007 Transfer
= CONTAINING_RECORD(TransferParameters
,
2009 TransferParameters
);
2011 Transfer
->Flags
|= TRANSFER_FLAG_COMPLETED
;
2012 Transfer
->CompletedTransferLen
= TransferLength
;
2014 if (((Transfer
->Flags
& TRANSFER_FLAG_SPLITED
) == 0) ||
2015 TransferLength
>= Transfer
->TransferParameters
.TransferBufferLength
)
2020 ParentTransfer
= Transfer
->ParentTransfer
;
2022 KeAcquireSpinLock(&ParentTransfer
->TransferSpinLock
, &OldIrql
);
2024 if (IsListEmpty(&ParentTransfer
->SplitTransfersList
))
2029 SplitHead
= &ParentTransfer
->SplitTransfersList
;
2030 Entry
= SplitHead
->Flink
;
2032 while (Entry
&& !IsListEmpty(SplitHead
))
2034 SplitTransfer
= CONTAINING_RECORD(Entry
,
2038 if (!(SplitTransfer
->Flags
& TRANSFER_FLAG_SUBMITED
))
2040 DPRINT1("USBPORT_MiniportCompleteTransfer: SplitTransfer->Flags - %X\n",
2041 SplitTransfer
->Flags
);
2042 //Add TRANSFER_FLAG_xxx
2045 Entry
= Entry
->Flink
;
2048 KeReleaseSpinLock(&ParentTransfer
->TransferSpinLock
, OldIrql
);
2051 USBPORT_QueueDoneTransfer(Transfer
, USBDStatus
);
2056 USBPORT_AsyncTimerDpc(IN PRKDPC Dpc
,
2057 IN PVOID DeferredContext
,
2058 IN PVOID SystemArgument1
,
2059 IN PVOID SystemArgument2
)
2061 PDEVICE_OBJECT FdoDevice
;
2062 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2063 PUSBPORT_ASYNC_CALLBACK_DATA AsyncCallbackData
;
2065 DPRINT("USBPORT_AsyncTimerDpc: ...\n");
2067 AsyncCallbackData
= DeferredContext
;
2068 FdoDevice
= AsyncCallbackData
->FdoDevice
;
2069 FdoExtension
= FdoDevice
->DeviceExtension
;
2071 (*AsyncCallbackData
->CallbackFunction
)(FdoExtension
->MiniPortExt
,
2072 &AsyncCallbackData
->CallbackContext
);
2074 ExFreePoolWithTag(AsyncCallbackData
, USB_PORT_TAG
);
2079 USBPORT_RequestAsyncCallback(IN PVOID MiniPortExtension
,
2080 IN ULONG TimerValue
,
2083 IN ASYNC_TIMER_CALLBACK
* Callback
)
2085 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2086 PDEVICE_OBJECT FdoDevice
;
2087 PUSBPORT_ASYNC_CALLBACK_DATA AsyncCallbackData
;
2088 LARGE_INTEGER DueTime
= {{0, 0}};
2090 DPRINT("USBPORT_RequestAsyncCallback: ...\n");
2092 FdoExtension
= (PUSBPORT_DEVICE_EXTENSION
)((ULONG_PTR
)MiniPortExtension
-
2093 sizeof(USBPORT_DEVICE_EXTENSION
));
2095 FdoDevice
= FdoExtension
->CommonExtension
.SelfDevice
;
2097 AsyncCallbackData
= ExAllocatePoolWithTag(NonPagedPool
,
2098 sizeof(USBPORT_ASYNC_CALLBACK_DATA
) + Length
,
2101 if (!AsyncCallbackData
)
2103 DPRINT1("USBPORT_RequestAsyncCallback: Not allocated AsyncCallbackData!\n");
2107 RtlZeroMemory(AsyncCallbackData
,
2108 sizeof(USBPORT_ASYNC_CALLBACK_DATA
) + Length
);
2112 RtlCopyMemory(&AsyncCallbackData
->CallbackContext
, Buffer
, Length
);
2115 AsyncCallbackData
->FdoDevice
= FdoDevice
;
2116 AsyncCallbackData
->CallbackFunction
= Callback
;
2118 KeInitializeTimer(&AsyncCallbackData
->AsyncTimer
);
2120 KeInitializeDpc(&AsyncCallbackData
->AsyncTimerDpc
,
2121 USBPORT_AsyncTimerDpc
,
2124 DueTime
.QuadPart
-= (KeQueryTimeIncrement() - 1) + 10000 * TimerValue
;
2126 KeSetTimer(&AsyncCallbackData
->AsyncTimer
,
2128 &AsyncCallbackData
->AsyncTimerDpc
);
2135 USBPORT_GetMappedVirtualAddress(IN ULONG PhysicalAddress
,
2136 IN PVOID MiniPortExtension
,
2137 IN PVOID MiniPortEndpoint
)
2139 PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer
;
2140 PUSBPORT_ENDPOINT Endpoint
;
2142 ULONG_PTR VirtualAddress
;
2144 DPRINT_CORE("USBPORT_GetMappedVirtualAddress ...\n");
2146 Endpoint
= (PUSBPORT_ENDPOINT
)((ULONG_PTR
)MiniPortEndpoint
-
2147 sizeof(USBPORT_ENDPOINT
));
2154 HeaderBuffer
= Endpoint
->HeaderBuffer
;
2156 Offset
= PhysicalAddress
- HeaderBuffer
->PhysicalAddress
;
2157 VirtualAddress
= HeaderBuffer
->VirtualAddress
+ Offset
;
2159 return (PVOID
)VirtualAddress
;
2164 USBPORT_InvalidateEndpoint(IN PVOID MiniPortExtension
,
2165 IN PVOID MiniPortEndpoint
)
2167 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2168 PDEVICE_OBJECT FdoDevice
;
2169 PUSBPORT_ENDPOINT Endpoint
;
2171 DPRINT_CORE("USBPORT_InvalidateEndpoint: ...\n");
2173 FdoExtension
= (PUSBPORT_DEVICE_EXTENSION
)((ULONG_PTR
)MiniPortExtension
-
2174 sizeof(USBPORT_DEVICE_EXTENSION
));
2176 FdoDevice
= FdoExtension
->CommonExtension
.SelfDevice
;
2178 if (!MiniPortEndpoint
)
2180 USBPORT_InvalidateEndpointHandler(FdoDevice
,
2182 INVALIDATE_ENDPOINT_ONLY
);
2186 Endpoint
= (PUSBPORT_ENDPOINT
)((ULONG_PTR
)MiniPortEndpoint
-
2187 sizeof(USBPORT_ENDPOINT
));
2189 USBPORT_InvalidateEndpointHandler(FdoDevice
,
2191 INVALIDATE_ENDPOINT_ONLY
);
2198 USBPORT_CompleteTransfer(IN PURB Urb
,
2199 IN USBD_STATUS TransferStatus
)
2201 struct _URB_CONTROL_TRANSFER
*UrbTransfer
;
2202 PUSBPORT_TRANSFER Transfer
;
2207 BOOLEAN WriteToDevice
;
2208 BOOLEAN IsFlushSuccess
;
2210 ULONG_PTR CurrentVa
;
2211 SIZE_T TransferLength
;
2212 PUSBPORT_ENDPOINT Endpoint
;
2213 PDEVICE_OBJECT FdoDevice
;
2214 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2215 PDMA_OPERATIONS DmaOperations
;
2217 DPRINT("USBPORT_CompleteTransfer: Urb - %p, TransferStatus - %X\n",
2221 UrbTransfer
= &Urb
->UrbControlTransfer
;
2222 Transfer
= UrbTransfer
->hca
.Reserved8
[0];
2224 Transfer
->USBDStatus
= TransferStatus
;
2225 Status
= USBPORT_USBDStatusToNtStatus(Urb
, TransferStatus
);
2227 UrbTransfer
->TransferBufferLength
= Transfer
->CompletedTransferLen
;
2229 if (Transfer
->Flags
& TRANSFER_FLAG_DMA_MAPPED
)
2231 Endpoint
= Transfer
->Endpoint
;
2232 FdoDevice
= Endpoint
->FdoDevice
;
2233 FdoExtension
= FdoDevice
->DeviceExtension
;
2234 DmaOperations
= FdoExtension
->DmaAdapter
->DmaOperations
;
2236 WriteToDevice
= Transfer
->Direction
== USBPORT_DMA_DIRECTION_TO_DEVICE
;
2237 Mdl
= UrbTransfer
->TransferBufferMDL
;
2238 CurrentVa
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2239 TransferLength
= UrbTransfer
->TransferBufferLength
;
2241 IsFlushSuccess
= DmaOperations
->FlushAdapterBuffers(FdoExtension
->DmaAdapter
,
2243 Transfer
->MapRegisterBase
,
2248 if (!IsFlushSuccess
)
2250 DPRINT("USBPORT_CompleteTransfer: no FlushAdapterBuffers !!!\n");
2254 KeRaiseIrql(DISPATCH_LEVEL
, &OldIrql
);
2256 DmaOperations
->FreeMapRegisters(FdoExtension
->DmaAdapter
,
2257 Transfer
->MapRegisterBase
,
2258 Transfer
->NumberOfMapRegisters
);
2260 KeLowerIrql(OldIrql
);
2263 if (Urb
->UrbHeader
.UsbdFlags
& USBD_FLAG_ALLOCATED_MDL
)
2265 IoFreeMdl(Transfer
->TransferBufferMDL
);
2266 Urb
->UrbHeader
.UsbdFlags
|= ~USBD_FLAG_ALLOCATED_MDL
;
2269 Urb
->UrbControlTransfer
.hca
.Reserved8
[0] = NULL
;
2270 Urb
->UrbHeader
.UsbdFlags
|= ~USBD_FLAG_ALLOCATED_TRANSFER
;
2272 Irp
= Transfer
->Irp
;
2276 if (!NT_SUCCESS(Status
))
2279 DPRINT1("USBPORT_CompleteTransfer: Irp - %p complete with Status - %lx\n",
2283 USBPORT_DumpingURB(Urb
);
2286 Irp
->IoStatus
.Status
= Status
;
2287 Irp
->IoStatus
.Information
= 0;
2289 KeRaiseIrql(DISPATCH_LEVEL
, &OldIrql
);
2290 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2291 KeLowerIrql(OldIrql
);
2294 Event
= Transfer
->Event
;
2298 KeSetEvent(Event
, EVENT_INCREMENT
, FALSE
);
2301 ExFreePoolWithTag(Transfer
, USB_PORT_TAG
);
2303 DPRINT_CORE("USBPORT_CompleteTransfer: exit\n");
2306 IO_ALLOCATION_ACTION
2308 USBPORT_MapTransfer(IN PDEVICE_OBJECT FdoDevice
,
2310 IN PVOID MapRegisterBase
,
2313 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2314 PDMA_ADAPTER DmaAdapter
;
2315 PUSBPORT_TRANSFER Transfer
;
2317 PUSBPORT_ENDPOINT Endpoint
;
2319 ULONG_PTR CurrentVa
;
2320 PUSBPORT_SCATTER_GATHER_LIST sgList
;
2321 SIZE_T CurrentLength
;
2323 BOOLEAN WriteToDevice
;
2324 PHYSICAL_ADDRESS PhAddr
= {{0, 0}};
2325 PHYSICAL_ADDRESS PhAddress
= {{0, 0}};
2326 ULONG TransferLength
;
2327 SIZE_T SgCurrentLength
;
2328 SIZE_T ElementLength
;
2329 PUSBPORT_DEVICE_HANDLE DeviceHandle
;
2330 PDMA_OPERATIONS DmaOperations
;
2331 USBD_STATUS USBDStatus
;
2333 PUSBPORT_TRANSFER transfer
;
2335 DPRINT_CORE("USBPORT_MapTransfer: ...\n");
2337 FdoExtension
= FdoDevice
->DeviceExtension
;
2338 DmaAdapter
= FdoExtension
->DmaAdapter
;
2339 DmaOperations
= DmaAdapter
->DmaOperations
;
2343 Urb
= Transfer
->Urb
;
2344 Endpoint
= Transfer
->Endpoint
;
2345 TransferLength
= Transfer
->TransferParameters
.TransferBufferLength
;
2347 Mdl
= Urb
->UrbControlTransfer
.TransferBufferMDL
;
2348 CurrentVa
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2350 sgList
= &Transfer
->SgList
;
2353 sgList
->CurrentVa
= CurrentVa
;
2354 sgList
->MappedSystemVa
= MmGetSystemAddressForMdlSafe(Mdl
,
2355 NormalPagePriority
);
2356 Transfer
->MapRegisterBase
= MapRegisterBase
;
2363 WriteToDevice
= Transfer
->Direction
== USBPORT_DMA_DIRECTION_TO_DEVICE
;
2364 ASSERT(Transfer
->Direction
!= 0);
2366 PhAddress
= DmaOperations
->MapTransfer(DmaAdapter
,
2373 DPRINT_CORE("USBPORT_MapTransfer: PhAddress.LowPart - %p, PhAddress.HighPart - %x, TransferLength - %x\n",
2378 PhAddress
.HighPart
= 0;
2379 SgCurrentLength
= TransferLength
;
2383 ElementLength
= PAGE_SIZE
- (PhAddress
.LowPart
& (PAGE_SIZE
- 1));
2385 if (ElementLength
> SgCurrentLength
)
2386 ElementLength
= SgCurrentLength
;
2388 DPRINT_CORE("USBPORT_MapTransfer: PhAddress.LowPart - %p, HighPart - %x, ElementLength - %x\n",
2393 sgList
->SgElement
[ix
].SgPhysicalAddress
= PhAddress
;
2394 sgList
->SgElement
[ix
].SgTransferLength
= ElementLength
;
2395 sgList
->SgElement
[ix
].SgOffset
= CurrentLength
+
2396 (TransferLength
- SgCurrentLength
);
2398 PhAddress
.LowPart
+= ElementLength
;
2399 SgCurrentLength
-= ElementLength
;
2403 while (SgCurrentLength
);
2405 if (PhAddr
.QuadPart
== PhAddress
.QuadPart
)
2407 DPRINT1("USBPORT_MapTransfer: PhAddr == PhAddress\n");
2413 CurrentLength
+= TransferLength
;
2414 CurrentVa
+= TransferLength
;
2416 TransferLength
= Transfer
->TransferParameters
.TransferBufferLength
-
2419 while (CurrentLength
!= Transfer
->TransferParameters
.TransferBufferLength
);
2421 sgList
->SgElementCount
= ix
;
2423 if (Endpoint
->EndpointProperties
.DeviceSpeed
== UsbHighSpeed
)
2425 Transfer
->Flags
|= TRANSFER_FLAG_HIGH_SPEED
;
2428 Transfer
->Flags
|= TRANSFER_FLAG_DMA_MAPPED
;
2430 if ((Transfer
->Flags
& TRANSFER_FLAG_ISO
) == 0)
2432 KeAcquireSpinLock(&Endpoint
->EndpointSpinLock
,
2433 &Endpoint
->EndpointOldIrql
);
2435 USBPORT_SplitTransfer(FdoDevice
, Endpoint
, Transfer
, &List
);
2437 while (!IsListEmpty(&List
))
2439 transfer
= CONTAINING_RECORD(List
.Flink
,
2443 RemoveHeadList(&List
);
2444 InsertTailList(&Endpoint
->TransferList
, &transfer
->TransferLink
);
2447 KeReleaseSpinLock(&Endpoint
->EndpointSpinLock
,
2448 Endpoint
->EndpointOldIrql
);
2452 USBDStatus
= USBPORT_InitializeIsoTransfer(FdoDevice
,
2453 &Urb
->UrbIsochronousTransfer
,
2456 if (USBDStatus
!= USBD_STATUS_SUCCESS
)
2458 KeAcquireSpinLock(&Endpoint
->EndpointSpinLock
,
2459 &Endpoint
->EndpointOldIrql
);
2461 USBPORT_QueueDoneTransfer(Transfer
, USBDStatus
);
2463 KeReleaseSpinLock(&Endpoint
->EndpointSpinLock
,
2464 Endpoint
->EndpointOldIrql
);
2468 DeviceHandle
= Urb
->UrbHeader
.UsbdDeviceHandle
;
2469 InterlockedDecrement(&DeviceHandle
->DeviceHandleLock
);
2471 if (USBPORT_EndpointWorker(Endpoint
, 0))
2473 USBPORT_InvalidateEndpointHandler(FdoDevice
,
2475 INVALIDATE_ENDPOINT_WORKER_THREAD
);
2478 return DeallocateObjectKeepRegisters
;
2483 USBPORT_FlushMapTransfers(IN PDEVICE_OBJECT FdoDevice
)
2485 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2486 PLIST_ENTRY MapTransferList
;
2487 PUSBPORT_TRANSFER Transfer
;
2488 ULONG NumMapRegisters
;
2490 SIZE_T TransferBufferLength
;
2491 ULONG_PTR VirtualAddr
;
2494 PDMA_OPERATIONS DmaOperations
;
2496 DPRINT_CORE("USBPORT_FlushMapTransfers: ...\n");
2498 FdoExtension
= FdoDevice
->DeviceExtension
;
2499 DmaOperations
= FdoExtension
->DmaAdapter
->DmaOperations
;
2501 KeRaiseIrql(DISPATCH_LEVEL
, &OldIrql
);
2505 MapTransferList
= &FdoExtension
->MapTransferList
;
2507 if (IsListEmpty(&FdoExtension
->MapTransferList
))
2509 KeLowerIrql(OldIrql
);
2513 Transfer
= CONTAINING_RECORD(MapTransferList
->Flink
,
2517 RemoveHeadList(MapTransferList
);
2519 Mdl
= Transfer
->Urb
->UrbControlTransfer
.TransferBufferMDL
;
2520 TransferBufferLength
= Transfer
->TransferParameters
.TransferBufferLength
;
2521 VirtualAddr
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2523 NumMapRegisters
= ADDRESS_AND_SIZE_TO_SPAN_PAGES(VirtualAddr
,
2524 TransferBufferLength
);
2526 Transfer
->NumberOfMapRegisters
= NumMapRegisters
;
2528 Status
= DmaOperations
->AllocateAdapterChannel(FdoExtension
->DmaAdapter
,
2531 USBPORT_MapTransfer
,
2534 if (!NT_SUCCESS(Status
))
2538 KeLowerIrql(OldIrql
);
2543 USBPORT_AllocateTransfer(IN PDEVICE_OBJECT FdoDevice
,
2545 IN PUSBPORT_DEVICE_HANDLE DeviceHandle
,
2549 PUSBPORT_DEVICE_EXTENSION FdoExtension
;
2550 SIZE_T TransferLength
;
2552 ULONG_PTR VirtualAddr
;
2553 ULONG PagesNeed
= 0;
2554 SIZE_T PortTransferLength
;
2555 SIZE_T FullTransferLength
;
2556 PUSBPORT_TRANSFER Transfer
;
2557 PUSBPORT_PIPE_HANDLE PipeHandle
;
2558 USBD_STATUS USBDStatus
;
2559 SIZE_T IsoBlockLen
= 0;
2561 DPRINT_CORE("USBPORT_AllocateTransfer: FdoDevice - %p, Urb - %p, DeviceHandle - %p, Irp - %p, Event - %p\n",
2568 FdoExtension
= FdoDevice
->DeviceExtension
;
2570 TransferLength
= Urb
->UrbControlTransfer
.TransferBufferLength
;
2571 PipeHandle
= Urb
->UrbControlTransfer
.PipeHandle
;
2575 Mdl
= Urb
->UrbControlTransfer
.TransferBufferMDL
;
2576 VirtualAddr
= (ULONG_PTR
)MmGetMdlVirtualAddress(Mdl
);
2578 PagesNeed
= ADDRESS_AND_SIZE_TO_SPAN_PAGES(VirtualAddr
,
2586 if (Urb
->UrbHeader
.Function
== URB_FUNCTION_ISOCH_TRANSFER
)
2588 DPRINT1("USBPORT_AllocateTransfer: ISOCH_TRANSFER UNIMPLEMENTED. FIXME\n");
2590 //IsoBlockLen = sizeof(USBPORT_ISO_BLOCK) +
2591 // Urb->UrbIsochronousTransfer.NumberOfPackets *
2592 // sizeof(USBPORT_ISO_BLOCK_PACKET);
2595 PortTransferLength
= sizeof(USBPORT_TRANSFER
) +
2596 PagesNeed
* sizeof(USBPORT_SCATTER_GATHER_ELEMENT
) +
2599 FullTransferLength
= PortTransferLength
+
2600 FdoExtension
->MiniPortInterface
->Packet
.MiniPortTransferSize
;
2602 Transfer
= ExAllocatePoolWithTag(NonPagedPool
,
2608 DPRINT1("USBPORT_AllocateTransfer: Transfer not allocated!\n");
2609 return USBD_STATUS_INSUFFICIENT_RESOURCES
;
2612 RtlZeroMemory(Transfer
, FullTransferLength
);
2614 Transfer
->Irp
= Irp
;
2615 Transfer
->Urb
= Urb
;
2616 Transfer
->Endpoint
= PipeHandle
->Endpoint
;
2617 Transfer
->Event
= Event
;
2618 Transfer
->PortTransferLength
= PortTransferLength
;
2619 Transfer
->FullTransferLength
= FullTransferLength
;
2620 Transfer
->IsoBlockPtr
= NULL
;
2621 Transfer
->Period
= 0;
2622 Transfer
->ParentTransfer
= Transfer
;
2626 Transfer
->IsoBlockPtr
= (PVOID
)((ULONG_PTR
)Transfer
+
2627 PortTransferLength
- IsoBlockLen
);
2629 Transfer
->Period
= PipeHandle
->Endpoint
->EndpointProperties
.Period
;
2630 Transfer
->Flags
|= TRANSFER_FLAG_ISO
;
2633 Transfer
->MiniportTransfer
= (PVOID
)((ULONG_PTR
)Transfer
+
2634 PortTransferLength
);
2636 KeInitializeSpinLock(&Transfer
->TransferSpinLock
);
2638 Urb
->UrbControlTransfer
.hca
.Reserved8
[0] = Transfer
;
2639 Urb
->UrbHeader
.UsbdFlags
|= USBD_FLAG_ALLOCATED_TRANSFER
;
2641 USBDStatus
= USBD_STATUS_SUCCESS
;
2643 DPRINT_CORE("USBPORT_AllocateTransfer: return USBDStatus - %x\n",
2651 USBPORT_Dispatch(IN PDEVICE_OBJECT DeviceObject
,
2654 PUSBPORT_COMMON_DEVICE_EXTENSION DeviceExtension
;
2655 PIO_STACK_LOCATION IoStack
;
2656 NTSTATUS Status
= STATUS_SUCCESS
;
2658 DeviceExtension
= DeviceObject
->DeviceExtension
;
2659 IoStack
= IoGetCurrentIrpStackLocation(Irp
);
2661 if (DeviceExtension
->PnpStateFlags
& USBPORT_PNP_STATE_FAILED
)
2663 DPRINT1("USBPORT_Dispatch: USBPORT_PNP_STATE_FAILED\n");
2667 switch (IoStack
->MajorFunction
)
2669 case IRP_MJ_DEVICE_CONTROL
:
2670 if (DeviceExtension
->IsPDO
)
2672 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2673 IoStack
->MajorFunction
,
2674 IoStack
->MinorFunction
);
2676 Status
= USBPORT_PdoDeviceControl(DeviceObject
, Irp
);
2680 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2681 IoStack
->MajorFunction
,
2682 IoStack
->MinorFunction
);
2684 Status
= USBPORT_FdoDeviceControl(DeviceObject
, Irp
);
2689 case IRP_MJ_INTERNAL_DEVICE_CONTROL
:
2690 if (DeviceExtension
->IsPDO
)
2692 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_INTERNAL_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2693 IoStack
->MajorFunction
,
2694 IoStack
->MinorFunction
);
2696 Status
= USBPORT_PdoInternalDeviceControl(DeviceObject
, Irp
);
2700 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_INTERNAL_DEVICE_CONTROL. Major - %d, Minor - %d\n",
2701 IoStack
->MajorFunction
,
2702 IoStack
->MinorFunction
);
2704 Status
= USBPORT_FdoInternalDeviceControl(DeviceObject
, Irp
);
2710 if (DeviceExtension
->IsPDO
)
2712 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_POWER. Major - %d, Minor - %d\n",
2713 IoStack
->MajorFunction
,
2714 IoStack
->MinorFunction
);
2716 Status
= USBPORT_PdoPower(DeviceObject
, Irp
);
2720 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_POWER. Major - %d, Minor - %d\n",
2721 IoStack
->MajorFunction
,
2722 IoStack
->MinorFunction
);
2724 Status
= USBPORT_FdoPower(DeviceObject
, Irp
);
2729 case IRP_MJ_SYSTEM_CONTROL
:
2730 if (DeviceExtension
->IsPDO
)
2732 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_SYSTEM_CONTROL. Major - %d, Minor - %d\n",
2733 IoStack
->MajorFunction
,
2734 IoStack
->MinorFunction
);
2736 Status
= Irp
->IoStatus
.Status
;
2737 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2741 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_SYSTEM_CONTROL. Major - %d, Minor - %d\n",
2742 IoStack
->MajorFunction
,
2743 IoStack
->MinorFunction
);
2745 IoSkipCurrentIrpStackLocation(Irp
);
2746 Status
= IoCallDriver(DeviceExtension
->LowerDevice
, Irp
);
2752 if (DeviceExtension
->IsPDO
)
2754 DPRINT("USBPORT_Dispatch: PDO IRP_MJ_PNP. Major - %d, Minor - %d\n",
2755 IoStack
->MajorFunction
,
2756 IoStack
->MinorFunction
);
2758 Status
= USBPORT_PdoPnP(DeviceObject
, Irp
);
2762 DPRINT("USBPORT_Dispatch: FDO IRP_MJ_PNP. Major - %d, Minor - %d\n",
2763 IoStack
->MajorFunction
,
2764 IoStack
->MinorFunction
);
2766 Status
= USBPORT_FdoPnP(DeviceObject
, Irp
);
2773 DPRINT("USBPORT_Dispatch: IRP_MJ_CREATE | IRP_MJ_CLOSE\n");
2774 Irp
->IoStatus
.Status
= Status
;
2775 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2779 if (DeviceExtension
->IsPDO
)
2781 DPRINT("USBPORT_Dispatch: PDO unhandled IRP_MJ_???. Major - %d, Minor - %d\n",
2782 IoStack
->MajorFunction
,
2783 IoStack
->MinorFunction
);
2787 DPRINT("USBPORT_Dispatch: FDO unhandled IRP_MJ_???. Major - %d, Minor - %d\n",
2788 IoStack
->MajorFunction
,
2789 IoStack
->MinorFunction
);
2792 Status
= STATUS_INVALID_DEVICE_REQUEST
;
2793 Irp
->IoStatus
.Status
= Status
;
2794 IoCompleteRequest(Irp
, IO_NO_INCREMENT
);
2798 DPRINT("USBPORT_Dispatch: Status - %x\n", Status
);
2804 USBPORT_GetHciMn(VOID
)
2806 return USBPORT_HCI_MN
;
2811 USBPORT_RegisterUSBPortDriver(IN PDRIVER_OBJECT DriverObject
,
2813 IN PUSBPORT_REGISTRATION_PACKET RegPacket
)
2815 PUSBPORT_MINIPORT_INTERFACE MiniPortInterface
;
2817 DPRINT("USBPORT_RegisterUSBPortDriver: DriverObject - %p, Version - %p, RegPacket - %p\n",
2822 DPRINT("USBPORT_RegisterUSBPortDriver: sizeof(USBPORT_MINIPORT_INTERFACE) - %x\n",
2823 sizeof(USBPORT_MINIPORT_INTERFACE
));
2825 DPRINT("USBPORT_RegisterUSBPortDriver: sizeof(USBPORT_DEVICE_EXTENSION) - %x\n",
2826 sizeof(USBPORT_DEVICE_EXTENSION
));
2828 if (Version
< USB10_MINIPORT_INTERFACE_VERSION
)
2830 return STATUS_UNSUCCESSFUL
;
2833 if (!USBPORT_Initialized
)
2835 InitializeListHead(&USBPORT_MiniPortDrivers
);
2836 InitializeListHead(&USBPORT_USB1FdoList
);
2837 InitializeListHead(&USBPORT_USB2FdoList
);
2839 KeInitializeSpinLock(&USBPORT_SpinLock
);
2840 USBPORT_Initialized
= TRUE
;
2843 MiniPortInterface
= ExAllocatePoolWithTag(NonPagedPool
,
2844 sizeof(USBPORT_MINIPORT_INTERFACE
),
2846 if (!MiniPortInterface
)
2848 return STATUS_INSUFFICIENT_RESOURCES
;
2851 RtlZeroMemory(MiniPortInterface
, sizeof(USBPORT_MINIPORT_INTERFACE
));
2853 MiniPortInterface
->DriverObject
= DriverObject
;
2854 MiniPortInterface
->DriverUnload
= DriverObject
->DriverUnload
;
2855 MiniPortInterface
->Version
= Version
;
2857 ExInterlockedInsertTailList(&USBPORT_MiniPortDrivers
,
2858 &MiniPortInterface
->DriverLink
,
2861 DriverObject
->DriverExtension
->AddDevice
= USBPORT_AddDevice
;
2862 DriverObject
->DriverUnload
= USBPORT_Unload
;
2864 DriverObject
->MajorFunction
[IRP_MJ_CREATE
] = USBPORT_Dispatch
;
2865 DriverObject
->MajorFunction
[IRP_MJ_CLOSE
] = USBPORT_Dispatch
;
2866 DriverObject
->MajorFunction
[IRP_MJ_DEVICE_CONTROL
] = USBPORT_Dispatch
;
2867 DriverObject
->MajorFunction
[IRP_MJ_INTERNAL_DEVICE_CONTROL
] = USBPORT_Dispatch
;
2868 DriverObject
->MajorFunction
[IRP_MJ_PNP
] = USBPORT_Dispatch
;
2869 DriverObject
->MajorFunction
[IRP_MJ_POWER
] = USBPORT_Dispatch
;
2870 DriverObject
->MajorFunction
[IRP_MJ_SYSTEM_CONTROL
] = USBPORT_Dispatch
;
2872 RegPacket
->UsbPortDbgPrint
= USBPORT_DbgPrint
;
2873 RegPacket
->UsbPortTestDebugBreak
= USBPORT_TestDebugBreak
;
2874 RegPacket
->UsbPortAssertFailure
= USBPORT_AssertFailure
;
2875 RegPacket
->UsbPortGetMiniportRegistryKeyValue
= USBPORT_GetMiniportRegistryKeyValue
;
2876 RegPacket
->UsbPortInvalidateRootHub
= USBPORT_InvalidateRootHub
;
2877 RegPacket
->UsbPortInvalidateEndpoint
= USBPORT_InvalidateEndpoint
;
2878 RegPacket
->UsbPortCompleteTransfer
= USBPORT_MiniportCompleteTransfer
;
2879 RegPacket
->UsbPortCompleteIsoTransfer
= USBPORT_CompleteIsoTransfer
;
2880 RegPacket
->UsbPortLogEntry
= USBPORT_LogEntry
;
2881 RegPacket
->UsbPortGetMappedVirtualAddress
= USBPORT_GetMappedVirtualAddress
;
2882 RegPacket
->UsbPortRequestAsyncCallback
= USBPORT_RequestAsyncCallback
;
2883 RegPacket
->UsbPortReadWriteConfigSpace
= USBPORT_ReadWriteConfigSpace
;
2884 RegPacket
->UsbPortWait
= USBPORT_Wait
;
2885 RegPacket
->UsbPortInvalidateController
= USBPORT_InvalidateController
;
2886 RegPacket
->UsbPortBugCheck
= USBPORT_BugCheck
;
2887 RegPacket
->UsbPortNotifyDoubleBuffer
= USBPORT_NotifyDoubleBuffer
;
2889 RtlCopyMemory(&MiniPortInterface
->Packet
,
2891 sizeof(USBPORT_REGISTRATION_PACKET
));
2893 return STATUS_SUCCESS
;
2898 DriverEntry(IN PDRIVER_OBJECT DriverObject
,
2899 IN PUNICODE_STRING RegistryPath
)
2901 return STATUS_SUCCESS
;