rom/usb/pciusbhc/ohci/cmd.c

   1 /*
   2    Copyright © 2002-2009, Chris Hodges. All rights reserved.
   3    Copyright © 2009-2017, The AROS Development Team. All rights reserved.
   4    $Id$
   5  */
   6
   7 #include <devices/usb_hub.h>
   8
   9 #include <proto/utility.h>
  10 #include <proto/exec.h>
  11 #include <proto/timer.h>
  12 #include <clib/alib_protos.h>
  13
  14 #include "debug.h"
  15
  16 #include "cmd_protos.h"
  17 #include "roothub_protos.h"
  18 #include "chip_protos.h"
  19 #include "pci_protos.h"
  20
  21 #include "pci.h"
  22 #include "chip.h"
  23
  24 struct my_NSDeviceQueryResult
  25 {
  26     ULONG DevQueryFormat;       /* this is type 0               */
  27     ULONG SizeAvailable;        /* bytes available              */
  28     UWORD DeviceType;           /* what the device does         */
  29     UWORD DeviceSubType;        /* depends on the main type     */
  30     const UWORD *SupportedCommands;     /* 0 terminated list of cmd's   */
  31 };
  32
  33 static BOOL OpenTimer(struct PCIUnit *unit, struct PCIDevice *base);
  34 static void CloseTimer(struct PCIUnit *unit, struct PCIDevice *base);
  35 static UWORD GetUsbState(struct IOUsbHWReq *ioreq,
  36     struct PCIUnit *unit, struct PCIDevice *base);
  37
  38 static const struct TagItem query_tags[] = {
  39     {UHA_Manufacturer, (IPTR) "Chris Hodges, AROS Development Team"},
  40     {UHA_Description, (IPTR) "Open Host Controller Interface driver"},
  41     {UHA_Copyright,
  42         (IPTR) "©2007-2012 Chris Hodges,\n AROS Development Team"},
  43     {UHA_Version, VERSION_NUMBER},
  44     {UHA_Revision, REVISION_NUMBER},
  45     {UHA_DriverVersion, 0x220},
  46     {TAG_END, 0}
  47 };
  48
  49 /* /// "OpenTimer()" */
  50 static BOOL OpenTimer(struct PCIUnit *unit, struct PCIDevice *base)
  51 {
  52     if ((unit->hu_MsgPort = CreateMsgPort()))
  53     {
  54         if ((unit->hu_TimerReq =
  55                 (struct timerequest *)CreateIORequest(unit->hu_MsgPort,
  56                     sizeof(struct timerequest))))
  57         {
  58             if (!OpenDevice("timer.device", UNIT_MICROHZ,
  59                     (struct IORequest *)unit->hu_TimerReq, 0))
  60             {
  61                 unit->hu_TimerReq->tr_node.io_Message.mn_Node.ln_Name =
  62                     "PCI hardware";
  63                 unit->hu_TimerReq->tr_node.io_Command = TR_ADDREQUEST;
  64                 KPRINTF(1, ("opened timer device\n"));
  65                 return TRUE;
  66             }
  67             DeleteIORequest((struct IORequest *)unit->hu_TimerReq);
  68             unit->hu_TimerReq = NULL;
  69         }
  70         DeleteMsgPort(unit->hu_MsgPort);
  71         unit->hu_MsgPort = NULL;
  72     }
  73     KPRINTF(5, ("failed to open timer.device\n"));
  74     return FALSE;
  75 }
  76 /* \\\ */
  77
  78 /* /// "DelayMS()" */
  79 void DelayMS(ULONG milli, struct PCIUnit *unit)
  80 {
  81     unit->hu_TimerReq->tr_time.tv_secs = 0;
  82     unit->hu_TimerReq->tr_time.tv_micro = milli * 1000;
  83     DoIO((struct IORequest *)unit->hu_TimerReq);
  84 }
  85 /* \\\ */
  86
  87 /* /// "CloseTimer()" */
  88 static void CloseTimer(struct PCIUnit *unit, struct PCIDevice *base)
  89 {
  90     if (unit->hu_MsgPort)
  91     {
  92         if (unit->hu_TimerReq)
  93         {
  94             KPRINTF(1, ("closing timer.device\n"));
  95             CloseDevice((APTR) unit->hu_TimerReq);
  96             DeleteIORequest((struct IORequest *)unit->hu_TimerReq);
  97             unit->hu_TimerReq = NULL;
  98         }
  99         DeleteMsgPort(unit->hu_MsgPort);
 100         unit->hu_MsgPort = NULL;
 101     }
 102 }
 103 /* \\\ */
 104
 105 /* /// "Open_Unit()" */
 106 struct Unit *Open_Unit(struct IOUsbHWReq *ioreq,
 107     LONG unitnr, struct PCIDevice *base)
 108 {
 109     struct PCIUnit *unit = NULL;
 110
 111     if (!base->hd_ScanDone)
 112     {
 113         base->hd_ScanDone = TRUE;
 114         if (!pciInit(base))
 115         {
 116             return NULL;
 117         }
 118     }
 119     unit = (struct PCIUnit *)base->hd_Units.lh_Head;
 120     while (((struct Node *)unit)->ln_Succ)
 121     {
 122         if (unit->hu_UnitNo == unitnr)
 123         {
 124             break;
 125         }
 126         unit = (struct PCIUnit *)((struct Node *)unit)->ln_Succ;
 127     }
 128     if (!((struct Node *)unit)->ln_Succ)
 129     {
 130         KPRINTF(20, ("Unit %ld does not exist!\n", unitnr));
 131         return NULL;
 132     }
 133     if (unit->hu_UnitAllocated)
 134     {
 135         ioreq->iouh_Req.io_Error = IOERR_UNITBUSY;
 136         KPRINTF(5, ("Unit %ld already open!\n", unitnr));
 137         return NULL;
 138     }
 139
 140     if (OpenTimer(unit, base))
 141     {
 142
 143         if (pciAllocUnit(unit)) // hardware self test
 144         {
 145             unit->hu_UnitAllocated = TRUE;
 146             unit->hu_NakTimeoutInt.is_Node.ln_Type = NT_INTERRUPT;
 147             unit->hu_NakTimeoutInt.is_Node.ln_Name = "PCI NakTimeout";
 148             unit->hu_NakTimeoutInt.is_Node.ln_Pri = -16;
 149             unit->hu_NakTimeoutInt.is_Data = unit;
 150             unit->hu_NakTimeoutInt.is_Code = (VOID_FUNC) NakTimeoutInt;
 151
 152             CopyMem(unit->hu_TimerReq, &unit->hu_NakTimeoutReq,
 153                 sizeof(struct timerequest));
 154             memset( &unit->hu_NakTimeoutMsgPort, 0, sizeof( unit->hu_NakTimeoutMsgPort ) );
 155             unit->hu_NakTimeoutMsgPort.mp_Node.ln_Type = NT_MSGPORT;
 156             unit->hu_NakTimeoutMsgPort.mp_Flags = PA_SOFTINT;
 157             unit->hu_NakTimeoutMsgPort.mp_SigTask = &unit->hu_NakTimeoutInt;
 158             NewList(&unit->hu_NakTimeoutMsgPort.mp_MsgList);
 159             unit->hu_NakTimeoutReq.tr_node.io_Message.mn_ReplyPort =
 160                 &unit->hu_NakTimeoutMsgPort;
 161             Cause(&unit->hu_NakTimeoutInt);
 162             return &unit->hu_Unit;
 163         }
 164         else
 165         {
 166             ioreq->iouh_Req.io_Error = IOERR_SELFTEST;
 167             KPRINTF(20, ("Hardware allocation failure!\n"));
 168         }
 169         CloseTimer(unit, base);
 170     }
 171     return NULL;
 172 }
 173 /* \\\ */
 174
 175 /* /// "Close_Unit()" */
 176 void Close_Unit(struct PCIDevice *base,
 177     struct PCIUnit *unit, struct IOUsbHWReq *ioreq)
 178 {
 179     /* Disable all interrupts */
 180     unit->hu_NakTimeoutMsgPort.mp_Flags = PA_IGNORE;
 181     unit->hu_NakTimeoutInt.is_Node.ln_Type = NT_SOFTINT;
 182     AbortIO((APTR) & unit->hu_NakTimeoutReq);
 183
 184     pciFreeUnit(unit);
 185
 186     CloseTimer(unit, base);
 187     unit->hu_UnitAllocated = FALSE;
 188 }
 189 /* \\\ */
 190
 191 /* /// "GetUsbState()" */
 192 static UWORD GetUsbState(struct IOUsbHWReq *ioreq,
 193     struct PCIUnit *unit, struct PCIDevice *base)
 194 {
 195     return ioreq->iouh_State = UHSF_OPERATIONAL;
 196 }
 197 /* \\\ */
 198
 199 /* /// "cmdReset()" */
 200 /*
 201  *======================================================================
 202  * cmdReset(ioreq, unit, base)
 203  *======================================================================
 204  *
 205  * This is the device CMD_RESET routine.
 206  *
 207  * Resets the whole USB hardware. Goes into USBOperational mode right
 208  * after. Must NOT be called from an interrupt.
 209  *
 210  */
 211
 212 WORD cmdReset(struct IOUsbHWReq * ioreq,
 213     struct PCIUnit * unit, struct PCIDevice * base)
 214 {
 215     KPRINTF(10, ("CMD_RESET ioreq: 0x%p\n", ioreq));
 216
 217     DelayMS(1, unit);
 218     GetUsbState(ioreq, unit, base);
 219
 220     if (ioreq->iouh_State & UHSF_OPERATIONAL)
 221     {
 222         return RC_OK;
 223     }
 224     return UHIOERR_USBOFFLINE;
 225 }
 226 /* \\\ */
 227
 228 /* /// "cmdUsbReset()" */
 229 /*
 230  *======================================================================
 231  * cmdUsbReset(ioreq, unit, base)
 232  *======================================================================
 233  *
 234  * This is the device UHCMD_USBRESET routine.
 235  *
 236  * Resets the USB bus. Goes into USBOperational mode right after. Must
 237  * NOT be called from an interrupt.
 238  *
 239  */
 240
 241 WORD cmdUsbReset(struct IOUsbHWReq * ioreq,
 242     struct PCIUnit * unit, struct PCIDevice * base)
 243 {
 244     KPRINTF(10, ("UHCMD_USBRESET ioreq: 0x%p\n", ioreq));
 245
 246     /* FIXME */
 247     GetUsbState(ioreq, unit, base);
 248
 249     unit->hu_FrameCounter = 1;
 250     unit->hu_RootHubAddr = 0;
 251
 252     if (ioreq->iouh_State & UHSF_OPERATIONAL)
 253     {
 254         return RC_OK;
 255     }
 256     return UHIOERR_USBOFFLINE;
 257 }
 258 /* \\\ */
 259
 260 /* /// "cmdUsbResume()" */
 261 /*
 262  *======================================================================
 263  * cmdUsbResume(ioreq, unit, base)
 264  *======================================================================
 265  *
 266  * This is the device UHCMD_USBRESUME routine.
 267  *
 268  * Tries to resume from USBSuspend mode into USBOperational.
 269  * Must NOT be called from an interrupt.
 270  *
 271  */
 272
 273 WORD cmdUsbResume(struct IOUsbHWReq * ioreq,
 274     struct PCIUnit * unit, struct PCIDevice * base)
 275 {
 276     KPRINTF(10, ("UHCMD_USBRESUME ioreq: 0x%p\n", ioreq));
 277
 278     /* FIXME */
 279     GetUsbState(ioreq, unit, base);
 280     if (ioreq->iouh_State & UHSF_OPERATIONAL)
 281     {
 282         return RC_OK;
 283     }
 284     return UHIOERR_USBOFFLINE;
 285 }
 286 /* \\\ */
 287
 288 /* /// "cmdUsbSuspend()" */
 289 /*
 290  *======================================================================
 291  * cmdUsbSuspend(ioreq, unit, base)
 292  *======================================================================
 293  *
 294  * This is the device UHCMD_USBSUSPEND routine.
 295  *
 296  * Sets the USB into USBSuspend mode.
 297  * Must NOT be called from an interrupt.
 298  *
 299  */
 300
 301 WORD cmdUsbSuspend(struct IOUsbHWReq * ioreq,
 302     struct PCIUnit * unit, struct PCIDevice * base)
 303 {
 304     KPRINTF(10, ("UHCMD_USBSUSPEND ioreq: 0x%p\n", ioreq));
 305
 306     /* FIXME */
 307     GetUsbState(ioreq, unit, base);
 308     if (ioreq->iouh_State & UHSF_SUSPENDED)
 309     {
 310         return RC_OK;
 311     }
 312     return UHIOERR_USBOFFLINE;
 313 }
 314 /* \\\ */
 315
 316 /* /// "cmdUsbOper()" */
 317 /*
 318  *======================================================================
 319  * cmdUsbOper(ioreq, unit, base)
 320  *======================================================================
 321  *
 322  * This is the device UHCMD_USBOPER routine.
 323  *
 324  * Sets the USB into USBOperational mode.
 325  * Must NOT be called from an interrupt.
 326  *
 327  */
 328
 329 WORD cmdUsbOper(struct IOUsbHWReq * ioreq,
 330     struct PCIUnit * unit, struct PCIDevice * base)
 331 {
 332     KPRINTF(10, ("UHCMD_USBOPER ioreq: 0x%p\n", ioreq));
 333
 334     /* FIXME */
 335     GetUsbState(ioreq, unit, base);
 336     if (ioreq->iouh_State & UHSF_OPERATIONAL)
 337     {
 338         return RC_OK;
 339     }
 340     return UHIOERR_USBOFFLINE;
 341 }
 342 /* \\\ */
 343
 344 /* /// "cmdQueryDevice()" */
 345 /*
 346  *======================================================================
 347  * cmdQueryDevice(ioreq, unit, base)
 348  *======================================================================
 349  *
 350  * This is the device UHCMD_QUERYDEVICE routine.
 351  *
 352  * Returns information about the hardware.
 353  *
 354  */
 355
 356 WORD cmdQueryDevice(struct IOUsbHWReq * ioreq,
 357     struct PCIUnit * unit, struct PCIDevice * base)
 358 {
 359     struct TagItem *taglist = (struct TagItem *)ioreq->iouh_Data;
 360     struct TagItem *tag;
 361     ULONG count = 0;
 362
 363     KPRINTF(10, ("UHCMD_QUERYDEVICE ioreq: 0x%p, taglist: 0x%p\n", ioreq,
 364             taglist));
 365
 366     while ((tag = NextTagItem(&taglist)) != NULL)
 367     {
 368         switch (tag->ti_Tag)
 369         {
 370         case UHA_State:
 371             *((ULONG *) tag->ti_Data) =
 372                 (ULONG) GetUsbState(ioreq, unit, base);
 373             break;
 374         case UHA_ProductName:
 375             *((STRPTR *) tag->ti_Data) = unit->hu_ProductName;
 376             break;
 377         default:
 378             *((IPTR *) tag->ti_Data) =
 379                 GetTagData(tag->ti_Tag, *((IPTR *) tag->ti_Data),
 380                 query_tags);
 381         }
 382         count++;
 383     }
 384
 385     ioreq->iouh_Actual = count;
 386     return RC_OK;
 387 }
 388 /* \\\ */
 389
 390 WORD cmdXFer(struct IOUsbHWReq * ioreq,
 391     struct PCIUnit * unit, struct PCIDevice * base)
 392 {
 393     struct PCIController *hc;
 394     UWORD xfer_type = 0;
 395
 396     // get transfer type
 397     switch (ioreq->iouh_Req.io_Command)
 398     {
 399     case UHCMD_CONTROLXFER:
 400         xfer_type = CTRL_XFER;
 401         break;
 402     case UHCMD_ISOXFER:
 403         xfer_type = ISO_XFER;
 404         break;
 405     case UHCMD_INTXFER:
 406         xfer_type = INT_XFER;
 407         break;
 408     case UHCMD_BULKXFER:
 409         xfer_type = BULK_XFER;
 410         break;
 411     }
 412
 413     KPRINTF(10, ("UHCMD_%sXFER ioreq: 0x%p\n", xfer_names[xfer_type],
 414             ioreq));
 415     GetUsbState(ioreq, unit, base);
 416     if (!(ioreq->iouh_State & UHSF_OPERATIONAL))
 417     {
 418         return UHIOERR_USBOFFLINE;
 419     }
 420
 421     if (xfer_type == CTRL_XFER)
 422     {
 423         /* Root Hub Emulation */
 424         if (ioreq->iouh_DevAddr == unit->hu_RootHubAddr)
 425         {
 426             return cmdControlXFerRootHub(ioreq, unit, base);
 427         }
 428     }
 429     else if (xfer_type == INT_XFER)
 430     {
 431         /* Root Hub Emulation */
 432         if (ioreq->iouh_DevAddr == unit->hu_RootHubAddr)
 433         {
 434             return cmdIntXFerRootHub(ioreq, unit, base);
 435         }
 436     }
 437     else if (xfer_type == BULK_XFER || xfer_type == ISO_XFER)
 438     {
 439         if (ioreq->iouh_Flags & UHFF_LOWSPEED)
 440         {
 441             return UHIOERR_BADPARAMS;
 442         }
 443     }
 444
 445     hc = unit->hu_DevControllers[ioreq->iouh_DevAddr];
 446     if (!hc)
 447     {
 448         return UHIOERR_HOSTERROR;
 449     }
 450
 451     ioreq->iouh_Req.io_Flags &= ~IOF_QUICK;
 452     ioreq->iouh_Actual = 0;
 453     ioreq->iouh_DriverPrivate1 = NULL;
 454
 455     Disable();
 456     AddTail(&hc->hc_XferQueues[xfer_type], (struct Node *)ioreq);
 457     Enable();
 458     Cause(&hc->hc_CompleteInt);
 459
 460     KPRINTF(10, ("UHCMD_%sXFER processed ioreq: 0x%p\n",
 461             xfer_names[xfer_type], ioreq));
 462     return RC_DONTREPLY;
 463 }
 464 /* \\\ */
 465
 466 /* /// "cmdFlush()" */
 467 /*
 468  *======================================================================
 469  * cmdFlush(ioreq, base)
 470  *======================================================================
 471  *
 472  * This is the device CMD_FLUSH routine.
 473  *
 474  * This routine abort all pending transfer requests.
 475  *
 476  */
 477
 478 WORD cmdFlush(struct IOUsbHWReq * ioreq,
 479     struct PCIUnit * unit, struct PCIDevice * base)
 480 {
 481     struct IOUsbHWReq *cmpioreq;
 482     struct PCIController *hc;
 483     UWORD i;
 484     struct List *list;
 485
 486     KPRINTF(10, ("CMD_FLUSH ioreq: 0x%p\n", ioreq));
 487
 488     Disable();
 489     cmpioreq = (struct IOUsbHWReq *)unit->hu_RHIOQueue.lh_Head;
 490     while (((struct Node *)cmpioreq)->ln_Succ)
 491     {
 492         Remove(&cmpioreq->iouh_Req.io_Message.mn_Node);
 493         cmpioreq->iouh_Req.io_Error = IOERR_ABORTED;
 494         ReplyMsg(&cmpioreq->iouh_Req.io_Message);
 495         cmpioreq = (struct IOUsbHWReq *)unit->hu_RHIOQueue.lh_Head;
 496     }
 497     hc = (struct PCIController *)unit->hu_Controllers.lh_Head;
 498     while (hc->hc_Node.ln_Succ)
 499     {
 500         for (i = 0; i < XFER_COUNT; i++)
 501         {
 502             list = (struct List *)&hc->hc_XferQueues[i];
 503             while ((cmpioreq = (struct IOUsbHWReq *)RemHead(list)) != NULL)
 504             {
 505                 cmpioreq->iouh_Req.io_Error = IOERR_ABORTED;
 506                 ReplyMsg(&cmpioreq->iouh_Req.io_Message);
 507             }
 508         }
 509         hc = (struct PCIController *)hc->hc_Node.ln_Succ;
 510     }
 511     Enable();
 512     /* Return success
 513      */
 514     return RC_OK;
 515 }
 516 /* \\\ */
 517
 518 /* /// "NSD stuff" */
 519
 520 static const UWORD NSDSupported[] = {
 521     CMD_FLUSH, CMD_RESET,
 522     UHCMD_QUERYDEVICE, UHCMD_USBRESET,
 523     UHCMD_USBRESUME, UHCMD_USBSUSPEND,
 524     UHCMD_USBOPER, UHCMD_CONTROLXFER,
 525     UHCMD_ISOXFER, UHCMD_INTXFER,
 526     UHCMD_BULKXFER,
 527     NSCMD_DEVICEQUERY, 0
 528 };
 529
 530 WORD cmdNSDeviceQuery(struct IOStdReq *ioreq,
 531     struct PCIUnit *unit, struct PCIDevice *base)
 532 {
 533     struct my_NSDeviceQueryResult *query;
 534
 535     query = (struct my_NSDeviceQueryResult *)ioreq->io_Data;
 536
 537     KPRINTF(10, ("NSCMD_DEVICEQUERY ioreq: 0x%p query: 0x%p\n", ioreq,
 538             query));
 539
 540     /* NULL ptr?
 541        Enough data?
 542        Valid request?
 543      */
 544     if ((!query) ||
 545         (ioreq->io_Length < sizeof(struct my_NSDeviceQueryResult)) ||
 546         (query->DevQueryFormat != 0) || (query->SizeAvailable != 0))
 547     {
 548         /* Return error. This is special handling, since iorequest is only
 549            guaranteed to be sizeof(struct IOStdReq). If we'd let our
 550            devBeginIO dispatcher return the error, it would trash some
 551            memory past end of the iorequest (ios2_WireError field).
 552          */
 553         ioreq->io_Error = IOERR_NOCMD;
 554         TermIO((struct IOUsbHWReq *)ioreq, base);
 555
 556         /* Don't reply, we already did.
 557          */
 558         return RC_DONTREPLY;
 559     }
 560
 561     ioreq->io_Actual = query->SizeAvailable
 562         = sizeof(struct my_NSDeviceQueryResult);
 563     query->DeviceType = NSDEVTYPE_USBHARDWARE;
 564     query->DeviceSubType = 0;
 565     query->SupportedCommands = NSDSupported;
 566
 567     /* Return success (note that this will NOT poke ios2_WireError).
 568      */
 569     return RC_OK;
 570 }
 571 /* \\\ */
 572
 573 /* /// "TermIO()" */
 574 /*
 575  *===========================================================
 576  * TermIO(ioreq, base)
 577  *===========================================================
 578  *
 579  * Return completed ioreq to sender.
 580  *
 581  */
 582
 583 void TermIO(struct IOUsbHWReq *ioreq, struct PCIDevice *base)
 584 {
 585     ioreq->iouh_Req.io_Message.mn_Node.ln_Type = NT_FREEMSG;
 586
 587     /* If not quick I/O, reply the message
 588      */
 589     if (!(ioreq->iouh_Req.io_Flags & IOF_QUICK))
 590     {
 591         ReplyMsg(&ioreq->iouh_Req.io_Message);
 592     }
 593 }
 594 /* \\\ */
 595
 596 /* /// "cmdAbortIO()" */
 597 BOOL cmdAbortIO(struct IOUsbHWReq *ioreq, struct PCIDevice *base)
 598 {
 599     struct PCIUnit *unit = (struct PCIUnit *)ioreq->iouh_Req.io_Unit;
 600     struct IOUsbHWReq *cmpioreq;
 601     struct PCIController *hc;
 602     BOOL foundit = FALSE;
 603     UWORD i;
 604
 605     KPRINTF(10, ("cmdAbort(%p)\n", ioreq));
 606
 607     Disable();
 608     cmpioreq = (struct IOUsbHWReq *)unit->hu_RHIOQueue.lh_Head;
 609     while (((struct Node *)cmpioreq)->ln_Succ)
 610     {
 611         if (ioreq == cmpioreq)
 612         {
 613             Remove(&ioreq->iouh_Req.io_Message.mn_Node);
 614             Enable();
 615             ioreq->iouh_Req.io_Error = IOERR_ABORTED;
 616             TermIO(ioreq, base);
 617             return TRUE;
 618         }
 619         cmpioreq =
 620             (struct IOUsbHWReq *)cmpioreq->iouh_Req.io_Message.
 621             mn_Node.ln_Succ;
 622     }
 623
 624     hc = (struct PCIController *)unit->hu_Controllers.lh_Head;
 625     while (hc->hc_Node.ln_Succ)
 626     {
 627         for (i = 0; i < XFER_COUNT && !foundit; i++)
 628         {
 629             for (cmpioreq =
 630                 (struct IOUsbHWReq *)hc->hc_XferQueues[i].lh_Head;
 631                 ((struct Node *)cmpioreq)->ln_Succ != NULL && !foundit;
 632                 cmpioreq =
 633                 (struct IOUsbHWReq *)cmpioreq->iouh_Req.io_Message.
 634                 mn_Node.ln_Succ)
 635             {
 636                 if (ioreq == cmpioreq)
 637                     foundit = TRUE;
 638             }
 639         }
 640         if (!foundit)
 641         {
 642             // IOReq is probably pending in some transfer structure
 643             cmpioreq = (struct IOUsbHWReq *)hc->hc_TDQueue.lh_Head;
 644             while (((struct Node *)cmpioreq)->ln_Succ)
 645             {
 646                 if (ioreq == cmpioreq)
 647                 {
 648                     /*
 649                      * Request's ED is in use by the HC, as well as its TDs
 650                      * and data buffers.
 651                      * Schedule abort on the HC driver and reply the request
 652                      * only when done. However return success.
 653                      */
 654                     ioreq->iouh_Req.io_Error = IOERR_ABORTED;
 655                     AbortRequest(hc, ioreq);
 656                     Enable();
 657                     return TRUE;
 658                 }
 659                 cmpioreq =
 660                     (struct IOUsbHWReq *)cmpioreq->iouh_Req.
 661                     io_Message.mn_Node.ln_Succ;
 662             }
 663             break;
 664
 665         }
 666         if (foundit)
 667         {
 668             Remove(&ioreq->iouh_Req.io_Message.mn_Node);
 669             break;
 670         }
 671         hc = (struct PCIController *)hc->hc_Node.ln_Succ;
 672     }
 673     Enable();
 674
 675     if (foundit)
 676     {
 677         ioreq->iouh_Req.io_Error = IOERR_ABORTED;
 678         TermIO(ioreq, base);
 679     }
 680     else
 681     {
 682         KPRINTF(20, ("WARNING, could not abort unknown IOReq %p\n", ioreq));
 683     }
 684     return foundit;
 685 }
 686 /* \\\ */
 687
 688 /* /// "CheckSpecialCtrlTransfers()" */
 689 void CheckSpecialCtrlTransfers(struct PCIController *hc,
 690     struct IOUsbHWReq *ioreq)
 691 {
 692     struct PCIUnit *unit = hc->hc_Unit;
 693
 694     /* Clear Feature(Endpoint halt) */
 695     if ((ioreq->iouh_SetupData.bmRequestType ==
 696             (URTF_STANDARD | URTF_ENDPOINT))
 697         && (ioreq->iouh_SetupData.bRequest == USR_CLEAR_FEATURE)
 698         && (ioreq->iouh_SetupData.wValue ==
 699             AROS_WORD2LE(UFS_ENDPOINT_HALT)))
 700     {
 701         KPRINTF(10, ("Resetting toggle bit for endpoint %ld\n",
 702                 AROS_WORD2LE(ioreq->iouh_SetupData.wIndex) & 0xf));
 703         unit->
 704             hu_DevDataToggle[(ioreq->iouh_DevAddr << 5) |
 705             (AROS_WORD2LE(ioreq->
 706                     iouh_SetupData.wIndex) & 0xf) | ((AROS_WORD2LE(ioreq->
 707                         iouh_SetupData.wIndex) & 0x80) >> 3)] = 0;
 708     }
 709     else if ((ioreq->iouh_SetupData.bmRequestType ==
 710             (URTF_STANDARD | URTF_DEVICE))
 711         && (ioreq->iouh_SetupData.bRequest == USR_SET_ADDRESS))
 712     {
 713         /* Set Address -> clear all endpoints */
 714         ULONG epnum;
 715         ULONG adr = AROS_WORD2BE(ioreq->iouh_SetupData.wValue) >> 3;
 716         KPRINTF(10, ("Resetting toggle bits for device address %ld\n",
 717                 adr >> 5));
 718         for (epnum = 0; epnum < 31; epnum++)
 719         {
 720             unit->hu_DevDataToggle[adr + epnum] = 0;
 721         }
 722         // transfer host controller ownership
 723         unit->hu_DevControllers[ioreq->iouh_DevAddr] = NULL;
 724         unit->hu_DevControllers[adr >> 5] = hc;
 725     }
 726     else if ((ioreq->iouh_SetupData.bmRequestType ==
 727             (URTF_CLASS | URTF_OTHER))
 728         && (ioreq->iouh_SetupData.bRequest == USR_SET_FEATURE)
 729         && (ioreq->iouh_SetupData.wValue == AROS_WORD2LE(UFS_PORT_RESET)))
 730     {
 731         // a hub will be enumerating a device on this host controller soon!
 732         KPRINTF(10, ("Hub RESET caught, assigning Dev0 to %p!\n", hc));
 733         unit->hu_DevControllers[0] = hc;
 734     }
 735 }
 736 /* \\\ */
 737
 738 /* /// "NakTimeoutInt()" */
 739 AROS_INTH1(NakTimeoutInt, struct PCIUnit *, unit)
 740 {
 741     AROS_INTFUNC_INIT
 742
 743     struct PCIController *hc;
 744     struct IOUsbHWReq *ioreq;
 745     UWORD target;
 746     ULONG framecnt;
 747
 748     KPRINTF(1, ("Enter NakTimeoutInt(0x%p)\n", unit));
 749
 750     // check for NAK Timeouts
 751     hc = (struct PCIController *)unit->hu_Controllers.lh_Head;
 752     while (hc->hc_Node.ln_Succ)
 753     {
 754         if (!(hc->hc_Flags & HCF_ONLINE))
 755         {
 756             hc = (struct PCIController *)hc->hc_Node.ln_Succ;
 757             continue;
 758         }
 759         UpdateFrameCounter(hc);
 760         framecnt = hc->hc_FrameCounter;
 761         // NakTimeout
 762         ioreq = (struct IOUsbHWReq *)hc->hc_TDQueue.lh_Head;
 763         while (((struct Node *)ioreq)->ln_Succ)
 764         {
 765             // Remember the successor because AbortRequest() will move the request to another list
 766             struct IOUsbHWReq *succ =
 767                 (struct IOUsbHWReq *)ioreq->iouh_Req.io_Message.
 768                 mn_Node.ln_Succ;
 769
 770             if (ioreq->iouh_Flags & UHFF_NAKTIMEOUT)
 771             {
 772                 KPRINTF(1, ("Examining IOReq=%p with OED=%p\n", ioreq,
 773                         ioreq->iouh_DriverPrivate1));
 774                 if (ioreq->iouh_DriverPrivate1)
 775                 {
 776                     KPRINTF(1,
 777                         ("CTRL=%04lx, CMD=%01lx, F=%ld, hccaDH=%08lx, "
 778                             "hcDH=%08lx, CH=%08lx, CCH=%08lx, "
 779                             "IntStatus=%08lx, IntEn=%08lx\n",
 780                             READREG32_LE(hc->hc_RegBase, OHCI_CONTROL),
 781                             READREG32_LE(hc->hc_RegBase, OHCI_CMDSTATUS),
 782                             READREG32_LE(hc->hc_RegBase, OHCI_FRAMECOUNT),
 783                             READMEM32_LE(&hc->hc_HCCA->ha_DoneHead),
 784                             READREG32_LE(hc->hc_RegBase, OHCI_DONEHEAD),
 785                             READREG32_LE(hc->hc_RegBase, OHCI_CTRL_HEAD_ED),
 786                             READREG32_LE(hc->hc_RegBase, OHCI_CTRL_ED),
 787                             READREG32_LE(hc->hc_RegBase, OHCI_INTSTATUS),
 788                             READREG32_LE(hc->hc_RegBase, OHCI_INTEN)));
 789
 790                     target =
 791                         (ioreq->iouh_DevAddr << 5) + ioreq->iouh_Endpoint +
 792                         ((ioreq->iouh_Dir == UHDIR_IN) ? 0x10 : 0);
 793                     if (framecnt > unit->hu_NakTimeoutFrame[target])
 794                     {
 795                         // give the thing the chance to exit gracefully
 796                         KPRINTF(200,
 797                             ("HC 0x%p NAK timeout %ld > %ld, IOReq=%p\n",
 798                                 hc, framecnt,
 799                                 unit->hu_NakTimeoutFrame[target], ioreq));
 800                         ioreq->iouh_Req.io_Error = UHIOERR_NAKTIMEOUT;
 801                         AbortRequest(hc, ioreq);
 802                     }
 803                 }
 804             }
 805             ioreq = succ;
 806         }
 807
 808         hc = (struct PCIController *)hc->hc_Node.ln_Succ;
 809     }
 810
 811     CheckRootHubChanges(unit);
 812
 813     unit->hu_NakTimeoutReq.tr_time.tv_micro = 150 * 1000;
 814     SendIO((APTR) & unit->hu_NakTimeoutReq);
 815
 816     KPRINTF(1, ("Exit NakTimeoutInt(0x%p)\n", unit));
 817
 818     return FALSE;
 819
 820     AROS_INTFUNC_EXIT
 821 }
 822 /* \\\ */