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