arch/i386-pc/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 <exec/lists.h>
  14 #include <dos/filesystem.h>
  15 #include <utility/tagitem.h>
  16 #include <utility/hooks.h>
  17 #include <hidd/hidd.h>
  18 #include <aros/bootloader.h>
  19
  20 #include <proto/exec.h>
  21 #include <proto/oop.h>
  22 #include <proto/utility.h>
  23 #include <proto/dos.h>
  24 #include <proto/bootloader.h>
  25 #include <proto/intuition.h>
  26 #include <oop/oop.h>
  27 #include <string.h>
  28
  29 #warning Fix this in a better way. It will break if things move around.
  30 #include "../../rom/devs/devs_private.h"
  31
  32 #include <aros/asmcall.h>
  33
  34 #define DEBUG 1
  35 #include <aros/debug.h>
  36
  37 #warning This is just a temporary and hackish way to get the HIDDs up and working
  38
  39 struct initbase
  40 {
  41     struct ExecBase     *sysbase;
  42     struct DosLibrary   *dosbase;
  43     struct Library      *oopbase;
  44 };
  45
  46 #define SysBase (base->sysbase)
  47 #define DOSBase (base->dosbase)
  48 #define OOPBase (base->oopbase)
  49
  50
  51 static BOOL init_gfx  ( STRPTR gfxclassname,   struct initbase *base);
  52 static BOOL init_device( STRPTR hiddclassname, STRPTR devicename,  struct initbase *base);
  53
  54 /************************************************************************/
  55
  56 #define BUFSIZE 100
  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, vga = FALSE;
  74     STRPTR defvhidd = "hidd.gfx.vga";
  75     STRPTR defvlib = "vgah.hidd";
  76     UBYTE gfxname[BUFSIZE];
  77     struct BootLoaderBase *BootLoaderBase;
  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         /* Initialize these HIDDs by default */
  92         if (!(OpenLibrary("mouse.hidd",0L)))
  93         {
  94             success = FALSE;
  95             bug("[DOS] InitHidds: Failed to open mouse.hidd\n");
  96         }
  97
  98         if (!(OpenLibrary("kbd.hidd",0L)))
  99         {
 100             success = FALSE;
 101             bug("[DOS] InitHidds: Failed to open kbd.hidd\n");
 102         }
 103         if (!(OpenLibrary("graphics.hidd",0L)))
 104         {
 105             success = FALSE;
 106             bug("[DOS] InitHidds: Failed to open graphics.hidd\n");
 107         }
 108
 109         /* Prepare the VGA hidd as a fallback */
 110         strncpy(gfxname,defvhidd,BUFSIZE-1);
 111         if ((BootLoaderBase = OpenResource("bootloader.resource")))
 112         {
 113             struct List *list;
 114             struct Node *node;
 115             struct VesaInfo *vi;
 116
 117             /* See if VESA mode specified. If so, we will use vesagfx.hidd instead
 118              * of vgah.hid by default */
 119             if ((vi = GetBootInfo(BL_Video)))
 120             {
 121                 if (vi->ModeNumber != 3)
 122                 {
 123                     /* Bootloader set vesa mode */
 124                     defvhidd = "hidd.gfx.vesa";
 125                     defvlib = "vesagfx.hidd";
 126                     strcpy(gfxname,defvhidd);
 127                     bug("[DOS] InitHidds: VESA graphics requested\n");
 128                 }
 129             }
 130             list = (struct List *)GetBootInfo(BL_Args);
 131             if (list)
 132             {
 133                 ForeachNode(list,node)
 134                 {
 135                     if (0 == strncmp(node->ln_Name,"gfx=",4))
 136                     {
 137                         bug("[DOS] InitHidds: Using %s as graphics driver\n",&node->ln_Name[4]);
 138                         strncpy(gfxname,&(node->ln_Name[4]),BUFSIZE-1);
 139                     }
 140                     if (0 == strncmp(node->ln_Name,"lib=",4))
 141                     {
 142                         bug("[DOS] InitHidds: Opening library %s\n",&node->ln_Name[4]);
 143                         if (!(OpenLibrary(&node->ln_Name[4],0L)))
 144                             bug("[DOS] InitHidds: Failed to open %s\n",&node->ln_Name[4]);
 145                         if (0 == strcmp(&node->ln_Name[4],defvlib))
 146                             vga = TRUE;
 147                     }
 148                 }
 149             }
 150         }
 151
 152         /* If we got no gfx hidd on the commandline, and did not load default hidd,
 153          * we will do that now. */
 154         if (0 == strcmp(gfxname,defvhidd) && vga == FALSE)
 155         {
 156             OpenLibrary(defvlib,0L);
 157         }
 158
 159         /* Set up the graphics HIDD system */
 160         if (!init_gfx(gfxname, base))
 161         {
 162             bug("[DOS] InitHidds: Could not init gfx hidd %s\n", gfxname);
 163             success = FALSE;
 164         }
 165
 166         /* And finally keyboard and mouse */
 167         if (!init_device("hidd.kbd.hw", "keyboard.device", base))
 168         {
 169             bug("[DOS] InitHidds: Could not init keyboard hidd\n");
 170             success = FALSE;
 171         }
 172
 173         if (!init_device("hidd.bus.mouse", "gameport.device", base))
 174         {
 175             bug("[DOS] InitHidds: Could not init mouse hidd\n");
 176             success = FALSE;
 177         }
 178         CloseLibrary(OOPBase);
 179     }
 180
 181     ReturnBool("init_hidds", success);
 182 }
 183
 184 /*****************
 185 **  init_gfx()  **
 186 *****************/
 187
 188 static BOOL init_gfx(STRPTR gfxclassname, struct initbase *base)
 189 {
 190     struct GfxBase *GfxBase;
 191     BOOL success = FALSE;
 192
 193     EnterFunc(bug("init_gfx(hiddbase=%s)\n", gfxclassname));
 194
 195     GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 37);
 196     if (GfxBase)
 197     {
 198         D(bug("gfx.library opened\n"));
 199
 200         /*  Call private gfx.library call to init the HIDD.
 201             Gfx library is responsable for closing the HIDD
 202             library (although it will probably not be neccesary).
 203         */
 204
 205         D(bug("calling private gfx LateGfxInit()\n"));
 206         if (LateGfxInit(gfxclassname))
 207         {
 208             struct IntuitionBase *IntuitionBase;
 209             D(bug("success\n"));
 210
 211             /* Now that gfx. is guaranteed to be up & working, let intuition open WB screen */
 212             IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 37);
 213             if (IntuitionBase)
 214             {
 215                 if (LateIntuiInit(NULL))
 216                 {
 217                     success = TRUE;
 218                 }
 219                 CloseLibrary((struct Library *)IntuitionBase);
 220             }
 221         }
 222         D(bug("Closing gfx\n"));
 223
 224         CloseLibrary((struct Library *)GfxBase);
 225     }
 226     ReturnBool ("init_gfxhidd", success);
 227 }
 228
 229
 230 static BOOL init_device( STRPTR hiddclassname, STRPTR devicename,  struct initbase *base)
 231 {
 232     BOOL success = FALSE;
 233     struct MsgPort *mp;
 234
 235
 236     EnterFunc(bug("init_device(classname=%s)\n", hiddclassname));
 237
 238     mp = CreateMsgPort();
 239     if (mp)
 240     {
 241         struct IORequest *io;
 242         io = CreateIORequest(mp, sizeof ( struct IOStdReq));
 243         {
 244             if (0 == OpenDevice(devicename, 0, io, 0))
 245             {
 246                 UBYTE *data;
 247
 248                 /* Allocate message data */
 249                 data = AllocMem(BUFSIZE, MEMF_PUBLIC);
 250                 if (data)
 251                 {
 252                     #define ioStd(x) ((struct IOStdReq *)x)
 253                     strcpy(data, hiddclassname);
 254                     ioStd(io)->io_Command = CMD_HIDDINIT;
 255                     ioStd(io)->io_Data = data;
 256                     ioStd(io)->io_Length = strlen(data);
 257
 258                     /* Let the device init the HIDD */
 259                     DoIO(io);
 260                     if (0 == io->io_Error)
 261                     {
 262                         success = TRUE;
 263                     }
 264
 265                     FreeMem(data, BUFSIZE);
 266                 }
 267                 CloseDevice(io);
 268
 269             }
 270             DeleteIORequest(io);
 271
 272         }
 273
 274         DeleteMsgPort(mp);
 275
 276     }
 277
 278     ReturnBool("init_device", success);
 279 }
 280