Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-03 06:55:55 +00:00
Code Issues Projects Releases Packages Wiki Activity

[USBOHCI]

Browse source 
- Add glue code for supporting iso transfers
- Remove dead from Handle
- Remove broken asserts
- Add support for string descriptors
- Add support for class specific endpoint requests (Needs be ported to usbehci)
- Link to usbd driver
- Add support for retrieving string descriptor
- Rewrite configuration descriptor handling in IUSBDevice. New code is smaller, smarter and handles a lot more cases. Needs to be ported to usbehci
- Wrap usbdlib.h include in extern c macro, it has c linkage
- Control transfers should now work 
- Need to implement support for isochronous / bulk / interrupt transfers until functional
- Tested with Bluetooth USB Stick (multi function, interrupt / bulk / control / isochronous) / USB Microphone (isochronous & control) in XP SP3

svn path=/branches/usb-bringup/; revision=51900
This commit is contained in:
Johannes Anderwald 2011-05-25 02:11:06 +00:00
parent beec9a7b25
commit 2c6077dc50
5 changed files with 266 additions and 273 deletions
Download patch file Download diff file Expand all files Collapse all files

2
drivers/usb/usbohci/CMakeLists.txt
View file

@ -30,6 +30,6 @@ else()
endif(MSVC) endif(MSVC)
set_module_type(usbohci kernelmodedriver) set_module_type(usbohci kernelmodedriver)
add_importlibs(usbohci ntoskrnl ks drmk hal) add_importlibs(usbohci ntoskrnl ks drmk hal usbd)
add_cab_target(usbohci 2) add_cab_target(usbohci 2)

160
drivers/usb/usbohci/hub_controller.cpp
View file

