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

   1 /*
   2     Copyright © 2013-2019, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   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 #if (0) // In host mode do not set address!
  55                     unsigned int otg_RegVal = rd32le(USB2OTG_DEVCFG);
  56                     otg_RegVal &= ~(0x7F << 4);
  57                     otg_RegVal |= ((val & 0x7F) << 4);
  58                     wr32le(USB2OTG_DEVCFG, otg_RegVal);
  59 #endif
  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 + 1) << 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 #if (0)
 178                     ULONG oldval = *((volatile unsigned int *)USB2OTG_HOSTPORT) & ~(USB2OTG_HOSTPORT_PRTENCHNG|USB2OTG_HOSTPORT_PRTCONNSTS);
 179                     ULONG newval = oldval;
 180 #else
 181                     unsigned int otg_RegVal;
 182 #endif
 183                     switch (val)
 184                     {
 185                         case UFS_PORT_ENABLE:
 186                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld enable requested although OTG cannot do that!\n", idx));
 187                             break;
 188
 189                         case UFS_PORT_SUSPEND:
 190                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Suspending Port #%ld\n", idx));
 191
 192                             otg_RegVal = rd32le(USB2OTG_HOSTPORT);
 193                             otg_RegVal &= ~USB2OTG_HOSTPORT_SC_BITS;
 194                             otg_RegVal |= USB2OTG_HOSTPORT_PRTSUSP;
 195                             wr32le(USB2OTG_HOSTPORT, otg_RegVal);
 196                             cmdgood = TRUE;
 197
 198                             break;
 199
 200                         case UFS_PORT_RESET:
 201                             {
 202                                 struct MsgPort *port = CreateMsgPort();
 203                                 struct timerequest *req = (struct timerequest *)CreateIORequest(port, sizeof(struct timerequest));
 204                                 OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *) req, 0);
 205
 206                                 D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Resetting Port #%ld\n", idx));
 207
 208                                 req->tr_node.io_Command = TR_ADDREQUEST;
 209                                 req->tr_time.tv_secs = 0;
 210                                 req->tr_time.tv_micro = 10000;
 211                                 DoIO((struct IORequest *)req);
 212                                 D(bug("[USB2OTG:Hub] Pause done...\n"));
 213                                 D(bug("[USB2OTG:Hub] port:%08x\n", rd32le(USB2OTG_HOSTPORT)));
 214
 215                                 otg_RegVal = rd32le(USB2OTG_HOSTPORT);
 216                                 otg_RegVal &= ~USB2OTG_HOSTPORT_SC_BITS;
 217                                 otg_RegVal |= USB2OTG_HOSTPORT_PRTRST;
 218                                 wr32le(USB2OTG_HOSTPORT, otg_RegVal);
 219
 220                                 D(bug("[USB2OTG:Hub] port:%08x\n", rd32le(USB2OTG_HOSTPORT)));
 221
 222                                 req->tr_time.tv_secs = 0;
 223                                 req->tr_time.tv_micro = 60000;
 224                                 DoIO((struct IORequest *)req);
 225                                 D(bug("[USB2OTG:Hub] Pause with port reset done...\n"));
 226                                 D(bug("[USB2OTG:Hub] port:%08x\n", rd32le(USB2OTG_HOSTPORT)));
 227
 228                                 otg_RegVal = rd32le(USB2OTG_HOSTPORT);
 229                                 otg_RegVal &= ~USB2OTG_HOSTPORT_SC_BITS;
 230                                 otg_RegVal &= ~USB2OTG_HOSTPORT_PRTRST;
 231                                 wr32le(USB2OTG_HOSTPORT, otg_RegVal);
 232
 233                                 D(bug("[USB2OTG:Hub] port:%08x\n", rd32le(USB2OTG_HOSTPORT)));
 234
 235                                 req->tr_time.tv_secs = 0;
 236                                 req->tr_time.tv_micro = 10000;
 237                                 DoIO((struct IORequest *)req);
 238                                 D(bug("[USB2OTG:Hub] Pause after deasserting reset done...\n"));
 239                                 D(bug("[USB2OTG:Hub] port:%08x\n", rd32le(USB2OTG_HOSTPORT)));
 240
 241                                 CloseDevice((struct IORequest *)req);
 242                                 DeleteIORequest((struct IORequest *)req);
 243                                 DeleteMsgPort(port);
 244
 245                                 cmdgood = TRUE;
 246                             }
 247                             break;
 248
 249                         case UFS_PORT_POWER:
 250                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Powering Port #%ld\n", idx));
 251
 252                             otg_RegVal = rd32le(USB2OTG_HOSTPORT);
 253                             otg_RegVal &= ~USB2OTG_HOSTPORT_SC_BITS;
 254                             otg_RegVal |= USB2OTG_HOSTPORT_PRTPWR;
 255                             wr32le(USB2OTG_HOSTPORT, otg_RegVal);
 256                             cmdgood = TRUE;
 257
 258                             break;
 259
 260                         /*
 261                             case UFS_PORT_LOW_SPEED:
 262                             case UFS_C_PORT_CONNECTION:
 263                             case UFS_C_PORT_OVER_CURRENT:
 264                         */
 265                         default:
 266                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_SET_FEATURE - Unhandled feature %ld for Port #%ld\n", val, idx));
 267                             break;
 268                     }
 269                     if (cmdgood)
 270                     {
 271 #if (0)
 272                         *((volatile unsigned int *)USB2OTG_HOSTPORT) = newval;
 273 #endif
 274                         return (0);
 275                     }
 276
 277                     break;
 278                 }
 279
 280                 case USR_CLEAR_FEATURE:
 281                 {
 282                     if ((!idx) || (idx > 1))
 283                     {
 284                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld out of range\n", idx));
 285                         return (UHIOERR_STALL);
 286                     }
 287
 288                     cmdgood = FALSE;
 289
 290                     ULONG oldval = rd32le(USB2OTG_HOSTPORT) & ~USB2OTG_HOSTPORT_SC_BITS;
 291                     ULONG newval = oldval;
 292
 293                     switch (val)
 294                     {
 295                         case UFS_PORT_ENABLE:
 296                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Enable\n", idx));
 297
 298                             newval |= USB2OTG_HOSTPORT_PRTENA;
 299                             cmdgood = TRUE;
 300
 301                             break;
 302
 303                         case UFS_PORT_SUSPEND:
 304                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Suspend\n", idx));
 305
 306                             newval |= USB2OTG_HOSTPORT_PRTRES;
 307                             cmdgood = TRUE;
 308
 309                             break;
 310
 311                         case UFS_PORT_POWER:
 312                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Power\n", idx));
 313
 314                             newval &= ~USB2OTG_HOSTPORT_PRTPWR;
 315                             cmdgood = TRUE;
 316
 317                             break;
 318
 319                         case UFS_C_PORT_CONNECTION:
 320                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Connect Change\n", idx));
 321
 322                             newval |= USB2OTG_HOSTPORT_PRTCONNDET;
 323                             otg_Unit->hu_HubPortChanged = TRUE;
 324                             cmdgood = TRUE;
 325
 326                             break;
 327
 328                         case UFS_C_PORT_ENABLE:
 329                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Enable Change\n", idx));
 330
 331                             newval |= USB2OTG_HOSTPORT_PRTENCHNG;
 332                             otg_Unit->hu_HubPortChanged = TRUE;
 333                             cmdgood = TRUE;
 334
 335                             break;
 336
 337                         case UFS_C_PORT_SUSPEND:
 338                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Suspend Change\n", idx));
 339
 340 //                            newval |= USB2OTG_HOSTPORT_PRTRES;
 341                             otg_Unit->hu_HubPortChanged = TRUE;
 342                             cmdgood = TRUE;
 343
 344                             break;
 345
 346                         case UFS_C_PORT_OVER_CURRENT:
 347                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Over-Current Change\n", idx));
 348
 349                             newval |= USB2OTG_HOSTPORT_PRTOVRCURRCHNG;
 350                             otg_Unit->hu_HubPortChanged = TRUE;
 351                             cmdgood = TRUE;
 352
 353                             break;
 354
 355                         case UFS_C_PORT_RESET:
 356                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE Port #%ld Reset Change\n", idx));
 357
 358                             newval &= ~USB2OTG_HOSTPORT_PRTRST;
 359                             otg_Unit->hu_HubPortChanged = TRUE;
 360                             cmdgood = TRUE;
 361
 362                             break;
 363
 364                         default:
 365                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: USR_CLEAR_FEATURE - Unhandled feature %ld for Port #%ld\n", val, idx));
 366                             break;
 367                     }
 368                     if (cmdgood)
 369                     {
 370                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld CLEAR_FEATURE %04lx->%04lx\n", idx, oldval, newval));
 371                         wr32le(USB2OTG_HOSTPORT, newval);
 372
 373                         return (0);
 374                     }
 375                     break;
 376                 }
 377             }
 378             break;
 379         }
 380
 381         case (URTF_IN|URTF_CLASS|URTF_OTHER):
 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: Get Port #%ld Status..\n", idx));
 390
 391                     if (len != sizeof(struct UsbPortStatus))
 392                     {
 393                         return (UHIOERR_STALL);
 394                     }
 395                     if ((!idx) || (idx > 1))
 396                     {
 397                         D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld out of range\n", idx));
 398                         return (UHIOERR_STALL);
 399                     }
 400
 401                     ULONG oldval = rd32le(USB2OTG_HOSTPORT);
 402
 403                     *mptr = 0;
 404                     if (oldval & USB2OTG_HOSTPORT_PRTPWR)        *mptr |= AROS_WORD2LE(UPSF_PORT_POWER);
 405                     if (oldval & USB2OTG_HOSTPORT_PRTENA)        *mptr |= AROS_WORD2LE(UPSF_PORT_ENABLE);
 406                     if (oldval & USB2OTG_HOSTPORT_PRTCONNSTS)    *mptr |= AROS_WORD2LE(UPSF_PORT_CONNECTION);
 407                     if (oldval & USB2OTG_HOSTPORT_PRTRST)        *mptr |= AROS_WORD2LE(UPSF_PORT_RESET);
 408                     if (oldval & USB2OTG_HOSTPORT_PRTSUSP)       *mptr |= AROS_WORD2LE(UPSF_PORT_SUSPEND);
 409
 410                     switch ((oldval >> 17) & 3)
 411                     {
 412                         case 0:
 413                             *mptr |= AROS_WORD2LE(UPSF_PORT_HIGH_SPEED);
 414                             break;
 415                         case 2:
 416                             *mptr |= AROS_WORD2LE(UPSF_PORT_LOW_SPEED);
 417                             break;
 418                         default:
 419                             break;
 420                     }
 421
 422                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld is %s\n", idx, (oldval & USB2OTG_HOSTPORT_PRTSPD_LOW) ? "LOWSPEED" : "FULLSPEED"));
 423                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld Status %08lx\n", idx, AROS_LE2WORD(*mptr)));
 424
 425                     mptr++;
 426                     *mptr = 0;
 427                     if (oldval & USB2OTG_HOSTPORT_PRTENCHNG)    *mptr |= AROS_WORD2LE(UPSF_PORT_ENABLE);
 428                     if (oldval & USB2OTG_HOSTPORT_PRTCONNDET)   *mptr |= AROS_WORD2LE(UPSF_PORT_CONNECTION);
 429                     if (oldval & USB2OTG_HOSTPORT_PRTRES)       *mptr |= AROS_WORD2LE(UPSF_PORT_SUSPEND|UPSF_PORT_ENABLE);
 430
 431                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Port #%ld Change %08lx\n", idx, AROS_LE2WORD(*mptr)));
 432
 433                     return (0);
 434                 }
 435             }
 436             break;
 437         }
 438
 439         case (URTF_IN|URTF_CLASS|URTF_DEVICE):
 440         {
 441             switch (req)
 442             {
 443                 case USR_GET_STATUS:
 444                 {
 445                     UWORD *mptr = ioreq->iouh_Data;
 446
 447                     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetHubStatus (%ld)\n", len));
 448
 449                     if (len < sizeof(struct UsbHubStatus))
 450                     {
 451                         return(UHIOERR_STALL);
 452                     }
 453
 454                     *mptr++ = 0;
 455                     *mptr++ = 0;
 456                     ioreq->iouh_Actual = 4;
 457                     return (0);
 458                 }
 459
 460                 case USR_GET_DESCRIPTOR:
 461                 {
 462                     switch (val >> 8)
 463                     {
 464                         case UDT_HUB:
 465                         {
 466                             ULONG hubdesclen = 9;
 467                             //ULONG powergood = 1;
 468
 469                             struct UsbHubDesc *uhd = (struct UsbHubDesc *) ioreq->iouh_Data;
 470                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: GetHubDescriptor (%ld)\n", len));
 471
 472                             ioreq->iouh_Actual = (len > hubdesclen) ? hubdesclen : len;
 473                             CopyMem((APTR)&OTGRootHubDesc, ioreq->iouh_Data, ioreq->iouh_Actual);
 474
 475                             if (ioreq->iouh_Length)
 476                             {
 477                                 uhd->bLength = hubdesclen;
 478                             }
 479
 480                             if (ioreq->iouh_Length >= hubdesclen)
 481                             {
 482                                 if (hubdesclen == 9)
 483                                 {
 484                                     uhd->DeviceRemovable = 0;
 485                                     uhd->PortPwrCtrlMask = (1 << 3) - 2;
 486                                 } else {
 487                                     // each field is 16 bits wide
 488                                     uhd->DeviceRemovable = 0;
 489                                     uhd->PortPwrCtrlMask = 0;
 490                                     ((UBYTE *)ioreq->iouh_Data)[9] = (1 << 3) - 2;
 491                                     ((UBYTE *)ioreq->iouh_Data)[10] = ((1 << 3) - 2) >> 8;
 492                                 }
 493                             }
 494                             return (0);
 495                         }
 496
 497                         default:
 498                             D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Unsupported Descriptor %04lx\n", idx));
 499                             break;
 500                     }
 501                     break;
 502                 }
 503             }
 504         }
 505     }
 506
 507     D(bug("[USB2OTG:Hub] UHCMD_CONTROLXFER: Unsupported command %02lx %02lx %04lx %04lx %04lx!\n", rt, req, idx, val, len));
 508
 509     return (UHIOERR_STALL);
 510 }
 511
 512 WORD FNAME_ROOTHUB(cmdIntXFer)(struct IOUsbHWReq *ioreq,
 513                        struct USB2OTGUnit *otg_Unit,
 514                        LIBBASETYPEPTR USB2OTGBase)
 515 {
 516     D(bug("[USB2OTG:Hub] UHCMD_INTXFER()\n"));
 517
 518     if ((ioreq->iouh_Endpoint != 1) || (!ioreq->iouh_Length))
 519     {
 520         return UHIOERR_STALL;
 521     }
 522
 523     if (otg_Unit->hu_HubPortChanged)
 524     {
 525         D(bug("[USB2OTG:Hub] UHCMD_INTXFER: Registering Immediate Portchange\n"));
 526
 527         if (ioreq->iouh_Length == 1)
 528         {
 529             *((UBYTE *) ioreq->iouh_Data) = 1;
 530             ioreq->iouh_Actual = 1;
 531         }
 532         else
 533         {
 534             ((UBYTE *) ioreq->iouh_Data)[0] = 1;
 535             ((UBYTE *) ioreq->iouh_Data)[1] = 0;
 536             ioreq->iouh_Actual = 2;
 537         }
 538         otg_Unit->hu_HubPortChanged = FALSE;
 539
 540         return 0;
 541     }
 542
 543     D(bug("[USB2OTG:Hub] UHCMD_INTXFER: Queueing request\n"));
 544
 545     ioreq->iouh_Req.io_Flags &= ~IOF_QUICK;
 546     Disable();
 547     AddTail(&otg_Unit->hu_IOPendingQueue, (struct Node *)ioreq);
 548     Enable();
 549
 550     return RC_DONTREPLY;
 551 }
 552
 553 void FNAME_ROOTHUB(PendingIO)(struct USB2OTGUnit *otg_Unit)
 554 {
 555     struct IOUsbHWReq *ioreq;
 556
 557     D(bug("[USB2OTG:Hub] PendingIO(0x%p)\n", otg_Unit));
 558
 559     if (otg_Unit->hu_HubPortChanged && otg_Unit->hu_IOPendingQueue.lh_Head->ln_Succ)
 560     {
 561         D(bug("[USB2OTG:Hub] PendingIO: PortChange detected\n"));
 562         Disable();
 563         ioreq = (struct IOUsbHWReq *) otg_Unit->hu_IOPendingQueue.lh_Head;
 564         while (((struct Node *) ioreq)->ln_Succ)
 565         {
 566             Remove(&ioreq->iouh_Req.io_Message.mn_Node);
 567             if (ioreq->iouh_Length == 1)
 568             {
 569                 *((UBYTE *) ioreq->iouh_Data) = 1;
 570                 ioreq->iouh_Actual = 1;
 571             } else {
 572                 ((UBYTE *) ioreq->iouh_Data)[0] = 1;
 573                 ((UBYTE *) ioreq->iouh_Data)[1] = 0;
 574                 ioreq->iouh_Actual = 2;
 575             }
 576             ReplyMsg(&ioreq->iouh_Req.io_Message);
 577             ioreq = (struct IOUsbHWReq *) otg_Unit->hu_IOPendingQueue.lh_Head;
 578         }
 579         otg_Unit->hu_HubPortChanged = FALSE;
 580         Enable();
 581     }
 582 }