8 Jan
2010
8 Jan
'10
9:34 a.m.
Author: mjmartin
Date: Fri Jan 8 10:34:36 2010
New Revision: 44993
URL: http://svn.reactos.org/svn/reactos?rev=44993&view=rev
Log:
[usb/usbehci]
- Initial implementation of usbehci, aka USB 2.0.
- Implement AddDevice, StartDevice, InterruptService and DPC Routines.
- Implement basic IRP queuing and handling.
- Implement starting, stopping of EHCI controller and querying port capabilities.
- Implement PNP for Query Relations, Query ID, Query BusInfo.
- Implement finding the active ports when USB devices are attached and releasing control
to companion controller if devices is not a high speed devices.
- Implement reporting devices connects to upper Pdo (hub) driver.
- Hub driver attaches successfully and sends URBs to query descriptors from USB devices on
Windows.
- Currently not build enabled as it will cause problems with current UsbDriver in trunk.
- Code heavily based on current PCI drivers and UsbDriver from trunk.
Added:
trunk/reactos/drivers/usb/usbehci/ (with props)
trunk/reactos/drivers/usb/usbehci/common.c (with props)
trunk/reactos/drivers/usb/usbehci/fdo.c (with props)
trunk/reactos/drivers/usb/usbehci/misc.c (with props)
trunk/reactos/drivers/usb/usbehci/pdo.c (with props)
trunk/reactos/drivers/usb/usbehci/usbehci.c (with props)
trunk/reactos/drivers/usb/usbehci/usbehci.h (with props)
trunk/reactos/drivers/usb/usbehci/usbehci.rbuild (with props)
trunk/reactos/drivers/usb/usbehci/usbehci.rc (with props)
Propchange: trunk/reactos/drivers/usb/usbehci/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Fri Jan 8 10:34:36 2010
@@ -1,0 +1,7 @@
+GNUmakefile
+*.vcproj
+*.user
+*.cbp
+*.ncb
+*.suo
+*.sln
Added: trunk/reactos/drivers/usb/usbehci/common.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/common…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/common.c (added)
+++ trunk/reactos/drivers/usb/usbehci/common.c [iso-8859-1] Fri Jan 8 10:34:36 2010
@@ -1,0 +1,147 @@
+
+#define INITGUID
+#include "usbehci.h"
+#include <wdmguid.h>
+#include <stdio.h>
+#define NDEBUG
+#include <debug.h>
+
+/* PUBLIC AND PRIVATE FUNCTIONS ***********************************************/
+
+NTSTATUS NTAPI
+GetBusInterface(PDEVICE_OBJECT DeviceObject, PBUS_INTERFACE_STANDARD busInterface)
+{
+ KEVENT Event;
+ NTSTATUS Status;
+ PIRP Irp;
+ IO_STATUS_BLOCK IoStatus;
+ PIO_STACK_LOCATION Stack;
+
+ if ((!DeviceObject) || (!busInterface))
+ return STATUS_UNSUCCESSFUL;
+
+ KeInitializeEvent(&Event, NotificationEvent, FALSE);
+
+ Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
+ DeviceObject,
+ NULL,
+ 0,
+ NULL,
+ &Event,
+ &IoStatus);
+
+ if (Irp == NULL)
+ {
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ Stack=IoGetNextIrpStackLocation(Irp);
+ Stack->MajorFunction = IRP_MJ_PNP;
+ Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
+ Stack->Parameters.QueryInterface.Size = sizeof(BUS_INTERFACE_STANDARD);
+ Stack->Parameters.QueryInterface.InterfaceType =
(LPGUID)&GUID_BUS_INTERFACE_STANDARD;
+ Stack->Parameters.QueryInterface.Version = 1;
+ Stack->Parameters.QueryInterface.Interface = (PINTERFACE)busInterface;
+ Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
+ Irp->IoStatus.Status=STATUS_NOT_SUPPORTED ;
+
+ Status=IoCallDriver(DeviceObject, Irp);
+
+ if (Status == STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+
+ Status=IoStatus.Status;
+ }
+
+ return Status;
+}
+
+NTSTATUS NTAPI
+ForwardAndWaitCompletionRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp, PKEVENT Event)
+{
+ if (Irp->PendingReturned)
+ {
+ KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
+ }
+ return STATUS_MORE_PROCESSING_REQUIRED;
+}
+
+NTSTATUS NTAPI
+ForwardAndWait(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ PFDO_DEVICE_EXTENSION DeviceExtensions;
+ KEVENT Event;
+ NTSTATUS Status;
+
+
+ DeviceExtensions = DeviceObject->DeviceExtension;
+ KeInitializeEvent(&Event, NotificationEvent, FALSE);
+ IoCopyCurrentIrpStackLocationToNext(Irp);
+ IoSetCompletionRoutine(Irp, (PIO_COMPLETION_ROUTINE)ForwardAndWaitCompletionRoutine,
&Event, TRUE, TRUE, TRUE);
+ Status = IoCallDriver(DeviceExtensions->LowerDevice, Irp);
+ if (Status == STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+ Status = Irp->IoStatus.Status;
+ }
+
+ return Status;
+}
+
+NTSTATUS NTAPI
+ForwardIrpAndForget(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ PDEVICE_OBJECT LowerDevice;
+
+ LowerDevice =
((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice;
+DPRINT1("DeviceObject %x, LowerDevice %x\n", DeviceObject, LowerDevice);
+ ASSERT(LowerDevice);
+
+ IoSkipCurrentIrpStackLocation(Irp);
+ return IoCallDriver(LowerDevice, Irp);
+}
+
+/* Copied fom trunk PCI drivers */
+NTSTATUS
+DuplicateUnicodeString(ULONG Flags, PCUNICODE_STRING SourceString, PUNICODE_STRING
DestinationString)
+{
+ if (SourceString == NULL || DestinationString == NULL
+ || SourceString->Length > SourceString->MaximumLength
+ || (SourceString->Length == 0 && SourceString->MaximumLength > 0
&& SourceString->Buffer == NULL)
+ || Flags == RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING || Flags >= 4)
+ {
+ return STATUS_INVALID_PARAMETER;
+ }
+
+
+ if ((SourceString->Length == 0)
+ && (Flags != (RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE |
+ RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING)))
+ {
+ DestinationString->Length = 0;
+ DestinationString->MaximumLength = 0;
+ DestinationString->Buffer = NULL;
+ }
+ else
+ {
+ USHORT DestMaxLength = SourceString->Length;
+
+ if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
+ DestMaxLength += sizeof(UNICODE_NULL);
+
+ DestinationString->Buffer = ExAllocatePool(PagedPool, DestMaxLength);
+ if (DestinationString->Buffer == NULL)
+ return STATUS_NO_MEMORY;
+
+ RtlCopyMemory(DestinationString->Buffer, SourceString->Buffer,
SourceString->Length);
+ DestinationString->Length = SourceString->Length;
+ DestinationString->MaximumLength = DestMaxLength;
+
+ if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
+ DestinationString->Buffer[DestinationString->Length / sizeof(WCHAR)] =
0;
+ }
+
+ return STATUS_SUCCESS;
+}
+
Propchange: trunk/reactos/drivers/usb/usbehci/common.c
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/drivers/usb/usbehci/fdo.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/fdo.c?…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/fdo.c (added)
+++ trunk/reactos/drivers/usb/usbehci/fdo.c [iso-8859-1] Fri Jan 8 10:34:36 2010
@@ -1,0 +1,819 @@
+
+/* INCLUDES *******************************************************************/
+#include "usbehci.h"
+#include <stdio.h>
+//#include "ntstrsafe.h"
+
+VOID NTAPI
+EhciDefferedRoutine(PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID
SystemArgument2)
+{
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ ULONG CStatus;
+
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION) DeferredContext;
+
+ CStatus = (ULONG) SystemArgument2;
+
+ /* Port Change */
+ if (CStatus & EHCI_STS_PCD)
+ {
+ LONG i;
+ ULONG tmp;
+ ULONG Base;
+
+ Base = (ULONG)FdoDeviceExtension->ResourceMemory;
+
+ /* Loop through the ports */
+ for (i = 0; i < FdoDeviceExtension->ECHICaps.HCSParams.PortCount; i++)
+ {
+ tmp = READ_REGISTER_ULONG((PULONG) ((Base + EHCI_PORTSC) + (4 * i)));
+
+ /* Check for port change on this port */
+ if (tmp & 0x02)
+ {
+ PIO_WORKITEM WorkItem = NULL;
+
+ /* Connect or Disconnect? */
+ if (tmp & 0x01)
+ {
+ DPRINT1("Device connected on port %d\n", i);
+
+ /* Check if a companion host controller exists */
+ if (FdoDeviceExtension->ECHICaps.HCSParams.CHCCount)
+ {
+ tmp = READ_REGISTER_ULONG((PULONG)((Base + EHCI_PORTSC) + (4 *
i)));
+
+ /* Port should be in disabled state, as per USB 2.0 specs */
+ if (tmp & 0x04)
+ {
+ DPRINT1("Warning: The port the device has just connected
to is not disabled!\n");
+ }
+
+ /* Is this non high speed device */
+ if (tmp & 0x400)
+ {
+ DPRINT1("Releasing ownership to companion host
controller!\n");
+ /* Release ownership to companion host controller */
+ WRITE_REGISTER_ULONG((PULONG) ((Base + EHCI_PORTSC) + (4 *
i)), 0x4000);
+ }
+ }
+
+ KeStallExecutionProcessor(30);
+ DPRINT("port tmp %x\n", tmp);
+
+ /* As per USB 2.0 Specs, 9.1.2. Reset the port and clear the status
change */
+ tmp |= 0x100 | 0x02;
+ /* Sanity, Disable port */
+ tmp &= ~0x04;
+
+ WRITE_REGISTER_ULONG((PULONG) ((Base + EHCI_PORTSC) + (4 * i)),
tmp);
+
+ KeStallExecutionProcessor(20);
+
+ tmp = READ_REGISTER_ULONG((PULONG)((Base + EHCI_PORTSC) + (4 * i)));
+
+ DPRINT("port tmp %x\n", tmp);
+
+ FdoDeviceExtension->ChildDeviceCount++;
+ CompletePendingRequest(FdoDeviceExtension);
+
+ WorkItem = IoAllocateWorkItem(FdoDeviceExtension->Pdo);
+
+ if (!WorkItem)
+ {
+ DPRINT1("WorkItem allocation failed!\n");
+ }
+
+ IoQueueWorkItem(WorkItem,
+ (PIO_WORKITEM_ROUTINE)DeviceArrivalWorkItem,
+ DelayedWorkQueue,
+ FdoDeviceExtension);
+ }
+ else
+ {
+ DPRINT1("Device disconnected on port %d\n", i);
+
+ /* Clear status change */
+ tmp = READ_REGISTER_ULONG((PULONG)((Base + EHCI_PORTSC) + (4 * i)));
+ tmp |= 0x02;
+ WRITE_REGISTER_ULONG((PULONG) ((Base + EHCI_PORTSC) + (4 * i)),
tmp);
+ }
+
+ }
+ }
+ }
+}
+
+BOOLEAN NTAPI
+InterruptService(PKINTERRUPT Interrupt, PVOID ServiceContext)
+{
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT) ServiceContext;
+ ULONG CurrentFrame;
+ ULONG Base;
+ ULONG CStatus = 0;
+
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
+
+ Base = (ULONG)FdoDeviceExtension->ResourceMemory;
+
+ /* Read device status */
+ CStatus = READ_REGISTER_ULONG ((PULONG) (Base + EHCI_USBSTS));
+ CurrentFrame = READ_REGISTER_ULONG((PULONG) (Base + EHCI_FRINDEX));
+
+ CStatus &= (EHCI_ERROR_INT | EHCI_STS_INT | EHCI_STS_IAA | EHCI_STS_PCD |
EHCI_STS_FLR);
+
+ if ((!CStatus) || (FdoDeviceExtension->DeviceState == 0))
+ {
+ /* This interrupt isnt for us or not ready for it. */
+ return FALSE;
+ }
+
+ /* Clear status */
+ WRITE_REGISTER_ULONG((PULONG) (Base + EHCI_USBSTS), CStatus);
+
+ if (CStatus & EHCI_ERROR_INT)
+ {
+ DPRINT1("EHCI Status=0x%x\n", CStatus);
+ }
+
+ if (CStatus & EHCI_STS_FATAL)
+ {
+ DPRINT1("EHCI: Host System Error. Possible PCI problems.\n");
+ ASSERT(FALSE);
+ }
+
+ if (CStatus & EHCI_STS_HALT)
+ {
+ DPRINT("EHCI: Host Controller unexpected halt.\n");
+ /* FIXME: Reset the controller */
+ }
+
+ if (CStatus & EHCI_STS_INT)
+ {
+ FdoDeviceExtension->AsyncComplete = TRUE;
+ }
+
+ KeInsertQueueDpc(&FdoDeviceExtension->DpcObject, FdoDeviceExtension,
(PVOID)CStatus);
+
+ return TRUE;
+}
+
+BOOLEAN
+ResetPort(PDEVICE_OBJECT DeviceObject)
+{
+
+ /*FIXME: Implement me */
+
+ return TRUE;
+}
+
+VOID
+StopEhci(PDEVICE_OBJECT DeviceObject)
+{
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PEHCI_USBCMD_CONTENT UsbCmd;
+ ULONG base;
+ LONG tmp;
+
+ DPRINT1("Stopping Ehci controller\n");
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+ base = (ULONG)FdoDeviceExtension->ResourceMemory;
+
+ WRITE_REGISTER_ULONG((PULONG) (base + EHCI_USBINTR), 0);
+
+ tmp = READ_REGISTER_ULONG((PULONG) (base + EHCI_USBCMD));
+ UsbCmd = (PEHCI_USBCMD_CONTENT) & tmp;
+ UsbCmd->Run = 0;
+ WRITE_REGISTER_ULONG((PULONG) (base + EHCI_USBCMD), tmp);
+}
+
+VOID
+StartEhci(PDEVICE_OBJECT DeviceObject)
+{
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PEHCI_USBCMD_CONTENT UsbCmd;
+ PEHCI_USBSTS_CONTEXT usbsts;
+ NTSTATUS Status;
+ LONG tmp;
+ LONG tmp2;
+ ULONG base;
+
+ DPRINT1("Starting Ehci controller\n");
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+ base = (ULONG)FdoDeviceExtension->ResourceMemory;
+
+ tmp = READ_REGISTER_ULONG ((PULONG)(base + EHCI_USBCMD));
+
+ /* Stop the device */
+ UsbCmd = (PEHCI_USBCMD_CONTENT) &tmp;
+ UsbCmd->Run = 0;
+ WRITE_REGISTER_ULONG ((PULONG)(base + EHCI_USBCMD), tmp);
+
+ /* Wait for the device to stop */
+ for (;;)
+ {
+ KeStallExecutionProcessor(10);
+ tmp = READ_REGISTER_ULONG((PULONG)(base + EHCI_USBSTS));
+ usbsts = (PEHCI_USBSTS_CONTEXT)&tmp;
+
+ if (usbsts->HCHalted)
+ {
+ break;
+ }
+ DPRINT("Waiting for Halt, USBSTS: %x\n", READ_REGISTER_ULONG
((PULONG)(base + EHCI_USBSTS)));
+ }
+
+ tmp = READ_REGISTER_ULONG ((PULONG)(base + EHCI_USBCMD));
+
+ /* Reset the device */
+ UsbCmd = (PEHCI_USBCMD_CONTENT) &tmp;
+ UsbCmd->HCReset = TRUE;
+ WRITE_REGISTER_ULONG ((PULONG)(base + EHCI_USBCMD), tmp);
+
+ /* Wait for the device to reset */
+ for (;;)
+ {
+ KeStallExecutionProcessor(10);
+ tmp = READ_REGISTER_ULONG((PULONG)(base + EHCI_USBCMD));
+ UsbCmd = (PEHCI_USBCMD_CONTENT)&tmp;
+
+ if (!UsbCmd->HCReset)
+ {
+ break;
+ }
+ DPRINT("Waiting for reset, USBCMD: %x\n", READ_REGISTER_ULONG
((PULONG)(base + EHCI_USBCMD)));
+ }
+
+ UsbCmd = (PEHCI_USBCMD_CONTENT) &tmp;
+
+ /* Disable Interrupts on the device */
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_USBINTR), 0);
+ /* Clear the Status */
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_USBSTS), 0x0000001f);
+
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_CTRLDSSEGMENT), 0);
+
+ /* Set the Periodic Frame List */
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_PERIODICLISTBASE),
FdoDeviceExtension->PeriodicFramListPhysAddr.LowPart);
+ /* Set the Async List Queue */
+ WRITE_REGISTER_ULONG((PULONG) (base + EHCI_ASYNCLISTBASE),
FdoDeviceExtension->AsyncListQueueHeadPtrPhysAddr.LowPart & ~(0x1f));
+
+ /* Set the ansync and periodic to disable */
+ UsbCmd->PeriodicEnable = 0;
+ UsbCmd->AsyncEnable = 0;
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_USBCMD), tmp);
+
+ /* Set the threshold */
+ UsbCmd->IntThreshold = 1;
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_USBCMD), tmp);
+
+ KeInitializeDpc(&FdoDeviceExtension->DpcObject,
+ EhciDefferedRoutine,
+ FdoDeviceExtension);
+
+ Status = IoConnectInterrupt(&FdoDeviceExtension->EhciInterrupt,
+ InterruptService,
+ FdoDeviceExtension->DeviceObject,
+ NULL,
+ FdoDeviceExtension->Vector,
+ FdoDeviceExtension->Irql,
+ FdoDeviceExtension->Irql,
+ FdoDeviceExtension->Mode,
+ FdoDeviceExtension->IrqShared,
+ FdoDeviceExtension->Affinity,
+ FALSE);
+
+ /* Turn back on interrupts */
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_USBINTR),
+ EHCI_USBINTR_ERR | EHCI_USBINTR_ASYNC | EHCI_USBINTR_HSERR
+ | EHCI_USBINTR_FLROVR | EHCI_USBINTR_PC);
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_USBINTR),
+ EHCI_USBINTR_INTE | EHCI_USBINTR_ERR | EHCI_USBINTR_ASYNC |
EHCI_USBINTR_HSERR
+ | EHCI_USBINTR_FLROVR | EHCI_USBINTR_PC);
+
+ //UsbCmd = (PEHCI_USBCMD_CONTENT) &tmp;
+
+ UsbCmd->Run = 1;
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_USBCMD), tmp);
+
+ /* Wait for the device to start */
+ for (;;)
+ {
+ KeStallExecutionProcessor(10);
+ tmp2 = READ_REGISTER_ULONG((PULONG)(base + EHCI_USBSTS));
+ usbsts = (PEHCI_USBSTS_CONTEXT)&tmp2;
+
+ if (!usbsts->HCHalted)
+ {
+ break;
+ }
+ DPRINT("Waiting for start, USBSTS: %x\n", READ_REGISTER_ULONG
((PULONG)(base + EHCI_USBSTS)));
+ }
+
+ /* Set all port routing to ECHI controller */
+ WRITE_REGISTER_ULONG((PULONG)(base + EHCI_CONFIGFLAG), 1);
+}
+
+VOID
+GetCapabilities(PFDO_DEVICE_EXTENSION DeviceExtension, ULONG Base)
+{
+ PEHCI_CAPS PCap;
+ PEHCI_HCS_CONTENT PHCS;
+ LONG i;
+
+ if (!DeviceExtension)
+ return;
+
+ PCap = &DeviceExtension->ECHICaps;
+
+ PCap->Length = READ_REGISTER_UCHAR((PUCHAR)Base);
+ PCap->Reserved = READ_REGISTER_UCHAR((PUCHAR)(Base + 1));
+ PCap->HCIVersion = READ_REGISTER_USHORT((PUSHORT)(Base + 2));
+ PCap->HCSParamsLong = READ_REGISTER_ULONG((PULONG)(Base + 4));
+ PCap->HCCParams = READ_REGISTER_ULONG((PULONG)(Base + 8));
+
+
+ DPRINT("Length %d\n", PCap->Length);
+ DPRINT("Reserved %d\n", PCap->Reserved);
+ DPRINT("HCIVersion %x\n", PCap->HCIVersion);
+ DPRINT("HCSParams %x\n", PCap->HCSParamsLong);
+ DPRINT("HCCParams %x\n", PCap->HCCParams);
+
+
+ if (PCap->HCCParams & 0x02)
+ DPRINT1("Frame list size is configurable\n");
+
+ if (PCap->HCCParams & 0x01)
+ DPRINT1("64bit address mode not supported!\n");
+
+ DPRINT1("Number of Ports: %d\n", PCap->HCSParams.PortCount);
+
+ if (PCap->HCSParams.PortPowerControl)
+ DPRINT1("Port Power Control is enabled\n");
+
+ if (!PCap->HCSParams.CHCCount)
+ {
+ DPRINT1("Number of Companion Host controllers %x\n",
PCap->HCSParams.CHCCount);
+ DPRINT1("Number of Ports Per CHC: %d\n",
PCap->HCSParams.PortPerCHC);
+ }
+
+ /* Copied from USBDRIVER in trunk */
+ PHCS = (PEHCI_HCS_CONTENT)&DeviceExtension->ECHICaps.HCSParams;
+ if (PHCS->PortRouteRules)
+ {
+ for (i = 0; i < 8; i++)
+ {
+ PCap->PortRoute[i] = READ_REGISTER_UCHAR((PUCHAR) (Base + 12 + i));
+ }
+ }
+}
+
+NTSTATUS
+StartDevice(PDEVICE_OBJECT DeviceObject, PCM_PARTIAL_RESOURCE_LIST raw,
PCM_PARTIAL_RESOURCE_LIST translated)
+{
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PCM_PARTIAL_RESOURCE_DESCRIPTOR resource;
+ DEVICE_DESCRIPTION DeviceDescription;
+ ULONG NumberResources;
+ ULONG iCount;
+ ULONG DeviceAddress;
+ ULONG PropertySize;
+ ULONG BusNumber;
+ NTSTATUS Status;
+
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+
+ RtlZeroMemory(&DeviceDescription, sizeof(DEVICE_DESCRIPTION));
+ DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
+ DeviceDescription.Master = TRUE;
+ DeviceDescription.ScatterGather = TRUE;
+ DeviceDescription.Dma32BitAddresses = TRUE;
+ DeviceDescription.DmaWidth = 2;
+ DeviceDescription.InterfaceType = PCIBus;
+ DeviceDescription.MaximumLength = EHCI_MAX_SIZE_TRANSFER;
+
+ FdoDeviceExtension->pDmaAdapter =
IoGetDmaAdapter(FdoDeviceExtension->LowerDevice,
+ &DeviceDescription,
+
&FdoDeviceExtension->MapRegisters);
+
+ if (FdoDeviceExtension->pDmaAdapter == NULL)
+ {
+ DPRINT1("IoGetDmaAdapter failed!\n");
+ ASSERT(FALSE);
+ }
+
+ /* Allocate Common Buffer for Periodic Frame List */
+ FdoDeviceExtension->PeriodicFramList =
+
FdoDeviceExtension->pDmaAdapter->DmaOperations->AllocateCommonBuffer(FdoDeviceExtension->pDmaAdapter,
+ sizeof(ULONG) * 1024, &FdoDeviceExtension->PeriodicFramListPhysAddr,
FALSE);
+
+ if (FdoDeviceExtension->PeriodicFramList == NULL)
+ {
+ DPRINT1("FdoDeviceExtension->PeriodicFramList is null\n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ /* Zeroize it */
+ RtlZeroMemory(FdoDeviceExtension->PeriodicFramList, sizeof(ULONG) * 1024);
+
+ /* Allocate Common Buffer for Async List Head Queue */
+ FdoDeviceExtension->AsyncListQueueHeadPtr =
+
FdoDeviceExtension->pDmaAdapter->DmaOperations->AllocateCommonBuffer(FdoDeviceExtension->pDmaAdapter,
+ /* FIXME: Memory Size should be calculated using
+ structures sizes needed for queue head + 20480 (max data transfer */
+ 20800,
+ &FdoDeviceExtension->AsyncListQueueHeadPtrPhysAddr, FALSE);
+
+ if (FdoDeviceExtension->AsyncListQueueHeadPtr == NULL)
+ {
+ DPRINT1("Failed to allocate common buffer for
AsyncListQueueHeadPtr!\n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ /* Zeroize it */
+ RtlZeroMemory(FdoDeviceExtension->AsyncListQueueHeadPtr,
+ /* FIXME: Same as FIXME above */
+ 20800);
+
+ Status = IoGetDeviceProperty(FdoDeviceExtension->LowerDevice,
+ DevicePropertyAddress,
+ sizeof(ULONG),
+ &DeviceAddress,
+ &PropertySize);
+ if (NT_SUCCESS(Status))
+ {
+ DPRINT1("--->DeviceAddress: %x\n", DeviceAddress);
+ }
+
+ Status = IoGetDeviceProperty(FdoDeviceExtension->LowerDevice,
+ DevicePropertyBusNumber,
+ sizeof(ULONG),
+ &BusNumber,
+ &PropertySize);
+ if (NT_SUCCESS(Status))
+ {
+ DPRINT1("--->BusNumber: %x\n", BusNumber);
+ }
+
+ /* Get the resources the PNP Manager gave */
+ NumberResources = translated->Count;
+ DPRINT("NumberResources %d\n", NumberResources);
+ for (iCount = 0; iCount < NumberResources; iCount++)
+ {
+ DPRINT("Resource Info %d:\n", iCount);
+ resource = &translated->PartialDescriptors[iCount];
+ switch(resource->Type)
+ {
+ case CmResourceTypePort:
+ {
+ DPRINT("Port Start: %x\n", resource->u.Port.Start);
+ DPRINT("Port Length %d\n", resource->u.Port.Length);
+ /* FIXME: Handle Ports */
+ break;
+ }
+ case CmResourceTypeInterrupt:
+ {
+ DPRINT("Interrupt Vector: %x\n",
resource->u.Interrupt.Vector);
+ FdoDeviceExtension->Vector = resource->u.Interrupt.Vector;
+ FdoDeviceExtension->Irql = resource->u.Interrupt.Level;
+ FdoDeviceExtension->Affinity = resource->u.Interrupt.Affinity;
+ FdoDeviceExtension->Mode = (resource->Flags ==
CM_RESOURCE_INTERRUPT_LATCHED) ? Latched : LevelSensitive;
+ FdoDeviceExtension->IrqShared = resource->ShareDisposition ==
CmResourceShareShared;
+ break;
+ }
+ case CmResourceTypeMemory:
+ {
+ ULONG ResourceBase = 0;
+ ULONG MemLength;
+
+ DPRINT("Mem Start: %x\n", resource->u.Memory.Start);
+ DPRINT("Mem Length: %d\n", resource->u.Memory.Length);
+
+ ResourceBase = (ULONG) MmMapIoSpace(resource->u.Memory.Start,
resource->u.Memory.Length, FALSE);
+ DPRINT("ResourceBase %x\n", ResourceBase);
+
+ FdoDeviceExtension->ResourceBase = (PULONG) ResourceBase;
+ GetCapabilities(FdoDeviceExtension, (ULONG)ResourceBase);
+ FdoDeviceExtension->ResourceMemory = (PULONG)((ULONG)ResourceBase +
FdoDeviceExtension->ECHICaps.Length);
+ DPRINT("ResourceMemory %x\n",
FdoDeviceExtension->ResourceMemory);
+ if (FdoDeviceExtension->ResourceBase == NULL)
+ {
+ DPRINT1("MmMapIoSpace failed!!!!!!!!!\n");
+ }
+ MemLength = resource->u.Memory.Length;
+ FdoDeviceExtension->Size = MemLength;
+
+ break;
+ }
+ case CmResourceTypeDma:
+ {
+ DPRINT("Dma Channel: %x\n", resource->u.Dma.Channel);
+ DPRINT("Dma Port: %d\n", resource->u.Dma.Port);
+ break;
+ }
+ default:
+ {
+ DPRINT1("PNP Manager gave invalid resource type!! Notify
Developers!\n");
+ ASSERT(FALSE);
+ break;
+ }
+ }
+ }
+
+ StartEhci(DeviceObject);
+ FdoDeviceExtension->DeviceState = DEVICESTARTED;
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+FdoQueryBusRelations(
+ PDEVICE_OBJECT DeviceObject,
+ PDEVICE_RELATIONS* pDeviceRelations)
+{
+ PFDO_DEVICE_EXTENSION DeviceExtension;
+ PDEVICE_RELATIONS DeviceRelations = NULL;
+ PDEVICE_OBJECT Pdo;
+ PPDO_DEVICE_EXTENSION PdoDeviceExtension;
+ NTSTATUS Status;
+ ULONG UsbDeviceNumber = 0;
+ WCHAR CharDeviceName[64];
+ UNICODE_STRING DeviceName;
+
+ DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+ /* Create the PDO */
+ while (TRUE)
+ {
+ /* FIXME: Use safe string sprintf*/
+ /* RtlStringCchPrintfW(CharDeviceName, 64, L"USBFDO-%d",
UsbDeviceNumber); */
+ swprintf(CharDeviceName, L"\\Device\\USBPDO-%d", UsbDeviceNumber);
+ RtlInitUnicodeString(&DeviceName, CharDeviceName);
+ DPRINT("DeviceName %wZ\n", &DeviceName);
+
+ Status = IoCreateDevice(DeviceObject->DriverObject,
+ sizeof(PDO_DEVICE_EXTENSION),
+ &DeviceName,
+ FILE_DEVICE_BUS_EXTENDER,
+ 0,
+ FALSE,
+ &Pdo);
+
+ if (NT_SUCCESS(Status))
+ break;
+
+ if ((Status == STATUS_OBJECT_NAME_EXISTS) || (Status ==
STATUS_OBJECT_NAME_COLLISION))
+ {
+ /* Try the next name */
+ UsbDeviceNumber++;
+ continue;
+ }
+
+ /* Bail on any other error */
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("UsbEhci: Failed to create PDO %wZ, Status %x\n",
&DeviceName, Status);
+ return Status;
+ }
+ }
+
+ PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)Pdo->DeviceExtension;
+ RtlZeroMemory(PdoDeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
+ PdoDeviceExtension->Common.IsFdo = FALSE;
+
+ PdoDeviceExtension->ControllerFdo = DeviceObject;
+
+ Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
+ DeviceExtension->Pdo = Pdo;
+
+ /*swprintf(CharSymLinkName, L"\\Device\\HCD%d", UsbDeviceNumber);
+ RtlInitUnicodeString(&SymLinkName, CharSymLinkName);
+ Status = IoCreateSymbolicLink(&SymLinkName, &DeviceName);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Warning: Unable to create symbolic link for ehci usb
device!\n");
+ }*/
+
+ DeviceRelations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool,
sizeof(DEVICE_RELATIONS));
+ if (!DeviceRelations)
+ {
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ DeviceRelations->Count = 1;
+ DeviceRelations->Objects[0] = Pdo;
+ ObReferenceObject(Pdo);
+
+ *pDeviceRelations = DeviceRelations;
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS NTAPI
+FdoDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
+{
+ NTSTATUS Status;
+ PIO_STACK_LOCATION Stack = NULL;
+ PCM_PARTIAL_RESOURCE_LIST raw;
+ PCM_PARTIAL_RESOURCE_LIST translated;
+ ULONG_PTR Information = 0;
+
+ Stack = IoGetCurrentIrpStackLocation(Irp);
+
+ switch(Stack->MinorFunction)
+ {
+ case IRP_MN_START_DEVICE:
+ {
+ DPRINT("START_DEVICE\n");
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Status = ForwardAndWait(DeviceObject, Irp);
+
+ raw =
&Stack->Parameters.StartDevice.AllocatedResources->List[0].PartialResourceList;
+ translated =
&Stack->Parameters.StartDevice.AllocatedResourcesTranslated->List[0].PartialResourceList;
+ Status = StartDevice(DeviceObject, raw, translated);
+ break;
+ }
+ case IRP_MN_QUERY_DEVICE_RELATIONS:
+ {
+ DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS\n");
+ switch(Stack->Parameters.QueryDeviceRelations.Type)
+ {
+ case BusRelations:
+ {
+ PDEVICE_RELATIONS DeviceRelations = NULL;
+ DPRINT("BusRelations\n");
+ Status = FdoQueryBusRelations(DeviceObject, &DeviceRelations);
+ Information = (ULONG_PTR)DeviceRelations;
+ break;
+ }
+ default:
+ {
+ DPRINT("Unknown query device relations type\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ }
+ }
+ break;
+ }
+ case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
+ {
+ DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
+ return ForwardIrpAndForget(DeviceObject, Irp);
+ break;
+ }
+ case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
+ {
+ DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
+ }
+ default:
+ {
+ DPRINT1("IRP_MJ_PNP / Unhandled minor function 0x%lx\n",
Stack->MinorFunction);
+ return ForwardIrpAndForget(DeviceObject, Irp);
+ }
+ }
+
+ Irp->IoStatus.Information = Information;
+ Irp->IoStatus.Status = Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return Status;
+}
+
+NTSTATUS NTAPI
+AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT Pdo)
+{
+ NTSTATUS Status = STATUS_UNSUCCESSFUL;
+ PDEVICE_OBJECT Fdo;
+ ULONG UsbDeviceNumber = 0;
+ WCHAR CharDeviceName[64];
+ WCHAR CharSymLinkName[64];
+ UNICODE_STRING DeviceName;
+ UNICODE_STRING SymLinkName;
+ ULONG BytesRead;
+ PCI_COMMON_CONFIG PciConfig;
+
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+
+ DPRINT1("Ehci AddDevice\n");
+
+ /* Create the FDO */
+ while (TRUE)
+ {
+ /* FIXME: Use safe string sprintf*/
+ /* RtlStringCchPrintfW(CharDeviceName, 64, L"USBFDO-%d",
UsbDeviceNumber); */
+ swprintf(CharDeviceName, L"\\Device\\USBFDO-%d", UsbDeviceNumber);
+ RtlInitUnicodeString(&DeviceName, CharDeviceName);
+ DPRINT1("DeviceName %wZ\n", &DeviceName);
+
+ Status = IoCreateDevice(DriverObject,
+ sizeof(FDO_DEVICE_EXTENSION),
+ &DeviceName,
+ FILE_DEVICE_CONTROLLER,
+ 0,
+ FALSE,
+ &Fdo);
+
+ if (NT_SUCCESS(Status))
+ break;
+
+ if ((Status == STATUS_OBJECT_NAME_EXISTS) || (Status ==
STATUS_OBJECT_NAME_COLLISION))
+ {
+ /* Try the next name */
+ UsbDeviceNumber++;
+ continue;
+ }
+
+ /* Bail on any other error */
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("UsbEhci: Failed to create %wZ, Status %x\n",
&DeviceName, Status);
+ return Status;
+ }
+ }
+
+ swprintf(CharSymLinkName, L"\\Device\\HCD%d", UsbDeviceNumber);
+ RtlInitUnicodeString(&SymLinkName, CharSymLinkName);
+ Status = IoCreateSymbolicLink(&SymLinkName, &DeviceName);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Warning: Unable to create symbolic link for ehci usb
device!\n");
+ }
+
+ DPRINT("Attaching created device %x to %x\n", Fdo, Pdo);
+
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION) Fdo->DeviceExtension;
+ RtlZeroMemory(FdoDeviceExtension, sizeof(PFDO_DEVICE_EXTENSION));
+
+ InitializeListHead(&FdoDeviceExtension->IrpQueue);
+ KeInitializeSpinLock(&FdoDeviceExtension->IrpQueueLock);
+
+ FdoDeviceExtension->Common.IsFdo = TRUE;
+ FdoDeviceExtension->DeviceObject = Fdo;
+
+ FdoDeviceExtension->LowerDevice = IoAttachDeviceToDeviceStack(Fdo, Pdo);
+ if (FdoDeviceExtension->LowerDevice == NULL)
+ {
+ DPRINT1("UsbEhci: Failed to attach to device stack!\n");
+ IoDeleteSymbolicLink(&SymLinkName);
+ IoDeleteDevice(Fdo);
+
+ return STATUS_NO_SUCH_DEVICE;
+ }
+
+ Fdo->Flags |= DO_BUFFERED_IO | DO_POWER_PAGABLE;
+
+ DPRINT("Attached %x!\n", FdoDeviceExtension->LowerDevice);
+ ASSERT(FdoDeviceExtension->LowerDevice == Pdo);
+ Status = GetBusInterface(FdoDeviceExtension->LowerDevice,
&FdoDeviceExtension->BusInterface);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("GetBusInterface() failed with %x\n", Status);
+ IoDetachDevice(FdoDeviceExtension->LowerDevice);
+ IoDeleteSymbolicLink(&SymLinkName);
+ IoDeleteDevice(Fdo);
+ return Status;
+ }
+
+ DPRINT("Context %x\n", FdoDeviceExtension->BusInterface.Context);
+
+ BytesRead = (*FdoDeviceExtension->BusInterface.GetBusData)(
+ FdoDeviceExtension->BusInterface.Context,
+ PCI_WHICHSPACE_CONFIG,
+ &PciConfig,
+ 0,
+ PCI_COMMON_HDR_LENGTH);
+
+
+ if (BytesRead != PCI_COMMON_HDR_LENGTH)
+ {
+ DPRINT1("GetBusData failed!\n");
+ IoDetachDevice(FdoDeviceExtension->LowerDevice);
+ IoDeleteSymbolicLink(&SymLinkName);
+ IoDeleteDevice(Fdo);
+
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ if (PciConfig.Command & PCI_ENABLE_IO_SPACE)
+ DPRINT("PCI_ENABLE_IO_SPACE\n");
+
+ if (PciConfig.Command & PCI_ENABLE_MEMORY_SPACE)
+ DPRINT("PCI_ENABLE_MEMORY_SPACE\n");
+
+ if (PciConfig.Command & PCI_ENABLE_BUS_MASTER)
+ DPRINT("PCI_ENABLE_BUS_MASTER\n");
+
+ DPRINT("BaseAddress[0] %x\n", PciConfig.u.type0.BaseAddresses[0]);
+ DPRINT("Vendor %x\n", PciConfig.VendorID);
+ DPRINT("Device %x\n", PciConfig.DeviceID);
+
+ FdoDeviceExtension->VendorId = PciConfig.VendorID;
+ FdoDeviceExtension->DeviceId = PciConfig.DeviceID;
+
+ DPRINT("FdoDeviceExtension->NextLowerDevice %x\n",
FdoDeviceExtension->LowerDevice);
+ FdoDeviceExtension->DeviceState = DEVICEINTIALIZED;
+
+ Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
+
+ return STATUS_SUCCESS;
+}
Propchange: trunk/reactos/drivers/usb/usbehci/fdo.c
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/drivers/usb/usbehci/misc.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/misc.c…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/misc.c (added)
+++ trunk/reactos/drivers/usb/usbehci/misc.c [iso-8859-1] Fri Jan 8 10:34:36 2010
@@ -1,0 +1,232 @@
+
+#include "usbehci.h"
+
+VOID
+QueueRequest(PFDO_DEVICE_EXTENSION DeviceExtension, PIRP Irp)
+{
+ KIRQL oldIrql;
+
+ KeAcquireSpinLock(&DeviceExtension->IrpQueueLock, &oldIrql);
+ InsertTailList(&DeviceExtension->IrpQueue,
&Irp->Tail.Overlay.ListEntry);
+ KeReleaseSpinLock(&DeviceExtension->IrpQueueLock, oldIrql);
+}
+
+VOID
+CompletePendingRequest(PFDO_DEVICE_EXTENSION DeviceExtension)
+{
+ PLIST_ENTRY NextIrp = NULL;
+ PIO_STACK_LOCATION Stack;
+ KIRQL oldIrql;
+ PIRP Irp = NULL;
+ URB *Urb;
+
+ KeAcquireSpinLock(&DeviceExtension->IrpQueueLock, &oldIrql);
+
+ /* No Irps in Queue? */
+ if (IsListEmpty(&DeviceExtension->IrpQueue))
+ {
+ KeReleaseSpinLock(&DeviceExtension->IrpQueueLock, oldIrql);
+ return;
+ }
+
+ NextIrp = RemoveHeadList(&DeviceExtension->IrpQueue);
+ while(TRUE)
+ {
+ Irp = CONTAINING_RECORD(NextIrp, IRP, Tail.Overlay.ListEntry);
+
+ if (!Irp)
+ break;
+
+ /* FIXME: Handle cancels */
+ /*if (!IoSetCancelRoutine(Irp, NULL))
+ {
+
+ }*/
+
+
+ Stack = IoGetCurrentIrpStackLocation(Irp);
+
+ Urb = (PURB) Stack->Parameters.Others.Argument1;
+
+ ASSERT(Urb);
+
+ /* FIXME: Fill in information for Argument1/URB */
+
+ DPRINT("TransferBuffer %x\n",
Urb->UrbControlDescriptorRequest.TransferBuffer);
+ DPRINT("TransferBufferLength %x\n",
Urb->UrbControlDescriptorRequest.TransferBufferLength);
+ DPRINT("Index %x\n", Urb->UrbControlDescriptorRequest.Index);
+ DPRINT("DescriptorType %x\n",
Urb->UrbControlDescriptorRequest.DescriptorType);
+ DPRINT("LanguageId %x\n",
Urb->UrbControlDescriptorRequest.LanguageId);
+
+ KeReleaseSpinLock(&DeviceExtension->IrpQueueLock, oldIrql);
+
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = 0;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return;
+ }
+
+ KeReleaseSpinLock(&DeviceExtension->IrpQueueLock, oldIrql);
+}
+
+NTSTATUS
+NTAPI
+ArrivalNotificationCompletion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID PContext)
+{
+ IoFreeIrp(Irp);
+ return STATUS_MORE_PROCESSING_REQUIRED;
+}
+
+VOID
+DeviceArrivalWorkItem(PDEVICE_OBJECT DeviceObject, PVOID Context)
+{
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PIO_STACK_LOCATION IrpStack = NULL;
+ PDEVICE_OBJECT PortDeviceObject = NULL;
+ PIRP Irp = NULL;
+
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)Context;
+
+ PortDeviceObject = IoGetAttachedDeviceReference(FdoDeviceExtension->Pdo);
+
+ if (!PortDeviceObject)
+ {
+ DPRINT1("Unable to notify Pdos parent of device arrival.\n");
+ return;
+ }
+
+ Irp = IoAllocateIrp(PortDeviceObject->StackSize, FALSE);
+
+ if (!Irp)
+ {
+ DPRINT1("Unable to allocate IRP\n");
+ }
+
+ IoSetCompletionRoutine(Irp,
+ (PIO_COMPLETION_ROUTINE)ArrivalNotificationCompletion,
+ NULL,
+ TRUE,
+ TRUE,
+ TRUE);
+
+ IrpStack = IoGetNextIrpStackLocation(Irp);
+ IrpStack->Parameters.QueryDeviceRelations.Type = TargetDeviceRelation;
+ IrpStack->MajorFunction = IRP_MJ_PNP;
+ IrpStack->MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS;
+
+ IoCallDriver(PortDeviceObject, Irp);
+}
+
+/*
+ Get SymblicName from Parameters in Registry Key
+ Caller is responsible for freeing pool of returned pointer
+*/
+PWSTR
+GetSymbolicName(PDEVICE_OBJECT DeviceObject)
+{
+ NTSTATUS Status;
+ HANDLE DevInstRegKey;
+ UNICODE_STRING SymbolicName;
+ PKEY_VALUE_PARTIAL_INFORMATION KeyPartInfo;
+ ULONG SizeNeeded;
+ PWCHAR SymbolicNameString = NULL;
+
+ Status = IoOpenDeviceRegistryKey(DeviceObject,
+ PLUGPLAY_REGKEY_DEVICE,
+ STANDARD_RIGHTS_ALL,
+ &DevInstRegKey);
+
+ DPRINT("IoOpenDeviceRegistryKey PLUGPLAY_REGKEY_DEVICE Status %x\n",
Status);
+
+ if (NT_SUCCESS(Status))
+ {
+ RtlInitUnicodeString(&SymbolicName, L"SymbolicName");
+ Status = ZwQueryValueKey(DevInstRegKey,
+ &SymbolicName,
+ KeyValuePartialInformation,
+ NULL,
+ 0,
+ &SizeNeeded);
+
+ DPRINT("ZwQueryValueKey status %x, %d\n", Status, SizeNeeded);
+
+ if (Status == STATUS_BUFFER_TOO_SMALL)
+ {
+ KeyPartInfo = (PKEY_VALUE_PARTIAL_INFORMATION ) ExAllocatePool(PagedPool,
SizeNeeded);
+ if (!KeyPartInfo)
+ {
+ DPRINT1("OUT OF MEMORY\n");
+ return NULL;
+ }
+ else
+ {
+ Status = ZwQueryValueKey(DevInstRegKey,
+ &SymbolicName,
+ KeyValuePartialInformation,
+ KeyPartInfo,
+ SizeNeeded,
+ &SizeNeeded);
+
+ SymbolicNameString = ExAllocatePool(PagedPool,
(KeyPartInfo->DataLength + sizeof(WCHAR)));
+ if (!SymbolicNameString)
+ {
+ return NULL;
+ }
+ RtlZeroMemory(SymbolicNameString, KeyPartInfo->DataLength + 2);
+ RtlCopyMemory(SymbolicNameString, KeyPartInfo->Data,
KeyPartInfo->DataLength);
+ }
+
+ ExFreePool(KeyPartInfo);
+ }
+
+ ZwClose(DevInstRegKey);
+ }
+
+ return SymbolicNameString;
+}
+
+/*
+ Get Physical Device Object Name from registry
+ Caller is responsible for freeing pool
+*/
+PWSTR
+GetPhysicalDeviceObjectName(PDEVICE_OBJECT DeviceObject)
+{
+ NTSTATUS Status;
+ PWSTR ObjectName = NULL;
+ ULONG SizeNeeded;
+
+ Status = IoGetDeviceProperty(DeviceObject,
+ DevicePropertyPhysicalDeviceObjectName,
+ 0,
+ NULL,
+ &SizeNeeded);
+
+ if (Status != STATUS_BUFFER_TOO_SMALL)
+ {
+ DPRINT1("Expected STATUS_BUFFER_TOO_SMALL, got %x!\n", Status);
+ return NULL;
+ }
+
+ ObjectName = (PWSTR) ExAllocatePool(PagedPool, SizeNeeded + sizeof(WCHAR));
+ if (!ObjectName)
+ {
+ DPRINT1("Out of memory\n");
+ return NULL;
+ }
+
+ Status = IoGetDeviceProperty(DeviceObject,
+ DevicePropertyPhysicalDeviceObjectName,
+ SizeNeeded,
+ ObjectName,
+ &SizeNeeded);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed to Get Property\n");
+ return NULL;
+ }
+
+ return ObjectName;
+}
+
Propchange: trunk/reactos/drivers/usb/usbehci/misc.c
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/drivers/usb/usbehci/pdo.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/pdo.c?…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/pdo.c (added)
+++ trunk/reactos/drivers/usb/usbehci/pdo.c [iso-8859-1] Fri Jan 8 10:34:36 2010
@@ -1,0 +1,424 @@
+
+/* INCLUDES *******************************************************************/
+#define INITGUID
+#include "usbehci.h"
+#include <wdmguid.h>
+#include <stdio.h>
+
+#define NDEBUG
+#include <debug.h>
+
+NTSTATUS NTAPI
+PdoDispatchInternalDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ PPDO_DEVICE_EXTENSION PdoDeviceExtension;
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ PIO_STACK_LOCATION Stack = NULL;
+ NTSTATUS Status = STATUS_UNSUCCESSFUL;
+ ULONG_PTR Information = 0;
+ DPRINT("PdoDispatchInternalDeviceControl\n");
+
+ PdoDeviceExtension = (PPDO_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
+ FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)
PdoDeviceExtension->ControllerFdo->DeviceExtension;
+
+ ASSERT(PdoDeviceExtension->Common.IsFdo == FALSE);
+ Stack = IoGetCurrentIrpStackLocation(Irp);
+ DPRINT("IoControlCode %x\n",
Stack->Parameters.DeviceIoControl.IoControlCode);
+ switch(Stack->Parameters.DeviceIoControl.IoControlCode)
+ {
+ case IOCTL_INTERNAL_USB_SUBMIT_URB:
+ {
+ URB *Urb;
+
+ DPRINT1("IOCTL_INTERNAL_USB_SUBMIT_URB\n");
+ DPRINT("Stack->Parameters.DeviceIoControl.InputBufferLength
%d\n",
+ Stack->Parameters.DeviceIoControl.InputBufferLength);
+ DPRINT("Stack->Parameters.Others.Argument1 %x\n",
Stack->Parameters.Others.Argument1);
+
+ Urb = (PURB) Stack->Parameters.Others.Argument1;
+ DPRINT("Header Size %d\n", Urb->UrbHeader.Length);
+ DPRINT("Header Type %d\n", Urb->UrbHeader.Function);
+ DPRINT("Index %x\n", Urb->UrbControlDescriptorRequest.Index);
+
+ /* Check the type */
+ switch(Urb->UrbHeader.Function)
+ {
+ case URB_FUNCTION_SELECT_CONFIGURATION:
+ {
+ DPRINT1("URB_FUNCTION_SELECT_CONFIGURATION\n");
+ break;
+ }
+ case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE:
+ {
+ URB *Urb;
+ DPRINT1("URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE\n");
+ Urb = (PURB) Stack->Parameters.Others.Argument1;
+ Urb->UrbHeader.Status = 0;
+
+ /* Check for ChildDevices */
+ if (!FdoDeviceExtension->ChildDeviceCount)
+ {
+ /* No device has been plugged in yet. So just queue
+ the irp and complete it when a device is connected */
+ if (FdoDeviceExtension->DeviceState)
+ QueueRequest(FdoDeviceExtension, Irp);
+
+ Information = 0;
+
+ IoMarkIrpPending(Irp);
+ Status = STATUS_PENDING;
+ }
+ else
+ {
+ DPRINT1("Reporting of device connects not implemented
yet.\n");
+ Status = STATUS_SUCCESS;
+ }
+ break;
+ }
+ /* FIXME: Handle all other Functions */
+ default:
+ DPRINT1("Not handled yet!\n");
+ }
+ break;
+ }
+ case IOCTL_INTERNAL_USB_CYCLE_PORT:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_CYCLE_PORT\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_ENABLE_PORT:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_ENABLE_PORT\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_BUS_INFO:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_BUS_INFO\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_BUSGUID_INFO:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_BUSGUID_INFO\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_CONTROLLER_NAME:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_CONTROLLER_NAME\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_HUB_COUNT:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_HUB_COUNT\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_HUB_NAME:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_HUB_NAME\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_PORT_STATUS:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_PORT_STATUS\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_RESET_PORT:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_RESET_PORT\n");
+ break;
+ }
+ case IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO\n");
+ /* This is document as Argument1 = PDO and Argument2 = FDO.
+ Its actually reversed, the FDO goes in Argument1 and PDO goes in Argument2
*/
+ if (Stack->Parameters.Others.Argument1)
+ Stack->Parameters.Others.Argument1 =
FdoDeviceExtension->DeviceObject;
+ if (Stack->Parameters.Others.Argument2)
+ Stack->Parameters.Others.Argument2 = FdoDeviceExtension->Pdo;
+
+ Irp->IoStatus.Information = 0;
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ return STATUS_SUCCESS;
+ break;
+ }
+ case IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION:
+ {
+ DPRINT("IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION\n");
+ break;
+ }
+ default:
+ {
+ DPRINT("Unhandled IoControlCode %x\n",
Stack->Parameters.DeviceIoControl.IoControlCode);
+ break;
+ }
+ }
+
+ Irp->IoStatus.Information = Information;
+ if (Status != STATUS_PENDING)
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return Status;
+}
+
+NTSTATUS
+PdoQueryId(PDEVICE_OBJECT DeviceObject, PIRP Irp, ULONG_PTR* Information)
+{
+ PPDO_DEVICE_EXTENSION PdoDeviceExtension;
+ PFDO_DEVICE_EXTENSION FdoDeviceExtension;
+ WCHAR Buffer[256];
+ ULONG Index = 0;
+ ULONG IdType;
+ UNICODE_STRING SourceString;
+ UNICODE_STRING String;
+ NTSTATUS Status;
+
+ IdType = IoGetCurrentIrpStackLocation(Irp)->Parameters.QueryId.IdType;
+ PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+ FdoDeviceExtension =
(PFDO_DEVICE_EXTENSION)PdoDeviceExtension->ControllerFdo->DeviceExtension;
+
+ /* FIXME: Read values from registry */
+
+ switch (IdType)
+ {
+ case BusQueryDeviceID:
+ {
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryDeviceID\n");
+ RtlInitUnicodeString(&SourceString, L"USB\\ROOT_HUB20");
+ break;
+ }
+ case BusQueryHardwareIDs:
+ {
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryHardwareIDs\n");
+
+ Index += swprintf(&Buffer[Index],
L"USB\\ROOT_HUB20&VID8086&PID265C&REV0000") + 1;
+ Index += swprintf(&Buffer[Index],
L"USB\\ROOT_HUB20&VID8086&PID265") + 1;
+ Index += swprintf(&Buffer[Index], L"USB\\ROOT_HUB20") + 1;
+
+ Buffer[Index] = UNICODE_NULL;
+ SourceString.Length = SourceString.MaximumLength = Index * sizeof(WCHAR);
+ SourceString.Buffer = Buffer;
+ break;
+ }
+ case BusQueryCompatibleIDs:
+ {
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryCompatibleIDs\n");
+ /* We have none */
+ return STATUS_SUCCESS;
+ break;
+ }
+ case BusQueryInstanceID:
+ {
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryInstanceID\n");
+
+ /*
+ Do we need to implement this?
+ At one point I hade DeviceCapabilities->UniqueID set to TRUE.
+ And caused usbhub to fail attaching
+ to the PDO. Setting UniqueID to FALSE, it works
+ */
+
+ return STATUS_SUCCESS;
+ break;
+ }
+ default:
+ {
+ DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_ID / unknown query id type
0x%lx\n", IdType);
+ return STATUS_NOT_SUPPORTED;
+ }
+ }
+
+ /* Lifted from hpoussin */
+ Status = DuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
+ &SourceString,
+ &String);
+
+ *Information = (ULONG_PTR)String.Buffer;
+ return Status;
+}
+
+NTSTATUS
+PdoQueryDeviceRelations(PDEVICE_OBJECT DeviceObject, PDEVICE_RELATIONS*
pDeviceRelations)
+{
+ PFDO_DEVICE_EXTENSION DeviceExtension;
+ PDEVICE_RELATIONS DeviceRelations;
+
+ DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+
+ DeviceRelations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool,
sizeof(DEVICE_RELATIONS));
+ if (!DeviceRelations)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ ObReferenceObject(DeviceObject);
+ DeviceRelations->Count = 1;
+ DeviceRelations->Objects[0] = DeviceObject;
+
+ *pDeviceRelations = DeviceRelations;
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS NTAPI
+PdoDispatchPnp(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ ULONG MinorFunction;
+ PIO_STACK_LOCATION Stack;
+ ULONG_PTR Information = 0;
+ NTSTATUS Status;
+
+ Stack = IoGetCurrentIrpStackLocation(Irp);
+ MinorFunction = Stack->MinorFunction;
+
+ switch (MinorFunction)
+ {
+ case IRP_MN_QUERY_REMOVE_DEVICE:
+ case IRP_MN_REMOVE_DEVICE:
+ case IRP_MN_CANCEL_REMOVE_DEVICE:
+ case IRP_MN_STOP_DEVICE:
+ case IRP_MN_QUERY_STOP_DEVICE:
+ case IRP_MN_QUERY_DEVICE_TEXT:
+ case IRP_MN_SURPRISE_REMOVAL:
+ {
+ Information = Irp->IoStatus.Information;
+ Status = STATUS_SUCCESS;
+ break;
+ }
+
+ case IRP_MN_START_DEVICE:
+ {
+ DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
+ Status = STATUS_SUCCESS;
+ break;
+ }
+ case IRP_MN_QUERY_DEVICE_RELATIONS:
+ {
+ switch (Stack->Parameters.QueryDeviceRelations.Type)
+ {
+ case TargetDeviceRelation:
+ {
+ PDEVICE_RELATIONS DeviceRelations = NULL;
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS /
TargetDeviceRelation\n");
+ Status = PdoQueryDeviceRelations(DeviceObject,
&DeviceRelations);
+ Information = (ULONG_PTR)DeviceRelations;
+ break;
+ }
+ default:
+ {
+ DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unhandled
type 0x%lx\n",
+ Stack->Parameters.QueryDeviceRelations.Type);
+ //ASSERT(FALSE);
+ Status = STATUS_NOT_SUPPORTED;
+ break;
+ }
+ }
+ break;
+ }
+ case IRP_MN_QUERY_CAPABILITIES:
+ {
+ PDEVICE_CAPABILITIES DeviceCapabilities;
+ ULONG i;
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_CAPABILITIES\n");
+ DeviceCapabilities =
(PDEVICE_CAPABILITIES)Stack->Parameters.DeviceCapabilities.Capabilities;
+ /* FIXME: capabilities can change with connected device */
+ DeviceCapabilities->LockSupported = FALSE;
+ DeviceCapabilities->EjectSupported = FALSE;
+ DeviceCapabilities->Removable = FALSE;
+ DeviceCapabilities->DockDevice = FALSE;
+ DeviceCapabilities->UniqueID = FALSE;//TRUE;
+ DeviceCapabilities->SilentInstall = FALSE;
+ DeviceCapabilities->RawDeviceOK = TRUE;
+ DeviceCapabilities->SurpriseRemovalOK = FALSE;
+
+ /* FIXME */
+ DeviceCapabilities->HardwareDisabled = FALSE;
+ //DeviceCapabilities->NoDisplayInUI = FALSE;
+ DeviceCapabilities->DeviceState[0] = PowerDeviceD0;
+ for (i = 0; i < PowerSystemMaximum; i++)
+ DeviceCapabilities->DeviceState[i] = PowerDeviceD3;
+ //DeviceCapabilities->DeviceWake = PowerDeviceUndefined;
+ DeviceCapabilities->D1Latency = 0;
+ DeviceCapabilities->D2Latency = 0;
+ DeviceCapabilities->D3Latency = 0;
+ Status = STATUS_SUCCESS;
+ break;
+ }
+ case IRP_MN_QUERY_RESOURCES:
+ {
+ Information = Irp->IoStatus.Information;
+ Status = Irp->IoStatus.Status;
+ break;
+ }
+ case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
+ {
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
+ Information = Irp->IoStatus.Information;
+ Status = Irp->IoStatus.Status;
+ break;
+ }
+ /*case IRP_MN_QUERY_DEVICE_TEXT:
+ {
+ Status = STATUS_NOT_SUPPORTED;
+ break;
+ }*/
+ case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
+ {
+ DPRINT("IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
+ Information = Irp->IoStatus.Information;
+ Status = Irp->IoStatus.Status;
+ break;
+ }
+ case IRP_MN_QUERY_ID:
+ {
+ Status = PdoQueryId(DeviceObject, Irp, &Information);
+ break;
+ }
+ case IRP_MN_QUERY_BUS_INFORMATION:
+ {
+ PPNP_BUS_INFORMATION BusInfo;
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_BUS_INFORMATION\n");
+
+ BusInfo = (PPNP_BUS_INFORMATION)ExAllocatePool(PagedPool,
sizeof(PNP_BUS_INFORMATION));
+ if (!BusInfo)
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ else
+ {
+ /* FIXME */
+ /*RtlCopyMemory(
+ &BusInfo->BusTypeGuid,
+ &GUID_DEVINTERFACE_XXX,
+ sizeof(GUID));*/
+
+ BusInfo->LegacyBusType = PNPBus;
+ BusInfo->BusNumber = 0;
+ Information = (ULONG_PTR)BusInfo;
+ Status = STATUS_SUCCESS;
+ }
+ break;
+ }
+ default:
+ {
+ /* We are the PDO. So ignore */
+ DPRINT1("IRP_MJ_PNP / Unknown minor function 0x%lx\n",
MinorFunction);
+
+ Information = Irp->IoStatus.Information;
+ Status = Irp->IoStatus.Status;
+ break;
+ }
+ }
+
+ Irp->IoStatus.Information = Information;
+ Irp->IoStatus.Status = Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return Status;
+}
+
Propchange: trunk/reactos/drivers/usb/usbehci/pdo.c
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/drivers/usb/usbehci/usbehci.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/usbehc…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/usbehci.c (added)
+++ trunk/reactos/drivers/usb/usbehci/usbehci.c [iso-8859-1] Fri Jan 8 10:34:36 2010
@@ -1,0 +1,138 @@
+/*
+ * ReactOS USB ehci driver
+ * Copyright (C) 2009 Michael Martin
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+/* DEFINES *******************************************************************/
+#include "usbehci.h"
+#define NDEBUG
+
+/* INCLUDES *******************************************************************/
+#include <debug.h>
+
+
+static NTSTATUS NTAPI
+IrpStub(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ NTSTATUS Status;
+
+ if (((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsFdo)
+ {
+ DPRINT1("ehci: FDO stub for major function 0x%lx\n",
+ IoGetCurrentIrpStackLocation(Irp)->MajorFunction);
+ return ForwardIrpAndForget(DeviceObject, Irp);
+ }
+
+ /* We are lower driver, So complete */
+ DPRINT1("ehci: PDO stub for major function 0x%lx\n",
+ IoGetCurrentIrpStackLocation(Irp)->MajorFunction);
+
+ Status = Irp->IoStatus.Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return Status;
+}
+
+NTSTATUS NTAPI
+DispatchDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ DPRINT("DispatchDeviceControl\n");
+ Irp->IoStatus.Information = 0;
+ Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS NTAPI
+DispatchInternalDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ DPRINT("DispatchInternalDeviceControl\n");
+ if (((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsFdo)
+ return IrpStub(DeviceObject, Irp);
+ else
+ return PdoDispatchInternalDeviceControl(DeviceObject, Irp);
+}
+
+NTSTATUS NTAPI
+UsbEhciCleanup(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ DPRINT1("UsbEhciCleanup\n");
+ Irp->IoStatus.Information = 0;
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS NTAPI
+UsbEhciCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ DPRINT1("UsbEhciCreate\n");
+ Irp->IoStatus.Information = 0;
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS NTAPI
+UsbEhciClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ DPRINT1("Close\n");
+ Irp->IoStatus.Information = 0;
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return STATUS_SUCCESS;
+}
+
+VOID NTAPI
+DriverUnload(PDRIVER_OBJECT DriverObject)
+{
+ DPRINT1("Unloading Driver\n");
+}
+
+NTSTATUS NTAPI
+DispatchPnp(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+ if (((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsFdo)
+ return FdoDispatchPnp(DeviceObject, Irp);
+ else
+ return PdoDispatchPnp(DeviceObject, Irp);
+}
+
+NTSTATUS NTAPI
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
+{
+ DPRINT1("Driver Entry %wZ!\n", RegistryPath);
+
+ DriverObject->DriverExtension->AddDevice = AddDevice;
+
+ DriverObject->MajorFunction[IRP_MJ_CREATE] = UsbEhciCreate;
+ DriverObject->MajorFunction[IRP_MJ_CLOSE] = UsbEhciClose;
+ DriverObject->MajorFunction[IRP_MJ_CLEANUP] = UsbEhciCleanup;
+ DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchDeviceControl;
+ DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] =
DispatchInternalDeviceControl;
+ DriverObject->MajorFunction[IRP_MJ_PNP] = DispatchPnp;
+
+ DriverObject->DriverUnload = DriverUnload;
+ DPRINT1("Driver entry done\n");
+
+ return STATUS_SUCCESS;
+}
+
Propchange: trunk/reactos/drivers/usb/usbehci/usbehci.c
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/drivers/usb/usbehci/usbehci.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/usbehc…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/usbehci.h (added)
+++ trunk/reactos/drivers/usb/usbehci/usbehci.h [iso-8859-1] Fri Jan 8 10:34:36 2010
@@ -1,0 +1,278 @@
+
+#ifndef __EHCI_H__
+#define __EHCI_H__
+
+#include <ntifs.h>
+#include <ntddk.h>
+#include <stdio.h>
+#define NDEBUG
+#include <debug.h>
+#include <usbioctl.h>
+#include <usb.h>
+
+#define DEVICEINTIALIZED 0x01
+#define DEVICESTARTED 0x02
+#define DEVICEBUSY 0x04
+#define DEVICESTOPPED 0x08
+
+
+#define MAX_USB_DEVICES 127
+#define EHCI_MAX_SIZE_TRANSFER 0x100000
+
+/* USB Command Register */
+#define EHCI_USBCMD 0x00
+#define EHCI_USBSTS 0x04
+#define EHCI_USBINTR 0x08
+#define EHCI_FRINDEX 0x0C
+#define EHCI_CTRLDSSEGMENT 0x10
+#define EHCI_PERIODICLISTBASE 0x14
+#define EHCI_ASYNCLISTBASE 0x18
+#define EHCI_CONFIGFLAG 0x40
+#define EHCI_PORTSC 0x44
+
+/* USB Interrupt Register Flags 32 Bits */
+#define EHCI_USBINTR_INTE 0x01
+#define EHCI_USBINTR_ERR 0x02
+#define EHCI_USBINTR_PC 0x04
+#define EHCI_USBINTR_FLROVR 0x08
+#define EHCI_USBINTR_HSERR 0x10
+#define EHCI_USBINTR_ASYNC 0x20
+/* Bits 6:31 Reserved */
+
+/* Status Register Flags 32 Bits */
+#define EHCI_STS_INT 0x01
+#define EHCI_STS_ERR 0x02
+#define EHCI_STS_PCD 0x04
+#define EHCI_STS_FLR 0x08
+#define EHCI_STS_FATAL 0x10
+#define EHCI_STS_IAA 0x20
+/* Bits 11:6 Reserved */
+#define EHCI_STS_HALT 0x1000
+#define EHCI_STS_RECL 0x2000
+#define EHCI_STS_PSS 0x4000
+#define EHCI_STS_ASS 0x8000
+#define EHCI_ERROR_INT ( EHCI_STS_FATAL | EHCI_STS_ERR )
+
+typedef struct _EHCI_HCS_CONTENT
+{
+ ULONG PortCount : 4;
+ ULONG PortPowerControl: 1;
+ ULONG Reserved : 2;
+ ULONG PortRouteRules : 1;
+ ULONG PortPerCHC : 4;
+ ULONG CHCCount : 4;
+ ULONG PortIndicator : 1;
+ ULONG Reserved2 : 3;
+ ULONG DbgPortNum : 4;
+ ULONG Reserved3 : 8;
+
+} EHCI_HCS_CONTENT, *PEHCI_HCS_CONTENT;
+
+typedef struct _EHCI_HCC_CONTENT
+{
+ ULONG CurAddrBits : 1;
+ ULONG VarFrameList : 1;
+ ULONG ParkMode : 1;
+ ULONG Reserved : 1;
+ ULONG IsoSchedThreshold : 4;
+ ULONG EECPCapable : 8;
+ ULONG Reserved2 : 16;
+
+} EHCI_HCC_CONTENT, *PEHCI_HCC_CONTENT;
+
+typedef struct _EHCI_CAPS {
+ UCHAR Length;
+ UCHAR Reserved;
+ USHORT HCIVersion;
+ union
+ {
+ EHCI_HCS_CONTENT HCSParams;
+ ULONG HCSParamsLong;
+ };
+ ULONG HCCParams;
+ UCHAR PortRoute [8];
+} EHCI_CAPS, *PEHCI_CAPS;
+
+
+typedef struct _COMMON_DEVICE_EXTENSION
+{
+ BOOLEAN IsFdo;
+ PDRIVER_OBJECT DriverObject;
+ PDEVICE_OBJECT DeviceObject;
+} COMMON_DEVICE_EXTENSION, *PCOMMON_DEVICE_EXTENSION;
+
+typedef struct _FDO_DEVICE_EXTENSION
+{
+ COMMON_DEVICE_EXTENSION Common;
+ PDRIVER_OBJECT DriverObject;
+ PDEVICE_OBJECT DeviceObject;
+ PDEVICE_OBJECT LowerDevice;
+ PDEVICE_OBJECT Pdo;
+ ULONG DeviceState;
+
+ /* USB Specs says a max of 127 devices */
+ ULONG ChildDeviceCount;
+
+ PDMA_ADAPTER pDmaAdapter;
+
+ ULONG Vector;
+ KIRQL Irql;
+
+ KINTERRUPT_MODE Mode;
+ BOOLEAN IrqShared;
+ PKINTERRUPT EhciInterrupt;
+ KDPC DpcObject;
+ KAFFINITY Affinity;
+
+ LIST_ENTRY IrpQueue;
+ KSPIN_LOCK IrpQueueLock;
+ PIRP CurrentIrp;
+
+ ULONG MapRegisters;
+
+ ULONG BusNumber;
+ ULONG BusAddress;
+ ULONG PCIAddress;
+ USHORT VendorId;
+ USHORT DeviceId;
+
+ BUS_INTERFACE_STANDARD BusInterface;
+
+ EHCI_CAPS ECHICaps;
+
+ union
+ {
+ PULONG ResourcePort;
+ PULONG ResourceMemory;
+ };
+
+ PULONG PeriodicFramList;
+ PULONG AsyncListQueueHeadPtr;
+ PHYSICAL_ADDRESS PeriodicFramListPhysAddr;
+ PHYSICAL_ADDRESS AsyncListQueueHeadPtrPhysAddr;
+
+ BOOLEAN AsyncComplete;
+
+ PULONG ResourceBase;
+ ULONG Size;
+
+} FDO_DEVICE_EXTENSION, *PFDO_DEVICE_EXTENSION;
+
+typedef struct _PDO_DEVICE_EXTENSION
+{
+ COMMON_DEVICE_EXTENSION Common;
+ PDEVICE_OBJECT DeviceObject;
+ PDEVICE_OBJECT ControllerFdo;
+
+} PDO_DEVICE_EXTENSION, *PPDO_DEVICE_EXTENSION;
+
+
+/* USBCMD register 32 bits */
+typedef struct _EHCI_USBCMD_CONTENT
+{
+ ULONG Run : 1;
+ ULONG HCReset : 1;
+ ULONG FrameListSize : 2;
+ ULONG PeriodicEnable : 1;
+ ULONG AsyncEnable : 1;
+ ULONG DoorBell : 1;
+ ULONG LightReset : 1;
+ ULONG AsyncParkCount : 2;
+ ULONG Reserved : 1;
+ ULONG AsyncParkEnable : 1;
+ ULONG Reserved1 : 4;
+ ULONG IntThreshold : 8;
+ ULONG Reserved2 : 8;
+
+} EHCI_USBCMD_CONTENT, *PEHCI_USBCMD_CONTENT;
+
+typedef struct _EHCI_USBSTS_CONTENT
+{
+ ULONG USBInterrupt:1;
+ ULONG ErrorInterrupt:1;
+ ULONG DetectChangeInterrupt:1;
+ ULONG FrameListRolloverInterrupt:1;
+ ULONG HostSystemErrorInterrupt:1;
+ ULONG AsyncAdvanceInterrupt:1;
+ ULONG Reserved:6;
+ ULONG HCHalted:1;
+ ULONG Reclamation:1;
+ ULONG PeriodicScheduleStatus:1;
+ ULONG AsynchronousScheduleStatus:1;
+} EHCI_USBSTS_CONTEXT, *PEHCI_USBSTS_CONTEXT;
+
+typedef struct _EHCI_USBPORTSC_CONTENT
+{
+ ULONG CurrentConnectStatus:1;
+ ULONG ConnectStatusChange:1;
+ ULONG PortEnabled:1;
+ ULONG PortEnableChanged:1;
+ ULONG OverCurrentActive:1;
+ ULONG OverCurrentChange:1;
+ ULONG ForcePortResume:1;
+ ULONG Suspend:1;
+ ULONG PortReset:1;
+ ULONG Reserved:1;
+ ULONG LineStatus:2;
+ ULONG PortPower:1;
+ ULONG PortOwner:1;
+} EHCI_USBPORTSC_CONTENT, *PEHCI_USBPORTSC_CONTENT;
+
+NTSTATUS NTAPI
+GetBusInterface(PDEVICE_OBJECT pcifido, PBUS_INTERFACE_STANDARD busInterface);
+
+NTSTATUS NTAPI
+ForwardAndWaitCompletionRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp, PKEVENT Event);
+
+NTSTATUS NTAPI
+ForwardAndWait(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+
+NTSTATUS NTAPI
+ForwardIrpAndForget(PDEVICE_OBJECT DeviceObject,PIRP Irp);
+
+NTSTATUS NTAPI
+FdoDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+
+NTSTATUS NTAPI
+PdoDispatchPnp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+
+NTSTATUS NTAPI
+AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT Pdo);
+
+NTSTATUS
+DuplicateUnicodeString(ULONG Flags, PCUNICODE_STRING SourceString, PUNICODE_STRING
DestinationString);
+
+PWSTR
+GetSymbolicName(PDEVICE_OBJECT DeviceObject);
+
+PWSTR
+GetPhysicalDeviceObjectName(PDEVICE_OBJECT DeviceObject);
+
+NTSTATUS NTAPI
+PdoDispatchInternalDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+
+BOOLEAN
+GetDeviceDescriptor(PFDO_DEVICE_EXTENSION DeviceExtension, USHORT Port);
+
+BOOLEAN
+GetDeviceDescriptor2(PFDO_DEVICE_EXTENSION DeviceExtension, USHORT Port);
+
+BOOLEAN
+GetStringDescriptor(PFDO_DEVICE_EXTENSION DeviceExtension, ULONG DecriptorStringNumber);
+
+VOID
+CompletePendingRequest(PFDO_DEVICE_EXTENSION DeviceExtension);
+
+VOID
+QueueRequest(PFDO_DEVICE_EXTENSION DeviceExtension, PIRP Irp);
+
+VOID
+QueueRequest(PFDO_DEVICE_EXTENSION DeviceExtension, PIRP Irp);
+
+VOID
+CompletePendingRequest(PFDO_DEVICE_EXTENSION DeviceExtension);
+
+VOID
+DeviceArrivalWorkItem(PDEVICE_OBJECT DeviceObject, PVOID Context);
+
+#endif
Propchange: trunk/reactos/drivers/usb/usbehci/usbehci.h
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/drivers/usb/usbehci/usbehci.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/usbehc…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/usbehci.rbuild (added)
+++ trunk/reactos/drivers/usb/usbehci/usbehci.rbuild [iso-8859-1] Fri Jan 8 10:34:36
2010
@@ -1,0 +1,11 @@
+<?xml version="1.0"?>
+<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
+<module name="usbehci" type="kernelmodedriver"
installbase="system32/drivers" installname="usbehci.sys">
+ <library>ntoskrnl</library>
+ <library>hal</library>
+ <file>usbehci.c</file>
+ <file>fdo.c</file>
+ <file>pdo.c</file>
+ <file>common.c</file>
+ <file>misc.c</file>
+</module>
Propchange: trunk/reactos/drivers/usb/usbehci/usbehci.rbuild
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/drivers/usb/usbehci/usbehci.rc
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/usb/usbehci/usbehc…
==============================================================================
--- trunk/reactos/drivers/usb/usbehci/usbehci.rc (added)
+++ trunk/reactos/drivers/usb/usbehci/usbehci.rc [iso-8859-1] Fri Jan 8 10:34:36 2010
@@ -1,0 +1,5 @@
+#define REACTOS_VERSION_DLL
+#define REACTOS_STR_FILE_DESCRIPTION "USB Ehci Driver\0"
+#define REACTOS_STR_INTERNAL_NAME "usbehci\0"
+#define REACTOS_STR_ORIGINAL_FILENAME "usbehci.sys\0"
+#include <reactos/version.rc>
Propchange: trunk/reactos/drivers/usb/usbehci/usbehci.rc
------------------------------------------------------------------------------
svn:eol-style = native