rom/dosboot/menu.c

   1 /*
   2    Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3    $Id$
   4
   5    Desc: Main bootmenu code
   6    Lang: english
   7 */
   8
   9 #include <aros/config.h>
  10 #include <aros/debug.h>
  11
  12 #include <proto/bootloader.h>
  13 #include <proto/exec.h>
  14 #include <proto/graphics.h>
  15 #include <proto/intuition.h>
  16 #include <proto/expansion.h>
  17 #include <proto/oop.h>
  18 #include <devices/keyboard.h>
  19 #include <devices/rawkeycodes.h>
  20 #include <devices/timer.h>
  21 #include <exec/memory.h>
  22 #include <graphics/driver.h>
  23 #include <libraries/expansionbase.h>
  24 #include <libraries/configvars.h>
  25 #include <dos/filehandler.h>
  26 #include <devices/trackdisk.h>
  27 #include <exec/rawfmt.h>
  28 #include <aros/bootloader.h>
  29 #include <aros/symbolsets.h>
  30
  31 #include LC_LIBDEFS_FILE
  32
  33 #include "dosboot_intern.h"
  34 #include "menu.h"
  35
  36 #define PAGE_MAIN 1
  37 #define PAGE_BOOT 2
  38 #define PAGE_DISPLAY 3
  39 #define PAGE_EXPANSION 4
  40 #define EXIT_BOOT 5
  41 #define EXIT_BOOT_WNSS 6
  42
  43 #if (AROS_FLAVOUR & AROS_FLAVOUR_STANDALONE)
  44 #ifdef __ppc__
  45 #define INITHIDDS_KLUDGE
  46 #endif
  47 #endif
  48
  49 #ifdef INITHIDDS_KLUDGE
  50
  51 /*
  52  * This is an extremely obsolete kludge.
  53  * It's still needed for ATI driver on PowerPC native.
  54  */
  55
  56 static BOOL init_gfx(STRPTR gfxclassname, BOOL bootmode, LIBBASETYPEPTR DOSBootBase)
  57 {
  58     OOP_Class *gfxclass;
  59     BOOL success = FALSE;
  60
  61     D(bug("[BootMenu] init_gfx('%s')\n", gfxclassname));
  62
  63     GfxBase = (void *)OpenLibrary("graphics.library", 41);
  64     if (!GfxBase)
  65         return FALSE;
  66
  67     gfxclass = OOP_FindClass(gfxclassname);
  68     if (gfxclass)
  69     {
  70         if (!AddDisplayDriver(gfxclass, NULL, DDRV_BootMode, bootmode, TAG_DONE))
  71             success = TRUE;
  72     }
  73
  74     CloseLibrary(&GfxBase->LibNode);
  75
  76     ReturnBool ("init_gfxhidd", success);
  77 }
  78
  79 static BOOL initHidds(LIBBASETYPEPTR DOSBootBase)
  80 {
  81     struct BootConfig *bootcfg = &DOSBootBase->bm_BootConfig;
  82
  83     D(bug("[BootMenu] initHidds()\n"));
  84
  85     if (bootcfg->gfxhidd) {
  86         if (!OpenLibrary(bootcfg->gfxlib, 0))
  87             return FALSE;
  88
  89         if (!init_gfx(bootcfg->gfxhidd, bootcfg->bootmode, DOSBootBase))
  90             return FALSE;
  91     }
  92
  93     D(bug("[BootMenu] initHidds: Hidds initialised\n"));
  94     return TRUE;
  95 }
  96
  97 #endif
  98
  99 static struct Gadget *createGadgetsBoot(LIBBASETYPEPTR DOSBootBase)
 100 {
 101     /* Create Option Gadgets */
 102     DOSBootBase->bm_MainGadgets.bootopt = createButton(
 103                                                         180, 63, 280, 14,
 104                                                         NULL, "Boot Options...",
 105                                                         BUTTON_BOOT_OPTIONS, (struct DOSBootBase *)DOSBootBase);
 106     DOSBootBase->bm_MainGadgets.displayopt = createButton(
 107                                                         180, 84, 280, 14,
 108                                                         DOSBootBase->bm_MainGadgets.bootopt->gadget, "Display Options...",
 109                                                         BUTTON_DISPLAY_OPTIONS, (struct DOSBootBase *)DOSBootBase);
 110     DOSBootBase->bm_MainGadgets.expboarddiag = createButton(
 111                                                         180, 105, 280, 14,
 112                                                         DOSBootBase->bm_MainGadgets.displayopt->gadget, "Expansion Board Diagnostic...",
 113                                                         BUTTON_EXPBOARDDIAG, (struct DOSBootBase *)DOSBootBase);
 114     /* Create BOOT Gadgets */
 115     DOSBootBase->bm_MainGadgets.boot = createButton(
 116                                                     16, DOSBootBase->bottomY, 280, 14,
 117                                                     DOSBootBase->bm_MainGadgets.expboarddiag->gadget, "Boot",
 118                                                     BUTTON_BOOT, (struct DOSBootBase *)DOSBootBase);
 119     DOSBootBase->bm_MainGadgets.bootnss = createButton(
 120                                                     344, DOSBootBase->bottomY, 280, 14,
 121                                                     DOSBootBase->bm_MainGadgets.boot->gadget, "Boot With No Startup-Sequence",
 122                                                     BUTTON_BOOT_WNSS, (struct DOSBootBase *)DOSBootBase);
 123     if (!DOSBootBase->bm_MainGadgets.bootopt ||
 124         !DOSBootBase->bm_MainGadgets.displayopt ||
 125         !DOSBootBase->bm_MainGadgets.expboarddiag ||
 126         !DOSBootBase->bm_MainGadgets.boot ||
 127         !DOSBootBase->bm_MainGadgets.bootnss)
 128         return NULL;
 129     return DOSBootBase->bm_MainGadgets.bootopt->gadget;
 130 }
 131
 132 static struct Gadget *createGadgetsUseCancel(LIBBASETYPEPTR DOSBootBase)
 133 {
 134     DOSBootBase->bm_MainGadgets.use = createButton(
 135                                                 16, DOSBootBase->bottomY, 280, 14,
 136                                                 NULL, "Use",
 137                                                 BUTTON_USE, (struct DOSBootBase *)DOSBootBase);
 138     DOSBootBase->bm_MainGadgets.cancel = createButton(
 139                                                 344, DOSBootBase->bottomY, 280, 14,
 140                                                 DOSBootBase->bm_MainGadgets.use->gadget, "Cancel",
 141                                                 BUTTON_CANCEL, (struct DOSBootBase *)DOSBootBase);
 142     if (!DOSBootBase->bm_MainGadgets.use ||
 143         !DOSBootBase->bm_MainGadgets.cancel)
 144         return NULL;
 145     return DOSBootBase->bm_MainGadgets.use->gadget;
 146 }
 147
 148
 149 static void freeGadgetsBoot(LIBBASETYPEPTR DOSBootBase)
 150 {
 151     freeButtonGadget(DOSBootBase->bm_MainGadgets.boot, (struct DOSBootBase *)DOSBootBase);
 152     freeButtonGadget(DOSBootBase->bm_MainGadgets.bootnss, (struct DOSBootBase *)DOSBootBase);
 153     freeButtonGadget(DOSBootBase->bm_MainGadgets.bootopt, (struct DOSBootBase *)DOSBootBase);
 154     freeButtonGadget(DOSBootBase->bm_MainGadgets.displayopt, (struct DOSBootBase *)DOSBootBase);
 155     freeButtonGadget(DOSBootBase->bm_MainGadgets.expboarddiag, (struct DOSBootBase *)DOSBootBase);
 156 }
 157
 158 static void freeGadgetsUseCancel(LIBBASETYPEPTR DOSBootBase)
 159 {
 160     freeButtonGadget(DOSBootBase->bm_MainGadgets.use, (struct DOSBootBase *)DOSBootBase);
 161     freeButtonGadget(DOSBootBase->bm_MainGadgets.cancel, (struct DOSBootBase *)DOSBootBase);
 162 }
 163
 164 static struct Gadget *createGadgets(LIBBASETYPEPTR DOSBootBase, WORD page)
 165 {
 166     if (page == PAGE_MAIN)
 167         return createGadgetsBoot(DOSBootBase);
 168     else
 169         return createGadgetsUseCancel(DOSBootBase);
 170 }
 171 static void freeGadgets(LIBBASETYPEPTR DOSBootBase, WORD page)
 172 {
 173     if (page == PAGE_MAIN)
 174         freeGadgetsBoot(DOSBootBase);
 175     else
 176         freeGadgetsUseCancel(DOSBootBase);
 177 }
 178
 179 static void toggleMode(LIBBASETYPEPTR DOSBootBase)
 180 {
 181 #ifdef mc68000
 182     /*
 183      * On m68k we may have ciaa.resource (if running on classic Amiga HW)
 184      */
 185     if (OpenResource("ciaa.resource")) {
 186         volatile UWORD *beamcon0 = (UWORD*)0xdff1dc;
 187         GfxBase->DisplayFlags ^= PAL | NTSC;
 188         *beamcon0 = (GfxBase->DisplayFlags & PAL) ? 0x0020 : 0x0000;
 189     }
 190 #endif
 191 }
 192
 193 static UWORD msgLoop(LIBBASETYPEPTR DOSBootBase, struct Window *win)
 194 {
 195     WORD exit = -1;
 196     struct IntuiMessage *msg;
 197     struct Gadget *g;
 198
 199     D(bug("[BootMenu] msgLoop(DOSBootBase @ %p, Window @ %p)\n", DOSBootBase, win));
 200
 201     do
 202     {
 203         if (win->UserPort)
 204         {
 205             WaitPort(win->UserPort);
 206             while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
 207             {
 208                 if (msg->Class == IDCMP_VANILLAKEY) {
 209                     if (msg->Code == 27)
 210                             exit = PAGE_MAIN;
 211                     else if (msg->Code >= '1' && msg->Code <= '3')
 212                             exit = PAGE_MAIN + msg->Code - '0';
 213                     else if (msg->Code >= 'a' && msg->Code <='j') {
 214                         BYTE pos = msg->Code - 'a', i = 0;
 215                         struct BootNode *bn;
 216                         DOSBootBase->db_BootNode = NULL;
 217
 218                         Forbid(); /* .. access to ExpansionBase->MountList */
 219                         ForeachNode(&DOSBootBase->bm_ExpansionBase->MountList, bn)
 220                         {
 221                             if (i++ == pos)
 222                             {
 223                                 DOSBootBase->db_BootNode = bn;
 224                                 break;
 225                             }
 226                         }
 227                         Permit();
 228
 229                         if (DOSBootBase->db_BootNode != NULL)
 230                         {
 231                             /* Refresh itself */
 232                             exit = PAGE_BOOT;
 233                             break;
 234                         }
 235                     }
 236                     else
 237                         toggleMode(DOSBootBase);
 238                 } else if (msg->Class == IDCMP_GADGETUP)
 239                 {
 240                     g = msg->IAddress;
 241                     switch (g->GadgetID)
 242                     {
 243                     case BUTTON_BOOT:
 244                         DOSBootBase->db_BootFlags &= ~BF_NO_STARTUP_SEQUENCE;
 245                         exit = EXIT_BOOT;
 246                         break;
 247                     case BUTTON_BOOT_WNSS:
 248                         DOSBootBase->db_BootFlags |= BF_NO_STARTUP_SEQUENCE;
 249                         exit = EXIT_BOOT_WNSS;
 250                         break;
 251                     case BUTTON_CANCEL:
 252                         DOSBootBase->db_BootNode = NULL;
 253                         /* Fallthrough */
 254                     case BUTTON_USE:
 255                     case BUTTON_CONTINUE:
 256                         exit = PAGE_MAIN;
 257                         break;
 258                     case BUTTON_BOOT_OPTIONS:
 259                                                 exit = PAGE_BOOT;
 260                                                 break;
 261                     case BUTTON_EXPBOARDDIAG:
 262                                                 exit = PAGE_EXPANSION;
 263                                                 break;
 264                     case BUTTON_DISPLAY_OPTIONS:
 265                                                 exit = PAGE_DISPLAY;
 266                                                 break;
 267                     }
 268                 }
 269                 ReplyMsg((struct Message *)msg);
 270             }
 271         }
 272         else
 273         {
 274             bug("[BootMenu] msgLoop: Window lacks a userport!\n");
 275             Wait(0);
 276         }
 277     } while (exit < 0);
 278
 279     while ((msg=(struct IntuiMessage *)GetMsg(win->UserPort)))
 280         ReplyMsg(&msg->ExecMessage);
 281
 282     return exit;
 283 }
 284
 285 static void initPageExpansion(LIBBASETYPEPTR DOSBootBase)
 286 {
 287     struct Window *win = DOSBootBase->bm_Window;
 288     struct ExpansionBase *ExpansionBase = DOSBootBase->bm_ExpansionBase;
 289     struct ConfigDev *cd;
 290     WORD y = 50, cnt;
 291     char text[100];
 292
 293     SetAPen(win->RPort, 1);
 294     cd = NULL;
 295     cnt = 0;
 296     while ((cd = FindConfigDev(cd, -1, -1))) {
 297         NewRawDoFmt("%2d: %08lx - %08lx (%08lx) %5d %3d %08lx", RAWFMTFUNC_STRING, text,
 298                 ++cnt,
 299                 cd->cd_BoardAddr, cd->cd_BoardAddr + cd->cd_BoardSize - 1, cd->cd_BoardSize,
 300                 cd->cd_Rom.er_Manufacturer, cd->cd_Rom.er_Product, cd->cd_Rom.er_SerialNumber);
 301         if ((cd->cd_Rom.er_Type & ERT_TYPEMASK) == ERT_ZORROIII)
 302             strcat(text, " Z3");
 303         else if ((cd->cd_Rom.er_Type & ERT_TYPEMASK) == ERT_ZORROII)
 304             strcat(text, " Z2");
 305         else
 306             strcat(text, "   ");
 307         if (cd->cd_Rom.er_Type & ERTF_DIAGVALID)
 308             strcat(text, " ROM");
 309         if (cd->cd_Rom.er_Type & ERTF_MEMLIST)
 310             strcat(text, " RAM");
 311          Move(win->RPort, 20, y);
 312         Text(win->RPort, text, strlen(text));
 313         y += 16;
 314    }
 315 }
 316
 317 static void initPageBoot(LIBBASETYPEPTR DOSBootBase)
 318 {
 319     struct Window *win = DOSBootBase->bm_Window;
 320     struct BootNode *bn;
 321     WORD y = 70;
 322     char text[100], *textp;
 323
 324     SetAPen(win->RPort, 1);
 325
 326     ForeachNode(&DOSBootBase->bm_ExpansionBase->MountList, bn)
 327     {
 328         struct DeviceNode *dn = bn->bn_DeviceNode;
 329         struct FileSysStartupMsg *fssm = BADDR(dn->dn_Startup);
 330         struct DosEnvec *de = NULL;
 331         struct IOStdReq *io;
 332         struct MsgPort *port;
 333         char dostype[5];
 334         UBYTE i;
 335         ULONG size;
 336         BOOL devopen, ismedia;
 337
 338         if (y >= DOSBootBase->bottomY - 20)
 339             break;
 340         if (!fssm || !fssm->fssm_Device)
 341             continue;
 342         if (fssm->fssm_Environ > (BPTR)0x64) {
 343             de = BADDR(fssm->fssm_Environ);
 344             if (de->de_TableSize < 15)
 345                 de = NULL;
 346         }
 347
 348         NewRawDoFmt("%c%10s: %4d %s-%ld", RAWFMTFUNC_STRING, text,
 349             (DOSBootBase->db_BootNode == bn) ? '*' : IsBootableNode(bn) ? '+' : ' ',
 350             AROS_BSTR_ADDR(dn->dn_Name),
 351             bn->bn_Node.ln_Pri,
 352             AROS_BSTR_ADDR(fssm->fssm_Device),
 353             fssm->fssm_Unit);
 354         Move(win->RPort, 20, y);
 355         Text(win->RPort, text, strlen(text));
 356
 357         textp = NULL;
 358         devopen = ismedia = FALSE;
 359         if ((port = (struct MsgPort*)CreateMsgPort())) {
 360             if ((io = (struct IOStdReq*)CreateIORequest(port, sizeof(struct IOStdReq)))) {
 361                 if (!OpenDevice(AROS_BSTR_ADDR(fssm->fssm_Device), fssm->fssm_Unit, (struct IORequest*)io, fssm->fssm_Flags)) {
 362                     devopen = TRUE;
 363                     io->io_Command = TD_CHANGESTATE;
 364                     io->io_Actual = 1;
 365                     DoIO((struct IORequest*)io);
 366                     if (!io->io_Error && io->io_Actual == 0)
 367                         ismedia = TRUE;
 368                     CloseDevice((struct IORequest*)io);
 369                 }
 370                 DeleteIORequest((struct IORequest*)io);
 371             }
 372             DeleteMsgPort(port);
 373         }
 374
 375         if (de && ismedia) {
 376             for (i = 0; i < 4; i++) {
 377                 dostype[i] = (de->de_DosType >> ((3 - i) * 8)) & 0xff;
 378                 if (dostype[i] < 9)
 379                     dostype[i] += '0';
 380                 else if (dostype[i] < 32)
 381                     dostype[i] = '.';
 382             }
 383             dostype[4] = 0;
 384
 385            size = (de->de_HighCyl - de->de_LowCyl + 1) * de->de_Surfaces * de->de_BlocksPerTrack;
 386            /* try to prevent ULONG overflow */
 387            if (de->de_SizeBlock <= 128)
 388                    size /= 2;
 389             else
 390                     size *= de->de_SizeBlock / 256;
 391
 392             NewRawDoFmt("%s [%08lx] %ldk", RAWFMTFUNC_STRING, text,
 393                 dostype, de->de_DosType,
 394                 size);
 395             textp = text;
 396         } else if (!devopen) {
 397             textp = "[device open error]";
 398         } else if (!ismedia) {
 399             textp = "[no media]";
 400         }
 401         if (textp) {
 402             Move(win->RPort, 400, y);
 403             Text(win->RPort, textp, strlen(textp));
 404         }
 405
 406         y += 16;
 407
 408
 409     }
 410 }
 411
 412 static void centertext(LIBBASETYPEPTR DOSBootBase, BYTE pen, WORD y, const char *text)
 413 {
 414     struct Window *win = DOSBootBase->bm_Window;
 415     SetAPen(win->RPort, pen);
 416     Move(win->RPort, win->Width / 2 - TextLength(win->RPort, text, strlen(text)) / 2, y);
 417     Text(win->RPort, text, strlen(text));
 418 }
 419
 420 static void initPage(LIBBASETYPEPTR DOSBootBase, WORD page)
 421 {
 422     UBYTE *text;
 423
 424     if (page == PAGE_DISPLAY)
 425             text = "Display Options";
 426     else if (page == PAGE_EXPANSION)
 427             text = "Expansion Board Diagnostic";
 428     else if (page == PAGE_BOOT)
 429         text = "Boot Options";
 430     else
 431         text = "AROS Early Startup Control";
 432     centertext(DOSBootBase, 2, 10, text);
 433
 434     if (page == PAGE_BOOT)
 435         initPageBoot(DOSBootBase);
 436     else if (page == PAGE_EXPANSION)
 437         initPageExpansion(DOSBootBase);
 438
 439     if (page == PAGE_MAIN && (GfxBase->DisplayFlags & (NTSC | PAL))) {
 440             ULONG modeid = GetVPModeID(&DOSBootBase->bm_Screen->ViewPort);
 441             if (modeid != INVALID_ID && (((modeid & MONITOR_ID_MASK) == NTSC_MONITOR_ID) || ((modeid & MONITOR_ID_MASK) == PAL_MONITOR_ID))) {
 442             centertext(DOSBootBase, 1, 30, "(press a key to toggle the display between PAL and NTSC)");
 443         }
 444     }
 445
 446     if (page == PAGE_BOOT)
 447     {
 448         centertext(DOSBootBase, 1, 30, "Press A-J to select boot device");
 449         centertext(DOSBootBase, 1, 45, "\"+\" => bootable, \"*\" => selected for boot");
 450     }
 451 }
 452
 453 static WORD initWindow(LIBBASETYPEPTR DOSBootBase, struct BootConfig *bcfg, WORD page)
 454 {
 455     struct Gadget *first = NULL;
 456     WORD newpage = -1;
 457
 458     if ((first = createGadgets(DOSBootBase, page)) != NULL)
 459     {
 460         struct NewWindow nw =
 461         {
 462             0, 0,                            /* Left, Top */
 463             DOSBootBase->bm_Screen->Width,   /* Width, Height */
 464             DOSBootBase->bm_Screen->Height,
 465             0, 1,                            /* DetailPen, BlockPen */
 466             IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_VANILLAKEY | IDCMP_GADGETUP | IDCMP_GADGETDOWN, /* IDCMPFlags */
 467             WFLG_SMART_REFRESH | WFLG_BORDERLESS | WFLG_ACTIVATE, /* Flags */
 468             first,                            /* FirstGadget */
 469             NULL,                            /* CheckMark */
 470             NULL,                            /* Title */
 471             DOSBootBase->bm_Screen,             /* Screen */
 472             NULL,                            /* BitMap */
 473             0, 0,                                /* MinWidth, MinHeight */
 474             0, 0,                            /* MaxWidth, MaxHeight */
 475             CUSTOMSCREEN,                    /* Type */
 476         };
 477
 478         D(bug("[BootMenu] initPage: Gadgets created @ %p\n", first));
 479
 480         if ((DOSBootBase->bm_Window = OpenWindow(&nw)) != NULL)
 481         {
 482             D(bug("[BootMenu] initScreen: Window opened @ %p\n", DOSBootBase->bm_Window));
 483             D(bug("[BootMenu] initScreen: Window RastPort @ %p\n", DOSBootBase->bm_Window->RPort));
 484             D(bug("[BootMenu] initScreen: Window UserPort @ %p\n", DOSBootBase->bm_Window->UserPort));
 485             initPage(DOSBootBase, page);
 486             newpage = msgLoop(DOSBootBase, DOSBootBase->bm_Window);
 487         }
 488         CloseWindow(DOSBootBase->bm_Window);
 489     }
 490     freeGadgets(DOSBootBase, page);
 491
 492     return newpage;
 493 }
 494
 495 static BOOL initScreen(LIBBASETYPEPTR DOSBootBase, struct BootConfig *bcfg)
 496 {
 497     WORD page;
 498
 499     D(bug("[BootMenu] initScreen()\n"));
 500
 501     page = -1;
 502     DOSBootBase->bm_Screen = OpenBootScreen(DOSBootBase);
 503     if (DOSBootBase->bm_Screen)
 504     {
 505         DOSBootBase->bottomY = DOSBootBase->bm_Screen->Height - (DOSBootBase->bm_Screen->Height > 256 ? 32 : 16);
 506         D(bug("[BootMenu] initScreen: Screen opened @ %p\n",  DOSBootBase->bm_Screen));
 507
 508         page = PAGE_MAIN;
 509         do {
 510             page = initWindow(DOSBootBase, bcfg, page);
 511         } while (page != EXIT_BOOT && page != EXIT_BOOT_WNSS);
 512         CloseBootScreen(DOSBootBase->bm_Screen, DOSBootBase);
 513     }
 514     return page >= 0;
 515 }
 516
 517 /* From keyboard.device/keyboard_intern.h */
 518 #define KB_MAXKEYS     256
 519 #define KB_MATRIXSIZE  (KB_MAXKEYS/(sizeof(UBYTE)*8))
 520 #define ioStd(x) ((struct IOStdReq *)x)
 521
 522 static BOOL buttonsPressed(LIBBASETYPEPTR DOSBootBase)
 523 {
 524     BOOL success = FALSE;
 525     struct MsgPort *mp = NULL;
 526     UBYTE matrix[KB_MATRIXSIZE];
 527
 528 #ifdef mc68000
 529     /*
 530      * On m68k we may have ciaa.resource (if running on classic Amiga HW)
 531      * Let's check mouse buttons.
 532      */
 533     if (OpenResource("ciaa.resource"))
 534     {
 535             volatile UBYTE *cia = (UBYTE*)0xbfe001;
 536             volatile UWORD *potinp = (UWORD*)0xdff016;
 537
 538             /* check left + right mouse button state */
 539             if ((cia[0] & 0x40) == 0 && (potinp[0] & 0x0400) == 0)
 540                 return TRUE;
 541     }
 542 #endif
 543
 544     if ((mp = CreateMsgPort()) != NULL)
 545     {
 546         struct IORequest *io = NULL;
 547         if ((io = CreateIORequest(mp, sizeof ( struct IOStdReq))) != NULL)
 548         {
 549             if (0 == OpenDevice("keyboard.device", 0, io, 0))
 550             {
 551                 D(bug("[BootMenu] buttonsPressed: Checking KBD_READMATRIX\n"));
 552                 ioStd(io)->io_Command = KBD_READMATRIX;
 553                 ioStd(io)->io_Data = matrix;
 554                 ioStd(io)->io_Length = sizeof(matrix);
 555                 DoIO(io);
 556                 if (0 == io->io_Error)
 557                 {
 558                     D(
 559                         int i;
 560                         bug("[BootMenu] buttonsPressed: Matrix : ");
 561                         for (i = 0; i < ioStd(io)->io_Actual; i ++)
 562                         {
 563                                 bug("%02x ", matrix[i]);
 564                         }
 565                         bug("\n");
 566                     );
 567                     if (matrix[RAWKEY_SPACE/8] & (1<<(RAWKEY_SPACE%8)))
 568                     {
 569                             D(bug("[BootMenu] SPACEBAR pressed\n"));
 570                             success = TRUE;
 571                     }
 572                 }
 573                 CloseDevice(io);
 574             }
 575             DeleteIORequest(io);
 576         }
 577         DeleteMsgPort(mp);
 578     }
 579     return success;
 580 }
 581
 582 int bootmenu_Init(LIBBASETYPEPTR LIBBASE, BOOL WantBootMenu)
 583 {
 584     BOOL bmi_RetVal = FALSE;
 585
 586     D(bug("[BootMenu] bootmenu_Init()\n"));
 587
 588 #ifdef INITHIDDS_KLUDGE
 589    /*
 590     * PCI hardware display drivers still need external initialization.
 591     * This urgently needs to be fixed. After fixing this kludge
 592     * will not be needed any more.
 593     */
 594     InitBootConfig(&LIBBASE->bm_BootConfig);
 595     if (!initHidds(LIBBASE))
 596         return FALSE;
 597 #endif
 598
 599     /* check keyboard if needed */
 600     if (!WantBootMenu)
 601         WantBootMenu = buttonsPressed(LIBBASE);
 602
 603     /* Bring up early startup menu if requested */
 604     if (WantBootMenu)
 605     {
 606         D(kprintf("[BootMenu] bootmenu_Init: Entering Boot Menu ...\n"));
 607         bmi_RetVal = initScreen(LIBBASE, &LIBBASE->bm_BootConfig);
 608     }
 609
 610     return bmi_RetVal;
 611 }