reactos/drivers/usb/usbuhci/usb_queue.cpp

549 lines
13 KiB
C++
Raw Normal View History

/*
* PROJECT: ReactOS Universal Serial Bus Host Controller Interface
* LICENSE: GPL - See COPYING in the top level directory
* FILE: drivers/usb/usbuhci/usb_queue.cpp
* PURPOSE: USB UHCI device driver.
* PROGRAMMERS:
* Michael Martin (michael.martin@reactos.org)
* Johannes Anderwald (johannes.anderwald@reactos.org)
*/
#include "usbuhci.h"
#define NDEBUG
#include <debug.h>
class CUSBQueue : public IUHCIQueue
{
public:
STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
STDMETHODIMP_(ULONG) AddRef()
{
InterlockedIncrement(&m_Ref);
return m_Ref;
}
STDMETHODIMP_(ULONG) Release()
{
InterlockedDecrement(&m_Ref);
if (!m_Ref)
{
delete this;
return 0;
}
return m_Ref;
}
// com
IMP_IUSBQUEUE
IMP_IUHCIQUEUE
// local
VOID LinkQueueHead(PUHCI_QUEUE_HEAD QueueHead, PUHCI_QUEUE_HEAD NextQueueHead);
VOID UnLinkQueueHead(PUHCI_QUEUE_HEAD PreviousQueueHead, PUHCI_QUEUE_HEAD NextQueueHead);
BOOLEAN IsQueueHeadComplete(PUHCI_QUEUE_HEAD QueueHead);
NTSTATUS AddQueueHead(PUHCI_QUEUE_HEAD NewQueueHead);
VOID QueueHeadCleanup(IN PUHCI_QUEUE_HEAD QueueHead, IN PUHCI_QUEUE_HEAD PreviousQueueHead, OUT PUHCI_QUEUE_HEAD *NextQueueHead);
// constructor / destructor
CUSBQueue(IUnknown *OuterUnknown){}
virtual ~CUSBQueue(){}
protected:
LONG m_Ref; // reference count
KSPIN_LOCK m_Lock; // list lock
PUHCIHARDWAREDEVICE m_Hardware; // hardware
};
//=================================================================================================
// COM
//
NTSTATUS
STDMETHODCALLTYPE
CUSBQueue::QueryInterface(
IN REFIID refiid,
OUT PVOID* Output)
{
if (IsEqualGUIDAligned(refiid, IID_IUnknown))
{
*Output = PVOID(PUNKNOWN(this));
PUNKNOWN(*Output)->AddRef();
return STATUS_SUCCESS;
}
return STATUS_UNSUCCESSFUL;
}
NTSTATUS
CUSBQueue::Initialize(
IN PUSBHARDWAREDEVICE Hardware,
IN PDMA_ADAPTER AdapterObject,
IN PDMAMEMORYMANAGER MemManager,
IN OPTIONAL PKSPIN_LOCK Lock)
{
//
// store hardware
//
m_Hardware = PUHCIHARDWAREDEVICE(Hardware);
//
// initialize spinlock
//
KeInitializeSpinLock(&m_Lock);
return STATUS_SUCCESS;
}
NTSTATUS
CUSBQueue::AddQueueHead(
PUHCI_QUEUE_HEAD NewQueueHead)
{
PUHCIREQUEST Request;
PUHCI_QUEUE_HEAD QueueHead = NULL;
//
// get request
//
Request = (PUHCIREQUEST)NewQueueHead->Request;
if (!Request)
{
//
// no request
//
return STATUS_INVALID_PARAMETER;
}
if (Request->GetTransferType() == USB_ENDPOINT_TYPE_CONTROL)
{
//
// get device speed
//
if (Request->GetDeviceSpeed() == UsbLowSpeed)
{
//
// use low speed queue
//
m_Hardware->GetQueueHead(UHCI_LOW_SPEED_CONTROL_QUEUE, &QueueHead);
}
else
{
//
// use full speed queue
//
m_Hardware->GetQueueHead(UHCI_FULL_SPEED_CONTROL_QUEUE, &QueueHead);
}
}
else if (Request->GetTransferType() == USB_ENDPOINT_TYPE_BULK)
{
//
// use full speed queue
//
m_Hardware->GetQueueHead(UHCI_BULK_QUEUE, &QueueHead);
}
else if (Request->GetTransferType() == USB_ENDPOINT_TYPE_INTERRUPT)
{
//
// use full speed queue
//
m_Hardware->GetQueueHead(UHCI_INTERRUPT_QUEUE, &QueueHead);
}
//
// FIXME support isochronous
//
ASSERT(QueueHead);
//
// add reference
//
Request->AddRef();
//
// now link the new queue head
//
LinkQueueHead(QueueHead, NewQueueHead);
return STATUS_SUCCESS;
}
NTSTATUS
CUSBQueue::AddUSBRequest(
IUSBRequest * Req)
{
PUHCI_QUEUE_HEAD NewQueueHead;
NTSTATUS Status;
PUHCIREQUEST Request;
// get request
Request = (PUHCIREQUEST)Req;
//
// get queue head
//
Status = Request->GetEndpointDescriptor(&NewQueueHead);
if (!NT_SUCCESS(Status))
{
//
// failed to create queue head
//
DPRINT1("[USBUHCI] Failed to create queue head %x\n", Status);
return Status;
}
//
// sanity check
//
ASSERT(PVOID(Request) == NewQueueHead->Request);
//
// add queue head
//
DPRINT("AddUSBRequest Request %p\n", Request);
DPRINT("NewQueueHead %p\n", NewQueueHead);
return AddQueueHead(NewQueueHead);
}
VOID
CUSBQueue::LinkQueueHead(
IN PUHCI_QUEUE_HEAD QueueHead,
IN PUHCI_QUEUE_HEAD NextQueueHead)
{
NextQueueHead->LinkPhysical = QueueHead->LinkPhysical;
NextQueueHead->NextLogicalDescriptor = QueueHead->NextLogicalDescriptor;
QueueHead->LinkPhysical = NextQueueHead->PhysicalAddress | QH_NEXT_IS_QH;
QueueHead->NextLogicalDescriptor = (PVOID)NextQueueHead;
}
VOID
CUSBQueue::UnLinkQueueHead(
PUHCI_QUEUE_HEAD QueueHeadToRemove,
PUHCI_QUEUE_HEAD PreviousQueueHead)
{
PreviousQueueHead->LinkPhysical = QueueHeadToRemove->LinkPhysical;
PreviousQueueHead->NextLogicalDescriptor = QueueHeadToRemove->NextLogicalDescriptor;
}
NTSTATUS
CUSBQueue::AbortDevicePipe(
IN UCHAR DeviceAddress,
IN PUSB_ENDPOINT_DESCRIPTOR EndDescriptor)
{
KIRQL OldLevel;
PUHCI_TRANSFER_DESCRIPTOR Descriptor;
PUHCI_QUEUE_HEAD QueueHead, PreviousQueueHead = NULL;
UCHAR EndpointAddress, EndpointDeviceAddress;
PUSB_ENDPOINT EndpointDescriptor;
// get descriptor
EndpointDescriptor = (PUSB_ENDPOINT)EndDescriptor;
// acquire lock
KeAcquireSpinLock(&m_Lock, &OldLevel);
// get queue head
m_Hardware->GetQueueHead(UHCI_INTERRUPT_QUEUE, &QueueHead);
while(QueueHead)
{
// get descriptor
Descriptor = (PUHCI_TRANSFER_DESCRIPTOR)QueueHead->NextElementDescriptor;
if (Descriptor)
{
// extract endpoint address
EndpointAddress = (Descriptor->Token >> TD_TOKEN_ENDPTADDR_SHIFT) & 0x0F;
// extract device address
EndpointDeviceAddress = (Descriptor->Token >> TD_TOKEN_DEVADDR_SHIFT) & 0x7F;
// check if they match
if (EndpointAddress == (EndpointDescriptor->EndPointDescriptor.bEndpointAddress & 0x0F) &&
DeviceAddress == EndpointDeviceAddress)
{
// cleanup queue head
QueueHeadCleanup(QueueHead, PreviousQueueHead, &QueueHead);
continue;
}
}
// move to next queue head
PreviousQueueHead = QueueHead;
QueueHead = (PUHCI_QUEUE_HEAD)QueueHead->NextLogicalDescriptor;
}
// release lock
KeReleaseSpinLock(&m_Lock, OldLevel);
return STATUS_SUCCESS;
}
NTSTATUS
CUSBQueue::CreateUSBRequest(
IUSBRequest **OutRequest)
{
PUSBREQUEST UsbRequest;
NTSTATUS Status;
*OutRequest = NULL;
Status = InternalCreateUSBRequest(&UsbRequest);
if (NT_SUCCESS(Status))
{
*OutRequest = UsbRequest;
}
return Status;
}
BOOLEAN
CUSBQueue::IsQueueHeadComplete(
IN PUHCI_QUEUE_HEAD QueueHead)
{
PUHCI_TRANSFER_DESCRIPTOR Descriptor;
ULONG ErrorCount;
if (QueueHead->NextElementDescriptor == NULL)
{
//
// empty queue head
//
DPRINT("QueueHead %p empty element physical\n", QueueHead);
return FALSE;
}
//
// check all descriptors
//
Descriptor = (PUHCI_TRANSFER_DESCRIPTOR)QueueHead->NextElementDescriptor;
while(Descriptor)
{
if (Descriptor->Status & TD_STATUS_ACTIVE)
{
//
// descriptor is still active
//
DPRINT("Descriptor %p is active Status %x BufferSize %lu\n", Descriptor, Descriptor->Status, Descriptor->BufferSize);
return FALSE;
}
if (Descriptor->Status & TD_ERROR_MASK)
{
//
// error happened
//
DPRINT1("[USBUHCI] Error detected at descriptor %p Physical %x\n", Descriptor, Descriptor->PhysicalAddress);
//
// get error count
//
ErrorCount = (Descriptor->Status >> TD_ERROR_COUNT_SHIFT) & TD_ERROR_COUNT_MASK;
if (ErrorCount == 0)
{
//
// error retry count elapsed
//
DPRINT1("[USBUHCI] ErrorBuffer %x TimeOut %x Nak %x BitStuff %x\n",
Descriptor->Status & TD_STATUS_ERROR_BUFFER,
Descriptor->Status & TD_STATUS_ERROR_TIMEOUT,
Descriptor->Status & TD_STATUS_ERROR_NAK,
Descriptor->Status & TD_STATUS_ERROR_BITSTUFF);
return TRUE;
}
else if (Descriptor->Status & TD_STATUS_ERROR_BABBLE)
{
//
// babble error
//
DPRINT1("[USBUHCI] Babble detected\n");
return TRUE;
}
else
{
//
// stall detected
//
DPRINT1("[USBUHCI] Stall detected\n");
}
}
//
// move to next descriptor
//
Descriptor = (PUHCI_TRANSFER_DESCRIPTOR)Descriptor->NextLogicalDescriptor;
}
//
// request is complete
//
return TRUE;
}
VOID
CUSBQueue::QueueHeadCleanup(
IN PUHCI_QUEUE_HEAD QueueHead,
IN PUHCI_QUEUE_HEAD PreviousQueueHead,
OUT PUHCI_QUEUE_HEAD *NextQueueHead)
{
PUHCIREQUEST Request;
PUHCI_QUEUE_HEAD NewQueueHead;
NTSTATUS Status;
//
// unlink queue head
//
UnLinkQueueHead(QueueHead, PreviousQueueHead);
//
// get next queue head
//
*NextQueueHead = (PUHCI_QUEUE_HEAD)PreviousQueueHead->NextLogicalDescriptor;
ASSERT(*NextQueueHead != QueueHead);
//
// the queue head is complete, is the transfer now completed?
//
Request = (PUHCIREQUEST)QueueHead->Request;
ASSERT(Request);
//
// free queue head
//
DPRINT("Request %p\n", Request);
Request->FreeEndpointDescriptor(QueueHead);
//
// check if transfer is complete
//
if (Request->IsRequestComplete())
{
//
// the transfer is complete
//
Request->CompletionCallback();
Request->Release();
return;
}
//
// grab new queue head
//
Status = Request->GetEndpointDescriptor(&NewQueueHead);
if (!NT_SUCCESS(Status))
{
//
// failed to get new queue head
//
DPRINT1("[USBUHCI] Failed to get new queue head with %x\n", Status);
Request->CompletionCallback();
Request->Release();
return;
}
//
// Link queue head
//
Status = AddQueueHead(NewQueueHead);
if (!NT_SUCCESS(Status))
{
//
// failed to get new queue head
//
DPRINT1("[USBUHCI] Failed to add queue head with %x\n", Status);
Request->CompletionCallback();
Request->Release();
return;
}
}
VOID
CUSBQueue::TransferInterrupt(
UCHAR ErrorInterrupt)
{
KIRQL OldLevel;
PUHCI_QUEUE_HEAD QueueHead, PreviousQueueHead = NULL;
BOOLEAN IsComplete;
//
// acquire lock
//
KeAcquireSpinLock(&m_Lock, &OldLevel);
//
// get queue head
//
m_Hardware->GetQueueHead(UHCI_INTERRUPT_QUEUE, &QueueHead);
while(QueueHead)
{
//
// is queue head complete
//
DPRINT("QueueHead %p\n", QueueHead);
IsComplete = IsQueueHeadComplete(QueueHead);
if (IsComplete)
{
//
// cleanup queue head
//
QueueHeadCleanup(QueueHead, PreviousQueueHead, &QueueHead);
continue;
}
//
// backup previous queue head
//
PreviousQueueHead = QueueHead;
//
// get next queue head
//
QueueHead = (PUHCI_QUEUE_HEAD)QueueHead->NextLogicalDescriptor;
}
//
// release lock
//
KeReleaseSpinLock(&m_Lock, OldLevel);
}
NTSTATUS
NTAPI
CreateUSBQueue(
PUSBQUEUE *OutUsbQueue)
{
PUSBQUEUE This;
//
// allocate controller
//
This = new(NonPagedPool, TAG_USBUHCI) CUSBQueue(0);
if (!This)
{
//
// failed to allocate
//
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// add reference count
//
This->AddRef();
//
// return result
//
*OutUsbQueue = (PUSBQUEUE)This;
//
// done
//
return STATUS_SUCCESS;
}