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                 Log_Log("ECHI", "Controller at PCI %i 0x%x IRQ 0x%x",
  75                         id, addr, irq);
  76
  77                 if( EHCI_InitController(addr, irq) )
  78                 {
  79                         // TODO: Detect other forms of failure than "out of slots"
  80                         break ;
  81                 }
  82
  83                 // TODO: Register with the USB stack
  84         }
  85         return 0;
  86 }
  87
  88 int EHCI_Cleanup(void)
  89 {
  90         return 0;
  91 }
  92
  93 // --- Driver Init ---
  94 int EHCI_InitController(tPAddr BaseAddress, Uint8 InterruptNum)
  95 {
  96         tEHCI_Controller        *cont = NULL;
  97
  98         for( int i = 0; i < EHCI_MAX_CONTROLLERS; i ++ )
  99         {
 100                 if( gaEHCI_Controllers[i].PhysBase == 0 ) {
 101                         cont = &gaEHCI_Controllers[i];
 102                         cont->PhysBase = BaseAddress;
 103                         break;
 104                 }
 105         }
 106
 107         if(!cont) {
 108                 Log_Notice("EHCI", "Too many controllers (EHCI_MAX_CONTROLLERS=%i)", EHCI_MAX_CONTROLLERS);
 109                 return 1;
 110         }
 111
 112         // -- Build up structure --
 113         cont->CapRegs = (void*)MM_MapHWPages(BaseAddress, 1);
 114         // TODO: Error check
 115         cont->OpRegs = (void*)( (Uint32*)cont->CapRegs + cont->CapRegs->CapLength / 4 );
 116         // - Allocate periodic queue
 117         cont->PeriodicQueue = (void*)MM_AllocDMA(1, 32, NULL);
 118         // TODO: Error check
 119         //  > Populate queue
 120
 121         // -- Bind IRQ --
 122         IRQ_AddHandler(InterruptNum, EHCI_InterruptHandler, cont);
 123
 124         // -- Initialisation procedure (from ehci-r10) --
 125         // - Reset controller
 126         cont->OpRegs->USBCmd = USBCMD_HCReset;
 127         // - Set CTRLDSSEGMENT (TODO: 64-bit support)
 128         // - Set USBINTR
 129         cont->OpRegs->USBIntr = USBINTR_IOC|USBINTR_PortChange|USBINTR_FrameRollover;
 130         // - Set PERIODICLIST BASE
 131         cont->OpRegs->PeridocListBase = MM_GetPhysAddr( cont->PeriodicQueue );
 132         // - Enable controller
 133         cont->OpRegs->USBCmd = (0x40 << 16) | USBCMD_PeriodicEnable | USBCMD_Run;
 134         // - Route all ports
 135         cont->OpRegs->ConfigFlag = 1;
 136
 137         return 0;
 138 }
 139
 140 void EHCI_InterruptHandler(int IRQ, void *Ptr)
 141 {
 142         tEHCI_Controller *cont = Ptr;
 143         Uint32  sts = cont->OpRegs->USBSts;
 144
 145         // Clear interrupts
 146         cont->OpRegs->USBSts = sts;
 147
 148         if( sts & 0xFFFF0FC0 ) {
 149                 LOG("Oops, reserved bits set (%08x), funny hardware?", sts);
 150                 sts &= ~0xFFFF0FFC0;
 151         }
 152
 153         // Unmask read-only bits
 154         sts &= ~(0xF000);
 155
 156         if( sts & USBINTR_IOC ) {
 157                 // IOC
 158                 sts &= ~USBINTR_IOC;
 159         }
 160
 161         if( sts & USBINTR_PortChange ) {
 162                 // Port change, determine what port and poke helper thread
 163                 LOG("Port status change");
 164                 sts &= ~USBINTR_PortChange;
 165         }
 166
 167         if( sts & USBINTR_FrameRollover ) {
 168                 // Frame rollover, used to aid timing (trigger per-second operations)
 169                 LOG("Frame rollover");
 170                 sts &= ~USBINTR_FrameRollover;
 171         }
 172
 173         if( sts ) {
 174                 // Unhandled interupt bits
 175                 // TODO: Warn
 176                 LOG("WARN - Bitmask %x unhandled", sts);
 177         }
 178
 179
 180 }
 181
 182 // --------------------------------------------------------------------
 183 // USB API
 184 // --------------------------------------------------------------------
 185 void *EHCI_InitInterrupt(void *Ptr, int Endpoint, int bOutbound, int Period,
 186         tUSBHostCb Cb, void *CbData, void *Buf, size_t Length)
 187 {
 188         tEHCI_Controller        *Cont = Ptr;
 189          int    pow2period, period_pow;
 190
 191         if( Endpoint >= 256*16 )
 192                 return NULL;
 193         if( Period <= 0 )
 194                 return NULL;
 195         if( Period > 256 )
 196                 Period = 256;
 197
 198         // Round the period to the closest power of two
 199         pow2period = 1;
 200         period_pow = 0;
 201         // - Find the first power above the period
 202         while( pow2period < Period )
 203         {
 204                 pow2period *= 2;
 205                 period_pow ++;
 206         }
 207         // - Check which is closest
 208         if( Period - pow2period / 2 > pow2period - Period )
 209                 Period = pow2period;
 210         else {
 211                 Period = pow2period/2;
 212                 period_pow --;
 213         }
 214
 215         // Allocate a QH
 216         tEHCI_QH *qh = EHCI_int_AllocateQH(Cont, Endpoint, Length);
 217         qh->Impl.IntPeriodPow = period_pow;
 218
 219         // Choose an interrupt slot to use
 220         int minslot = 0, minslot_load = INT_MAX;
 221         for( int slot = 0; slot < Period; slot ++ )
 222         {
 223                  int    load = 0;
 224                 for( int i = 0; i < PERIODIC_SIZE; i += Period )
 225                         load += Cont->InterruptLoad[i+slot];
 226                 if( load == 0 ) break;
 227                 if( load < minslot_load ) {
 228                         minslot = slot;
 229                         minslot_load = load;
 230                 }
 231         }
 232         // Increase loading on the selected slot
 233         for( int i = 0; i < PERIODIC_SIZE; i += Period )
 234                 Cont->InterruptLoad[i+minslot] += Length;
 235         qh->Impl.IntOfs = minslot;
 236
 237         // Allocate TD for the data
 238         tEHCI_qTD *td = EHCI_int_AllocateTD(Cont, (bOutbound ? PID_OUT : PID_IN), Buf, Length, Cb, CbData);
 239         EHCI_int_AppendTD(qh, td);
 240
 241         // Insert into the periodic list
 242
 243         return qh;
 244 }
 245
 246 void *EHCI_InitIsoch(void *Ptr, int Endpoint, size_t MaxPacketSize)
 247 {
 248         return (void*)(tVAddr)(Endpoint + 1);
 249 }
 250 void *EHCI_InitControl(void *Ptr, int Endpoint, size_t MaxPacketSize)
 251 {
 252         tEHCI_Controller *Cont = Ptr;
 253
 254         // Allocate a QH
 255         tEHCI_QH *qh = EHCI_int_AllocateQH(Cont, Endpoint, MaxPacketSize);
 256
 257         // Append to async list
 258         if( Cont->LastAsyncHead ) {
 259                 Cont->LastAsyncHead->HLink = MM_GetPhysAddr(qh)|2;
 260                 Cont->LastAsyncHead->Impl.Next = qh;
 261         }
 262         else
 263                 Cont->OpRegs->AsyncListAddr = MM_GetPhysAddr(qh)|2;
 264         Cont->LastAsyncHead = qh;
 265
 266         return qh;
 267 }
 268 void *EHCI_InitBulk(void *Ptr, int Endpoint, size_t MaxPacketSize)
 269 {
 270         return EHCI_InitControl(Ptr, Endpoint, MaxPacketSize);
 271 }
 272 void EHCI_RemEndpoint(void *Ptr, void *Handle)
 273 {
 274         if( Handle == NULL )
 275                 return ;
 276         else if( (tVAddr)Handle <= 256*16 )
 277                 return ;        // Isoch
 278         else {
 279                 // Remove QH from list
 280                 // - If it's a polling endpoint, need to remove from all periodic lists
 281
 282                 // Deallocate QH
 283                 EHCI_int_DeallocateQH(Ptr, Handle);
 284         }
 285 }
 286
 287 void *EHCI_SendControl(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData,
 288         int isOutbound,
 289         const void *SetupData, size_t SetupLength,
 290         const void *OutData, size_t OutLength,
 291         void *InData, size_t InLength
 292         )
 293 {
 294         tEHCI_Controller *Cont = Ptr;
 295         tEHCI_qTD       *td_setup, *td_data, *td_status;
 296
 297         // Sanity checks
 298         if( (tVAddr)Dest <= 256*16 )
 299                 return NULL;
 300
 301         // Check size of SETUP and status
 302
 303         // Allocate TDs
 304         td_setup = EHCI_int_AllocateTD(Cont, PID_SETUP, (void*)SetupData, SetupLength, NULL, NULL);
 305         if( isOutbound )
 306         {
 307                 td_data = EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength, NULL, NULL);
 308                 td_status = EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength, Cb, CbData);
 309         }
 310         else
 311         {
 312                 td_data = EHCI_int_AllocateTD(Cont, PID_IN, InData, InLength, NULL, NULL);
 313                 td_status = EHCI_int_AllocateTD(Cont, PID_OUT, (void*)OutData, OutLength, Cb, CbData);
 314         }
 315
 316         // Append TDs
 317         EHCI_int_AppendTD(Dest, td_setup);
 318         EHCI_int_AppendTD(Dest, td_data);
 319         EHCI_int_AppendTD(Dest, td_status);
 320
 321         return td_status;
 322 }
 323
 324 void *EHCI_SendBulk(void *Ptr, void *Dest, tUSBHostCb Cb, void *CbData, int Dir, void *Data, size_t Length)
 325 {
 326         tEHCI_Controller        *Cont = Ptr;
 327
 328         // Sanity check the pointer
 329         // - Can't be NULL or an isoch
 330         if( (tVAddr)Dest <= 256*16 )
 331                 return NULL;
 332
 333         // Allocate single TD
 334         tEHCI_qTD       *td = EHCI_int_AllocateTD(Cont, (Dir ? PID_OUT : PID_IN), Data, Length, Cb, CbData);
 335         EHCI_int_AppendTD(Dest, td);
 336
 337         return td;
 338 }
 339
 340 void EHCI_FreeOp(void *Ptr, void *Handle)
 341 {
 342         tEHCI_Controller        *Cont = Ptr;
 343
 344         EHCI_int_DeallocateTD(Cont, Handle);
 345 }
 346
 347 // --------------------------------------------------------------------
 348 // Internals
 349 // --------------------------------------------------------------------
 350 tEHCI_qTD *EHCI_int_AllocateTD(tEHCI_Controller *Cont, int PID, void *Data, size_t Length, tUSBHostCb Cb, void *CbData)
 351 {
 352         return NULL;
 353 }
 354
 355 void EHCI_int_DeallocateTD(tEHCI_Controller *Cont, tEHCI_qTD *TD)
 356 {
 357 }
 358
 359 void EHCI_int_AppendTD(tEHCI_QH *QH, tEHCI_qTD *TD)
 360 {
 361 }
 362
 363 tEHCI_QH *EHCI_int_AllocateQH(tEHCI_Controller *Cont, int Endpoint, size_t MaxPacketSize)
 364 {
 365         return NULL;
 366 }
 367
 368 void EHCI_int_DeallocateQH(tEHCI_Controller *Cont, tEHCI_QH *QH)
 369 {
 370 }
 371