@ -66,7 +66,9 @@ public:
NTSTATUS HandleSelectInterface(IN OUT PIRP Irp, PURB Urb); NTSTATUS HandleSelectInterface(IN OUT PIRP Irp, PURB Urb);
NTSTATUS HandleClassOther(IN OUT PIRP Irp, PURB Urb); NTSTATUS HandleClassOther(IN OUT PIRP Irp, PURB Urb);
NTSTATUS HandleClassInterface(IN OUT PIRP Irp, PURB Urb); NTSTATUS HandleClassInterface(IN OUT PIRP Irp, PURB Urb);
NTSTATUS HandleClassEndpoint(IN OUT PIRP Irp, PURB Urb);
NTSTATUS HandleBulkOrInterruptTransfer(IN OUT PIRP Irp, PURB Urb); NTSTATUS HandleBulkOrInterruptTransfer(IN OUT PIRP Irp, PURB Urb);
NTSTATUS HandleIsochronousTransfer(IN OUT PIRP Irp, PURB Urb);
friend VOID StatusChangeEndpointCallBack(PVOID Context); friend VOID StatusChangeEndpointCallBack(PVOID Context);
@ -756,6 +758,47 @@ CHubController::HandlePower(
IoCompleteRequest(Irp, IO_NO_INCREMENT); IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_IMPLEMENTED; return STATUS_NOT_IMPLEMENTED;
} }
//-----------------------------------------------------------------------------------------
NTSTATUS
CHubController::HandleIsochronousTransfer(
IN OUT PIRP Irp,
PURB Urb)
{
PUSBDEVICE UsbDevice;
PUSB_ENDPOINT_DESCRIPTOR EndPointDesc = NULL;
//
// Check PipeHandle to determine if this is a Bulk or Interrupt Transfer Request
//
EndPointDesc = (PUSB_ENDPOINT_DESCRIPTOR)Urb->UrbIsochronousTransfer.PipeHandle;
if (!EndPointDesc)
{
DPRINT1("No EndpointDesc\n");
Urb->UrbIsochronousTransfer.Hdr.Status = USBD_STATUS_INVALID_PIPE_HANDLE;
return STATUS_INVALID_PARAMETER;
}
//
// sanity checks
//
ASSERT(EndPointDesc);
ASSERT((EndPointDesc->bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_ISOCHRONOUS);
//
// check if this is a valid usb device handle
//
PC_ASSERT(ValidateUsbDevice(PUSBDEVICE(Urb->UrbHeader.UsbdDeviceHandle)));
//
// get device
//
UsbDevice = PUSBDEVICE(Urb->UrbHeader.UsbdDeviceHandle);
return UsbDevice->SubmitIrp(Irp);
}
//----------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------
NTSTATUS NTSTATUS
CHubController::HandleBulkOrInterruptTransfer( CHubController::HandleBulkOrInterruptTransfer(
@ -794,22 +837,11 @@ CHubController::HandleBulkOrInterruptTransfer(
// //
EndPointDesc = (PUSB_ENDPOINT_DESCRIPTOR)Urb->UrbBulkOrInterruptTransfer.PipeHandle; EndPointDesc = (PUSB_ENDPOINT_DESCRIPTOR)Urb->UrbBulkOrInterruptTransfer.PipeHandle;
switch(EndPointDesc->bmAttributes & 0x0F) //
{ // sanity checks
case USB_ENDPOINT_TYPE_CONTROL: //
DPRINT1("Control Transfer is not expected!!!\n"); ASSERT(EndPointDesc);
return STATUS_INVALID_DEVICE_REQUEST; ASSERT((EndPointDesc->bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_BULK || (EndPointDesc->bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_INTERRUPT);
case USB_ENDPOINT_TYPE_BULK:
DPRINT("Initiating Bulk Transfer\n");
break;
case USB_ENDPOINT_TYPE_ISOCHRONOUS:
case USB_ENDPOINT_TYPE_INTERRUPT:
DPRINT1("Not Supported\n");
break;
default:
DPRINT1("Unknown EndPoint Type!\n");
break;
}
// //
// check if this is a valid usb device handle // check if this is a valid usb device handle
@ -1199,6 +1231,7 @@ CHubController::HandleGetDescriptor(
{ {
NTSTATUS Status = STATUS_NOT_IMPLEMENTED; NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor; PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor;
USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
PUCHAR Buffer; PUCHAR Buffer;
PUSBDEVICE UsbDevice; PUSBDEVICE UsbDevice;
ULONG Length; ULONG Length;
@ -1299,8 +1332,6 @@ CHubController::HandleGetDescriptor(
} }
else else
{ {
DPRINT1("Length %u\n", Urb->UrbControlDescriptorRequest.TransferBufferLength);
// //
// check if this is a valid usb device handle // check if this is a valid usb device handle
// //
@ -1330,11 +1361,6 @@ CHubController::HandleGetDescriptor(
// //
UsbDevice->GetConfigurationDescriptors((PUSB_CONFIGURATION_DESCRIPTOR)Urb->UrbControlDescriptorRequest.TransferBuffer, Urb->UrbControlDescriptorRequest.TransferBufferLength, &Length); UsbDevice->GetConfigurationDescriptors((PUSB_CONFIGURATION_DESCRIPTOR)Urb->UrbControlDescriptorRequest.TransferBuffer, Urb->UrbControlDescriptorRequest.TransferBufferLength, &Length);
//
// sanity check
//
PC_ASSERT(Urb->UrbControlDescriptorRequest.TransferBufferLength >= Length);
// //
// store result size // store result size
// //
@ -1363,9 +1389,19 @@ CHubController::HandleGetDescriptor(
UsbDevice = PUSBDEVICE(Urb->UrbHeader.UsbdDeviceHandle); UsbDevice = PUSBDEVICE(Urb->UrbHeader.UsbdDeviceHandle);
// //
// unimplemented // generate setup packet
// //
ASSERT(FALSE); CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
CtrlSetup.wValue.LowByte = Urb->UrbControlDescriptorRequest.Index;
CtrlSetup.wValue.HiByte = Urb->UrbControlDescriptorRequest.DescriptorType;
CtrlSetup.wIndex.W = Urb->UrbControlDescriptorRequest.LanguageId;
CtrlSetup.wLength = (USHORT)Urb->UrbControlDescriptorRequest.TransferBufferLength;
CtrlSetup.bmRequestType.B = 0x80;
//
// submit setup packet
//
Status = UsbDevice->SubmitSetupPacket(&CtrlSetup, Urb->UrbControlDescriptorRequest.TransferBufferLength, Urb->UrbControlDescriptorRequest.TransferBuffer);
break; break;
} }
default: default:
@ -1379,6 +1415,70 @@ CHubController::HandleGetDescriptor(
return Status; return Status;
} }
//-----------------------------------------------------------------------------------------
NTSTATUS
CHubController::HandleClassEndpoint(
IN OUT PIRP Irp,
IN OUT PURB Urb)
{
USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
NTSTATUS Status;
PUSBDEVICE UsbDevice;
//
// sanity check
//
PC_ASSERT(Urb->UrbControlVendorClassRequest.TransferBuffer);
PC_ASSERT(Urb->UrbControlVendorClassRequest.TransferBufferLength);
PC_ASSERT(Urb->UrbHeader.UsbdDeviceHandle);
//
// check if this is a valid usb device handle
//
PC_ASSERT(ValidateUsbDevice(PUSBDEVICE(Urb->UrbHeader.UsbdDeviceHandle)));
//
// get device
//
UsbDevice = PUSBDEVICE(Urb->UrbHeader.UsbdDeviceHandle);
DPRINT1("URB_FUNCTION_CLASS_ENDPOINT\n");
DPRINT1("TransferFlags %x\n", Urb->UrbControlVendorClassRequest.TransferFlags);
DPRINT1("TransferBufferLength %x\n", Urb->UrbControlVendorClassRequest.TransferBufferLength);
DPRINT1("TransferBuffer %x\n", Urb->UrbControlVendorClassRequest.TransferBuffer);
DPRINT1("TransferBufferMDL %x\n", Urb->UrbControlVendorClassRequest.TransferBufferMDL);
DPRINT1("RequestTypeReservedBits %x\n", Urb->UrbControlVendorClassRequest.RequestTypeReservedBits);
DPRINT1("Request %x\n", Urb->UrbControlVendorClassRequest.Request);
DPRINT1("Value %x\n", Urb->UrbControlVendorClassRequest.Value);
DPRINT1("Index %x\n", Urb->UrbControlVendorClassRequest.Index);
//
// initialize setup packet
//
CtrlSetup.bmRequestType.B = 0xa2; //FIXME: Const.
CtrlSetup.bRequest = Urb->UrbControlVendorClassRequest.Request;
CtrlSetup.wValue.W = Urb->UrbControlVendorClassRequest.Value;
CtrlSetup.wIndex.W = Urb->UrbControlVendorClassRequest.Index;
CtrlSetup.wLength = Urb->UrbControlVendorClassRequest.TransferBufferLength;
//
// issue request
//
Status = UsbDevice->SubmitSetupPacket(&CtrlSetup, Urb->UrbControlVendorClassRequest.TransferBufferLength, Urb->UrbControlVendorClassRequest.TransferBuffer);
//
// assert on failure
//
PC_ASSERT(NT_SUCCESS(Status));
//
// done
//
return Status;
}
//----------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------
NTSTATUS NTSTATUS
CHubController::HandleClassInterface( CHubController::HandleClassInterface(
@ -1500,9 +1600,15 @@ CHubController::HandleDeviceControl(
case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
Status = HandleBulkOrInterruptTransfer(Irp, Urb); Status = HandleBulkOrInterruptTransfer(Irp, Urb);
break; break;
case URB_FUNCTION_ISOCH_TRANSFER:
Status = HandleIsochronousTransfer(Irp, Urb);
break;
case URB_FUNCTION_CLASS_INTERFACE: case URB_FUNCTION_CLASS_INTERFACE:
Status = HandleClassInterface(Irp, Urb); Status = HandleClassInterface(Irp, Urb);
break; break;
case URB_FUNCTION_CLASS_ENDPOINT:
Status = HandleClassEndpoint(Irp, Urb);
break;
default: default:
DPRINT1("IOCTL_INTERNAL_USB_SUBMIT_URB Function %x NOT IMPLEMENTED\n", Urb->UrbHeader.Function); DPRINT1("IOCTL_INTERNAL_USB_SUBMIT_URB Function %x NOT IMPLEMENTED\n", Urb->UrbHeader.Function);
break; break;
@ -2290,12 +2396,8 @@ USBHI_RestoreUsbDevice(
PC_ASSERT(Controller->ValidateUsbDevice(OldUsbDevice)); PC_ASSERT(Controller->ValidateUsbDevice(OldUsbDevice));
DPRINT1("NewUsbDevice: DeviceAddress %x\n", NewUsbDevice->GetDeviceAddress()); DPRINT1("NewUsbDevice: DeviceAddress %x\n", NewUsbDevice->GetDeviceAddress());
DPRINT1("OldUsbDevice: DeviceAddress %x\n", OldUsbDevice->GetDeviceAddress()); DPRINT1("OldUsbDevice: DeviceAddress %x\n", OldUsbDevice->GetDeviceAddress());
PC_ASSERT(FALSE);
// //
// remove old device handle // remove old device handle
// //

364
drivers/usb/usbohci/usb_device.cpp
View file

@ -11,24 +11,6 @@
#define INITGUID #define INITGUID
#include "usbohci.h" #include "usbohci.h"
typedef struct _USB_ENDPOINT
{
USB_ENDPOINT_DESCRIPTOR EndPointDescriptor;
} USB_ENDPOINT, *PUSB_ENDPOINT;
typedef struct _USB_INTERFACE
{
USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
USB_ENDPOINT *EndPoints;
} USB_INTERFACE, *PUSB_INTERFACE;
typedef struct _USB_CONFIGURATION
{
USB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor;
USB_INTERFACE *Interfaces;
} USB_CONFIGURATION, *PUSB_CONFIGURATION;
class CUSBDevice : public IUSBDevice class CUSBDevice : public IUSBDevice
{ {
public: public:
@ -97,8 +79,7 @@ protected:
ULONG m_PortStatus; ULONG m_PortStatus;
PUSBQUEUE m_Queue; PUSBQUEUE m_Queue;
PDMAMEMORYMANAGER m_DmaManager; PDMAMEMORYMANAGER m_DmaManager;
PUSB_CONFIGURATION_DESCRIPTOR *m_ConfigurationDescriptors;
PUSB_CONFIGURATION m_ConfigurationDescriptors;
}; };
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
@ -400,12 +381,12 @@ CUSBDevice::SetDeviceAddress(
// //
// allocate configuration descriptor // allocate configuration descriptor
// //
m_ConfigurationDescriptors = (PUSB_CONFIGURATION) ExAllocatePoolWithTag(NonPagedPool, sizeof(USB_CONFIGURATION) * m_DeviceDescriptor.bNumConfigurations, TAG_USBOHCI); m_ConfigurationDescriptors = (PUSB_CONFIGURATION_DESCRIPTOR*) ExAllocatePoolWithTag(NonPagedPool, sizeof(PUSB_CONFIGURATION_DESCRIPTOR) * m_DeviceDescriptor.bNumConfigurations, TAG_USBOHCI);
// //
// zero configuration descriptor // zero configuration descriptor
// //
RtlZeroMemory(m_ConfigurationDescriptors, sizeof(USB_CONFIGURATION) * m_DeviceDescriptor.bNumConfigurations); RtlZeroMemory(m_ConfigurationDescriptors, sizeof(PUSB_CONFIGURATION_DESCRIPTOR) * m_DeviceDescriptor.bNumConfigurations);
// //
// retrieve the configuration descriptors // retrieve the configuration descriptors
@ -683,10 +664,7 @@ CUSBDevice::CreateConfigurationDescriptor(
USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup; USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
NTSTATUS Status; NTSTATUS Status;
PMDL Mdl; PMDL Mdl;
ULONG InterfaceIndex, EndPointIndex;
PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor; PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor;
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
PUSB_ENDPOINT_DESCRIPTOR EndPointDescriptor;
// //
@ -783,100 +761,9 @@ CUSBDevice::CreateConfigurationDescriptor(
PC_ASSERT(ConfigurationDescriptor->bNumInterfaces); PC_ASSERT(ConfigurationDescriptor->bNumInterfaces);
// //
// request is complete, initialize configuration descriptor // store configuration descriptor
// //
RtlCopyMemory(&m_ConfigurationDescriptors[Index].ConfigurationDescriptor, ConfigurationDescriptor, ConfigurationDescriptor->bLength); m_ConfigurationDescriptors[Index] = ConfigurationDescriptor;
//
// now allocate interface descriptors
//
m_ConfigurationDescriptors[Index].Interfaces = (PUSB_INTERFACE)ExAllocatePoolWithTag(NonPagedPool, sizeof(USB_INTERFACE) * ConfigurationDescriptor->bNumInterfaces, TAG_USBOHCI);
if (!m_ConfigurationDescriptors[Index].Interfaces)
{
//
// failed to allocate interface descriptors
//
ExFreePool(Buffer);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// zero interface descriptor
//
RtlZeroMemory(m_ConfigurationDescriptors[Index].Interfaces, sizeof(USB_INTERFACE) * ConfigurationDescriptor->bNumInterfaces);
//
// get first interface descriptor
//
InterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR)(ConfigurationDescriptor + 1);
//
// setup interface descriptors
//
for(InterfaceIndex = 0; InterfaceIndex < ConfigurationDescriptor->bNumInterfaces; InterfaceIndex++)
{
//
// sanity check
//
PC_ASSERT(InterfaceDescriptor->bLength == sizeof(USB_INTERFACE_DESCRIPTOR));
PC_ASSERT(InterfaceDescriptor->bNumEndpoints);
//
// copy current interface descriptor
//
RtlCopyMemory(&m_ConfigurationDescriptors[Index].Interfaces[InterfaceIndex].InterfaceDescriptor, InterfaceDescriptor, InterfaceDescriptor->bLength);
//
// allocate end point descriptors
//
m_ConfigurationDescriptors[Index].Interfaces[InterfaceIndex].EndPoints = (PUSB_ENDPOINT)ExAllocatePoolWithTag(NonPagedPool, sizeof(USB_ENDPOINT) * InterfaceDescriptor->bNumEndpoints, TAG_USBOHCI);
if (!m_ConfigurationDescriptors[Index].Interfaces[InterfaceIndex].EndPoints)
{
//
// failed to allocate endpoint
//
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
//
// zero memory
//
RtlZeroMemory(m_ConfigurationDescriptors[Index].Interfaces[InterfaceIndex].EndPoints, sizeof(USB_ENDPOINT) * InterfaceDescriptor->bNumEndpoints);
//
// initialize end point descriptors
//
EndPointDescriptor = (PUSB_ENDPOINT_DESCRIPTOR)(InterfaceDescriptor + 1);
for(EndPointIndex = 0; EndPointIndex < InterfaceDescriptor->bNumEndpoints; EndPointIndex++)
{
//
// sanity check
//
PC_ASSERT(EndPointDescriptor->bLength == sizeof(USB_ENDPOINT_DESCRIPTOR));
//
// copy endpoint descriptor
//
RtlCopyMemory(&m_ConfigurationDescriptors[Index].Interfaces[InterfaceIndex].EndPoints[EndPointIndex].EndPointDescriptor, EndPointDescriptor, EndPointDescriptor->bLength);
//
// move to next offset
//
EndPointDescriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)EndPointDescriptor + EndPointDescriptor->bLength);
}
//
// update interface descriptor offset
//
InterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR)EndPointDescriptor;
}
//
// free buffer
//
ExFreePoolWithTag(Buffer, TAG_USBOHCI);
// //
// done // done
@ -890,9 +777,6 @@ CUSBDevice::GetConfigurationDescriptors(
IN ULONG BufferLength, IN ULONG BufferLength,
OUT PULONG OutBufferLength) OUT PULONG OutBufferLength)
{ {
PVOID Buffer;
ULONG InterfaceIndex, EndpointIndex;
// //
// sanity check // sanity check
// //
@ -911,78 +795,10 @@ CUSBDevice::GetConfigurationDescriptors(
PC_ASSERT(m_DeviceDescriptor.bNumConfigurations == 1); PC_ASSERT(m_DeviceDescriptor.bNumConfigurations == 1);
// //
// copy first configuration descriptor // copy configuration descriptor
// //
RtlCopyMemory(ConfigDescriptorBuffer, &m_ConfigurationDescriptors[0].ConfigurationDescriptor, sizeof(USB_CONFIGURATION_DESCRIPTOR)); RtlCopyMemory(ConfigDescriptorBuffer, m_ConfigurationDescriptors[0], min(m_ConfigurationDescriptors[0]->wTotalLength, BufferLength));
*OutBufferLength = m_ConfigurationDescriptors[0]->wTotalLength;
//
// subtract length
//
BufferLength -= sizeof(USB_CONFIGURATION_DESCRIPTOR);
*OutBufferLength += sizeof(USB_CONFIGURATION_DESCRIPTOR);
//
// increment offset
//
Buffer = (PVOID)(ConfigDescriptorBuffer + 1);
for(InterfaceIndex = 0; InterfaceIndex < m_ConfigurationDescriptors[0].ConfigurationDescriptor.bNumInterfaces; InterfaceIndex++)
{
if (BufferLength < sizeof(USB_INTERFACE_DESCRIPTOR))
{
//
// no more room in buffer
//
return;
}
//
// copy interface descriptor
//
RtlCopyMemory(Buffer, &m_ConfigurationDescriptors[0].Interfaces[InterfaceIndex].InterfaceDescriptor, sizeof(USB_INTERFACE_DESCRIPTOR));
//
// increment offset
//
Buffer = (PVOID)((ULONG_PTR)Buffer + sizeof(USB_INTERFACE_DESCRIPTOR));
BufferLength -= sizeof(USB_INTERFACE_DESCRIPTOR);
*OutBufferLength += sizeof(USB_INTERFACE_DESCRIPTOR);
//
// does the interface have endpoints
//
if (m_ConfigurationDescriptors[0].Interfaces[InterfaceIndex].InterfaceDescriptor.bNumEndpoints)
{
//
// is enough space available
//
if (BufferLength < sizeof(USB_ENDPOINT_DESCRIPTOR) * m_ConfigurationDescriptors[0].Interfaces[InterfaceIndex].InterfaceDescriptor.bNumEndpoints)
{
//
// no buffer
//
return;
}
//
// copy end points
//
for(EndpointIndex = 0; EndpointIndex < m_ConfigurationDescriptors[0].Interfaces[InterfaceIndex].InterfaceDescriptor.bNumEndpoints; EndpointIndex++)
{
//
// copy endpoint
//
RtlCopyMemory(Buffer, &m_ConfigurationDescriptors[0].Interfaces[InterfaceIndex].EndPoints[EndpointIndex].EndPointDescriptor, sizeof(USB_ENDPOINT_DESCRIPTOR));
//
// increment buffer offset
//
Buffer = (PVOID)((ULONG_PTR)Buffer + sizeof(USB_ENDPOINT_DESCRIPTOR));
BufferLength -= sizeof(USB_ENDPOINT_DESCRIPTOR);
*OutBufferLength += sizeof(USB_ENDPOINT_DESCRIPTOR);
}
}
}
} }
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
@ -994,7 +810,10 @@ CUSBDevice::GetConfigurationDescriptorsLength()
// //
PC_ASSERT(m_DeviceDescriptor.bNumConfigurations == 1); PC_ASSERT(m_DeviceDescriptor.bNumConfigurations == 1);
return m_ConfigurationDescriptors[0].ConfigurationDescriptor.wTotalLength; ASSERT(m_ConfigurationDescriptors[0]);
ASSERT(m_ConfigurationDescriptors[0]->wTotalLength);
return m_ConfigurationDescriptors[0]->wTotalLength;
} }
//---------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------
VOID VOID
@ -1074,21 +893,28 @@ CUSBDevice::SelectConfiguration(
IN PUSBD_INTERFACE_INFORMATION InterfaceInfo, IN PUSBD_INTERFACE_INFORMATION InterfaceInfo,
OUT USBD_CONFIGURATION_HANDLE *ConfigurationHandle) OUT USBD_CONFIGURATION_HANDLE *ConfigurationHandle)
{ {
ULONG ConfigurationIndex = 0;
ULONG InterfaceIndex, PipeIndex; ULONG InterfaceIndex, PipeIndex;
USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup; USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
NTSTATUS Status; NTSTATUS Status;
PUSB_CONFIGURATION_DESCRIPTOR CurrentConfigurationDescriptor;
PUSB_INTERFACE_DESCRIPTOR CurrentInterfaceDescriptor;
PUSB_ENDPOINT_DESCRIPTOR CurrentEndpointDescriptor;
PVOID StartPosition;
// //
// FIXME: support multiple configurations // FIXME: support multiple configurations
// //
PC_ASSERT(m_DeviceDescriptor.bNumConfigurations == 1); ASSERT(m_DeviceDescriptor.bNumConfigurations == 1);
PC_ASSERT(ConfigurationDescriptor->iConfiguration == m_ConfigurationDescriptors[ConfigurationIndex].ConfigurationDescriptor.iConfiguration); ASSERT(m_ConfigurationDescriptors[0]);
CurrentConfigurationDescriptor = m_ConfigurationDescriptors[0];
// //
// sanity check // sanity check
// //
PC_ASSERT(ConfigurationDescriptor->bNumInterfaces <= m_ConfigurationDescriptors[ConfigurationIndex].ConfigurationDescriptor.bNumInterfaces); PC_ASSERT(ConfigurationDescriptor->iConfiguration == CurrentConfigurationDescriptor->iConfiguration);
PC_ASSERT(ConfigurationDescriptor->bNumInterfaces <= CurrentConfigurationDescriptor->bNumInterfaces);
DPRINT1("CUSBDevice::SelectConfiguration NumInterfaces %lu\n", ConfigurationDescriptor->bNumInterfaces);
// //
// copy interface info and pipe info // copy interface info and pipe info
@ -1096,36 +922,62 @@ CUSBDevice::SelectConfiguration(
for(InterfaceIndex = 0; InterfaceIndex < ConfigurationDescriptor->bNumInterfaces; InterfaceIndex++) for(InterfaceIndex = 0; InterfaceIndex < ConfigurationDescriptor->bNumInterfaces; InterfaceIndex++)
{ {
// //
// sanity check: is the info pre-layed out // find interface descriptor
// //
PC_ASSERT(InterfaceInfo->NumberOfPipes == m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].InterfaceDescriptor.bNumEndpoints); CurrentInterfaceDescriptor = USBD_ParseConfigurationDescriptor(CurrentConfigurationDescriptor, InterfaceInfo->InterfaceNumber, InterfaceInfo->AlternateSetting);
PC_ASSERT(InterfaceInfo->Length != 0);
//
// sanity check
//
ASSERT(CurrentInterfaceDescriptor);
ASSERT(CurrentInterfaceDescriptor->bLength != 0);
ASSERT(InterfaceInfo->NumberOfPipes == CurrentInterfaceDescriptor->bNumEndpoints);
ASSERT(InterfaceInfo->Length != 0);
#ifdef _MSC_VER #ifdef _MSC_VER
PC_ASSERT(InterfaceInfo->Length == FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes[InterfaceInfo->NumberOfPipes])); PC_ASSERT(InterfaceInfo->Length == FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes[InterfaceInfo->NumberOfPipes]));
#endif #endif
DPRINT1("CUSBDevice::SelectConfiguration InterfaceNumber %lu AlternativeSetting %lu bNumEndpoints %lu\n", InterfaceInfo->InterfaceNumber, InterfaceInfo->AlternateSetting, CurrentInterfaceDescriptor->bNumEndpoints);
// //
// copy interface info // copy interface info
// //
InterfaceInfo->InterfaceHandle = (USBD_INTERFACE_HANDLE)&m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex]; InterfaceInfo->InterfaceHandle = (USBD_INTERFACE_HANDLE)CurrentInterfaceDescriptor;
InterfaceInfo->Class = m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].InterfaceDescriptor.bInterfaceClass; InterfaceInfo->Class = CurrentInterfaceDescriptor->bInterfaceClass;
InterfaceInfo->SubClass = m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].InterfaceDescriptor.bInterfaceSubClass; InterfaceInfo->SubClass = CurrentInterfaceDescriptor->bInterfaceSubClass;
InterfaceInfo->Protocol = m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].InterfaceDescriptor.bInterfaceProtocol; InterfaceInfo->Protocol = CurrentInterfaceDescriptor->bInterfaceProtocol;
InterfaceInfo->Reserved = 0; InterfaceInfo->Reserved = 0;
// //
// copy endpoint info // copy endpoint info
// //
StartPosition = CurrentInterfaceDescriptor;
for(PipeIndex = 0; PipeIndex < InterfaceInfo->NumberOfPipes; PipeIndex++) for(PipeIndex = 0; PipeIndex < InterfaceInfo->NumberOfPipes; PipeIndex++)
{ {
//
// find corresponding endpoint descriptor
//
CurrentEndpointDescriptor = (PUSB_ENDPOINT_DESCRIPTOR)USBD_ParseDescriptors(CurrentConfigurationDescriptor, CurrentConfigurationDescriptor->wTotalLength, StartPosition, USB_ENDPOINT_DESCRIPTOR_TYPE);
//
// sanity checks
//
ASSERT(CurrentEndpointDescriptor);
ASSERT(CurrentEndpointDescriptor->bDescriptorType == USB_ENDPOINT_DESCRIPTOR_TYPE);
// //
// copy pipe info // copy pipe info
// //
InterfaceInfo->Pipes[PipeIndex].MaximumPacketSize = m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].EndPoints[PipeIndex].EndPointDescriptor.wMaxPacketSize; InterfaceInfo->Pipes[PipeIndex].MaximumPacketSize = CurrentEndpointDescriptor->wMaxPacketSize;
InterfaceInfo->Pipes[PipeIndex].EndpointAddress = m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].EndPoints[PipeIndex].EndPointDescriptor.bEndpointAddress; InterfaceInfo->Pipes[PipeIndex].EndpointAddress = CurrentEndpointDescriptor->bEndpointAddress;
InterfaceInfo->Pipes[PipeIndex].Interval = m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].EndPoints[PipeIndex].EndPointDescriptor.bInterval; InterfaceInfo->Pipes[PipeIndex].Interval = CurrentEndpointDescriptor->bInterval;
InterfaceInfo->Pipes[PipeIndex].PipeType = (USBD_PIPE_TYPE)m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].EndPoints[PipeIndex].EndPointDescriptor.bmAttributes; InterfaceInfo->Pipes[PipeIndex].PipeType = (USBD_PIPE_TYPE)CurrentEndpointDescriptor->bmAttributes;
InterfaceInfo->Pipes[PipeIndex].PipeHandle = (PVOID)&m_ConfigurationDescriptors[ConfigurationIndex].Interfaces[InterfaceIndex].EndPoints[PipeIndex].EndPointDescriptor; InterfaceInfo->Pipes[PipeIndex].PipeHandle = (PVOID)CurrentEndpointDescriptor;
//
// move start position beyond the current endpoint descriptor
//
StartPosition = (PVOID)(CurrentEndpointDescriptor + 1);
} }
// //
@ -1161,7 +1013,7 @@ CUSBDevice::SelectConfiguration(
// //
// store configuration handle // store configuration handle
// //
*ConfigurationHandle = &m_ConfigurationDescriptors[ConfigurationIndex]; *ConfigurationHandle = m_ConfigurationDescriptors[0];
} }
// //
@ -1177,65 +1029,49 @@ CUSBDevice::SelectInterface(
IN OUT PUSBD_INTERFACE_INFORMATION InterfaceInfo) IN OUT PUSBD_INTERFACE_INFORMATION InterfaceInfo)
{ {
ULONG ConfigurationIndex = 0; ULONG ConfigurationIndex = 0;
PUSB_CONFIGURATION Configuration; PUSB_CONFIGURATION_DESCRIPTOR Configuration;
ULONG PipeIndex; ULONG PipeIndex;
USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup; USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
NTSTATUS Status; NTSTATUS Status;
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
PUSB_ENDPOINT_DESCRIPTOR CurrentEndpointDescriptor;
PVOID StartPosition;
// //
// FIXME support multiple configurations // FIXME support multiple configurations
// //
PC_ASSERT(&m_ConfigurationDescriptors[ConfigurationIndex] == (PUSB_CONFIGURATION)ConfigurationHandle); PC_ASSERT(m_ConfigurationDescriptors[0] == (PUSB_CONFIGURATION_DESCRIPTOR)ConfigurationHandle);
// //
// get configuration struct // get configuration struct
// //
Configuration = (PUSB_CONFIGURATION)ConfigurationHandle; Configuration = (PUSB_CONFIGURATION_DESCRIPTOR)ConfigurationHandle;
// //
// sanity checks // sanity checks
// //
PC_ASSERT(Configuration->ConfigurationDescriptor.bNumInterfaces > InterfaceInfo->InterfaceNumber); PC_ASSERT(Configuration->bNumInterfaces > InterfaceInfo->InterfaceNumber);
PC_ASSERT(Configuration->Interfaces[InterfaceInfo->InterfaceNumber].InterfaceDescriptor.bNumEndpoints == InterfaceInfo->NumberOfPipes);
#ifdef _MSC_VER #ifdef _MSC_VER
PC_ASSERT(InterfaceInfo->Length == FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes[InterfaceInfo->NumberOfPipes])); //PC_ASSERT(InterfaceInfo->Length == FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes[InterfaceInfo->NumberOfPipes]));
#endif #endif
// //
// copy pipe handles // FIXME: check bandwidth
// //
for(PipeIndex = 0; PipeIndex < InterfaceInfo->NumberOfPipes; PipeIndex++)
{
//
// copy pipe handle
//
DPRINT1("PipeIndex %lu\n", PipeIndex);
DPRINT1("EndpointAddress %x\n", InterfaceInfo->Pipes[PipeIndex].EndpointAddress);
DPRINT1("Interval %d\n", InterfaceInfo->Pipes[PipeIndex].Interval);
DPRINT1("MaximumPacketSize %d\n", InterfaceInfo->Pipes[PipeIndex].MaximumPacketSize);
DPRINT1("MaximumTransferSize %d\n", InterfaceInfo->Pipes[PipeIndex].MaximumTransferSize);
DPRINT1("PipeFlags %d\n", InterfaceInfo->Pipes[PipeIndex].PipeFlags);
DPRINT1("PipeType %dd\n", InterfaceInfo->Pipes[PipeIndex].PipeType);
DPRINT1("UsbEndPoint %x\n", Configuration->Interfaces[InterfaceInfo->InterfaceNumber].EndPoints[PipeIndex].EndPointDescriptor.bEndpointAddress);
PC_ASSERT(Configuration->Interfaces[InterfaceInfo->InterfaceNumber].EndPoints[PipeIndex].EndPointDescriptor.bEndpointAddress == InterfaceInfo->Pipes[PipeIndex].EndpointAddress);
InterfaceInfo->Pipes[PipeIndex].PipeHandle = &Configuration->Interfaces[InterfaceInfo->InterfaceNumber].EndPoints[PipeIndex].EndPointDescriptor;
if (Configuration->Interfaces[InterfaceInfo->InterfaceNumber].EndPoints[PipeIndex].EndPointDescriptor.bmAttributes & (USB_ENDPOINT_TYPE_ISOCHRONOUS | USB_ENDPOINT_TYPE_INTERRUPT))
{
// //
// FIXME: check if enough bandwidth is available // find interface number
// //
} InterfaceDescriptor = USBD_ParseConfigurationDescriptor(Configuration, InterfaceInfo->InterfaceNumber, InterfaceInfo->AlternateSetting);
} ASSERT(InterfaceDescriptor);
// //
// initialize setup packet // initialize setup packet
// //
RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET)); RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
CtrlSetup.bRequest = USB_REQUEST_SET_INTERFACE; CtrlSetup.bRequest = USB_REQUEST_SET_INTERFACE;
CtrlSetup.wValue.W = Configuration->Interfaces[InterfaceInfo->InterfaceNumber].InterfaceDescriptor.bAlternateSetting; CtrlSetup.wValue.W = InterfaceDescriptor->bAlternateSetting;
CtrlSetup.wIndex.W = Configuration->Interfaces[InterfaceInfo->InterfaceNumber].InterfaceDescriptor.bInterfaceNumber; CtrlSetup.wIndex.W = InterfaceDescriptor->bInterfaceNumber;
CtrlSetup.bmRequestType.B = 0x01; CtrlSetup.bmRequestType.B = 0x01;
// //
@ -1247,7 +1083,55 @@ CUSBDevice::SelectInterface(
// informal debug print // informal debug print
// //
DPRINT1("CUSBDevice::SelectInterface AlternateSetting %x InterfaceNumber %x Status %x\n", InterfaceInfo->AlternateSetting, InterfaceInfo->InterfaceNumber, Status); DPRINT1("CUSBDevice::SelectInterface AlternateSetting %x InterfaceNumber %x Status %x\n", InterfaceInfo->AlternateSetting, InterfaceInfo->InterfaceNumber, Status);
DPRINT1("CUSBDevice::SelectInterface bInterfaceNumber %u bAlternateSetting %u NumberOfPipes %u Length %lu\n",
InterfaceDescriptor->bInterfaceNumber, InterfaceDescriptor->bAlternateSetting, InterfaceInfo->NumberOfPipes, InterfaceInfo->Length);
InterfaceInfo->InterfaceHandle = InterfaceDescriptor;
InterfaceInfo->NumberOfPipes = InterfaceDescriptor->bNumEndpoints;
//
// are there end points
//
if (InterfaceDescriptor->bNumEndpoints)
{
//
// sanity check
//
ASSERT(InterfaceInfo->Length == sizeof(USBD_INTERFACE_INFORMATION) + (InterfaceDescriptor->bNumEndpoints > 1 ? sizeof(USBD_PIPE_INFORMATION) * (InterfaceDescriptor->bNumEndpoints - 1) : 0));
//
// store number of pipes
//
InterfaceInfo->NumberOfPipes = InterfaceDescriptor->bNumEndpoints;
StartPosition = InterfaceDescriptor;
for(PipeIndex = 0; PipeIndex < InterfaceInfo->NumberOfPipes; PipeIndex++)
{
//
// find corresponding endpoint descriptor
//
CurrentEndpointDescriptor = (PUSB_ENDPOINT_DESCRIPTOR)USBD_ParseDescriptors(Configuration, Configuration->wTotalLength, StartPosition, USB_ENDPOINT_DESCRIPTOR_TYPE);
//
// sanity checks
//
ASSERT(CurrentEndpointDescriptor);
ASSERT(CurrentEndpointDescriptor->bDescriptorType == USB_ENDPOINT_DESCRIPTOR_TYPE);
//
// copy pipe info
//
InterfaceInfo->Pipes[PipeIndex].MaximumPacketSize = CurrentEndpointDescriptor->wMaxPacketSize;
InterfaceInfo->Pipes[PipeIndex].EndpointAddress = CurrentEndpointDescriptor->bEndpointAddress;
InterfaceInfo->Pipes[PipeIndex].Interval = CurrentEndpointDescriptor->bInterval;
InterfaceInfo->Pipes[PipeIndex].PipeType = (USBD_PIPE_TYPE)CurrentEndpointDescriptor->bmAttributes;
InterfaceInfo->Pipes[PipeIndex].PipeHandle = (PVOID)CurrentEndpointDescriptor;
//
// move start position beyond the current endpoint descriptor
//
StartPosition = (PVOID)(CurrentEndpointDescriptor + 1);
}
}
// //
// done // done
// //

2
drivers/usb/usbohci/usb_queue.cpp
View file

@ -146,10 +146,10 @@ CUSBQueue::AddUSBRequest(
{ {
case USB_ENDPOINT_TYPE_ISOCHRONOUS: case USB_ENDPOINT_TYPE_ISOCHRONOUS:
case USB_ENDPOINT_TYPE_INTERRUPT: case USB_ENDPOINT_TYPE_INTERRUPT:
case USB_ENDPOINT_TYPE_BULK:
/* NOT IMPLEMENTED IN QUEUE */ /* NOT IMPLEMENTED IN QUEUE */
Status = STATUS_NOT_SUPPORTED; Status = STATUS_NOT_SUPPORTED;
break; break;
case USB_ENDPOINT_TYPE_BULK:
case USB_ENDPOINT_TYPE_CONTROL: case USB_ENDPOINT_TYPE_CONTROL:
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
break; break;

7
drivers/usb/usbohci/usbohci.h
View file

@ -7,6 +7,13 @@
#include <hubbusif.h> #include <hubbusif.h>
#include <usbbusif.h> #include <usbbusif.h>
#include <usbioctl.h> #include <usbioctl.h>
extern
"C"
{
#include <usbdlib.h>
}
// //
// FIXME: // FIXME:
// #include <usbprotocoldefs.h> // #include <usbprotocoldefs.h>