workbench/devs/USB/stack/usb_init.c

   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 #include <aros/symbolsets.h>
  22
  23 #include <exec/types.h>
  24 #include <oop/oop.h>
  25 #include <dos/dos.h>
  26 #include <dos/dosextens.h>
  27
  28 #include <hidd/hidd.h>
  29 #include <usb/usb.h>
  30
  31 #include <devices/timer.h>
  32
  33 #define DEBUG 1
  34
  35 #include <proto/exec.h>
  36 #include <proto/oop.h>
  37 #include <proto/dos.h>
  38 #include <aros/debug.h>
  39
  40 #include "usb.h"
  41 #include LC_LIBDEFS_FILE
  42
  43 OOP_AttrBase HiddUSBAttrBase;
  44 OOP_AttrBase HiddUSBDeviceAttrBase;
  45 OOP_AttrBase HiddUSBHubAttrBase;
  46 OOP_AttrBase HiddUSBDrvAttrBase;
  47 OOP_AttrBase HiddAttrBase;
  48
  49 void usb_process();
  50
  51 static void USB_ProcessStarter(struct usb_staticdata *sd, struct Task *parent)
  52 {
  53         struct Library *DOSBase;
  54         struct MsgPort *msgPort = CreateMsgPort();
  55         struct timerequest *tr = CreateIORequest(msgPort, sizeof(struct timerequest));
  56
  57         OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)tr, 0);
  58
  59         D(bug("[USB] Process starter\n"));
  60
  61         while(!(DOSBase = OpenLibrary("dos.library", 0)))
  62         {
  63                 tr->tr_time.tv_usec = 0;
  64                 tr->tr_time.tv_sec = 2;
  65                 tr->tr_node.io_Command = TR_ADDREQUEST;
  66
  67                 DoIO((struct IORequest *)tr);
  68         };
  69
  70         D(bug("[USB] Process starter: dos.library up and running\n"));
  71         D(bug("[USB] Process starter: Creating the main USB process\n"));
  72         struct usbEvent message;
  73
  74         struct TagItem tags[] = {
  75                         { NP_Entry,             (IPTR)usb_process },
  76                         { NP_UserData,  (IPTR)sd },
  77                         { NP_Priority,  5 },
  78                         { NP_Name,              (IPTR)"USB" },
  79                         { NP_WindowPtr, -1 },
  80                         { TAG_DONE,     0UL },
  81         };
  82
  83         message.ev_Message.mn_ReplyPort = CreateMsgPort();
  84         message.ev_Type = evt_Startup;
  85
  86         sd->usbProcess = CreateNewProc(tags);
  87         PutMsg(&sd->usbProcess->pr_MsgPort, (struct Message *)&message);
  88         WaitPort(message.ev_Message.mn_ReplyPort);
  89         DeleteMsgPort(message.ev_Message.mn_ReplyPort);
  90
  91         CloseLibrary(DOSBase);
  92         CloseDevice((struct IORequest *)tr);
  93         DeleteIORequest(tr);
  94         DeleteMsgPort(msgPort);
  95
  96         if (parent)
  97                 Signal(parent, SIGF_SINGLE);
  98 }
  99
 100 static int USB_Init(LIBBASETYPEPTR LIBBASE)
 101 {
 102     struct OOP_ABDescr attrbases[] = {
 103             { (STRPTR)IID_Hidd,             &HiddAttrBase },
 104             { (STRPTR)IID_Hidd_USB,         &HiddUSBAttrBase },
 105             { (STRPTR)IID_Hidd_USBDevice,   &HiddUSBDeviceAttrBase },
 106             { (STRPTR)IID_Hidd_USBHub,      &HiddUSBHubAttrBase },
 107             { (STRPTR)IID_Hidd_USBDrv,      &HiddUSBDrvAttrBase },
 108             { NULL, NULL }
 109     };
 110
 111     D(bug("[USB] USB Init\n"));
 112
 113     NEWLIST(&LIBBASE->sd.driverList);
 114     NEWLIST(&LIBBASE->sd.extClassList);
 115     InitSemaphore(&LIBBASE->sd.global_lock);
 116     InitSemaphore(&LIBBASE->sd.driverListLock);
 117
 118     if (OOP_ObtainAttrBases(attrbases))
 119     {
 120         LIBBASE->sd.usb = OOP_NewObject(NULL, CLID_Hidd_USB, NULL);
 121
 122         if ((LIBBASE->sd.MemPool = CreatePool(MEMF_PUBLIC|MEMF_CLEAR|MEMF_SEM_PROTECTED, 8192, 4096)) != NULL)
 123         {
 124                 struct Library *DOSBase = OpenLibrary("dos.library", 0);
 125
 126                 struct TagItem tags[] = {
 127                                 { TASKTAG_ARG1,   (IPTR)&LIBBASE->sd },
 128                                 { TASKTAG_ARG2,   0UL },
 129                                 { TAG_DONE,       0UL }};
 130
 131                 if (DOSBase)
 132                         tags[1].ti_Data = (IPTR)FindTask(NULL);
 133
 134                 struct Task *t = AllocMem(sizeof(struct Task), MEMF_PUBLIC|MEMF_CLEAR);
 135                 struct MemList *ml = AllocMem(sizeof(struct MemList) + sizeof(struct MemEntry), MEMF_PUBLIC|MEMF_CLEAR);
 136
 137                 if (t && ml)
 138                 {
 139                         uint8_t *sp = AllocMem(10240, MEMF_PUBLIC|MEMF_CLEAR);
 140                         uint8_t *name = "USB Process starter";
 141
 142                         t->tc_SPLower = sp;
 143                         t->tc_SPUpper = sp + 10240;
 144 #if AROS_STACK_GROWS_DOWNWARDS
 145                         t->tc_SPReg = (char *)t->tc_SPUpper - SP_OFFSET;
 146 #else
 147                         t->tc_SPReg = (char *)t->tc_SPLower + SP_OFFSET;
 148 #endif
 149
 150                         ml->ml_NumEntries = 2;
 151                         ml->ml_ME[0].me_Addr = t;
 152                         ml->ml_ME[0].me_Length = sizeof(struct Task);
 153                         ml->ml_ME[1].me_Addr = sp;
 154                         ml->ml_ME[1].me_Length = 10240;
 155
 156                         NEWLIST(&t->tc_MemEntry);
 157                         ADDHEAD(&t->tc_MemEntry, &ml->ml_Node);
 158
 159                         t->tc_Node.ln_Name = name;
 160                         t->tc_Node.ln_Type = NT_TASK;
 161                         t->tc_Node.ln_Pri = 1;     /* same priority as input.device */
 162
 163                         /* Add task. It will get back in touch soon */
 164                         NewAddTask(t, USB_ProcessStarter, NULL, &tags[0]);
 165
 166                         if (DOSBase)
 167                                 Wait(SIGF_SINGLE);
 168
 169                         return TRUE;
 170                 }
 171
 172                 if (DOSBase)
 173                         CloseLibrary(DOSBase);
 174         }
 175         OOP_ReleaseAttrBases(attrbases);
 176     }
 177
 178     return FALSE;
 179 }
 180
 181 static int USB_Expunge(LIBBASETYPEPTR LIBBASE)
 182 {
 183     struct OOP_ABDescr attrbases[] = {
 184             { (STRPTR)IID_Hidd,                 &HiddAttrBase },
 185             { (STRPTR)IID_Hidd_USB,             &HiddUSBAttrBase },
 186             { (STRPTR)IID_Hidd_USBDevice,       &HiddUSBDeviceAttrBase },
 187             { (STRPTR)IID_Hidd_USBHub,          &HiddUSBHubAttrBase },
 188             { (STRPTR)IID_Hidd_USBDrv,          &HiddUSBDrvAttrBase },
 189             { NULL, NULL }
 190     };
 191     struct usbEvent message;
 192
 193     D(bug("[USB] USB Expunge\n"));
 194
 195     message.ev_Message.mn_ReplyPort = CreateMsgPort();
 196     message.ev_Type = evt_Cleanup;
 197
 198     PutMsg(&LIBBASE->sd.usbProcess->pr_MsgPort, (struct Message *)&message);
 199     WaitPort(message.ev_Message.mn_ReplyPort);
 200     DeleteMsgPort(message.ev_Message.mn_ReplyPort);
 201
 202     OOP_ReleaseAttrBases(attrbases);
 203
 204     DeletePool(LIBBASE->sd.MemPool);
 205
 206     return TRUE;
 207 }
 208
 209 ADD2INITLIB(USB_Init, 0)
 210 ADD2EXPUNGELIB(USB_Expunge, 0)