/// <summary>
/// Insert head
/// </summary>
/// <param name="controller">UHCIController</param>
/// <param name="head"></param>
public static void InsertHead(UHCIController controller, UHCIQueueHead *head)
{
mMutex.Lock();
UHCIQueueHead *end = controller.FirstHead;
while (true)
{
if (end->Next != null)
{
end = end->Next;
}
else
{
break;
}
}
head->Head = TD_POINTER_TERMINATE;
head->Previous = end;
head->Next = null;
end->Next = head;
end->Head = (int)Paging.GetPhysicalFromVirtual(head) | TD_POINTER_QH;
mMutex.Unlock();
}
public static void RemoveHead(UHCIController controller, UHCIQueueHead *head)
{
mMutex.Lock();
/**
* Set next to previous
*/
if (head->Previous != null)
{
if (head->Next != null)
{
head->Previous->Head = head->Head;
head->Previous->Next = head->Next;
}
else
{
head->Previous->Head = TD_POINTER_TERMINATE;
head->Previous->Next = null;
}
}
/**
* Set previous to next
*/
if (head->Next != null)
{
head->Next->Previous = head->Previous;
}
FreeHead(controller, head);
mMutex.Unlock();
}
public static void WaitForQueueHead(UHCIController controller, UHCIQueueHead *head)
{
while (!head->Transfer->Executed)
{
ProcessHead(controller, head);
}
}
/// <summary>
/// Prepare interrupt
/// </summary>
/// <param name="dev"></param>
/// <param name="transfer"></param>
private static void PrepareInterrupt(USBDevice dev, USBTransfer *transfer)
{
UHCIController controller = (UHCIController)dev.Controller;
uint endp = (uint)(dev.EndPointDesc->Address & 0xF);
UHCITransmitDescriptor *td = GetTransmit(controller);
if (td == null)
{
transfer->Success = false;
transfer->Executed = true;
}
UHCITransmitDescriptor *head = td;
/**
* Initalize read
*/
InitTransmit(td, null, dev.Speed, dev.Address, endp, dev.Toggle, TRANS_PACKET_IN, transfer->Length, transfer->Data);
UHCIQueueHead *qh = GetQueueHead(controller);
qh->Element = (int)Paging.GetPhysicalFromVirtual(head);
qh->Head = 0;
qh->Transfer = transfer;
qh->Transmit = head;
InsertHead(controller, qh);
}
public static void PrintQueue(int num, UHCIQueueHead *head)
{
Console.Write("QUEUE HEAD (");
Console.WriteNum(num);
Console.Write(") , cur = ");
Console.WriteHex((int)head);
Console.Write(", Next = ");
Console.WriteHex((int)head->Next);
Console.Write(", Prev = ");
Console.WriteHex((int)head->Previous);
Console.Write(", ELEM = ");
Console.WriteHex((int)head->Element);
Console.WriteLine("");
}
/// <summary>
/// Transfer
/// </summary>
/// <param name="dev">Device</param>
/// <param name="transfer">Transfers</param>
/// <param name="length">Number of transfers</param>
private static unsafe void TransferOne(USBDevice dev, USBTransfer *transfer)
{
USBDeviceRequest request = transfer->Request;
UHCIController controller = (UHCIController)dev.Controller;
UHCITransmitDescriptor *td = GetTransmit(controller);
InitTransmit(td, null, dev.Speed, dev.Address, transfer->Endpoint, dev.Toggle, (transfer->Type == 0) ? TRANS_PACKET_IN : TRANS_PACKET_OUT, transfer->Length, transfer->Data);
UHCIQueueHead *qh = GetQueueHead(controller);
qh->Element = (int)Paging.GetPhysicalFromVirtual(td);
qh->Head = 0;
qh->Transfer = transfer;
qh->Transmit = td;
InsertHead(controller, qh);
WaitForQueueHead(controller, qh);
}
public static void FreeHead(UHCIController controller, UHCIQueueHead *head)
{
head->Allocated = false;
}
/// <summary>
/// Process Queue Head
/// </summary>
/// <param name="device"></param>
/// <param name="head"></param>
public static void ProcessHead(UHCIController controller, UHCIQueueHead *head)
{
USBTransfer *transfer = head->Transfer;
UHCITransmitDescriptor *td = head->Transmit;
if ((head->Element & ~0xF) == 0)
{
transfer->Executed = true;
transfer->Success = true;
}
else
{
if ((td->Control & TD_CONTROL_NAK) > 0)
{
}
if ((td->Control & TD_CONTROL_STALLED) > 0)
{
Console.WriteLine("Stalled");
transfer->Executed = true;
transfer->Success = false;
}
if ((td->Control & TD_CONTROL_BABBLE) > 0)
{
Console.WriteLine("Control Babble error");
}
if ((td->Control & TD_CONTROL_CRC) > 0)
{
Console.WriteLine("CRC Timeout");
transfer->Executed = true;
transfer->Success = false;
}
if ((td->Control & TD_CONTROL_BITSTUFF) > 0)
{
Console.WriteLine("Bitstuff error");
}
}
if (transfer->Executed)
{
//if(transfer->ID > 0)
//{
// PrintQueue(transfer->ID, head);
//}
head->Transfer = null;
/**
* We need to toggle endpoint state here
*/
/**
* Remove head from schedule
*/
RemoveHead(controller, head);
/**
* Free transmit descriptors
*/
UHCITransmitDescriptor *tdE = td;
while (tdE != null)
{
UHCITransmitDescriptor *next = tdE->Next;
FreeTransmit(controller, tdE);
tdE = next;
}
}
}
/// <summary>
/// Control USB Device
/// </summary>
/// <param name="dev"></param>
/// <param name="transfer"></param>
private static void Control(USBDevice dev, USBTransfer *transfer)
{
USBDeviceRequest request = transfer->Request;
#if __UHCI_DIAG
Console.WriteLine("------ UHCI Control message ---------");
Console.Write("Request: ");
Console.WriteHex(request.Request);
Console.WriteLine("");
Console.Write("Index: ");
Console.WriteHex(request.Index);
Console.WriteLine("");
Console.Write("Length:");
Console.WriteHex(request.Length);
Console.WriteLine("");
Console.Write("Type:");
Console.WriteHex(request.Type);
Console.WriteLine("");
Console.Write("Value:");
Console.WriteHex(request.Value);
Console.WriteLine("");
Console.WriteLine("--------------------------------------");
#endif
UHCIController controller = (UHCIController)dev.Controller;
UHCITransmitDescriptor *td = GetTransmit(controller);
UHCITransmitDescriptor *head = td;
UHCITransmitDescriptor *prev = null;
USBDeviceRequest *a = (USBDeviceRequest *)Heap.Alloc(sizeof(USBDeviceRequest));
a->Request = request.Request;
a->Index = request.Index;
a->Length = request.Length;
a->Type = request.Type;
a->Value = request.Value;
InitTransmit(td, prev, dev.Speed, dev.Address, 0, 0, TRANS_PACKET_SETUP, (uint)sizeof(USBDeviceRequest), (byte *)a);
prev = td;
uint packetType = ((request.Type & USBDevice.TYPE_DEVICETOHOST) > 0) ? TRANS_PACKET_IN : TRANS_PACKET_OUT;
byte *ptr = transfer->Data;
uint packetSize = transfer->Length;
uint offset = 0;
uint toggle = 0;
uint remaining = packetSize;
while (remaining > 0)
{
td = GetTransmit(controller);
if (td == null)
{
return;
}
packetSize = remaining;
if (packetSize > dev.MaxPacketSize)
{
packetSize = dev.MaxPacketSize;
}
remaining -= packetSize;
toggle ^= 1;
InitTransmit(td, prev, dev.Speed, dev.Address, 0, toggle, packetType, packetSize, ptr + offset);
prev = td;
offset += packetSize;
}
td = GetTransmit(controller);
if (td == null)
{
return;
}
packetType = ((request.Type & USBDevice.TYPE_DEVICETOHOST) > 0) ? TRANS_PACKET_OUT : TRANS_PACKET_IN;
toggle = 1;
InitTransmit(td, prev, dev.Speed, dev.Address, 0, toggle, packetType, 0, null);
UHCIQueueHead *qh = GetQueueHead(controller);
qh->Element = (int)Paging.GetPhysicalFromVirtual(head);
qh->Head = 0;
qh->Transfer = transfer;
qh->Transmit = head;
InsertHead(controller, qh);
WaitForQueueHead(controller, qh);
}
private static void initDevice(PciDevice dev)
{
if ((dev.BAR4.flags & Pci.BAR_IO) == 0)
{
Console.WriteLine("[UHCI] Only Portio supported");
}
Pci.EnableBusMastering(dev);
UHCIController uhciDev = new UHCIController();
uhciDev.IOBase = (ushort)dev.BAR4.Address;
uhciDev.Poll = Poll;
Console.Write("[UHCI] Initalize at 0x");
Console.WriteHex(uhciDev.IOBase);
Console.WriteLine("");
uhciDev.FrameList = (int *)Heap.AlignedAlloc(0x1000, sizeof(int) * 1024);
uhciDev.QueueHeadPool = (UHCIQueueHead *)Heap.AlignedAlloc(0x1000, sizeof(UHCIQueueHead) * MAX_HEADS);
uhciDev.TransmitPool = (UHCITransmitDescriptor *)Heap.AlignedAlloc(0x1000, sizeof(UHCITransmitDescriptor) * MAX_TRANSMIT);
Memory.Memclear(uhciDev.QueueHeadPool, sizeof(UHCIQueueHead) * MAX_HEADS);
Memory.Memclear(uhciDev.TransmitPool, sizeof(UHCITransmitDescriptor) * MAX_TRANSMIT);
UHCIQueueHead *head = GetQueueHead(uhciDev);
head->Head = TD_POINTER_TERMINATE;
head->Element = TD_POINTER_TERMINATE;
uhciDev.FirstHead = head;
for (int i = 0; i < 1024; i++)
{
uhciDev.FrameList[i] = TD_POINTER_QH | (int)Paging.GetPhysicalFromVirtual(head);
}
PortIO.Out16((ushort)(uhciDev.IOBase + REG_LEGSUP), 0x8f00);
/**
* Initalize framelist
*/
PortIO.Out16((ushort)(uhciDev.IOBase + REG_FRNUM), 0);
PortIO.Out32((ushort)(uhciDev.IOBase + REG_FRBASEADD), (uint)Paging.GetPhysicalFromVirtual(uhciDev.FrameList));
PortIO.Out8(((ushort)(uhciDev.IOBase + REG_SOFMOD)), 0x40); // Ensure default value of 64 (aka cycle time of 12000)
/**
* We are going to poll!
*/
PortIO.Out16((ushort)(uhciDev.IOBase + REG_USBINTR), 0x00);
/**
* Clear any pending statusses
*/
PortIO.Out16((ushort)(uhciDev.IOBase + REG_USBSTS), 0xFFFF);
/**
* Enable device
*/
PortIO.Out16((ushort)(uhciDev.IOBase + REG_USBCMD), USBCMD_RS);
probe(uhciDev);
Sharpen.USB.USB.RegisterController(uhciDev);
}
