arch/arm-native/soc/broadcom/2708/usb/usb2otg/usb2otg_hub.c

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