+ // TODO: Check size of SETUP and status
+
+ // Allocate TDs
+ td_setup = EHCI_int_AllocateTD(Cont, PID_SETUP, (void*)SetupData, SetupLength, NULL, NULL);
+ if( isOutbound )
+ {
+ td_data = OutData ? EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength, NULL, NULL) : NULL;
+ td_status = EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength, Cb, CbData);
+ }
+ else
+ {
+ td_data = InData ? EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength, NULL, NULL) : NULL;
+ td_status = EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength, Cb, CbData);
+ }
+ td_status->Token |= QTD_TOKEN_IOC; // IOC
+
+ // Append TDs
+ if( td_data ) {
+ td_setup->Link = MM_GetPhysAddr(td_data);
+ td_setup->Next = td_data;
+ td_data->Link = MM_GetPhysAddr(td_status);
+ td_data->Next = td_status;
+ td_data->Token |= QTD_TOKEN_STS_ACTIVE; // Active
+ }
+ else {
+ td_setup->Link = MM_GetPhysAddr(td_status);
+ td_setup->Next = td_status;
+ }
+ td_setup->Token |= QTD_TOKEN_STS_ACTIVE; // Active
+ td_status->Token |= QTD_TOKEN_STS_ACTIVE;
+ td_status->Link = 1;
+ td_status->Link2 = 1;
+ EHCI_int_AppendTD(Cont, Dest, td_setup);
+
+ LOG("return td_status=%p", td_status);
+ return td_status;
+}
+
+void *EHCI_SendBulk(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData, int Dir, void *Data, size_t Length)
+{
+ tEHCI_Controller *Cont = Ptr;
+
+ // Sanity check the pointer
+ // - Can't be NULL or an isoch
+ if( (tVAddr)Dest <= 256*16 )
+ return NULL;
+
+ // Allocate single TD
+ tEHCI_qTD *td = EHCI_int_AllocateTD(Cont, (Dir ? PID_OUT : PID_IN), Data, Length, Cb, CbData);
+ EHCI_int_AppendTD(Cont, Dest, td);
+
+ return td;
+}
+
+void EHCI_FreeOp(void *Ptr, void *Handle)
+{
+ tEHCI_Controller *Cont = Ptr;
+
+ EHCI_int_DeallocateTD(Cont, Handle);
+}
+
+Uint32 EHCI_int_RootHub_FeatToMask(int Feat)
+{
+ switch(Feat)
+ {
+ case PORT_RESET: return PORTSC_PortReset;
+ case PORT_ENABLE: return PORTSC_PortEnabled;
+ default:
+ Log_Warning("EHCI", "Unknown root hub port feature %i", Feat);
+ return 0;
+ }
+}
+
+void EHCI_RootHub_SetPortFeature(void *Ptr, int Port, int Feat)
+{
+ tEHCI_Controller *Cont = Ptr;
+ if(Port >= Cont->nPorts) return;
+
+ Cont->OpRegs->PortSC[Port] |= EHCI_int_RootHub_FeatToMask(Feat);
+}
+
+void EHCI_RootHub_ClearPortFeature(void *Ptr, int Port, int Feat)
+{
+ tEHCI_Controller *Cont = Ptr;
+ if(Port >= Cont->nPorts) return;
+
+ Cont->OpRegs->PortSC[Port] &= ~EHCI_int_RootHub_FeatToMask(Feat);
+}
+
+int EHCI_RootHub_GetPortStatus(void *Ptr, int Port, int Flag)
+{
+ tEHCI_Controller *Cont = Ptr;
+ if(Port >= Cont->nPorts) return 0;
+
+ return !!(Cont->OpRegs->PortSC[Port] & EHCI_int_RootHub_FeatToMask(Flag));
+}
+
+// --------------------------------------------------------------------
+// Internals
+// --------------------------------------------------------------------
+tEHCI_qTD *EHCI_int_GetTDFromPhys(tEHCI_Controller *Cont, Uint32 Addr)
+{
+ if( Addr == 0 ) return NULL;
+ LOG("%p + (%x - %x)", Cont->TDPool, Addr, MM_GetPhysAddr(Cont->TDPool));
+ return Cont->TDPool + (Addr - MM_GetPhysAddr(Cont->TDPool))/sizeof(tEHCI_qTD);
+}
+
+tEHCI_qTD *EHCI_int_AllocateTD(tEHCI_Controller *Cont, int PID, void *Data, size_t Length, tUSBHostCb Cb, void *CbData)
+{
+// Semaphore_Wait(&Cont->TDSemaphore, 1);
+ Mutex_Acquire(&Cont->TDPoolMutex);
+ for( int i = 0; i < TD_POOL_SIZE; i ++ )
+ {
+ if( ((Cont->TDPool[i].Token >> 8) & 3) != 3 )
+ continue ;
+ Cont->TDPool[i].Token = (PID << 8) | (Length << 16);
+ Mutex_Release(&Cont->TDPoolMutex);
+
+ tEHCI_qTD *td = &Cont->TDPool[i];
+ td->Size = Length;
+ td->Callback = Cb;
+ td->CallbackData = CbData;
+ // NOTE: Assumes that `Length` is <= PAGE_SIZE
+ ASSERTC(Length, <, PAGE_SIZE);
+ // TODO: Handle bouncing >32-bit pages
+ #if PHYS_BITS > 32
+ ASSERT( MM_GetPhysAddr(Data) >> 32 == 0 );
+ #endif
+ td->Pages[0] = MM_GetPhysAddr(Data);
+ if( (td->Pages[0] & (PAGE_SIZE-1)) + Length - 1 > PAGE_SIZE )
+ td->Pages[1] = MM_GetPhysAddr((char*)Data + Length - 1) & ~(PAGE_SIZE-1);
+ LOG("Allocated %p(%P) for PID %i on %P",
+ td, MM_GetPhysAddr(td), PID, Cont->PhysBase);
+ return td;
+ }
+
+ Mutex_Release(&Cont->TDPoolMutex);
+ return NULL;
+}
+
+void EHCI_int_DeallocateTD(tEHCI_Controller *Cont, tEHCI_qTD *TD)
+{
+ UNIMPLEMENTED();
+}
+
+void EHCI_int_AppendTD(tEHCI_Controller *Cont, tEHCI_QH *QH, tEHCI_qTD *TD)
+{
+ tEHCI_qTD *ptd = NULL;
+ Uint32 link = QH->CurrentTD;
+ tPAddr dead_td = MM_GetPhysAddr(Cont->DeadTD);
+
+ {
+ Mutex_Acquire(&Cont->ActiveTDsLock);
+ if( Cont->ActiveTDTail )
+ Cont->ActiveTDTail->Next = TD;
+ else
+ Cont->ActiveTDHead = TD;
+ tEHCI_qTD *last;
+ for( last = TD; last->Next; last = last->Next )
+ ;
+ Cont->ActiveTDTail = last;
+ Mutex_Release(&Cont->ActiveTDsLock);
+ }
+
+ // TODO: Need locking and validation here
+ while( link && !(link & 1) && link != dead_td )
+ {
+ ptd = EHCI_int_GetTDFromPhys(Cont, link);
+ link = ptd->Link;
+ }
+ // TODO: Figure out how to follow this properly
+ if( !ptd ) {
+ QH->CurrentTD = MM_GetPhysAddr(TD)|2;
+ QH->Overlay.Link = QH->CurrentTD;
+ LOG("Appended %p to beginning of %p", TD, QH);
+ }
+ else {
+ ptd->Link = MM_GetPhysAddr(TD);
+ ptd->Link2 = MM_GetPhysAddr(TD);
+ LOG("Appended %p to end of %p", TD, QH);
+ }
+ QH->Endpoint |= QH_ENDPT_H;
+ QH->Overlay.Token &= ~QTD_TOKEN_STS_HALT;
+}
+
+tEHCI_QH *EHCI_int_AllocateQH(tEHCI_Controller *Cont, int Endpoint, size_t MaxPacketSize)
+{
+ tEHCI_QH *ret;
+ Mutex_Acquire(&Cont->QHPoolMutex);
+ for( int i = 0; i < QH_POOL_SIZE; i ++ )
+ {
+ if( !MM_GetPhysAddr( Cont->QHPools[i/QH_POOL_NPERPAGE] ) ) {
+ tPAddr tmp;
+ Cont->QHPools[i/QH_POOL_NPERPAGE] = (void*)MM_AllocDMA(1, 32, &tmp);
+ memset(Cont->QHPools[i/QH_POOL_NPERPAGE], 0, PAGE_SIZE);
+ }
+
+ ret = &Cont->QHPools[i/QH_POOL_NPERPAGE][i%QH_POOL_NPERPAGE];
+ if( ret->HLink == 0 ) {
+ memset(ret, 0, sizeof(*ret));
+ ret->HLink = 1;
+ ret->Overlay.Link = MM_GetPhysAddr(Cont->DeadTD);
+ ret->Endpoint = (Endpoint >> 4) | 0x80 | ((Endpoint & 0xF) << 8)
+ | (MaxPacketSize << 16);
+ ret->EndpointExt = (1<<30);
+ // TODO: Endpoint speed (13:12) 0:Full, 1:Low, 2:High
+ // TODO: Control Endpoint Flag (27) 0:*, 1:Full/Low Control
+ Mutex_Release(&Cont->QHPoolMutex);
+ return ret;
+ }
+ }
+ Mutex_Release(&Cont->QHPoolMutex);
+ return NULL;
+}
+
+void EHCI_int_DeallocateQH(tEHCI_Controller *Cont, tEHCI_QH *QH)
+{
+ // TODO: Ensure it's unused (somehow)
+ QH->HLink = 0;
+}
+
+void EHCI_int_HandlePortConnectChange(tEHCI_Controller *Cont, int Port)
+{
+ // Connect Event
+ if( Cont->OpRegs->PortSC[Port] & PORTSC_CurrentConnectStatus )
+ {
+ // Is the device low-speed?
+ if( (Cont->OpRegs->PortSC[Port] & PORTSC_LineStatus_MASK) == PORTSC_LineStatus_Kstate )
+ {
+ LOG("Low speed device on %P Port %i, giving to companion", Cont->PhysBase, Port);
+ Cont->OpRegs->PortSC[Port] |= PORTSC_PortOwner;
+ }
+ // not a low-speed device, EHCI reset
+ else
+ {
+ LOG("Device connected on %P Port %i", Cont->PhysBase, Port);
+ // Reset procedure.
+ USB_PortCtl_BeginReset(Cont->RootHub, Port);
+ }
+ }
+ // Disconnect Event
+ else
+ {
+ if( Cont->OpRegs->PortSC[Port] & PORTSC_PortOwner ) {
+ LOG("Device disconnected on %P Port %i (companion), taking it back",
+ Cont->PhysBase, Port);
+ Cont->OpRegs->PortSC[Port] &= ~PORTSC_PortOwner;
+ }
+ else {
+ LOG("Device disconnected on %P Port %i", Cont->PhysBase, Port);
+ USB_DeviceDisconnected(Cont->RootHub, Port);
+ }
+ }
+}
+
+void EHCI_int_InterruptThread(void *ControllerPtr)
+{
+ tEHCI_Controller *Cont = ControllerPtr;
+ while(Cont->OpRegs)
+ {
+ Uint32 events;
+
+ LOG("sleeping for events");
+ events = Threads_WaitEvents(EHCI_THREADEVENT_IOC|EHCI_THREADEVENT_PORTSC);
+ if( !events ) {
+ // TODO: Should this cause a termination?
+ }
+ LOG("events = 0x%x", events);
+
+ if( events & EHCI_THREADEVENT_IOC )
+ {
+ // IOC, Do whatever it is you do
+ Log_Warning("EHCI", "%P IOC - TODO: Call registered callbacks and reclaim",
+ Cont->PhysBase);
+ // Scan active TDs
+ Mutex_Acquire(&Cont->ActiveTDsLock);
+ tEHCI_qTD *prev = NULL;
+ for(tEHCI_qTD *td = Cont->ActiveTDHead; td; td = td->Next)
+ {
+ LOG("td(%p)->Token = %x", td, td->Token);
+ // If active, continue
+ if( td->Token & QTD_TOKEN_STS_ACTIVE ) {
+ prev = td;
+ continue ;
+ }
+
+ // Inactive
+ LOG("%p Complete", td);
+ // - call the callback
+ if( td->Callback )
+ {
+ void *ptr = NULL;
+ if( td->Pages[0] ) {
+ Log_Warning("EHCI", "TODO: Map %x,%x+%i for callback",
+ td->Pages[0], td->Pages[1], td->Size);
+ }
+ td->Callback(td->CallbackData, ptr, td->Size);
+ }
+
+ // Remove and release
+ *(prev ? &prev->Next : &Cont->ActiveTDHead) = td->Next;
+ td->Token = 0;
+ }
+ Cont->ActiveTDTail = prev;
+ Mutex_Release(&Cont->ActiveTDsLock);
+ }
+
+ // Port status change interrupt
+ if( events & EHCI_THREADEVENT_PORTSC )
+ {
+ // Check for port status changes
+ for(int i = 0; i < Cont->nPorts; i ++ )
+ {
+ Uint32 sts = Cont->OpRegs->PortSC[i];
+ LOG("Port %i: sts = %x", i, sts);
+ Cont->OpRegs->PortSC[i] = sts;
+ if( sts & PORTSC_ConnectStatusChange )
+ EHCI_int_HandlePortConnectChange(Cont, i);
+
+ if( sts & PORTSC_PortEnableChange )
+ {
+ // Handle enable/disable
+ }
+
+ if( sts & PORTSC_OvercurrentChange )
+ {
+ // Handle over-current change
+ }
+ }
+ }
+
+ LOG("Going back to sleep");
+ }