+_error:
+ cont->PhysBase = 0;
+ if( cont->CapRegs )
+ MM_Deallocate( cont->CapRegs );
+ if( cont->PeriodicQueue )
+ MM_Deallocate( cont->PeriodicQueue );
+ if( cont->TDPool )
+ MM_Deallocate( cont->TDPool );
+ LEAVE('i', 2);
+ return 2;
+}
+
+
+static inline int _GetClosestPower2(int Period)
+{
+ // Round the period to the closest power of two
+ int pow2period = 1;
+ int period_pow = 0;
+ // - Find the first power above the period
+ while( pow2period < Period )
+ {
+ pow2period *= 2;
+ period_pow ++;
+ }
+ // - Check which is closest
+ if( Period - pow2period / 2 > pow2period - Period ) {
+ ;
+ }
+ else {
+ period_pow --;
+ }
+ LOG("period_pow = %i (%ims) from %ims", period_pow, 1 << period_pow, Period);
+ return period_pow;
+}
+
+void EHCI_int_AddToPeriodic(tEHCI_Controller *Cont, tEHCI_QH *qh, int PeriodPow2, size_t Load)
+{
+ int Period = 1 << PeriodPow2;
+ Mutex_Acquire(&Cont->PeriodicListLock);
+
+ // Choose an interrupt slot to use
+ int minslot = 0, minslot_load = INT_MAX;
+ for( int slot = 0; slot < Period; slot ++ )
+ {
+ int load = 0;
+ for( int i = 0; i < PERIODIC_SIZE; i += Period )
+ load += Cont->InterruptLoad[i+slot];
+ if( load == 0 ) break;
+ if( load < minslot_load ) {
+ minslot = slot;
+ minslot_load = load;
+ }
+ }
+ // Increase loading on the selected slot
+ for( int i = minslot; i < PERIODIC_SIZE; i += Period )
+ Cont->InterruptLoad[i] += Load;
+ qh->Impl.Endpt->InterruptOfs = minslot;
+ LOG("Using slot %i", minslot);
+
+ // Insert into the periodic list
+ for( int i = 0; i < PERIODIC_SIZE; i += Period )
+ {
+ // Walk list until
+ // - the end is reached
+ // - this QH is found
+ // - A QH with a lower period is encountered
+ tEHCI_QH *pqh = NULL;
+ tEHCI_QH *nqh;
+ for( nqh = Cont->PeriodicQueueV[i]; nqh; pqh = nqh, nqh = nqh->Impl.Next )
+ {
+ if( nqh == qh )
+ break;
+ if( nqh->Impl.Endpt->PeriodPow2 < PeriodPow2 )
+ break;
+ }
+
+ // Somehow, we've already been added to this queue.
+ if( nqh && nqh == qh )
+ continue ;
+
+ if( qh->Impl.Next && qh->Impl.Next != nqh ) {
+ Log_Warning("EHCI", "Suspected bookkeeping error on %p - int list %i+%i overlap",
+ Cont, PeriodPow2, minslot);
+ break;
+ }
+
+ if( nqh ) {
+ qh->Impl.Next = nqh;
+ qh->HLink = MM_GetPhysAddr(nqh) | 2;
+ }
+ else {
+ qh->Impl.Next = NULL;
+ qh->HLink = 2|1; // QH, Terminate
+ }
+
+ if( pqh ) {
+ pqh->Impl.Next = qh;
+ pqh->HLink = MM_GetPhysAddr(qh) | 2;
+ }
+ else {
+ Cont->PeriodicQueueV[i] = qh;
+ Cont->PeriodicQueue[i] = MM_GetPhysAddr(qh) | 2;
+ }
+ }
+ Mutex_Release(&Cont->PeriodicListLock);
+}
+
+// --------------------------------------------------------------------
+// USB API
+// --------------------------------------------------------------------
+void *EHCI_InitInterrupt(void *Ptr, int Endpoint, int bOutbound, int Period,
+ tUSBHostCb Cb, void *CbData, void *Buf, size_t Length)
+{
+ tEHCI_Controller *Cont = Ptr;
+
+ ASSERTCR(Endpoint, <, 256*16, NULL);
+ ASSERTCR(Period, >, 0, NULL);
+ if( Period > 256 )
+ Period = 256;
+
+ LOG("Endpoint=%x, bOutbound=%i, Period=%i, Length=%i", Endpoint, bOutbound, Period, Length);
+
+ int period_pow = _GetClosestPower2(Period);
+
+ tEHCI_Endpoint *endpt = EHCI_int_AllocateEndpt(Cont, Endpoint, Length, period_pow);
+ endpt->Next = Cont->FirstInterruptEndpt;
+ Cont->FirstInterruptEndpt = endpt;
+
+ // Allocate a QH
+ tEHCI_QH *qh = EHCI_int_AllocateQH(Cont, endpt, Cb, CbData);
+ qh->EndpointExt |= 1; // TODO: uFrame load balancing (8 entry bitfield)
+
+ // Allocate TD for the data
+ tEHCI_qTD *td = EHCI_int_AllocateTD(Cont, (bOutbound ? PID_OUT : PID_IN), Buf, Length);
+ qh->CurrentTD = MM_GetPhysAddr(td);
+ qh->Impl.FirstTD = td;
+ qh->Impl.LastTD = td;
+
+ // - Insert into period queue
+ EHCI_int_AddToPeriodic(Cont, qh, period_pow, Length);
+
+ return endpt;
+}
+
+void *EHCI_InitIsoch(void *Ptr, int Endpoint, size_t MaxPacketSize)
+{
+ ENTER("pPtr iEndpoint iMaxPacketSize",
+ Ptr, Endpoint, MaxPacketSize);
+ LEAVE_RET('p', (void*)(tVAddr)(Endpoint + 1));
+}
+void *EHCI_InitControl(void *Ptr, int Endpoint, size_t MaxPacketSize)
+{
+ return EHCI_int_AllocateEndpt(Ptr, Endpoint, MaxPacketSize, -1);
+}
+void *EHCI_InitBulk(void *Ptr, int Endpoint, size_t MaxPacketSize)
+{
+ return EHCI_int_AllocateEndpt(Ptr, Endpoint, MaxPacketSize, -2);
+}
+void EHCI_RemEndpoint(void *Ptr, void *Handle)
+{
+ if( Handle == NULL )
+ return ;
+ else if( (tVAddr)Handle <= 256*16 )
+ return ; // Isoch
+ else {
+ tEHCI_Endpoint *endpt = Ptr;
+
+ // Remove QH from list
+ // - If it's a polling endpoint, need to remove from all periodic lists
+ if( endpt->PeriodPow2 >= 0) {
+ // Poll
+ }
+ else {
+ // Control/Bulk
+ }
+
+ // Deallocate endpoint
+ // TODO: Write EHCI_DeallocateEndpoint
+ free(endpt);
+ }
+}
+
+void *EHCI_SendControl(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData,
+ int isOutbound,
+ const void *SetupData, size_t SetupLength,
+ const void *OutData, size_t OutLength,
+ void *InData, size_t InLength
+ )
+{
+ tEHCI_Controller *Cont = Ptr;
+ tEHCI_Endpoint *endpt = Dest;
+ tEHCI_QH *qh;
+ tEHCI_qTD *td_setup, *td_data, *td_status;
+
+ // Sanity checks
+ if( (tVAddr)Dest <= 256*16 )
+ return NULL;
+ if( endpt->PeriodPow2 != -1 ) {
+ Log_Notice("EHCI", "Non-control endpoint passed to SendControl");
+ return NULL;
+ }
+ if( SetupLength > endpt->MaxPacketSize )
+ return NULL;
+ // TODO: Check size of status
+
+
+ LOG("Dest=%p, isOutbound=%i, Lengths(Setup:%i,Out:%i,In:%i)",
+ Dest, isOutbound, SetupLength, OutLength, InLength);
+
+ // Allocate a QH to work with
+ qh = EHCI_int_AllocateQH(Cont, endpt, Cb, CbData);
+
+ // Allocate TDs
+ td_setup = EHCI_int_AllocateTD(Cont, PID_SETUP, (void*)SetupData, SetupLength);
+ if( isOutbound )
+ {
+ td_data = OutData ? EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength) : NULL;
+ td_status = EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength);
+ }
+ else
+ {
+ td_data = InData ? EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength) : NULL;
+ td_status = EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength);
+ }
+ td_status->Token |= QTD_TOKEN_IOC; // IOC
+
+ // Append TDs
+ if( td_data ) {
+ td_setup->Link = MM_GetPhysAddr(td_data);
+ td_data->Link = MM_GetPhysAddr(td_status);
+ td_data->Token |= QTD_TOKEN_STS_ACTIVE; // Active
+ }
+ else {
+ td_setup->Link = MM_GetPhysAddr(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;
+
+ // Set QH's current pointer
+ qh->CurrentTD = MM_GetPhysAddr(td_setup);
+ qh->Impl.FirstTD = td_setup;
+ qh->Impl.LastTD = td_status;
+ EHCI_int_AppendQHToAsync(Cont, qh);
+
+ return qh;
+}
+
+void *EHCI_SendBulk(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData, int Dir, void *Data, size_t Length)
+{
+ tEHCI_Controller *Cont = Ptr;
+ tEHCI_Endpoint *endpt = Dest;
+
+ // Sanity check the pointer
+ // - Can't be NULL or an isoch
+ if( (tVAddr)Dest <= 256*16 )
+ return NULL;
+ if( endpt->PeriodPow2 != -2 ) {
+ return NULL;
+ }
+ LOG("Ptr=%p,Dest=%p(%x),Cb=%p(%p),DirIsOut=%i,Data=%p+0x%x)",
+ Ptr, Dest, endpt->EndpointID, Cb, CbData, Dir, Data, Length);
+
+ // Allocate a QH to work with
+ tEHCI_QH *qh = EHCI_int_AllocateQH(Cont, endpt, Cb, CbData);
+
+ // Allocate single TD
+ tEHCI_qTD *td = EHCI_int_AllocateTD(Cont, (Dir ? PID_OUT : PID_IN), Data, Length);
+ td->Token |= QTD_TOKEN_IOC | QTD_TOKEN_STS_ACTIVE;
+ qh->CurrentTD = MM_GetPhysAddr(td);
+ qh->Impl.FirstTD = td;
+ qh->Impl.LastTD = td;
+
+ EHCI_int_AppendQHToAsync(Cont, qh);
+
+ return qh;
+}
+
+void EHCI_FreeOp(void *Ptr, void *Handle)
+{
+ tEHCI_Controller *Cont = Ptr;
+
+ EHCI_int_DeallocateQH(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_Endpoint *EHCI_int_AllocateEndpt(tEHCI_Controller *Cont, int Endpoint, size_t MaxPacketSize, int PeriodPow2)
+{
+ ENTER("pCont iEndpoint iMaxPacketSize",
+ Cont, Endpoint, MaxPacketSize);
+
+ tEHCI_Endpoint *endpt = malloc( sizeof(*endpt) );
+ endpt->NextToggle = FALSE;
+ endpt->EndpointID = Endpoint;
+ endpt->MaxPacketSize = MaxPacketSize; // TODO: Sanity Check
+ endpt->PeriodPow2 = PeriodPow2;
+ endpt->InterruptOfs = 0;
+ endpt->ActiveQHs = NULL;
+ // TODO: store endpoints on controller
+
+ LOG("Created %p for %P Ep 0x%x - %i bytes MPS",
+ endpt, Cont->PhysBase, Endpoint, MaxPacketSize);
+
+ LEAVE('p', endpt);
+ return endpt;
+}
+
+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)
+{
+// Semaphore_Wait(&Cont->TDSemaphore, 1);
+ Mutex_Acquire(&Cont->TDPoolMutex);
+ for( int i = 0; i < TD_POOL_SIZE; i ++ )
+ {
+ // PID code == 3: Avaliable for use
+ 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->Impl.Ptr = Data;
+ td->Impl.Length = Length;
+ td->Link = 1;
+ td->Link2 = 1;
+
+ // TODO: Support breaking across multiple pages
+ 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) PID%i on %P (Token=0x%x)",
+ td, MM_GetPhysAddr(td), PID, Cont->PhysBase,
+ td->Token);
+ return td;
+ }
+
+ Mutex_Release(&Cont->TDPoolMutex);
+ return NULL;
+}
+
+void EHCI_int_DeallocateTD(tEHCI_Controller *Cont, tEHCI_qTD *TD)
+{
+ UNIMPLEMENTED();
+}
+
+tEHCI_QH *EHCI_int_AllocateQH(tEHCI_Controller *Cont, tEHCI_Endpoint *Endpoint, tUSBHostCb Cb, void *CbData)
+{
+ tEHCI_QH *ret;
+ Mutex_Acquire(&Cont->QHPoolMutex);
+ for( int i = 0; i < QH_POOL_SIZE; i ++ )
+ {
+ // If page not yet allocated, allocate it
+ 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 )
+ continue ;
+
+ memset(ret, 0, sizeof(*ret));
+ ret->HLink = 1;
+ Mutex_Release(&Cont->QHPoolMutex);
+
+ if( Endpoint )
+ {
+ ret->Endpoint = (Endpoint->EndpointID >> 4) | 0x80 | ((Endpoint->EndpointID & 0xF) << 8)
+ | (Endpoint->MaxPacketSize << 16);
+ }
+ ret->EndpointExt = (1<<30);
+ ret->Impl.Next = NULL;
+ ret->Impl.Callback = Cb;
+ ret->Impl.CallbackData = CbData;
+ ret->Impl.Endpt = Endpoint;
+ // TODO: Endpoint speed (13:12) 0:Full, 1:Low, 2:High
+ // TODO: Control Endpoint Flag (27) 0:*, 1:Full/Low Control
+ return ret;
+ }
+ Mutex_Release(&Cont->QHPoolMutex);
+ return NULL;