KernelLand/Modules/USB/EHCI/ehci.c

   1 /*
   2  * Acess2 EHCI Driver
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * ehci.c
   6  * - Driver Core
   7  */
   8 #define DEBUG   1
   9 #define VERSION VER2(0,1)
  10 #include <acess.h>
  11 #include <modules.h>
  12 #include <usb_host.h>
  13 #include "ehci.h"
  14 #include <drv_pci.h>
  15 #include <limits.h>
  16
  17 // === CONSTANTS ===
  18 #define EHCI_MAX_CONTROLLERS    4
  19
  20 // === PROTOTYPES ===
  21  int    EHCI_Initialise(char **Arguments);
  22  int    EHCI_Cleanup(void);
  23  int    EHCI_InitController(tPAddr BaseAddress, Uint8 InterruptNum);
  24 void    EHCI_InterruptHandler(int IRQ, void *Ptr);
  25 // -- API ---
  26 void    *EHCI_InitInterrupt(void *Ptr, int Endpoint, int bInput, int Period, tUSBHostCb Cb, void *CbData, void *Buf, size_t Length);
  27 void    *EHCI_InitIsoch  (void *Ptr, int Endpoint, size_t MaxPacketSize);
  28 void    *EHCI_InitControl(void *Ptr, int Endpoint, size_t MaxPacketSize);
  29 void    *EHCI_InitBulk   (void *Ptr, int Endpoint, size_t MaxPacketSize);
  30 void    EHCI_RemEndpoint(void *Ptr, void *Handle);
  31 void    *EHCI_SendControl(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData,
  32         int isOutbound,
  33         const void *SetupData, size_t SetupLength,
  34         const void *OutData, size_t OutLength,
  35         void *InData, size_t InLength
  36         );
  37 void    *EHCI_SendBulk(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData, int Dir, void *Data, size_t Length);
  38 void    EHCI_FreeOp(void *Ptr, void *Handle);
  39 // --- Internals ---
  40 tEHCI_qTD       *EHCI_int_AllocateTD(tEHCI_Controller *Cont, int PID, void *Data, size_t Length, tUSBHostCb Cb, void *CbData);
  41 void    EHCI_int_DeallocateTD(tEHCI_Controller *Cont, tEHCI_qTD *TD);
  42 void    EHCI_int_AppendTD(tEHCI_QH *QH, tEHCI_qTD *TD);
  43 tEHCI_QH        *EHCI_int_AllocateQH(tEHCI_Controller *Cont, int Endpoint, size_t MaxPacketSize);
  44 void    EHCI_int_DeallocateQH(tEHCI_Controller *Cont, tEHCI_QH *QH);
  45
  46 // === GLOBALS ===
  47 MODULE_DEFINE(0, VERSION, USB_EHCI, EHCI_Initialise, NULL, "USB_Core", NULL);
  48 tEHCI_Controller        gaEHCI_Controllers[EHCI_MAX_CONTROLLERS];
  49 tUSBHostDef     gEHCI_HostDef = {
  50         .InitInterrupt = EHCI_InitInterrupt,
  51         .InitIsoch     = EHCI_InitIsoch,
  52         .InitBulk      = EHCI_InitBulk,
  53         .RemEndpoint   = EHCI_RemEndpoint,
  54         .SendIsoch   = NULL,
  55         .SendControl = EHCI_SendControl,
  56         .SendBulk    = EHCI_SendBulk,
  57         .FreeOp      = EHCI_FreeOp
  58         };
  59
  60 // === CODE ===
  61 int EHCI_Initialise(char **Arguments)
  62 {
  63         for( int id = -1; (id = PCI_GetDeviceByClass(0x0C0320, 0xFFFFFF, id)) >= 0;  )
  64         {
  65                 Uint32  addr = PCI_GetBAR(id, 0);
  66                 if( addr == 0 ) {
  67                         // Oops, PCI BIOS emulation time
  68                 }
  69                 Uint8   irq = PCI_GetIRQ(id);
  70                 if( irq == 0 ) {
  71                         // TODO: The same
  72                 }
  73
  74                 if( EHCI_InitController(addr, irq) ) {
  75                         // TODO: Detect other forms of failure than "out of slots"
  76                         break ;
  77                 }
  78         }
  79         return 0;
  80 }
  81
  82 int EHCI_Cleanup(void)
  83 {
  84         return 0;
  85 }
  86
  87 // --- Driver Init ---
  88 int EHCI_InitController(tPAddr BaseAddress, Uint8 InterruptNum)
  89 {
  90         tEHCI_Controller        *cont = NULL;
  91
  92         for( int i = 0; i < EHCI_MAX_CONTROLLERS; i ++ )
  93         {
  94                 if( gaEHCI_Controllers[i].PhysBase == 0 ) {
  95                         cont = &gaEHCI_Controllers[i];
  96                         cont->PhysBase = BaseAddress;
  97                         break;
  98                 }
  99         }
 100
 101         if(!cont) {
 102                 return 1;
 103         }
 104
 105         // -- Build up structure --
 106         cont->CapRegs = (void*)MM_MapHWPages(BaseAddress, 1);
 107         // TODO: Error check
 108         cont->OpRegs = (void*)( (Uint32*)cont->CapRegs + cont->CapRegs->CapLength / 4 );
 109         // - Allocate periodic queue
 110         cont->PeriodicQueue = (void*)MM_AllocDMA(1, 32, NULL);
 111         // TODO: Error check
 112         //  > Populate queue
 113
 114         // -- Bind IRQ --
 115         IRQ_AddHandler(InterruptNum, EHCI_InterruptHandler, cont);
 116
 117         // -- Initialisation procedure (from ehci-r10) --
 118         // - Reset controller
 119         cont->OpRegs->USBCmd = USBCMD_HCReset;
 120         // - Set CTRLDSSEGMENT (TODO: 64-bit support)
 121         // - Set USBINTR
 122         cont->OpRegs->USBIntr = USBINTR_IOC|USBINTR_PortChange|USBINTR_FrameRollover;
 123         // - Set PERIODICLIST BASE
 124         cont->OpRegs->PeridocListBase = MM_GetPhysAddr( cont->PeriodicQueue );
 125         // - Enable controller
 126         cont->OpRegs->USBCmd = (0x40 << 16) | USBCMD_PeriodicEnable | USBCMD_Run;
 127         // - Route all ports
 128         cont->OpRegs->ConfigFlag = 1;
 129
 130         return 0;
 131 }
 132
 133 void EHCI_InterruptHandler(int IRQ, void *Ptr)
 134 {
 135         tEHCI_Controller *cont = Ptr;
 136         Uint32  sts = cont->OpRegs->USBSts;
 137
 138         // Clear interrupts
 139         cont->OpRegs->USBSts = sts;
 140
 141         if( sts & USBINTR_IOC ) {
 142                 // IOC
 143                 sts &= ~USBINTR_IOC;
 144         }
 145
 146         if( sts & USBINTR_PortChange ) {
 147                 // Port change, determine what port and poke helper thread
 148                 sts &= ~USBINTR_PortChange;
 149         }
 150
 151         if( sts & USBINTR_FrameRollover ) {
 152                 // Frame rollover, used to aid timing (trigger per-second operations)
 153                 sts &= ~USBINTR_FrameRollover;
 154         }
 155
 156         if( sts ) {
 157                 // Unhandled interupt bits
 158                 // TODO: Warn
 159         }
 160 }
 161
 162 // --------------------------------------------------------------------
 163 // USB API
 164 // --------------------------------------------------------------------
 165 void *EHCI_InitInterrupt(void *Ptr, int Endpoint, int bOutbound, int Period,
 166         tUSBHostCb Cb, void *CbData, void *Buf, size_t Length)
 167 {
 168         tEHCI_Controller        *Cont = Ptr;
 169          int    pow2period, period_pow;
 170
 171         if( Endpoint >= 256*16 )
 172                 return NULL;
 173         if( Period <= 0 )
 174                 return NULL;
 175         if( Period > 256 )
 176                 Period = 256;
 177
 178         // Round the period to the closest power of two
 179         pow2period = 1;
 180         period_pow = 0;
 181         // - Find the first power above the period
 182         while( pow2period < Period )
 183         {
 184                 pow2period *= 2;
 185                 period_pow ++;
 186         }
 187         // - Check which is closest
 188         if( Period - pow2period / 2 > pow2period - Period )
 189                 Period = pow2period;
 190         else {
 191                 Period = pow2period/2;
 192                 period_pow --;
 193         }
 194
 195         // Allocate a QH
 196         tEHCI_QH *qh = EHCI_int_AllocateQH(Cont, Endpoint, Length);
 197         qh->Impl.IntPeriodPow = period_pow;
 198
 199         // Choose an interrupt slot to use
 200         int minslot = 0, minslot_load = INT_MAX;
 201         for( int slot = 0; slot < Period; slot ++ )
 202         {
 203                  int    load = 0;
 204                 for( int i = 0; i < PERIODIC_SIZE; i += Period )
 205                         load += Cont->InterruptLoad[i+slot];
 206                 if( load == 0 ) break;
 207                 if( load < minslot_load ) {
 208                         minslot = slot;
 209                         minslot_load = load;
 210                 }
 211         }
 212         // Increase loading on the selected slot
 213         for( int i = 0; i < PERIODIC_SIZE; i += Period )
 214                 Cont->InterruptLoad[i+minslot] += Length;
 215         qh->Impl.IntOfs = minslot;
 216
 217         // Allocate TD for the data
 218         tEHCI_qTD *td = EHCI_int_AllocateTD(Cont, (bOutbound ? PID_OUT : PID_IN), Buf, Length, Cb, CbData);
 219         EHCI_int_AppendTD(qh, td);
 220
 221         // Insert into the periodic list
 222
 223         return qh;
 224 }
 225
 226 void *EHCI_InitIsoch(void *Ptr, int Endpoint, size_t MaxPacketSize)
 227 {
 228         return (void*)(tVAddr)(Endpoint + 1);
 229 }
 230 void *EHCI_InitControl(void *Ptr, int Endpoint, size_t MaxPacketSize)
 231 {
 232         tEHCI_Controller *Cont = Ptr;
 233
 234         // Allocate a QH
 235         tEHCI_QH *qh = EHCI_int_AllocateQH(Cont, Endpoint, MaxPacketSize);
 236
 237         // Append to async list
 238         if( Cont->LastAsyncHead ) {
 239                 Cont->LastAsyncHead->HLink = MM_GetPhysAddr(qh)|2;
 240                 Cont->LastAsyncHead->Impl.Next = qh;
 241         }
 242         else
 243                 Cont->OpRegs->AsyncListAddr = MM_GetPhysAddr(qh)|2;
 244         Cont->LastAsyncHead = qh;
 245
 246         return qh;
 247 }
 248 void *EHCI_InitBulk(void *Ptr, int Endpoint, size_t MaxPacketSize)
 249 {
 250         return EHCI_InitControl(Ptr, Endpoint, MaxPacketSize);
 251 }
 252 void EHCI_RemEndpoint(void *Ptr, void *Handle)
 253 {
 254         if( Handle == NULL )
 255                 return ;
 256         else if( (tVAddr)Handle <= 256*16 )
 257                 return ;        // Isoch
 258         else {
 259                 // Remove QH from list
 260                 // - If it's a polling endpoint, need to remove from all periodic lists
 261
 262                 // Deallocate QH
 263                 EHCI_int_DeallocateQH(Ptr, Handle);
 264         }
 265 }
 266
 267 void *EHCI_SendControl(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData,
 268         int isOutbound,
 269         const void *SetupData, size_t SetupLength,
 270         const void *OutData, size_t OutLength,
 271         void *InData, size_t InLength
 272         )
 273 {
 274         tEHCI_Controller *Cont = Ptr;
 275         tEHCI_qTD       *td_setup, *td_data, *td_status;
 276
 277         // Sanity checks
 278         if( (tVAddr)Dest <= 256*16 )
 279                 return NULL;
 280
 281         // Check size of SETUP and status
 282
 283         // Allocate TDs
 284         td_setup = EHCI_int_AllocateTD(Cont, PID_SETUP, (void*)SetupData, SetupLength, NULL, NULL);
 285         if( isOutbound )
 286         {
 287                 td_data = EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength, NULL, NULL);
 288                 td_status = EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength, Cb, CbData);
 289         }
 290         else
 291         {
 292                 td_data = EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength, NULL, NULL);
 293                 td_status = EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength, Cb, CbData);
 294         }
 295
 296         // Append TDs
 297         EHCI_int_AppendTD(Dest, td_setup);
 298         EHCI_int_AppendTD(Dest, td_data);
 299         EHCI_int_AppendTD(Dest, td_status);
 300
 301         return td_status;
 302 }
 303
 304 void *EHCI_SendBulk(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData, int Dir, void *Data, size_t Length)
 305 {
 306         tEHCI_Controller        *Cont = Ptr;
 307
 308         // Sanity check the pointer
 309         // - Can't be NULL or an isoch
 310         if( (tVAddr)Dest <= 256*16 )
 311                 return NULL;
 312
 313         // Allocate single TD
 314         tEHCI_qTD       *td = EHCI_int_AllocateTD(Cont, (Dir ? PID_OUT : PID_IN), Data, Length, Cb, CbData);
 315         EHCI_int_AppendTD(Dest, td);
 316
 317         return td;
 318 }
 319
 320 void EHCI_FreeOp(void *Ptr, void *Handle)
 321 {
 322         tEHCI_Controller        *Cont = Ptr;
 323
 324         EHCI_int_DeallocateTD(Cont, Handle);
 325 }
 326
 327 // --------------------------------------------------------------------
 328 // Internals
 329 // --------------------------------------------------------------------
 330 tEHCI_qTD *EHCI_int_AllocateTD(tEHCI_Controller *Cont, int PID, void *Data, size_t Length, tUSBHostCb Cb, void *CbData)
 331 {
 332         return NULL;
 333 }
 334
 335 void EHCI_int_DeallocateTD(tEHCI_Controller *Cont, tEHCI_qTD *TD)
 336 {
 337 }
 338
 339 void EHCI_int_AppendTD(tEHCI_QH *QH, tEHCI_qTD *TD)
 340 {
 341 }
 342
 343 tEHCI_QH *EHCI_int_AllocateQH(tEHCI_Controller *Cont, int Endpoint, size_t MaxPacketSize)
 344 {
 345         return NULL;
 346 }
 347
 348 void EHCI_int_DeallocateQH(tEHCI_Controller *Cont, tEHCI_QH *QH)
 349 {
 350 }
 351