arch/arm-native/soc/broadcom/2708/usb/usb2otg/usb2otg_device.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 <proto/alib.h>
  14
  15 #include "usb2otg_intern.h"
  16
  17 #define DEVNAME         "usb2otg.device"
  18
  19 const char devname[]    = MOD_NAME_STRING;
  20
  21 AROS_INTP(FNAME_DEV(PendingInt));
  22 AROS_INTP(FNAME_DEV(NakTimeoutInt));
  23
  24 IPTR    __arm_periiobase __attribute__((used)) = 0 ;
  25
  26 static void GlobalIRQHandler(struct USB2OTGUnit *USBUnit, struct ExecBase *SysBase)
  27 {
  28     volatile unsigned int otg_RegVal;
  29
  30     D(bug("[USB2OTG] %s: Received USB interrupt for Unit @ 0x%p\n",
  31                  __PRETTY_FUNCTION__, USBUnit));
  32
  33     otg_RegVal = *((volatile unsigned int *)USB2OTG_INTR);
  34
  35     if (otg_RegVal & USB2OTG_INTRCORE_HOSTCHANNEL)
  36     {
  37         volatile unsigned int otg_ChanVal;
  38         otg_ChanVal = *((volatile unsigned int *)USB2OTG_HOSTINTR);
  39         *((volatile unsigned int *)USB2OTG_HOSTINTR) = otg_ChanVal;
  40 #if (0)
  41               for (chan = 0; chan < ... ; chan ++)
  42               {
  43                       if (otg_ChanVal & (1 << chan))
  44                       {
  45                               *((volatile unsigned int *)USB2OTG_HOST_CHANBASE + (chan * USB2OTG_HOST_CHANREGSIZE) + 0x0c) = 0;
  46                               D(bug("[USB2OTG] %s: Host Channel #%d Interrupt\n",
  47                                       __PRETTY_FUNCTION__, chan));
  48                       }
  49               }
  50 #endif
  51     }
  52
  53     *((volatile unsigned int *)USB2OTG_INTR) = otg_RegVal;
  54 }
  55
  56 /*
  57  *===========================================================
  58  * Init(base)
  59  *===========================================================
  60  */
  61 static int FNAME_DEV(Init)(LIBBASETYPEPTR USB2OTGBase)
  62 {
  63     volatile unsigned int *pmmailbox;
  64     volatile unsigned int otg_RegVal;
  65     unsigned int otg_OperatingMode = 0, pmres;
  66
  67     KernelBase = OpenResource("kernel.resource");
  68
  69     __arm_periiobase = KrnGetSystemAttr(KATTR_PeripheralBase);
  70
  71     pmmailbox = (volatile unsigned int *)(ARM_PERIIOBASE + 0xB880);
  72
  73     D(bug("[USB2OTG] %s: USB2OTGBase @ 0x%p, SysBase @ 0x%p\n",
  74                  __PRETTY_FUNCTION__, USB2OTGBase, SysBase));
  75
  76     otg_RegVal = *((volatile unsigned int *)USB2OTG_VENDORID);
  77
  78     if ((otg_RegVal & 0xFFFFF000) != 0x4F542000)
  79     {
  80         bug("[USB2OTG] Unsupported HS OTG USB Core Found\n");
  81         bug("[USB2OTG] Hardware: %c%c%x.%x%x%x\n",
  82                     ((otg_RegVal >> 24) & 0xFF), ((otg_RegVal >> 16) & 0xFF),
  83                     ((otg_RegVal >> 12) & 0xF), ((otg_RegVal >> 8) & 0xF), ((otg_RegVal >> 4) & 0xF), (otg_RegVal & 0xF)
  84                     );
  85
  86         USB2OTGBase = NULL;
  87     }
  88     else
  89     {
  90         USB2OTGBase->hd_KernelBase = OpenResource("kernel.resource");
  91         D(bug("[USB2OTG] %s: kernel.resource opened @ 0x%p\n",
  92                 __PRETTY_FUNCTION__, USB2OTGBase->hd_KernelBase));
  93
  94         if((USB2OTGBase->hd_MsgPort = CreateMsgPort()))
  95         {
  96             if((USB2OTGBase->hd_TimerReq = (struct timerequest *) CreateIORequest(USB2OTGBase->hd_MsgPort, sizeof(struct timerequest))))
  97             {
  98                 if(!OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *) USB2OTGBase->hd_TimerReq, 0))
  99                 {
 100                     USB2OTGBase->hd_TimerReq->tr_node.io_Message.mn_Node.ln_Name = "USB2OTG Timer";
 101                     USB2OTGBase->hd_TimerReq->tr_node.io_Command = TR_ADDREQUEST;
 102                     D(bug("[USB2OTG] %s: timer.device opened\n",
 103                             __PRETTY_FUNCTION__));
 104
 105                     bug("[USB2OTG] HS OTG Core Release: %c%c%x.%x%x%x\n",
 106                                 ((otg_RegVal >> 24) & 0xFF), ((otg_RegVal >> 16) & 0xFF),
 107                                 ((otg_RegVal >> 12) & 0xF), ((otg_RegVal >> 8) & 0xF), ((otg_RegVal >> 4) & 0xF), (otg_RegVal & 0xF)
 108                                 );
 109
 110                     otg_RegVal = *((volatile unsigned int *)USB2OTG_HARDWARE2);
 111                     bug("[USB2OTG] Architecture: %d - ", ((otg_RegVal & (3 << 3)) >> 3));
 112                     switch (((otg_RegVal & (3 << 3)) >> 3))
 113                     {
 114                         case 2:
 115                             bug("Internal DMA\n");
 116                             break;
 117                         case 1:
 118                             bug("External DMA\n");
 119                             break;
 120                         default:
 121                             bug("Slave Only\n");
 122                             break;
 123                     }
 124
 125                     D(bug("[USB2OTG] %s: Disabling USB Interrupts (Globaly)..\n", __PRETTY_FUNCTION__));
 126                     otg_RegVal = *((volatile unsigned int *)USB2OTG_AHB);
 127                     otg_RegVal &= ~USB2OTG_AHB_INTENABLE;
 128                     *((volatile unsigned int *)USB2OTG_INTRMASK) = 0;
 129                     *((volatile unsigned int *)USB2OTG_AHB) = otg_RegVal;
 130
 131                     while (pmmailbox[6] & 0x80000000);
 132                     pmmailbox[8] = 0x80;
 133                     do {
 134                         while (pmmailbox[6] & 0x40000000);
 135                     } while (((pmres = pmmailbox[0]) & 0xf) != 0);
 136                     if (pmres != 0x80)
 137                     {
 138                         bug("[USB2OTG] Failed to power on controller\n");
 139                         //USB2OTGBase->hd_TimerReq
 140                         //USB2OTGBase->hd_MsgPort
 141                         USB2OTGBase = NULL;
 142                         return FALSE;
 143                     }
 144
 145                     if ((USB2OTGBase->hd_UtilityBase = (APTR)OpenLibrary("utility.library", 39)) != NULL)
 146                     {
 147                         USB2OTGBase->hd_MemPool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR | MEMF_SEM_PROTECTED, 16384, 4096);
 148                         if (USB2OTGBase->hd_MemPool)
 149                         {
 150                             int ns;
 151
 152                             D(bug("[USB2OTG] %s: Allocated MemPool @ 0x%p\n",
 153                                         __PRETTY_FUNCTION__, USB2OTGBase->hd_MemPool));
 154
 155                             if (USB2OTGBase)
 156                             {
 157                                 D(
 158                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_HARDWARE);
 159                                     bug("[USB2OTG] %s: HWConfig: %08x-", __PRETTY_FUNCTION__, otg_RegVal);
 160                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_HARDWARE2);
 161                                     bug("%08x-", otg_RegVal);
 162                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_HARDWARE3);
 163                                     bug("%08x-", otg_RegVal);
 164                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_HARDWARE4);
 165                                     bug("%08x\n", otg_RegVal);
 166                                 )
 167
 168                                 if ((USB2OTGBase->hd_Unit = AllocPooled(USB2OTGBase->hd_MemPool, sizeof(struct USB2OTGUnit))) != NULL)
 169                                 {
 170                                     D(bug("[USB2OTG] %s: Unit Allocated at 0x%p\n",
 171                                                 __PRETTY_FUNCTION__, USB2OTGBase->hd_Unit));
 172
 173                                     NewList(&USB2OTGBase->hd_Unit->hu_IOPendingQueue);
 174
 175                                     NewList(&USB2OTGBase->hd_Unit->hu_CtrlXFerQueue);
 176                                     NewList(&USB2OTGBase->hd_Unit->hu_IntXFerQueue);
 177                                     NewList(&USB2OTGBase->hd_Unit->hu_IsoXFerQueue);
 178                                     NewList(&USB2OTGBase->hd_Unit->hu_BulkXFerQueue);
 179                                     NewList(&USB2OTGBase->hd_Unit->hu_TDQueue);
 180                                     NewList(&USB2OTGBase->hd_Unit->hu_AbortQueue);
 181                                     NewList(&USB2OTGBase->hd_Unit->hu_PeriodicTDQueue);
 182
 183                                     USB2OTGBase->hd_Unit->hu_PendingInt.is_Node.ln_Type = NT_INTERRUPT;
 184                                     USB2OTGBase->hd_Unit->hu_PendingInt.is_Node.ln_Name = "OTG2USB Pending Work Interrupt";
 185                                     USB2OTGBase->hd_Unit->hu_PendingInt.is_Node.ln_Pri  = 0;
 186                                     USB2OTGBase->hd_Unit->hu_PendingInt.is_Data = USB2OTGBase->hd_Unit;
 187                                     USB2OTGBase->hd_Unit->hu_PendingInt.is_Code = (VOID_FUNC)FNAME_DEV(PendingInt);
 188
 189                                     USB2OTGBase->hd_Unit->hu_NakTimeoutInt.is_Node.ln_Type = NT_INTERRUPT;
 190                                     USB2OTGBase->hd_Unit->hu_NakTimeoutInt.is_Node.ln_Name = "OTG2USB NakTimeout Interrupt";
 191                                     USB2OTGBase->hd_Unit->hu_NakTimeoutInt.is_Node.ln_Pri  = -16;
 192                                     USB2OTGBase->hd_Unit->hu_NakTimeoutInt.is_Data = USB2OTGBase->hd_Unit;
 193                                     USB2OTGBase->hd_Unit->hu_NakTimeoutInt.is_Code = (VOID_FUNC)FNAME_DEV(NakTimeoutInt);
 194
 195                                     USB2OTGBase->hd_Unit->hu_NakTimeoutMsgPort.mp_Node.ln_Type = NT_MSGPORT;
 196                                     USB2OTGBase->hd_Unit->hu_NakTimeoutMsgPort.mp_Flags = PA_SOFTINT;
 197                                     USB2OTGBase->hd_Unit->hu_NakTimeoutMsgPort.mp_SigTask = &USB2OTGBase->hd_Unit->hu_NakTimeoutInt;
 198                                     NewList(&USB2OTGBase->hd_Unit->hu_NakTimeoutMsgPort.mp_MsgList);
 199
 200                                     CopyMem(USB2OTGBase->hd_TimerReq, &USB2OTGBase->hd_Unit->hu_NakTimeoutReq, sizeof(struct timerequest));
 201                                     USB2OTGBase->hd_Unit->hu_NakTimeoutReq.tr_node.io_Message.mn_ReplyPort = &USB2OTGBase->hd_Unit->hu_NakTimeoutMsgPort;
 202
 203                                     USB2OTGBase->hd_Unit->hu_HubPortChanged = FALSE;
 204
 205                                     USB2OTGBase->hd_Unit->hu_OperatingMode = (otg_OperatingMode == (USB2OTG_USBHOSTMODE|USB2OTG_USBDEVICEMODE)) ? 0 : otg_OperatingMode;
 206
 207 #if (0)
 208                                     D(bug("[USB2OTG] %s: Unit Mode %d\n",
 209                                                 __PRETTY_FUNCTION__, USB2OTGBase->hd_Unit->hu_OperatingMode));
 210 #endif
 211                                     USB2OTGBase->hd_Unit->hu_GlobalIRQHandle = KrnAddIRQHandler(IRQ_VC_USB, GlobalIRQHandler, USB2OTGBase->hd_Unit, SysBase);
 212
 213                                     D(bug("[USB2OTG] %s: Installed Global IRQ Handler [handle @ 0x%p] for IRQ #%ld\n",
 214                                                 __PRETTY_FUNCTION__, USB2OTGBase->hd_Unit->hu_GlobalIRQHandle, IRQ_HOSTPORT));
 215
 216                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 217                                     otg_RegVal &= ~(USB2OTG_USB_ULPIDRIVEEXTERNALVBUS|USB2OTG_USB_TSDLINEPULSEENABLE);
 218                                     *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 219
 220                                     D(bug("[USB2OTG] %s: Reseting Controller ..\n", __PRETTY_FUNCTION__));
 221                                     *((volatile unsigned int *)USB2OTG_RESET) = USB2OTG_RESET_CORESOFT;
 222                                     for (ns = 0; ns < 10000; ns++) { asm volatile("mov r0, r0\n"); } // Wait 10ms
 223                                     if ((*((volatile unsigned int *)USB2OTG_RESET) & USB2OTG_RESET_CORESOFT) != 0)
 224                                         bug("[USB2OTG] %s: Reset Timed-Out!\n", __PRETTY_FUNCTION__);
 225
 226                                     D(bug("[USB2OTG] %s: Initialising PHY ..\n", __PRETTY_FUNCTION__));
 227                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 228                                     otg_RegVal &= ~USB2OTG_USB_PHYINTERFACE;
 229                                     otg_RegVal &= ~USB2OTG_USB_MODESELECT_UTMI;
 230                                     *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 231
 232 #if (0)
 233                                     D(bug("[USB2OTG] %s: Reseting Controller ..\n", __PRETTY_FUNCTION__));
 234                                     *((volatile unsigned int *)USB2OTG_RESET) = USB2OTG_RESET_CORESOFT;
 235                                     for (ns = 0; ns < 10000; ns++) { asm volatile("mov r0, r0\n"); } // Wait 10ms
 236                                     if ((*((volatile unsigned int *)USB2OTG_RESET) & USB2OTG_RESET_CORESOFT) != 0)
 237                                         bug("[USB2OTG] %s: Reset Timed-Out!\n", __PRETTY_FUNCTION__);
 238 #endif
 239
 240                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_HARDWARE2);
 241                                     if (((otg_RegVal & (3 << 6) >> 6) == 2) && ((otg_RegVal & (3 << 8) >> 8) == 1))
 242                                     {
 243                                         D(bug("[USB2OTG] %s: ULPI FSLS configuration: enabled.\n", __PRETTY_FUNCTION__));
 244                                         otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 245                                         otg_RegVal |= (USB2OTG_USB_ULPIFSLS|USB2OTG_USB_ULPI_CLK_SUS_M);
 246                                         *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 247                                     } else {
 248                                         D(bug("[USB2OTG] %s: ULPI FSLS configuration: disabled.\n", __PRETTY_FUNCTION__));
 249                                         otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 250                                         otg_RegVal &= ~(USB2OTG_USB_ULPIFSLS|USB2OTG_USB_ULPI_CLK_SUS_M);
 251                                         *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 252                                     }
 253
 254                                     D(bug("[USB2OTG] %s: Enabling DMA configuration..\n", __PRETTY_FUNCTION__));
 255                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_AHB);
 256                                     otg_RegVal &= ~(1 << USB2OTG_AHB_DMAREMAINDERMODE);
 257                                     otg_RegVal |= (USB2OTG_AHB_DMAENABLE|USB2OTG_AHB_DMAREMAINDERMODE_INCR);
 258                                     *((volatile unsigned int *)USB2OTG_AHB) = otg_RegVal;
 259
 260 #if (0)
 261                                     D(bug("[USB2OTG] %s: Operating Mode: ", __PRETTY_FUNCTION__));
 262                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_HARDWARE2);
 263                                     switch (otg_RegVal & 7)
 264                                     {
 265                                         case 0:
 266                                             D(bug("HNP/SRP\n"));
 267                                             otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 268                                             otg_RegVal |= (USB2OTG_USB_HNPCAPABLE|USB2OTG_USB_SRPCAPABLE);
 269                                             *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 270                                             break;
 271                                         case 1:
 272                                         case 3:
 273                                         case 5:
 274                                             D(bug("SRP\n"));
 275                                             otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 276                                             otg_RegVal &= ~USB2OTG_USB_HNPCAPABLE;
 277                                             otg_RegVal |= USB2OTG_USB_SRPCAPABLE;
 278                                             *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 279                                             break;
 280                                         case 2:
 281                                         case 4:
 282                                         case 6:
 283                                             D(bug("No HNP or SRP\n"));
 284                                             otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 285                                             otg_RegVal &= ~(USB2OTG_USB_HNPCAPABLE|USB2OTG_USB_SRPCAPABLE);
 286                                             *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 287                                             break;
 288                                     }
 289 #else
 290                                     D(bug("[USB2OTG] %s: Disable HNP/SRP\n", __PRETTY_FUNCTION__));
 291                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_USB);
 292                                     otg_RegVal &= ~(USB2OTG_USB_HNPCAPABLE|USB2OTG_USB_SRPCAPABLE);
 293                                     *((volatile unsigned int *)USB2OTG_USB) = otg_RegVal;
 294 #endif
 295
 296                                     D(bug("[USB2OTG] %s: Enabling Global Interrupts ...\n", __PRETTY_FUNCTION__));
 297                                     otg_RegVal = *((volatile unsigned int *)USB2OTG_INTR);
 298                                     otg_RegVal = ~0UL;
 299                                     *((volatile unsigned int *)USB2OTG_INTR) = otg_RegVal;
 300
 301                                     bug("[USB2OTG] HS OTG USB Driver Initialised\n");
 302                                 }
 303                             }
 304                         }
 305                         else
 306                         {
 307                             D(bug("[USB2OTG] %s: Failed to Create MemPool\n",
 308                                         __PRETTY_FUNCTION__));
 309
 310                             CloseLibrary((struct Library *) UtilityBase);
 311                             USB2OTGBase = NULL;
 312                         }
 313                     }
 314                     else
 315                     {
 316                         D(bug("[USB2OTG] %s: OpenLibrary(\"utility.library\", 39) failed!\n",
 317                                     __PRETTY_FUNCTION__));
 318
 319                         USB2OTGBase = NULL;
 320                     }
 321                 }
 322                 else
 323                 {
 324                     D(bug("[USB2OTG] %s: OpenDevice(\"timer.device\") failed!\n",
 325                                 __PRETTY_FUNCTION__));
 326
 327                     USB2OTGBase = NULL;
 328                 }
 329             }
 330             else
 331             {
 332                 D(bug("[USB2OTG] %s: Failed to allocate timer IORequest\n",
 333                             __PRETTY_FUNCTION__));
 334
 335                 USB2OTGBase = NULL;
 336             }
 337         }
 338         else
 339         {
 340             D(bug("[USB2OTG] %s: Failed to create MsgPort\n",
 341                         __PRETTY_FUNCTION__));
 342
 343             USB2OTGBase = NULL;
 344         }
 345     }
 346
 347     return USB2OTGBase ? TRUE : FALSE;
 348 }
 349
 350 /*
 351  *===========================================================
 352  * Open(ioreq, unit, flags, base)
 353  *===========================================================
 354  *
 355  * This is the the DEV_OPEN function.
 356  *
 357  */
 358 static int FNAME_DEV(Open)(LIBBASETYPEPTR USB2OTGBase, struct IOUsbHWReq *ioreq, ULONG otg_Unit, ULONG flags)
 359 {
 360     D(bug("[USB2OTG] %s: IOReq @ 0x%p, unit #%ld, flags = 0x%08lx, USB2OTGBase @ 0x%p\n",
 361                 __PRETTY_FUNCTION__, ioreq, otg_Unit, flags, USB2OTGBase));
 362
 363     D(bug("[USB2OTG] %s: openCnt = %ld\n",
 364                 __PRETTY_FUNCTION__, USB2OTGBase->hd_Library.lib_OpenCnt));
 365
 366     if (ioreq->iouh_Req.io_Message.mn_Length < sizeof(struct IOUsbHWReq))
 367     {
 368         D(bug("[USB2OTG] %s: invalid MN_LENGTH!\n",
 369                     __PRETTY_FUNCTION__));
 370
 371         ioreq->iouh_Req.io_Error = IOERR_BADLENGTH;
 372     }
 373     else
 374     {
 375         ioreq->iouh_Req.io_Error = IOERR_OPENFAIL;
 376
 377         ioreq->iouh_Req.io_Unit = FNAME_DEV(OpenUnit)(ioreq, otg_Unit, USB2OTGBase);
 378         if (!(ioreq->iouh_Req.io_Unit))
 379         {
 380             D(bug("[USB2OTG] %s: could not open unit!\n",
 381                         __PRETTY_FUNCTION__));
 382
 383         }
 384         else
 385         {
 386             ioreq->iouh_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 387             ioreq->iouh_Req.io_Error                   = 0;
 388
 389             return TRUE;
 390         }
 391     }
 392
 393     return FALSE;
 394 }
 395
 396
 397 /*
 398  *===========================================================
 399  * Close(ioreq, base)
 400  *===========================================================
 401  *
 402  * This is the the DEV_EXPUNGE function.
 403  *
 404  */
 405 static int FNAME_DEV(Close)(LIBBASETYPEPTR USB2OTGBase, struct IOUsbHWReq *ioreq)
 406 {
 407     D(bug("[USB2OTG] %s: IOReq @ 0x%p, USB2OTGBase @ 0x%p\n",
 408                 __PRETTY_FUNCTION__, ioreq, USB2OTGBase));
 409
 410     FNAME_DEV(CloseUnit)(ioreq, (struct USB2OTGUnit *) ioreq->iouh_Req.io_Unit, USB2OTGBase);
 411
 412     ioreq->iouh_Req.io_Unit   = (APTR) -1;
 413     ioreq->iouh_Req.io_Device = (APTR) -1;
 414     return TRUE;
 415 }
 416
 417 static int FNAME_DEV(Expunge)(LIBBASETYPEPTR USB2OTGBase)
 418 {
 419     DeletePool(USB2OTGBase->hd_MemPool);
 420
 421     D(bug("[USB2OTG] %s: closing utility.library @ 0x%p\n",
 422                 __PRETTY_FUNCTION__, UtilityBase));
 423
 424     CloseLibrary((struct Library *) UtilityBase);
 425     return TRUE;
 426 }
 427
 428 ADD2INITLIB(FNAME_DEV(Init), 0)
 429 ADD2OPENDEV(FNAME_DEV(Open), 0)
 430 ADD2CLOSEDEV(FNAME_DEV(Close), 0)
 431 ADD2EXPUNGELIB(FNAME_DEV(Expunge), 0)
 432
 433 /*
 434  *===========================================================
 435  * BeginIO(ioreq, base)
 436  *===========================================================
 437  *
 438  * This is the DEV_BEGINIO vector of the device.
 439  *
 440  */
 441 AROS_LH1(void, FNAME_DEV(BeginIO),
 442          AROS_LHA(struct IOUsbHWReq *, ioreq, A1),
 443              LIBBASETYPEPTR, USB2OTGBase, 5, usb2otg)
 444 {
 445     AROS_LIBFUNC_INIT
 446
 447     struct USB2OTGUnit *otg_Unit = (struct USB2OTGUnit *) ioreq->iouh_Req.io_Unit;
 448     WORD ret;
 449
 450     D(bug("[USB2OTG] %s: IOReq @ 0x%08lx, USB2OTGBase @ 0x%08lx [cmd:%lu]\n",
 451                 __PRETTY_FUNCTION__, ioreq, USB2OTGBase, ioreq->iouh_Req.io_Command));
 452
 453     ioreq->iouh_Req.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 454     ioreq->iouh_Req.io_Error                   = UHIOERR_NO_ERROR;
 455
 456     if (ioreq->iouh_Req.io_Command < NSCMD_DEVICEQUERY)
 457     {
 458         switch (ioreq->iouh_Req.io_Command)
 459         {
 460             case CMD_RESET:
 461                 ret = FNAME_DEV(cmdReset)(ioreq, otg_Unit, USB2OTGBase);
 462                 break;
 463
 464             case CMD_FLUSH:
 465                 ret = FNAME_DEV(cmdFlush)(ioreq, otg_Unit, USB2OTGBase);
 466                 break;
 467
 468             case UHCMD_QUERYDEVICE:
 469                 ret = FNAME_DEV(cmdQueryDevice)(ioreq, otg_Unit, USB2OTGBase);
 470                 break;
 471
 472             case UHCMD_USBRESET:
 473                 ret = FNAME_DEV(cmdUsbReset)(ioreq, otg_Unit, USB2OTGBase);
 474                 break;
 475
 476             case UHCMD_USBRESUME:
 477                 ret = FNAME_DEV(cmdUsbResume)(ioreq, otg_Unit, USB2OTGBase);
 478                 break;
 479
 480             case UHCMD_USBSUSPEND:
 481                 ret = FNAME_DEV(cmdUsbSuspend)(ioreq, otg_Unit, USB2OTGBase);
 482                 break;
 483
 484             case UHCMD_USBOPER:
 485                 ret = FNAME_DEV(cmdUsbOper)(ioreq, otg_Unit, USB2OTGBase);
 486                 break;
 487
 488             case UHCMD_CONTROLXFER:
 489                 ret = FNAME_DEV(cmdControlXFer)(ioreq, otg_Unit, USB2OTGBase);
 490                 break;
 491
 492             case UHCMD_BULKXFER:
 493                 ret = FNAME_DEV(cmdBulkXFer)(ioreq, otg_Unit, USB2OTGBase);
 494                 break;
 495
 496             case UHCMD_INTXFER:
 497                 ret = FNAME_DEV(cmdIntXFer)(ioreq, otg_Unit, USB2OTGBase);
 498                 break;
 499
 500             case UHCMD_ISOXFER:
 501                 ret = FNAME_DEV(cmdIsoXFer)(ioreq, otg_Unit, USB2OTGBase);
 502                 break;
 503
 504             default:
 505                 ret = IOERR_NOCMD;
 506                 break;
 507         }
 508     }
 509     else
 510     {
 511         switch(ioreq->iouh_Req.io_Command)
 512         {
 513             case NSCMD_DEVICEQUERY:
 514                 ret = FNAME_DEV(cmdNSDeviceQuery)((struct IOStdReq *) ioreq, otg_Unit, USB2OTGBase);
 515                 break;
 516
 517             default:
 518                 ret = IOERR_NOCMD;
 519                 break;
 520         }
 521     }
 522
 523     if (ret != RC_DONTREPLY)
 524     {
 525         D(bug("[USB2OTG] %s: Terminating I/O..\n",
 526                     __PRETTY_FUNCTION__));
 527
 528         if (ret != RC_OK)
 529         {
 530             ioreq->iouh_Req.io_Error = ret & 0xff;
 531         }
 532         FNAME_DEV(TermIO)(ioreq, USB2OTGBase);
 533     }
 534
 535     AROS_LIBFUNC_EXIT
 536 }
 537
 538 /*
 539  *===========================================================
 540  * AbortIO(ioreq, base)
 541  *===========================================================
 542  *
 543  * This is the DEV_ABORTIO vector of the device. It abort
 544  * the given iorequest, and set
 545  *
 546  */
 547 AROS_LH1(LONG, FNAME_DEV(AbortIO),
 548          AROS_LHA(struct IOUsbHWReq *, ioreq, A1),
 549              LIBBASETYPEPTR, USB2OTGBase, 6, usb2otg)
 550 {
 551     AROS_LIBFUNC_INIT
 552
 553     D(bug("[USB2OTG] %s: IOReq @ 0x%p, command %ld, status %ld\n",
 554                 __PRETTY_FUNCTION__, ioreq, ioreq->iouh_Req.io_Command, ioreq->iouh_Req.io_Message.mn_Node.ln_Type));
 555
 556     /* Is it pending? */
 557     if (ioreq->iouh_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE)
 558     {
 559 #if (0)
 560         if (FNAME_DEV(cmdAbortIO)(ioreq, USB2OTGBase))
 561         {
 562             return(0);
 563         }
 564 #endif
 565     }
 566     return(-1);
 567
 568     AROS_LIBFUNC_EXIT
 569 }
 570
 571 void FNAME_DEV(Cause)(LIBBASETYPEPTR USB2OTGBase, struct Interrupt *interrupt)
 572 {
 573     /* this is a workaround for the original Cause() function missing tailed calls */
 574     Disable();
 575
 576     if((interrupt->is_Node.ln_Type == NT_SOFTINT) || (interrupt->is_Node.ln_Type == NT_USER))
 577     {
 578         // signal tailed call
 579         interrupt->is_Node.ln_Type = NT_USER;
 580     } else {
 581         do
 582         {
 583             interrupt->is_Node.ln_Type = NT_SOFTINT;
 584             Forbid(); // make sure code is not interrupted by other tasks
 585             Enable();
 586             AROS_INTC1(interrupt->is_Code, interrupt->is_Data);
 587             Disable();
 588             Permit();
 589         } while(interrupt->is_Node.ln_Type != NT_SOFTINT);
 590         interrupt->is_Node.ln_Type = NT_INTERRUPT;
 591     }
 592     Enable();
 593 }