?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
grub2: bring back build of aros-side grub2 tools
[AROS.git] / workbench / devs / USB / stack / usbhubclass.c
blob1c4e7f8406ae9987c0993abbb93e801c5c1b8276
1 /*
2 Copyright (C) 2006 by Michal Schulz
3 $Id$
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with this program; if not, write to the
17 Free Software Foundation, Inc.,
18 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20 /*
21 * CHANGELOG:
22 * DATE NAME ENTRY
23 * ---------- ------------------ -------------------------------------------------------------------
24 * 2009-03-07 T. Wiszkowski Taught hub to re-attempt device discovery at later time
25 * if no suitable driver is present initially
26 * 2008-06-02 T. Wiszkowski Updated device detection mechanism so the stack is aware of already
27 * connected devices
28 */
29
30 #define DEBUG 0
31
32 #include <inttypes.h>
33
34 #include <aros/debug.h>
35
36 #include <exec/types.h>
37 #include <oop/oop.h>
38
39 #include <hidd/hidd.h>
40 #include <usb/usb.h>
41 #include <usb/usb_core.h>
42
43 #include <dos/dos.h>
44 #include <dos/dosextens.h>
45
46 #include <devices/timer.h>
47
48 #include <proto/oop.h>
49 #include <proto/utility.h>
50 #include <proto/dos.h>
51
52 #include <stdio.h>
53
54 #include "usb.h"
55 #include "misc.h"
56
57 #define STACK_SIZE 10240
58
59 static void hub_process();
60
61 /*
62 * The HubInterrupt() is a tiny software interrupt routine that signals the
63 * hub process about the need of hub exploration
64 */
65 AROS_INTH1(HubInterrupt, HubData *, hub)
66 {
67 AROS_INTFUNC_INIT
68
69 /* Signal the HUB process about incoming interrupt */
70 if (hub->hub_task)
71 Signal(hub->hub_task, 1 << hub->sigInterrupt);
72
73 return FALSE;
74
75 AROS_INTFUNC_EXIT
76 }
77
78 /*
79 * Initialize HUB class properly. Find out all relevant data and start the
80 * HUB process.
81 */
82 OOP_Object *METHOD(USBHub, Root, New)
83 {
84 struct Task *t;
85 struct MemList *ml;
86
87 D(bug("[USB] USBHub::New()\n"));
88
89 o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
90 if (o)
91 {
92 HubData *hub = OOP_INST_DATA(cl, o);
93 char *name;
94
95 /* HUB devices do need a bit longer timeout than anything else */
96 HIDD_USBDevice_SetTimeout(o, NULL, 5000);
97
98 hub->root = GetTagData(aHidd_USBHub_IsRoot, FALSE, msg->attrList);
99 hub->enabled = FALSE;
100 hub->got_descriptor = FALSE;
101
102 OOP_GetAttr(o, aHidd_USBDevice_ProductName, (intptr_t *)&name);
103
104 hub->got_descriptor = HIDD_USBHub_GetHubDescriptor(o, &hub->descriptor);
105
106 if (hub->got_descriptor)
107 DumpDescriptor((usb_descriptor_t *)&hub->descriptor);
108 else
109 {
110 D(bug("[USBHub] HUB descriptor not present. I will try later...\n"));
111 hub->descriptor.bNbrPorts = GetTagData(aHidd_USBHub_NumPorts, 1, msg->attrList);
112 }
113
114 D(bug("[USBHub] %s hub with %d ports\n",
115 hub->root ? "Root" : "A", hub->descriptor.bNbrPorts));
116
117 hub->children = AllocVecPooled(SD(cl)->MemPool, hub->descriptor.bNbrPorts * sizeof(OOP_Object *));
118
119 D(bug("[USB] USBHub has name \"%s\"\n", name));
120
121 hub->sd = SD(cl);
122 hub->hub_name = name ? name : "unknown";
123 hub->proc_name = AllocVecPooled(SD(cl)->MemPool, 10 + strlen(name ? name : "unknown"));
124
125 sprintf(hub->proc_name, "USBHub (%s)", name ? name : "unknown");
126
127 HIDD_USBDevice_Configure(o, 0);
128
129 usb_endpoint_descriptor_t *ep = HIDD_USBDevice_GetEndpoint(o, 0, 0);
130
131 D(bug("[USBHub] Endpoint descriptor %p\n", ep));
132
133 if (ep)
134 {
135 DumpDescriptor((usb_descriptor_t *)ep);
136
137 if ((ep->bmAttributes & UE_XFERTYPE) != UE_INTERRUPT)
138 {
139 bug("[USBHub] Wrong endpoint type\n");
140 HIDD_USBDevice_Configure(o, USB_UNCONFIG_INDEX);
141 // TODO: unconfigure, error, coercemethod
142 }
143
144 OOP_Object *drv = NULL;
145 OOP_GetAttr(o, aHidd_USBDevice_Bus, (IPTR *)&drv);
146
147 if (drv)
148 {
149 hub->interrupt.is_Data = hub;
150 hub->interrupt.is_Code = (VOID_FUNC)HubInterrupt;
151 hub->intr_pipe = HIDD_USBDevice_CreatePipe(o, PIPE_Interrupt, ep->bEndpointAddress, ep->bInterval, AROS_LE2WORD(ep->wMaxPacketSize), 0);
152 // HIDD_USBDrv_AddInterrupt(drv, hub->intr_pipe, &hub->status[0], AROS_LE2WORD(ep->wMaxPacketSize), &hub->interrupt);
153 HIDD_USBDrv_AddInterrupt(drv, hub->intr_pipe, &hub->status[0], 1, &hub->interrupt);
154 }
155
156 }
157
158 struct TagItem tags[] = {
159 { TASKTAG_ARG1, (IPTR)hub },
160 { TASKTAG_ARG2, (IPTR)o },
161 { TASKTAG_ARG3, (IPTR)FindTask(NULL) },
162 { TAG_DONE, 0UL },
163 };
164
165 t = AllocMem(sizeof(struct Task), MEMF_PUBLIC|MEMF_CLEAR);
166 ml = AllocMem(sizeof(struct MemList) + sizeof(struct MemEntry), MEMF_PUBLIC|MEMF_CLEAR);
167
168 if (t && ml)
169 {
170 char *sp = AllocMem(STACK_SIZE, MEMF_PUBLIC|MEMF_CLEAR);
171 t->tc_SPLower = sp;
172 t->tc_SPUpper = sp + STACK_SIZE;
173 #if AROS_STACK_GROWS_DOWNWARDS
174 t->tc_SPReg = (char *)t->tc_SPUpper - SP_OFFSET;
175 #else
176 t->tc_SPReg = (char *)t->tc_SPLower + SP_OFFSET;
177 #endif
178
179 ml->ml_NumEntries = 2;
180 ml->ml_ME[0].me_Addr = t;
181 ml->ml_ME[0].me_Length = sizeof(struct Task);
182 ml->ml_ME[1].me_Addr = sp;
183 ml->ml_ME[1].me_Length = STACK_SIZE;
184
185 NEWLIST(&t->tc_MemEntry);
186 ADDHEAD(&t->tc_MemEntry, &ml->ml_Node);
187
188 t->tc_Node.ln_Name = hub->proc_name;
189 t->tc_Node.ln_Type = NT_TASK;
190 t->tc_Node.ln_Pri = 0;
191
192 NewAddTask(t, hub_process, NULL, &tags[0]);
193 hub->hub_task = t;
194 }
195
196 Wait(SIGF_SINGLE);
197 }
198
199 D(bug("[USB] USBHub::New() = %p\n",o));
200
201 return o;
202 }
203
204 void METHOD(USBHub, Root, Dispose)
205 {
206 D(bug("[USB] USBHub::Dispose\n"));
207 HubData *hub = OOP_INST_DATA(cl, o);
208 struct usbEvent message;
209
210 message.ev_Message.mn_ReplyPort = CreateMsgPort();
211 message.ev_Type = evt_Cleanup;
212
213 PutMsg(hub->hub_port, (struct Message *)&message);
214 WaitPort(message.ev_Message.mn_ReplyPort);
215 DeleteMsgPort(message.ev_Message.mn_ReplyPort);
216
217 FreeVecPooled(SD(cl)->MemPool, hub->children);
218 FreeVecPooled(SD(cl)->MemPool, hub->proc_name);
219
220 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
221 }
222
223 void METHOD(USBHub, Root, Get)
224 {
225 uint32_t idx;
226 HubData *hub = OOP_INST_DATA(cl, o);
227
228 if (IS_USBHUB_ATTR(msg->attrID, idx))
229 {
230 switch (idx)
231 {
232 case aoHidd_USBHub_IsRoot:
233 *msg->storage = hub->root;
234 break;
235 case aoHidd_USBHub_IsCompound:
236 *msg->storage = 0;
237 break;
238 case aoHidd_USBHub_HubCurrent:
239 *msg->storage = 0;
240 break;
241 case aoHidd_USBHub_NumPorts:
242 *msg->storage = hub->descriptor.bNbrPorts;
243 break;
244 default:
245 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
246 }
247 }
248 else
249 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
250 }
251
252 void METHOD(USBHub, Root, Set)
253 {
254 uint32_t idx;
255 struct TagItem *tag;
256 struct TagItem *tags = msg->attrList;
257
258 while ((tag = NextTagItem(&tags)))
259 {
260 if (IS_USBHUB_ATTR(tag->ti_Tag, idx))
261 {
262
263 }
264 }
265
266 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
267 }
268
269 OOP_Object * METHOD(USBHub, Hidd_USBHub, GetChild)
270 {
271 HubData *hub = OOP_INST_DATA(cl, o);
272 if ((msg->port > 0) && (msg->port <= hub->descriptor.bNbrPorts))
273 return (hub->children[msg->port-1]);
274 else
275 return NULL;
276 }
277
278 BOOL METHOD(USBHub, Hidd_USBHub, OnOff)
279 {
280 HubData *hub = OOP_INST_DATA(cl, o);
281 struct usbEvent message;
282
283 D(bug("[USBHub] USBHub::OnOff(%d)\n", msg->on));
284
285 hub->enabled = msg->on;
286
287 message.ev_Message.mn_ReplyPort = CreateMsgPort();
288 message.ev_Type = evt_OnOff;
289
290 PutMsg(hub->hub_port, (struct Message *)&message);
291 WaitPort(message.ev_Message.mn_ReplyPort);
292 DeleteMsgPort(message.ev_Message.mn_ReplyPort);
293
294 return FALSE;
295 }
296
297 BOOL METHOD(USBHub, Hidd_USBHub, PortEnable)
298 {
299 D(bug("[USBHub] USBHub::PortEnable(%d, %d)\n", msg->portNummer, msg->enable));
300 return FALSE;
301 }
302
303 BOOL METHOD(USBHub, Hidd_USBHub, PortReset)
304 {
305 HubData *hub = OOP_INST_DATA(cl, o);
306 BOOL retval = FALSE;
307 USBDevice_Request req;
308 int n = 10;
309 usb_port_status_t ps;
310
311 req.bmRequestType = UT_WRITE_CLASS_OTHER;
312 req.bRequest = UR_SET_FEATURE;
313 req.wValue = AROS_WORD2LE(UHF_PORT_RESET);
314 req.wIndex = AROS_WORD2LE(msg->portNummer);
315 req.wLength = AROS_WORD2LE(0);
316
317 retval = HIDD_USBDevice_ControlMessage(o, NULL, &req, NULL, 0);
318
319 if (retval) do
320 {
321 USBDelay(hub->tr, USB_PORT_RESET_DELAY);
322
323 retval = HIDD_USBHub_GetPortStatus(o, msg->portNummer, &ps);
324
325 if (!retval)
326 break;
327
328 if (!(AROS_LE2WORD(ps.wPortStatus) & UPS_CURRENT_CONNECT_STATUS))
329 {
330 retval = TRUE;
331 break;
332 }
333 } while ((AROS_LE2WORD(ps.wPortChange) & UPS_C_PORT_RESET) == 0 && --n > 0);
334
335 if (n==0)
336 retval = FALSE;
337 else
338 {
339 HIDD_USBHub_ClearPortFeature(o, msg->portNummer, UHF_C_PORT_RESET);
340 USBDelay(hub->tr, USB_PORT_RESET_RECOVERY);
341 }
342
343 D(bug("[USBHub] USBHub::PortReset(%d) %s\n", msg->portNummer, retval ? "OK":"Error"));
344
345 return retval;
346 }
347
348 BOOL METHOD(USBHub, Hidd_USBHub, GetPortStatus)
349 {
350 D(bug("[USBHub] USBHub::GetPortStatus()\n"));
351
352 USBDevice_Request req;
353
354 req.bmRequestType = UT_READ_CLASS_OTHER;
355 req.bRequest = UR_GET_STATUS;
356 req.wValue = AROS_WORD2LE(0);
357 req.wIndex = AROS_WORD2LE(msg->port);
358 req.wLength = AROS_WORD2LE(sizeof(usb_port_status_t));
359
360 return HIDD_USBDevice_ControlMessage(o, NULL, &req, msg->status, sizeof(usb_port_status_t));
361 }
362
363 BOOL METHOD(USBHub, Hidd_USBHub, GetHubStatus)
364 {
365 D(bug("[USBHub] USBHub::GetHubStatus()\n"));
366
367 USBDevice_Request req;
368
369 req.bmRequestType = UT_READ_CLASS_DEVICE;
370 req.bRequest = UR_GET_STATUS;
371 req.wValue = AROS_WORD2LE(0);
372 req.wIndex = AROS_WORD2LE(0);
373 req.wLength = AROS_WORD2LE(sizeof(usb_hub_status_t));
374
375 return HIDD_USBDevice_ControlMessage(o, NULL, &req, msg->status, sizeof(usb_hub_status_t));
376 }
377
378 BOOL METHOD(USBHub, Hidd_USBHub, ClearHubFeature)
379 {
380 D(bug("[USBHub] USBHub::ClearHubFeature()\n"));
381
382 USBDevice_Request req;
383
384 req.bmRequestType = UT_WRITE_CLASS_DEVICE;
385 req.bRequest = UR_CLEAR_FEATURE;
386 req.wValue = AROS_WORD2LE(msg->feature);
387 req.wIndex = AROS_WORD2LE(0);
388 req.wLength = AROS_WORD2LE(0);
389
390 return HIDD_USBDevice_ControlMessage(o, NULL, &req, NULL, 0);
391 }
392
393 BOOL METHOD(USBHub, Hidd_USBHub, SetHubFeature)
394 {
395 D(bug("[USBHub] USBHub::SetHubFeature()\n"));
396
397 USBDevice_Request req;
398
399 req.bmRequestType = UT_WRITE_CLASS_DEVICE;
400 req.bRequest = UR_SET_FEATURE;
401 req.wValue = AROS_WORD2LE(msg->feature);
402 req.wIndex = AROS_WORD2LE(0);
403 req.wLength = AROS_WORD2LE(0);
404
405 return HIDD_USBDevice_ControlMessage(o, NULL, &req, NULL, 0);
406 }
407
408 BOOL METHOD(USBHub, Hidd_USBHub, ClearPortFeature)
409 {
410 D(bug("[USBHub] USBHub::ClearPortFeature(%p, %d, %d)\n", o, msg->port, msg->feature));
411
412 USBDevice_Request req;
413
414 req.bmRequestType = UT_WRITE_CLASS_OTHER;
415 req.bRequest = UR_CLEAR_FEATURE;
416 req.wValue = AROS_WORD2LE(msg->feature);
417 req.wIndex = AROS_WORD2LE(msg->port);
418 req.wLength = AROS_WORD2LE(0);
419
420 return HIDD_USBDevice_ControlMessage(o, NULL, &req, NULL, 0);
421 }
422
423 BOOL METHOD(USBHub, Hidd_USBHub, SetPortFeature)
424 {
425 D(bug("[USBHub] USBHub::SetPortFeature(%p, %d, %d)\n", o, msg->port, msg->feature));
426
427 USBDevice_Request req;
428
429 req.bmRequestType = UT_WRITE_CLASS_OTHER;
430 req.bRequest = UR_SET_FEATURE;
431 req.wValue = AROS_WORD2LE(msg->feature);
432 req.wIndex = AROS_WORD2LE(msg->port);
433 req.wLength = AROS_WORD2LE(0);
434
435 return HIDD_USBDevice_ControlMessage(o, NULL, &req, NULL, 0);
436 }
437
438 BOOL METHOD(USBHub, Hidd_USBHub, GetHubDescriptor)
439 {
440 USBDevice_Request request = {
441 bmRequestType: UT_READ_CLASS_DEVICE,
442 bRequest: UR_GET_DESCRIPTOR,
443 wValue: AROS_WORD2LE(((uint8_t)UDESC_HUB) << 8),
444 wIndex: AROS_WORD2LE(0),
445 wLength: AROS_WORD2LE(USB_HUB_DESCRIPTOR_SIZE)
446 };
447
448 return HIDD_USBDevice_ControlMessage(o, NULL, &request, msg->descriptor, USB_HUB_DESCRIPTOR_SIZE);
449 }
450
451
452
453 static void hub_enable(OOP_Class *cl, OOP_Object *o)
454 {
455 HubData *hub = OOP_INST_DATA(cl, o);
456 int pwrdly, port;
457
458 if (!hub->got_descriptor)
459 hub->got_descriptor = HIDD_USBHub_GetHubDescriptor(o, &hub->descriptor);
460
461 pwrdly = hub->descriptor.bPwrOn2PwrGood * UHD_PWRON_FACTOR + USB_EXTRA_POWER_UP_TIME;
462
463 for (port = 1; port <= hub->descriptor.bNbrPorts; port++)
464 {
465 if (!HIDD_USBHub_SetPortFeature(o, port, UHF_PORT_POWER))
466 bug("[USBHub] PowerOn on port %d failed\n", port);
467
468 USBDelay(hub->tr, pwrdly);
469 }
470 }
471
472 static void hub_disable(OOP_Class *cl, OOP_Object *o)
473 {
474 HubData *hub = OOP_INST_DATA(cl, o);
475 int pwrdly, port;
476
477 if (!hub->got_descriptor)
478 hub->got_descriptor = HIDD_USBHub_GetHubDescriptor(o, &hub->descriptor);
479
480 pwrdly = hub->descriptor.bPwrOn2PwrGood * UHD_PWRON_FACTOR + USB_EXTRA_POWER_UP_TIME;
481
482 for (port = 1; port <= hub->descriptor.bNbrPorts; port++)
483 {
484 if (!HIDD_USBHub_ClearPortFeature(o, port, UHF_PORT_POWER))
485 bug("[USBHub] PowerOff on port %d failed\n", port);
486
487 USBDelay(hub->tr, pwrdly);
488 }
489 }
490
491 static BOOL hub_explore(OOP_Class *cl, OOP_Object *o)
492 {
493 HubData *hub = OOP_INST_DATA(cl, o);
494 BOOL more = FALSE;
495 int port;
496
497 D(bug("[USBHub Process] hub_explore()\n"));
498
499 if (!hub->got_descriptor)
500 hub->got_descriptor = HIDD_USBHub_GetHubDescriptor(o, &hub->descriptor);
501
502 for (port=1; port <= hub->descriptor.bNbrPorts; port++)
503 {
504 usb_port_status_t port_status;
505 uint16_t status, change;
506
507 if (!HIDD_USBHub_GetPortStatus(o, port, &port_status))
508 {
509 D(bug("[USBHub Process] HIDD_USBHub_GetPortStatus(%p, %d, %p) failed\n",
510 o, port, &status));
511 continue;
512 }
513
514 status = AROS_LE2WORD(port_status.wPortStatus);
515 change = AROS_LE2WORD(port_status.wPortChange);
516
517 D(bug("[USBHub Process] Port %d, status %04x, change %04x\n", port, status, change));
518
519 if (change & UPS_C_PORT_ENABLED)
520 {
521 D(bug("[USBHub Process] C_PORT_ENABLED\n"));
522 HIDD_USBHub_ClearPortFeature(o, port, UHF_C_PORT_ENABLE);
523 // TODO: Extend
524 }
525
526 if (change & UPS_C_CONNECT_STATUS)
527 {
528 D(bug("[USBHub Process] C_CONNECT_STATUS\n"));
529 HIDD_USBHub_ClearPortFeature(o, port, UHF_C_PORT_CONNECTION);
530 }
531
532 /*
533 * if connection status has not changed and device is still disconnected skip port.
534 * the original method did not analyse ports after reset.
535 */
536 if ((0 == (status & UPS_CURRENT_CONNECT_STATUS)) == (0 == hub->children[port-1]))
537 {
538 // D(bug("[USBHub Process] !C_CONNECT_STATUS\n"));
539 D(bug("[USBHub Process] UPS_CURRENT_CONNECT_STATUS reflects actual mapping\n"));
540 continue;
541 }
542
543 if (hub->children[port-1])
544 {
545 OOP_DisposeObject(hub->children[port-1]);
546 hub->children[port-1] = NULL;
547 }
548
549 if (!(status & UPS_CURRENT_CONNECT_STATUS))
550 {
551 D(bug("[USBHub Process] !CURRENT_CONNECT_STATUS\n"));
552 continue;
553 }
554
555 if (!(status & UPS_PORT_POWER))
556 D(bug("[USBHub Process] Port %d without power???\n", port));
557
558 /*
559 * i am not sure we want to keep restarting USB ports
560 * in case where we have no driver to utilize the device
561 * however i will leave it here for now
562 */
563 USBDelay(hub->tr, USB_PORT_POWERUP_DELAY);
564
565 D(bug("[USBHub Process]\tRestarting device in port %d\n", port));
566 if (!HIDD_USBHub_PortReset(o, port))
567 {
568 D(bug("[USBHub Process] Port %d reset failed\n", port));
569 continue;
570 }
571
572 if (!HIDD_USBHub_GetPortStatus(o, port, &port_status))
573 {
574 D(bug("[USBHub Process] HIDD_USBHub_GetPortStatus(%p, %d, %p) failed\n",
575 o, port, &status));
576 continue;
577 }
578 status = AROS_LE2WORD(port_status.wPortStatus);
579 change = AROS_LE2WORD(port_status.wPortChange);
580
581 D(bug("[USBHub Process] Port %d, status %04x, change %04x\n", port, status, change));
582
583 if (!(status & UPS_CURRENT_CONNECT_STATUS))
584 {
585 D(bug("[USBHub Process] Device on port %d disappeared after reset???\n", port));
586 continue;
587 }
588
589 hub->children[port-1] = HIDD_USB_NewDevice(SD(cl)->usb, o, !(status & UPS_LOW_SPEED));
590 if (NULL == hub->children[port-1])
591 {
592 D(bug("[USBHub Process]\tNo known handler for selected drive. Restoring connection flag.\n"));
593 more = TRUE;
594 //HIDD_USBHub_SetPortFeature(o, port, UHF_C_PORT_CONNECTION);
595 }
596 }
597
598 return more;
599 }
600
601 static void hub_process(HubData *hub, OOP_Object *o, struct Task *parent)
602 {
603 struct Task *hub_task = FindTask(NULL);
604 struct usb_staticdata *sd = hub->sd;
605 OOP_Object *drv = NULL;
606 OOP_Class *cl = sd->hubClass;
607 struct usbEvent *ev = NULL;
608 struct timerequest *rescan;
609 uint32_t sigset = 0;
610 uint32_t sigmask = 0;
611
612 hub->tr = USBCreateTimer();
613 hub->hub_port = CreateMsgPort();
614
615 rescan = USBCreateTimer();
616
617 OOP_GetAttr(o, aHidd_USBDevice_Bus, (IPTR *)&drv);
618 SetTaskPri(hub_task, 10);
619
620 D(bug("[USBHub Process] HUB process (%p)\n", FindTask(NULL)));
621
622 Signal(parent, SIGF_SINGLE);
623
624 for (;;)
625 {
626 D(bug("[USBHub Process] YAWN...\n"));
627
628 sigset = Wait( (1 << hub->hub_port->mp_SigBit) |
629 (sigmask) |
630 (1 << hub->sigInterrupt)
631 );
632 D(bug("[USBHub Process] signals rcvd: %p\n", sigset));
633
634 /* handle messages */
635 while ((ev = (struct usbEvent *)GetMsg(hub->hub_port)) != NULL)
636 {
637 BOOL reply = TRUE;
638
639 switch (ev->ev_Type)
640 {
641 case evt_Startup:
642 D(bug("[USBHub Process] Startup MSG\n"));
643 break;
644
645 case evt_Method:
646 D(bug("[USBHub Process] Sync method call\n"));
647 ev->ev_RetVal = OOP_DoMethod(ev->ev_Target, (OOP_Msg)&ev->ev_Event);
648 break;
649
650 case evt_AsyncMethod:
651 D(bug("[USBHub Process] Async method call\n"));
652 OOP_DoMethod(ev->ev_Target, (OOP_Msg)&ev->ev_Event);
653 FreeVecPooled(sd->MemPool, ev);
654 reply = FALSE;
655 break;
656
657 case evt_Cleanup:
658 D(bug("[USBHub Process] Cleanup MSG\n"));
659 USBDeleteTimer(hub->tr);
660 ReplyMsg(&ev->ev_Message);
661 return;
662
663 case evt_OnOff:
664 D(bug("[USBHub Process] Hub %s\n", hub->enabled ? "on" : "off"));
665 D(bug("----->MARKER 1<-----\n"));
666 if (hub->enabled)
667 hub_enable(cl, o);
668 else
669 hub_disable(cl, o);
670 D(bug("----->MARKER 2<-----\n"));
671 break;
672
673 default:
674 break;
675 }
676 D(bug("----->MARKER 3<-----\n"));
677 if (reply)
678 ReplyMsg(&ev->ev_Message);
679 }
680
681 D(bug("----->MARKER 4<-----\n"));
682
683 /* handle signals */
684 if ((sigset & (1 << hub->sigInterrupt)) ||
685 (sigset & sigmask))
686 {
687 struct usb_driver *d = NULL, *d2 = NULL;
688
689 if (sigset & sigmask)
690 USBTimerDone(rescan);
691
692 D(bug("[USBHub Process] Interrupt signalled\n"));
693
694 ObtainSemaphore(&sd->driverListLock);
695 ForeachNode(&sd->driverList, d)
696 {
697 if (d->d_Driver == drv)
698 {
699 d2 = d;
700 break;
701 }
702 }
703 ReleaseSemaphore(&sd->driverListLock);
704
705 if (d2)
706 {
707 ObtainSemaphore(&d2->d_Lock);
708
709 /*
710 * check if some devices failed to be created
711 * if so, attempt to re-detect in 10 seconds,
712 * maybe we will have adequate drivers available
713 */
714 if (hub_explore(cl, o))
715 {
716 /* wake up in 10 secs and check again */
717 sigmask = USBTimer(rescan, 10000);
718 }
719 ReleaseSemaphore(&d2->d_Lock);
720 }
721 }
722 else
723 {
724 sigset = 0;
725 }
726 }
727 }
Mirror of AROS' svn.