arch/arm-raspi/usb/usb2otg/usb2otg_hub.c

   1 /*
   2     Copyright © 2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 1
   7 #include <aros/debug.h>
   8
   9 #include <proto/exec.h>
  10 #include <proto/kernel.h>
  11 #include <proto/utility.h>
  12
  13 #include <asm/bcm2835.h>
  14 #include <hardware/usb2otg.h>
  15 #include <devices/usb_hub.h>
  16
  17 #include "usb2otg_intern.h"
  18 #include "usb2otg_hub.h"
  19
  20 WORD FNAME_ROOTHUB(cmdControlXFer)(struct IOUsbHWReq *ioreq,
  21                        struct USB2OTGUnit *otg_Unit,
  22                        LIBBASETYPEPTR USB2OTGBase)
  23 {
  24     UWORD rt = ioreq->iouh_SetupData.bmRequestType;
  25     UWORD req = ioreq->iouh_SetupData.bRequest;
  26     UWORD idx = AROS_WORD2LE(ioreq->iouh_SetupData.wIndex);
  27     UWORD val = AROS_WORD2LE(ioreq->iouh_SetupData.wValue);
  28     UWORD len = AROS_WORD2LE(ioreq->iouh_SetupData.wLength);
  29     BOOL cmdgood;
  30     ULONG cnt;
  31
  32     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER(%ld:%ld)\n", rt, req));
  33
  34 #if defined(OTG_FORCEHOSTMODE)
  35     if (ioreq->iouh_Endpoint)
  36     {
  37         return (UHIOERR_STALL);
  38     }
  39 #endif
  40
  41     if (len != ioreq->iouh_Length)
  42     {
  43         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: IOReq Len mismatch! %ld != %ld\n", len, ioreq->iouh_Length));
  44         return (UHIOERR_STALL);
  45     }
  46
  47     switch (rt)
  48     {
  49         case (URTF_STANDARD|URTF_DEVICE):
  50             switch (req)
  51             {
  52                 case USR_SET_ADDRESS:
  53                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Set Device Address to #%ld\n", val));
  54                     otg_Unit->hu_HubAddr = val;
  55                     ioreq->iouh_Actual = len;
  56
  57                     unsigned int otg_RegVal = *((volatile unsigned int *)USB2OTG_DEVCFG);
  58                     otg_RegVal &= ~(0x7F << 4);
  59                     otg_RegVal |= ((val & 0x7F) << 4);
  60                     *((volatile unsigned int *)USB2OTG_DEVCFG) = otg_RegVal;
  61
  62                     return (0);
  63
  64                 case USR_SET_CONFIGURATION:
  65                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Set Device Configuration to #%ld\n", val));
  66                     ioreq->iouh_Actual = len;
  67                     return (0);
  68             }
  69             break;
  70
  71         case (URTF_IN|URTF_STANDARD|URTF_DEVICE):
  72             switch (req)
  73             {
  74                 case USR_GET_STATUS:
  75                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetStatus (%ld)\n", len));
  76                     if (len == 2);
  77                     {
  78                         UWORD *mptr = ioreq->iouh_Data;
  79                         *mptr++ = AROS_WORD2LE(U_GSF_SELF_POWERED);
  80                         return (0);
  81                     }
  82                     break;
  83
  84                 case USR_GET_DESCRIPTOR:
  85                     switch (val >> 8)
  86                     {
  87                         case UDT_DEVICE:
  88                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetDeviceDescriptor (%ld)\n", len));
  89                             ioreq->iouh_Actual = (len > sizeof(struct UsbStdDevDesc)) ? sizeof(struct UsbStdDevDesc) : len;
  90                             CopyMem((APTR)&OTGRootHubDevDesc, ioreq->iouh_Data, ioreq->iouh_Actual);
  91
  92                             return (0);
  93
  94                         case UDT_CONFIGURATION:
  95                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetConfigDescriptor (%ld)\n", len));
  96                             ioreq->iouh_Actual = (len > sizeof(struct OTGHubCfg)) ? sizeof(struct OTGHubCfg) : len;
  97                             CopyMem((APTR)&OTGRootHubCfg, ioreq->iouh_Data, ioreq->iouh_Actual);
  98
  99                             return (0);
 100
 101                         case UDT_STRING:
 102                             if (val & 0xFF) /* get lang array */
 103                             {
 104                                 CONST_STRPTR source = NULL;
 105                                 UWORD *mptr = ioreq->iouh_Data;
 106                                 UWORD slen;
 107                                 D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetString %04lx (%ld)\n", val, len));
 108                                 if ((val & 0xFF) > 4) /* index too high? */
 109                                 {
 110                                     return (UHIOERR_STALL);
 111                                 }
 112
 113                                 source = OTGRootHubStrings[(val & 0xFF) - 1];
 114                                 slen = strlen(source);
 115
 116                                 if (len > 1)
 117                                 {
 118                                     ioreq->iouh_Actual = 2;
 119                                     *mptr++ = AROS_WORD2BE((slen << 9)|UDT_STRING);
 120                                     /* "expand" string to utf16 */
 121                                     while ((ioreq->iouh_Actual + 1) < len)
 122                                     {
 123                                         *mptr++ = AROS_WORD2LE(*source++);
 124                                         ioreq->iouh_Actual += 2;
 125                                         if (!(*source))
 126                                         {
 127                                             break;
 128                                         }
 129                                     }
 130                                 }
 131                             } else {
 132                                 UWORD *mptr = ioreq->iouh_Data;
 133                                 D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetLangArray %04lx (%ld)\n", val, len));
 134                                 if (len > 1)
 135                                 {
 136                                    ioreq->iouh_Actual = 2;
 137                                    mptr[0] = AROS_WORD2BE((4 << 8)|UDT_STRING);
 138                                    if (len > 3)
 139                                    {
 140                                       ioreq->iouh_Actual += 2;
 141                                       mptr[1] = AROS_WORD2LE(0x0409);
 142                                    }
 143                                 }
 144                             }
 145                             return (0);
 146
 147                         default:
 148                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Unsupported Descriptor %04lx\n", idx));
 149                             break;
 150                     }
 151                     break;
 152
 153                 case USR_GET_CONFIGURATION:
 154                     if (len == 1)
 155                     {
 156                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetConfiguration\n"));
 157                         ((UBYTE *) ioreq->iouh_Data)[0] = 1; // TODO: Expose 3 configurations? 1 = Host + Device, 2 = Host Only, 3 = Device Only?
 158                         ioreq->iouh_Actual = len;
 159                         return (0);
 160                     }
 161                     break;
 162             }
 163             break;
 164
 165         case (URTF_CLASS|URTF_OTHER):
 166         {
 167             switch (req)
 168             {
 169                 case USR_SET_FEATURE:
 170                 {
 171                     if ((!idx) || (idx > 1))
 172                     {
 173                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld out of range\n", idx));
 174                         return (UHIOERR_STALL);
 175                     }
 176
 177                     cmdgood = FALSE;
 178
 179                     ULONG oldval = *((volatile unsigned int *)USB2OTG_HOSTPORT) & ~(USB2OTG_HOSTPORT_PRTENCHNG|USB2OTG_HOSTPORT_PRTCONNSTS);
 180                     ULONG newval = oldval;
 181
 182                     switch (val)
 183                     {
 184                         case UFS_PORT_ENABLE:
 185                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Enabling Port #%ld\n", idx));
 186
 187                             newval |= USB2OTG_HOSTPORT_PRTENA;
 188                             cmdgood = TRUE;
 189
 190                             break;
 191
 192                         case UFS_PORT_SUSPEND:
 193                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Suspending Port #%ld\n", idx));
 194
 195                             newval |= USB2OTG_HOSTPORT_PRTSUSP;
 196                             cmdgood = TRUE;
 197
 198                             break;
 199
 200                         case UFS_PORT_RESET:
 201                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Resetting Port #%ld\n", idx));
 202
 203                             newval |= USB2OTG_HOSTPORT_PRTRST;
 204                             cmdgood = TRUE;
 205
 206                             break;
 207
 208                         case UFS_PORT_POWER:
 209                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Powering Port #%ld\n", idx));
 210
 211                             newval |= USB2OTG_HOSTPORT_PRTPWR;
 212                             cmdgood = TRUE;
 213
 214                             break;
 215
 216                         /*
 217                             case UFS_PORT_LOW_SPEED:
 218                             case UFS_C_PORT_CONNECTION:
 219                             case UFS_C_PORT_OVER_CURRENT:
 220                         */
 221                         default:
 222                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_SET_FEATURE - Unhandled feature %ld for Port #%ld\n", val, idx));
 223                             break;
 224                     }
 225                     if (cmdgood)
 226                     {
 227                         *((volatile unsigned int *)USB2OTG_HOSTPORT) = newval;
 228
 229                         return (0);
 230                     }
 231
 232                     break;
 233                 }
 234
 235                 case USR_CLEAR_FEATURE:
 236                 {
 237                     if ((!idx) || (idx > 1))
 238                     {
 239                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld out of range\n", idx));
 240                         return (UHIOERR_STALL);
 241                     }
 242
 243                     cmdgood = FALSE;
 244
 245                     ULONG oldval = *((volatile unsigned int *)USB2OTG_HOSTPORT) & ~(USB2OTG_HOSTPORT_PRTENCHNG|USB2OTG_HOSTPORT_PRTCONNSTS);
 246                     ULONG newval = oldval;
 247
 248                     switch (val)
 249                     {
 250                         case UFS_PORT_ENABLE:
 251                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Enable\n", idx));
 252
 253                             newval &= ~USB2OTG_HOSTPORT_PRTENA;
 254                             cmdgood = TRUE;
 255
 256                             break;
 257
 258                         case UFS_PORT_SUSPEND:
 259                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Suspend\n", idx));
 260
 261                             newval &= ~USB2OTG_HOSTPORT_PRTSUSP;
 262                             cmdgood = TRUE;
 263
 264                             break;
 265
 266                         case UFS_PORT_POWER:
 267                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Power\n", idx));
 268
 269                             newval &= ~USB2OTG_HOSTPORT_PRTPWR;
 270                             cmdgood = TRUE;
 271
 272                             break;
 273
 274                         case UFS_C_PORT_CONNECTION:
 275                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Connect Change\n", idx));
 276
 277                             newval &= ~USB2OTG_HOSTPORT_PRTCONNDET;
 278                             otg_Unit->hu_HubPortChanged = TRUE;
 279                             cmdgood = TRUE;
 280
 281                             break;
 282
 283                         case UFS_C_PORT_ENABLE:
 284                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Enable Change\n", idx));
 285
 286                             newval &= ~USB2OTG_HOSTPORT_PRTENCHNG;
 287                             otg_Unit->hu_HubPortChanged = TRUE;
 288                             cmdgood = TRUE;
 289
 290                             break;
 291
 292                         case UFS_C_PORT_SUSPEND:
 293                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Suspend Change\n", idx));
 294
 295                             newval &= ~USB2OTG_HOSTPORT_PRTRES;
 296                             otg_Unit->hu_HubPortChanged = TRUE;
 297                             cmdgood = TRUE;
 298
 299                             break;
 300
 301                         case UFS_C_PORT_OVER_CURRENT:
 302                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Over-Current Change\n", idx));
 303
 304                             newval &= ~USB2OTG_HOSTPORT_PRTOVRCURRCHNG;
 305                             otg_Unit->hu_HubPortChanged = TRUE;
 306                             cmdgood = TRUE;
 307
 308                             break;
 309
 310                         case UFS_C_PORT_RESET:
 311                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Reset Change\n", idx));
 312
 313                             newval &= ~USB2OTG_HOSTPORT_PRTRST;
 314                             otg_Unit->hu_HubPortChanged = TRUE;
 315                             cmdgood = TRUE;
 316
 317                             break;
 318
 319                         default:
 320                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE - Unhandled feature %ld for Port #%ld\n", val, idx));
 321                             break;
 322                     }
 323                     if (cmdgood)
 324                     {
 325                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld CLEAR_FEATURE %04lx->%04lx\n", idx, oldval, newval));
 326                         *((volatile unsigned int *)USB2OTG_HOSTPORT) = newval;
 327
 328                         return (0);
 329                     }
 330                     break;
 331                 }
 332             }
 333             break;
 334         }
 335
 336         case (URTF_IN|URTF_CLASS|URTF_OTHER):
 337         {
 338             switch (req)
 339             {
 340                 case USR_GET_STATUS:
 341                 {
 342                     UWORD *mptr = ioreq->iouh_Data;
 343
 344                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Get Port #%ld Status..\n", idx));
 345
 346                     if (len != sizeof(struct UsbPortStatus))
 347                     {
 348                         return (UHIOERR_STALL);
 349                     }
 350                     if ((!idx) || (idx > 1))
 351                     {
 352                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld out of range\n", idx));
 353                         return (UHIOERR_STALL);
 354                     }
 355
 356                     ULONG oldval = *((volatile unsigned int *)USB2OTG_HOSTPORT);
 357
 358                     *mptr = 0;
 359                     if (oldval & USB2OTG_HOSTPORT_PRTPWR)        *mptr |= AROS_WORD2LE(UPSF_PORT_POWER);
 360                     if (oldval & USB2OTG_HOSTPORT_PRTENA)        *mptr |= AROS_WORD2LE(UPSF_PORT_ENABLE);
 361                     if (oldval & USB2OTG_HOSTPORT_PRTCONNSTS)    *mptr |= AROS_WORD2LE(UPSF_PORT_CONNECTION);
 362                     if (oldval & USB2OTG_HOSTPORT_PRTSPD_LOW)    *mptr |= AROS_WORD2LE(UPSF_PORT_LOW_SPEED);
 363                     if (oldval & USB2OTG_HOSTPORT_PRTRST)        *mptr |= AROS_WORD2LE(UPSF_PORT_RESET);
 364                     if (oldval & USB2OTG_HOSTPORT_PRTSUSP)       *mptr |= AROS_WORD2LE(UPSF_PORT_SUSPEND);
 365
 366                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld is %s\n", idx, (oldval & USB2OTG_HOSTPORT_PRTSPD_LOW) ? "LOWSPEED" : "FULLSPEED"));
 367                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld Status %08lx\n", idx, *mptr));
 368
 369                     mptr++;
 370                     *mptr = 0;
 371                     if (oldval & USB2OTG_HOSTPORT_PRTENCHNG)    *mptr |= AROS_WORD2LE(UPSF_PORT_ENABLE);
 372                     if (oldval & USB2OTG_HOSTPORT_PRTCONNDET)   *mptr |= AROS_WORD2LE(UPSF_PORT_CONNECTION);
 373                     if (oldval & USB2OTG_HOSTPORT_PRTRES)       *mptr |= AROS_WORD2LE(UPSF_PORT_SUSPEND|UPSF_PORT_ENABLE);
 374
 375                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld Change %08lx\n", idx, *mptr));
 376
 377                     return (0);
 378                 }
 379             }
 380             break;
 381         }
 382
 383         case (URTF_IN|URTF_CLASS|URTF_DEVICE):
 384         {
 385             switch (req)
 386             {
 387                 case USR_GET_STATUS:
 388                 {
 389                     UWORD *mptr = ioreq->iouh_Data;
 390
 391                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetHubStatus (%ld)\n", len));
 392
 393                     if (len < sizeof(struct UsbHubStatus))
 394                     {
 395                         return(UHIOERR_STALL);
 396                     }
 397
 398                     *mptr++ = 0;
 399                     *mptr++ = 0;
 400                     ioreq->iouh_Actual = 4;
 401                     return (0);
 402                 }
 403
 404                 case USR_GET_DESCRIPTOR:
 405                 {
 406                     switch (val >> 8)
 407                     {
 408                         case UDT_HUB:
 409                         {
 410                             ULONG hubdesclen = 9;
 411                             ULONG powergood = 1;
 412
 413                             struct UsbHubDesc *uhd = (struct UsbHubDesc *) ioreq->iouh_Data;
 414                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetHubDescriptor (%ld)\n", len));
 415
 416                             ioreq->iouh_Actual = (len > hubdesclen) ? hubdesclen : len;
 417                             CopyMem((APTR)&OTGRootHubDesc, ioreq->iouh_Data, ioreq->iouh_Actual);
 418
 419                             if (ioreq->iouh_Length)
 420                             {
 421                                 uhd->bLength = hubdesclen;
 422                             }
 423
 424                             if (ioreq->iouh_Length >= hubdesclen)
 425                             {
 426                                 if (hubdesclen == 9)
 427                                 {
 428                                     uhd->DeviceRemovable = 0;
 429                                     uhd->PortPwrCtrlMask = (1 << 3) - 2;
 430                                 } else {
 431                                     // each field is 16 bits wide
 432                                     uhd->DeviceRemovable = 0;
 433                                     uhd->PortPwrCtrlMask = 0;
 434                                     ((UBYTE *)ioreq->iouh_Data)[9] = (1 << 3) - 2;
 435                                     ((UBYTE *)ioreq->iouh_Data)[10] = ((1 << 3) - 2) >> 8;
 436                                 }
 437                             }
 438                             return (0);
 439                         }
 440
 441                         default:
 442                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Unsupported Descriptor %04lx\n", idx));
 443                             break;
 444                     }
 445                     break;
 446                 }
 447             }
 448         }
 449     }
 450
 451     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Unsupported command %02lx %02lx %04lx %04lx %04lx!\n", rt, req, idx, val, len));
 452
 453     return (UHIOERR_STALL);
 454 }
 455
 456 WORD FNAME_ROOTHUB(cmdIntXFer)(struct IOUsbHWReq *ioreq,
 457                        struct USB2OTGUnit *otg_Unit,
 458                        LIBBASETYPEPTR USB2OTGBase)
 459 {
 460     D(bug("[USB2OTG:Hub] UHCMD_INTXFER()\n"));
 461
 462     if ((ioreq->iouh_Endpoint != 1) || (!ioreq->iouh_Length))
 463     {
 464         return UHIOERR_STALL;
 465     }
 466
 467     if (otg_Unit->hu_HubPortChanged)
 468     {
 469         D(bug("[USB2OTG:Hub] UHCMD_INTXFER: Registering Immediate Portchange\n"));
 470
 471         if (ioreq->iouh_Length == 1)
 472         {
 473             *((UBYTE *) ioreq->iouh_Data) = 1;
 474             ioreq->iouh_Actual = 1;
 475         }
 476         else
 477         {
 478             ((UBYTE *) ioreq->iouh_Data)[0] = 1;
 479             ((UBYTE *) ioreq->iouh_Data)[1] = 0;
 480             ioreq->iouh_Actual = 2;
 481         }
 482         otg_Unit->hu_HubPortChanged = FALSE;
 483
 484         return 0;
 485     }
 486
 487     D(bug("[USB2OTG:Hub] UHCMD_INTXFER: Queueing request\n"));
 488
 489     ioreq->iouh_Req.io_Flags &= ~IOF_QUICK;
 490     Disable();
 491     AddTail(&otg_Unit->hu_IOPendingQueue, (struct Node *)ioreq);
 492     Enable();
 493
 494     return RC_DONTREPLY;
 495 }
 496
 497 void FNAME_ROOTHUB(PendingIO)(struct USB2OTGUnit *otg_Unit)
 498 {
 499     struct IOUsbHWReq *ioreq;
 500
 501     if (otg_Unit->hu_HubPortChanged && otg_Unit->hu_IOPendingQueue.lh_Head->ln_Succ)
 502     {
 503         D(bug("[USB2OTG:Hub] PendingIO: PortChange detected\n"));
 504         Disable();
 505         ioreq = (struct IOUsbHWReq *) otg_Unit->hu_IOPendingQueue.lh_Head;
 506         while (((struct Node *) ioreq)->ln_Succ)
 507         {
 508             Remove(&ioreq->iouh_Req.io_Message.mn_Node);
 509             if (ioreq->iouh_Length == 1)
 510             {
 511                 *((UBYTE *) ioreq->iouh_Data) = 1;
 512                 ioreq->iouh_Actual = 1;
 513             } else {
 514                 ((UBYTE *) ioreq->iouh_Data)[0] = 1;
 515                 ((UBYTE *) ioreq->iouh_Data)[1] = 0;
 516                 ioreq->iouh_Actual = 2;
 517             }
 518             ReplyMsg(&ioreq->iouh_Req.io_Message);
 519             ioreq = (struct IOUsbHWReq *) otg_Unit->hu_IOPendingQueue.lh_Head;
 520         }
 521         otg_Unit->hu_HubPortChanged = FALSE;
 522         Enable();
 523     }
 524 }