NTAPI
StatusChangeWorkItemRoutine(PVOID Context);
-class CUSBHardwareDevice : public IUSBHardwareDevice
+class CUSBHardwareDevice : public IOHCIHardwareDevice
{
public:
STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::Initialize(
PDRIVER_OBJECT DriverObject,
PDEVICE_OBJECT FunctionalDeviceObject,
PCI_COMMON_CONFIG PciConfig;
NTSTATUS Status;
ULONG BytesRead;
+ PUSBQUEUE Queue;
DPRINT("CUSBHardwareDevice::Initialize\n");
//
// Create the UsbQueue class that will handle the Asynchronous and Periodic Schedules
//
- Status = CreateUSBQueue((PUSBQUEUE*)&m_UsbQueue);
+ Status = CreateUSBQueue(&Queue);
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to create UsbQueue!\n");
return Status;
}
+ // get ohci queue
+ m_UsbQueue = POHCIQUEUE(Queue);
+
+ // sanity check
+ ASSERT(m_UsbQueue);
+
//
// store device objects
//
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::PnpStart(
PCM_RESOURCE_LIST RawResources,
PCM_RESOURCE_LIST TranslatedResources)
//
// Initialize the UsbQueue now that we have an AdapterObject.
//
- Status = m_UsbQueue->Initialize(PUSBHARDWAREDEVICE(this), m_Adapter, m_MemoryManager, NULL);
+ Status = m_UsbQueue->Initialize(this, m_Adapter, m_MemoryManager, NULL);
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to Initialize the UsbQueue\n");
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::PnpStop(void)
{
UNIMPLEMENTED
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetDeviceDetails(
OUT OPTIONAL PUSHORT VendorId,
OUT OPTIONAL PUSHORT DeviceId,
return STATUS_SUCCESS;
}
-NTSTATUS CUSBHardwareDevice::GetDMA(
+NTSTATUS
+STDMETHODCALLTYPE
+CUSBHardwareDevice::GetDMA(
OUT struct IDMAMemoryManager **OutDMAMemoryManager)
{
if (!m_MemoryManager)
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetUSBQueue(
OUT struct IUSBQueue **OutUsbQueue)
{
}
VOID
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetBulkHeadEndpointDescriptor(
struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor)
{
}
VOID
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetInterruptEndpointDescriptors(
struct _OHCI_ENDPOINT_DESCRIPTOR *** OutDescriptor)
{
}
VOID
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetIsochronousHeadEndpointDescriptor(
struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor)
{
}
VOID
+STDMETHODCALLTYPE
CUSBHardwareDevice::HeadEndpointDescriptorModified(
ULONG Type)
{
}
VOID
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetControlHeadEndpointDescriptor(
struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor)
{
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::ResetPort(
IN ULONG PortIndex)
{
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetPortStatus(
ULONG PortId,
OUT USHORT *PortStatus,
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::ClearPortStatus(
ULONG PortId,
ULONG Status)
NTSTATUS
+STDMETHODCALLTYPE
CUSBHardwareDevice::SetPortFeature(
ULONG PortId,
ULONG Feature)
VOID
+STDMETHODCALLTYPE
CUSBHardwareDevice::SetStatusChangeEndpointCallBack(
PVOID CallBack,
PVOID Context)
}
VOID
+STDMETHODCALLTYPE
CUSBHardwareDevice::GetCurrentFrameNumber(
PULONG FrameNumber)
{
}
NTSTATUS
+NTAPI
CreateUSBHardware(
PUSBHARDWAREDEVICE *OutHardware)
{
#include "usbohci.h"
#include "hardware.h"
-class CUSBQueue : public IUSBQueue
+class CUSBQueue : public IOHCIQueue
{
public:
STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBQueue::Initialize(
IN PUSBHARDWAREDEVICE Hardware,
IN PDMA_ADAPTER AdapterObject,
IN PDMAMEMORYMANAGER MemManager,
IN OPTIONAL PKSPIN_LOCK Lock)
{
+ if (!Hardware)
+ {
+ // WTF
+ DPRINT1("[USBOHCI] Failed to initialize queue\n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
//
// store hardware
//
m_Hardware = POHCIHARDWAREDEVICE(Hardware);
-
+ ASSERT(m_Hardware);
//
// get bulk endpoint descriptor
NTSTATUS
+STDMETHODCALLTYPE
CUSBQueue::AddUSBRequest(
IUSBRequest * Req)
{
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBQueue::CreateUSBRequest(
IUSBRequest **OutRequest)
{
}
VOID
+STDMETHODCALLTYPE
CUSBQueue::TransferDescriptorCompletionCallback(
ULONG TransferDescriptorLogicalAddress)
{
}
NTSTATUS
+STDMETHODCALLTYPE
CUSBQueue::AbortDevicePipe(
IN UCHAR DeviceAddress,
IN PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor)
NTSTATUS
+NTAPI
CreateUSBQueue(
PUSBQUEUE *OutUsbQueue)
{
#include "usbohci.h"
#include "hardware.h"
-class CUSBRequest : public IUSBRequest
+class CUSBRequest : public IOHCIRequest
{
public:
STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
//----------------------------------------------------------------------------------------
NTSTATUS
+STDMETHODCALLTYPE
CUSBRequest::InitializeWithSetupPacket(
IN PDMAMEMORYMANAGER DmaManager,
IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
}
//----------------------------------------------------------------------------------------
NTSTATUS
+STDMETHODCALLTYPE
CUSBRequest::InitializeWithIrp(
IN PDMAMEMORYMANAGER DmaManager,
IN struct IUSBDevice* Device,
//----------------------------------------------------------------------------------------
BOOLEAN
+STDMETHODCALLTYPE
CUSBRequest::IsRequestComplete()
{
//
}
//----------------------------------------------------------------------------------------
ULONG
+STDMETHODCALLTYPE
CUSBRequest::GetTransferType()
{
//
}
UCHAR
+STDMETHODCALLTYPE
CUSBRequest::GetInterval()
{
ASSERT(m_EndpointDescriptor);
//----------------------------------------------------------------------------------------
UCHAR
+STDMETHODCALLTYPE
CUSBRequest::GetDeviceAddress()
{
PIO_STACK_LOCATION IoStack;
//----------------------------------------------------------------------------------------
NTSTATUS
+STDMETHODCALLTYPE
CUSBRequest::GetEndpointDescriptor(
struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor)
{
ULONG TransferType;
NTSTATUS Status;
+
//
// get transfer type
//
break;
}
+
+
if (NT_SUCCESS(Status))
{
//
//----------------------------------------------------------------------------------------
VOID
+STDMETHODCALLTYPE
CUSBRequest::GetResultStatus(
OUT OPTIONAL NTSTATUS * NtStatusCode,
OUT OPTIONAL PULONG UrbStatusCode)
}
VOID
+STDMETHODCALLTYPE
CUSBRequest::FreeEndpointDescriptor(
struct _OHCI_ENDPOINT_DESCRIPTOR * OutDescriptor)
{
TransferDescriptor = (POHCI_GENERAL_TD)TransferDescriptor->NextLogicalDescriptor;
}
}
-
-
-
}
VOID
+STDMETHODCALLTYPE
CUSBRequest::CompletionCallback()
{
PIO_STACK_LOCATION IoStack;
}
}
-#if 0
-//-----------------------------------------------------------------------------------------
-BOOLEAN
-CUSBRequest::IsQueueHeadComplete(
- struct _QUEUE_HEAD * QueueHead)
-{
- UNIMPLEMENTED
- return TRUE;
-}
-#endif
-
-
//-----------------------------------------------------------------------------------------
NTSTATUS
+NTAPI
InternalCreateUSBRequest(
PUSBREQUEST *OutRequest)
{
(VOID)((!(exp)) ? \
RtlAssert((PVOID) #exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
+extern "C"
+{
+
//
// hardware.cpp
//
-NTSTATUS CreateUSBHardware(PUSBHARDWAREDEVICE *OutHardware);
+NTSTATUS NTAPI CreateUSBHardware(PUSBHARDWAREDEVICE *OutHardware);
//
// usb_queue.cpp
//
-NTSTATUS CreateUSBQueue(PUSBQUEUE *OutUsbQueue);
+NTSTATUS NTAPI CreateUSBQueue(PUSBQUEUE *OutUsbQueue);
//
// usb_request.cpp
//
-NTSTATUS InternalCreateUSBRequest(PUSBREQUEST *OutRequest);
-
+NTSTATUS NTAPI InternalCreateUSBRequest(PUSBREQUEST *OutRequest);
+}
#endif
}
NTSTATUS
+NTAPI
CreateHCDController(
PHCDCONTROLLER *OutHcdController)
{
NTSTATUS
+NTAPI
CreateHubController(
PHUBCONTROLLER *OutHcdController)
{
//
DRIVER_ADD_DEVICE USBLIB_AddDevice;
+extern
+"C"
+{
NTSTATUS
NTAPI
USBLIB_AddDevice(
return Status;
}
+}
+extern
+"C"
+{
NTSTATUS
NTAPI
USBLIB_Dispatch(
return Status;
}
+}
\ No newline at end of file
RtlAssert((PVOID) #exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
// hcd_controller.cpp
-NTSTATUS CreateHCDController(PHCDCONTROLLER *HcdController);
+extern "C"
+{
+NTSTATUS NTAPI CreateHCDController(PHCDCONTROLLER *HcdController);
// hardware.cpp
-NTSTATUS CreateUSBHardware(PUSBHARDWAREDEVICE *OutHardware);
+NTSTATUS NTAPI CreateUSBHardware(PUSBHARDWAREDEVICE *OutHardware);
// misc.cpp
NTSTATUS NTAPI SyncForwardIrp(PDEVICE_OBJECT DeviceObject, PIRP Irp);
NTSTATUS NTAPI GetBusInterface(PDEVICE_OBJECT DeviceObject, PBUS_INTERFACE_STANDARD busInterface);
// root_hub_controller.cpp
-NTSTATUS CreateHubController(PHUBCONTROLLER * OutHubController);
+NTSTATUS NTAPI CreateHubController(PHUBCONTROLLER * OutHubController);
// memory_manager.cpp
-NTSTATUS CreateDMAMemoryManager(PDMAMEMORYMANAGER *OutMemoryManager);
-
+NTSTATUS NTAPI CreateDMAMemoryManager(PDMAMEMORYMANAGER *OutMemoryManager);
// usb_device.cpp
-NTSTATUS CreateUSBDevice(PUSBDEVICE *OutDevice);
-
-// usb_queue.cpp
-NTSTATUS CreateUSBQueue(PUSBQUEUE *OutUsbQueue);
-
-// usb_request.cpp
-NTSTATUS InternalCreateUSBRequest(PUSBREQUEST *OutRequest);
+NTSTATUS NTAPI CreateUSBDevice(PUSBDEVICE *OutDevice);
// libusb.cpp
NTSTATUS NTAPI USBLIB_AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject);
NTSTATUS NTAPI USBLIB_Dispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+}
#endif
}
NTSTATUS
+NTAPI
CreateDMAMemoryManager(
PDMAMEMORYMANAGER *OutMemoryManager)
{
//----------------------------------------------------------------------------------------
NTSTATUS
+NTAPI
CreateUSBDevice(
PUSBDEVICE *OutDevice)
{