rom/dos/inithidds.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Code that loads and initializes necessary HIDDs.
   6     Lang: english
   7 */
   8
   9 #include <exec/memory.h>
  10 #include <exec/resident.h>
  11 #include <exec/alerts.h>
  12 #include <exec/io.h>
  13 #include <dos/filesystem.h>
  14 #include <utility/tagitem.h>
  15 #include <utility/hooks.h>
  16 #include <hidd/hidd.h>
  17
  18 #include <proto/exec.h>
  19 #include <proto/oop.h>
  20 #include <proto/utility.h>
  21 #include <proto/dos.h>
  22 #include <proto/intuition.h>
  23 #include <oop/oop.h>
  24 #include <string.h>
  25
  26 #include "devs_private.h"
  27
  28 #ifdef __AROS__
  29 #include <aros/asmcall.h>
  30 #endif /* __AROS__ */
  31
  32 #define SDEBUG 0
  33 #define DEBUG 0
  34 #include <aros/debug.h>
  35
  36 #warning This is just a temporary and hackish way to get the HIDDs up and working
  37
  38 struct initbase
  39 {
  40     struct ExecBase     *sysbase;
  41     struct DosLibrary   *dosbase;
  42     struct Library      *oopbase;
  43 };
  44
  45 #define DOSBase (base->dosbase)
  46 #define OOPBase (base->oopbase)
  47
  48
  49 static BOOL init_gfx  ( STRPTR gfxclassname,   struct initbase *base);
  50 static BOOL init_device( STRPTR hiddclassname, STRPTR devicename,  struct initbase *base);
  51
  52 /************************************************************************/
  53
  54 #define BUFSIZE 100
  55
  56 #define HIDDPREFSFILE "SYS:S/hidd.prefs"
  57
  58 /* We don't link with c library so I must implement this separately */
  59 #define isblank(c) \
  60         (c == '\t' || c == ' ')
  61 #define isspace(c) \
  62         (c == '\t' || c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\v')
  63
  64
  65 #include <proto/graphics.h>
  66
  67 BOOL init_hidds(struct ExecBase *sysBase, struct DosLibrary *dosBase)
  68 {
  69 /* This is the initialisation code for InitHIDDs module */
  70
  71
  72     struct initbase stack_b, *base = &stack_b;
  73     BOOL success = TRUE;
  74     UBYTE buf[BUFSIZE];
  75     UBYTE gfxname[BUFSIZE], kbdname[BUFSIZE], mousename[BUFSIZE];
  76     BOOL got_gfx = FALSE, got_kbd = FALSE, got_mouse = FALSE, got_library = TRUE;
  77
  78
  79     base->sysbase = sysBase;
  80     base->dosbase = dosBase;
  81
  82     EnterFunc(bug("init_hidds\n"));
  83
  84     OOPBase = OpenLibrary(AROSOOP_NAME, 0);
  85     if (!OOPBase)
  86     {
  87         success = FALSE;
  88     }
  89     else
  90     {
  91         BPTR fh;
  92
  93         D(bug("OOP opened\n"));
  94
  95         /* Open the hidd prefsfile */
  96
  97         fh = Open(HIDDPREFSFILE, FMF_READ);
  98         if (!fh)
  99         {
 100             success = FALSE;
 101         }
 102         else
 103         {
 104             STRPTR libname = NULL;
 105
 106             D(bug("hiddprefs file opened\n"));
 107             while (FGets(fh, buf, BUFSIZE))
 108             {
 109                 STRPTR keyword = buf, arg, end;
 110                 STRPTR s;
 111
 112                 s = buf;
 113                 if (*s) {
 114                     for (; *s; s ++)
 115                         ;
 116                     if (s[-1] == 10) {
 117                         s[-1] = 0;
 118                     }
 119                 }
 120
 121
 122
 123                 D(bug("Got line\n"));
 124                 D(bug("Line: %s\n", buf));
 125
 126                   /* Get keyword */
 127                 while ((*keyword != 0) && isspace(*keyword))
 128                     keyword ++;
 129
 130                 if (*keyword == 0)
 131                     continue;
 132
 133                   /* terminate keyword */
 134                 arg = keyword;
 135                 while ((*arg != 0) && (!isblank(*arg)))
 136                 {
 137                     arg ++;
 138                 }
 139                 if (*arg == 0)
 140                     continue;
 141
 142                 *arg = 0;
 143
 144                 arg ++;
 145
 146                   /* Find start of argument */
 147                 D(bug("Find argument at %s\n", arg));
 148                 while ((*arg != 0) && isblank(*arg))
 149                     arg ++;
 150
 151                 if (*arg == 0)
 152                     continue;
 153
 154                 D(bug("Terminate argument at %s\n", arg));
 155                   /* terminate argument */
 156                 end = arg;
 157                 while ( (*end != 0) && (!isblank(*end)))
 158                     end ++;
 159                 if (*end != 0)
 160                     *end = 0;
 161
 162                 D(bug("Got keyword \"%s\"\n", keyword));
 163                 D(bug("Got arg \"%s\"\n", arg));
 164
 165                 if (0 == strcmp(keyword, "library"))
 166                 {
 167                     D(bug("Opening library\n"));
 168                       /* Open a specified library */
 169                     libname = arg;
 170                     if (NULL == OpenLibrary(libname, 0))
 171                     {
 172                         success = FALSE;
 173                         got_library = FALSE;
 174                         break;
 175                     }
 176                 }
 177                 else if (0 == strcmp(keyword, "gfx"))
 178                 {
 179                     strncpy(gfxname, arg, BUFSIZE - 1);
 180                     got_gfx = TRUE;
 181                 }
 182                 else if (0 == strcmp(keyword, "mouse"))
 183                 {
 184                     strncpy(mousename, arg, BUFSIZE - 1);
 185                     got_mouse = TRUE;
 186                 }
 187                 else if (0 == strcmp(keyword, "kbd"))
 188                 {
 189                     strncpy(kbdname, arg, BUFSIZE - 1);
 190                     got_kbd = TRUE;
 191                 }
 192             }
 193
 194             Close(fh);
 195
 196             if (!got_library)
 197             {
 198                 success = FALSE;
 199                 kprintf("Could not open library %s\n", libname);
 200                 goto end;
 201             }
 202
 203             if (!got_gfx)
 204             {
 205                 success = FALSE;
 206                 kprintf("No configuration for gfx hidd\n");
 207                 goto end;
 208             }
 209
 210             if (!got_mouse)
 211             {
 212                 success = FALSE;
 213                 kprintf("No configuration for mouse hidd\n");
 214                 goto end;
 215             }
 216
 217             if (!got_kbd)
 218             {
 219                 success = FALSE;
 220                 kprintf("No configuration for keyboard hidd\n");
 221                 goto end;
 222             }
 223
 224             if (!init_gfx(gfxname, base))
 225             {
 226                 kprintf("Could not init gfx hidd %s\n", gfxname);
 227                 success = FALSE;
 228                 goto end;
 229             }
 230
 231             if (!init_device(kbdname, "keyboard.device", base))
 232             {
 233                 kprintf("Could not init keyboard hidd %s\n", kbdname);
 234                 success = FALSE;
 235                 goto end;
 236             }
 237
 238             if (!init_device(mousename, "gameport.device", base))
 239             {
 240                 kprintf("Could not init mouse hidd %s\n", mousename);
 241                 success = FALSE;
 242                 goto end;
 243             }
 244         }
 245 end:
 246         CloseLibrary(OOPBase);
 247     }
 248
 249     ReturnBool("init_hidds", success);
 250 }
 251
 252 /*****************
 253 **  init_gfx()  **
 254 *****************/
 255
 256 static BOOL init_gfx(STRPTR gfxclassname, struct initbase *base)
 257 {
 258     struct GfxBase *GfxBase;
 259     BOOL success = FALSE;
 260
 261     EnterFunc(bug("init_gfx(hiddbase=%s)\n", gfxclassname));
 262
 263     GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 37);
 264     if (GfxBase)
 265     {
 266         D(bug("gfx.library opened\n"));
 267
 268         /*  Call private gfx.library call to init the HIDD.
 269             Gfx library is responsable for closing the HIDD
 270             library (although it will probably not be neccesary).
 271         */
 272
 273         D(bug("calling private gfx LateGfxInit()\n"));
 274         if (LateGfxInit(gfxclassname))
 275         {
 276             struct IntuitionBase *IntuitionBase;
 277             D(bug("success\n"));
 278
 279             /* Now that gfx. is guaranteed to be up & working, let intuition open WB screen */
 280             IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37);
 281             if (IntuitionBase)
 282             {
 283                 if (LateIntuiInit(NULL))
 284                 {
 285                     success = TRUE;
 286                 }
 287                 CloseLibrary((struct Library *)IntuitionBase);
 288             }
 289         }
 290         D(bug("Closing gfx\n"));
 291
 292         CloseLibrary((struct Library *)GfxBase);
 293     }
 294     ReturnBool ("init_gfxhidd", success);
 295 }
 296
 297
 298 static BOOL init_device( STRPTR hiddclassname, STRPTR devicename,  struct initbase *base)
 299 {
 300     BOOL success = FALSE;
 301     struct MsgPort *mp;
 302
 303
 304     EnterFunc(bug("init_device(classname=%s)\n", hiddclassname));
 305
 306     mp = CreateMsgPort();
 307     if (mp)
 308     {
 309         struct IORequest *io;
 310         io = CreateIORequest(mp, sizeof ( struct IOStdReq));
 311         {
 312             if (0 == OpenDevice(devicename, 0, io, 0))
 313             {
 314                 UBYTE *data;
 315
 316                 /* Allocate message data */
 317                 data = AllocMem(BUFSIZE, MEMF_PUBLIC);
 318                 if (data)
 319                 {
 320                     #define ioStd(x) ((struct IOStdReq *)x)
 321                     strcpy(data, hiddclassname);
 322                     ioStd(io)->io_Command = CMD_HIDDINIT;
 323                     ioStd(io)->io_Data = data;
 324                     ioStd(io)->io_Length = strlen(data);
 325
 326                     /* Let the device init the HIDD */
 327                     DoIO(io);
 328                     if (0 == io->io_Error)
 329                     {
 330                         success = TRUE;
 331                     }
 332
 333                     FreeMem(data, BUFSIZE);
 334                 }
 335                 CloseDevice(io);
 336
 337             }
 338             DeleteIORequest(io);
 339
 340         }
 341
 342         DeleteMsgPort(mp);
 343
 344     }
 345
 346     ReturnBool("init_device", success);
 347 }
 348