rom/dosboot/menu.c

   1 /*
   2    Copyright © 1995-2011, 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
 214                         toggleMode(DOSBootBase);
 215                 } else if (msg->Class == IDCMP_GADGETUP)
 216                 {
 217                     g = msg->IAddress;
 218                     switch (g->GadgetID)
 219                     {
 220                     case BUTTON_BOOT:
 221                             DOSBootBase->db_BootFlags &= ~BF_NO_STARTUP_SEQUENCE;
 222                             exit = EXIT_BOOT;
 223                             break;
 224                     case BUTTON_BOOT_WNSS:
 225                             DOSBootBase->db_BootFlags |= BF_NO_STARTUP_SEQUENCE;
 226                             exit = EXIT_BOOT_WNSS;
 227                             break;
 228                     case BUTTON_USE:
 229                     case BUTTON_CANCEL:
 230                     case BUTTON_CONTINUE:
 231                             exit = PAGE_MAIN;
 232                             break;
 233                     case BUTTON_BOOT_OPTIONS:
 234                             exit = PAGE_BOOT;
 235                             break;
 236                     case BUTTON_EXPBOARDDIAG:
 237                             exit = PAGE_EXPANSION;
 238                             break;
 239                     case BUTTON_DISPLAY_OPTIONS:
 240                             exit = PAGE_DISPLAY;
 241                             break;
 242                     }
 243                 }
 244                 ReplyMsg((struct Message *)msg);
 245             }
 246         }
 247         else
 248         {
 249             bug("[BootMenu] msgLoop: Window lacks a userport!\n");
 250             Wait(0);
 251         }
 252     } while (exit < 0);
 253     while ((msg=(struct IntuiMessage *)GetMsg(win->UserPort)))
 254         ReplyMsg(&msg->ExecMessage);
 255     return exit;
 256 }
 257
 258 static void initPageExpansion(LIBBASETYPEPTR DOSBootBase)
 259 {
 260     struct Window *win = DOSBootBase->bm_Window;
 261     struct ExpansionBase *ExpansionBase = DOSBootBase->bm_ExpansionBase;
 262     struct ConfigDev *cd;
 263     WORD y = 50, cnt;
 264     char text[100];
 265
 266     SetAPen(win->RPort, 1);
 267     cd = NULL;
 268     cnt = 0;
 269     while ((cd = FindConfigDev(cd, -1, -1))) {
 270         NewRawDoFmt("%2d: %08lx - %08lx (%08lx) %5d %3d %08lx", RAWFMTFUNC_STRING, text,
 271             ++cnt,
 272             cd->cd_BoardAddr, cd->cd_BoardAddr + cd->cd_BoardSize - 1, cd->cd_BoardSize,
 273             cd->cd_Rom.er_Manufacturer, cd->cd_Rom.er_Product, cd->cd_Rom.er_SerialNumber);
 274         if ((cd->cd_Rom.er_Type & ERT_TYPEMASK) == ERT_ZORROIII)
 275             strcat(text, " Z3");
 276         else if ((cd->cd_Rom.er_Type & ERT_TYPEMASK) == ERT_ZORROII)
 277             strcat(text, " Z2");
 278         else
 279             strcat(text, "   ");
 280         if (cd->cd_Rom.er_Type & ERTF_DIAGVALID)
 281             strcat(text, " ROM");
 282         if (cd->cd_Rom.er_Type & ERTF_MEMLIST)
 283             strcat(text, " RAM");
 284         Move(win->RPort, 20, y);
 285         Text(win->RPort, text, strlen(text));
 286         y += 16;
 287    }
 288 }
 289
 290 static BOOL bstreqcstr(BSTR bstr, CONST_STRPTR cstr)
 291 {
 292     int clen;
 293     int blen;
 294
 295     clen = strlen(cstr);
 296     blen = AROS_BSTR_strlen(bstr);
 297     if (clen != blen)
 298         return FALSE;
 299
 300     return (memcmp(AROS_BSTR_ADDR(bstr),cstr,clen) == 0);
 301 }
 302
 303 void selectBootDevice(LIBBASETYPEPTR DOSBootBase)
 304 {
 305     struct BootNode *bn;
 306
 307     if (DOSBootBase->db_BootDevice == NULL &&
 308         DOSBootBase->db_BootNode != NULL)
 309         return;
 310
 311     Forbid(); /* .. access to ExpansionBase->MountList */
 312
 313     if (DOSBootBase->db_BootNode == NULL && DOSBootBase->db_BootDevice == NULL)
 314     {
 315         bn = (APTR)GetHead(&DOSBootBase->bm_ExpansionBase->MountList);
 316     }
 317     else
 318     {
 319         ForeachNode(&DOSBootBase->bm_ExpansionBase->MountList, bn)
 320         {
 321             struct DeviceNode *dn;
 322
 323             dn = bn->bn_DeviceNode;
 324             if (dn == NULL || dn->dn_Name == BNULL)
 325                 continue;
 326
 327             if (bstreqcstr(dn->dn_Name, DOSBootBase->db_BootDevice))
 328                 break;
 329         }
 330     }
 331
 332     Permit();
 333
 334     DOSBootBase->db_BootNode = bn;
 335     DOSBootBase->db_BootDevice = NULL;
 336 }
 337
 338 /* This makes the selected boot device the actual
 339  * boot device. It also updates the boot flags.
 340  */
 341 static void setBootDevice(LIBBASETYPEPTR DOSBootBase)
 342 {
 343     struct BootNode *bn;
 344
 345     bn = DOSBootBase->db_BootNode;
 346
 347     if (bn != NULL)
 348     {
 349         Remove((struct Node *)bn);
 350         bn->bn_Node.ln_Type = NT_BOOTNODE;
 351         bn->bn_Node.ln_Pri = 127;
 352         /* We use AddHead() instead of Enqueue() here
 353          * to *insure* that this gets to the front of
 354          * the boot list.
 355          */
 356         AddHead(&DOSBootBase->bm_ExpansionBase->MountList, (struct Node *)&bn);
 357     }
 358
 359     DOSBootBase->bm_ExpansionBase->eb_BootFlags = DOSBootBase->db_BootFlags;
 360 }
 361
 362 static void initPageBoot(LIBBASETYPEPTR DOSBootBase)
 363 {
 364     struct Window *win = DOSBootBase->bm_Window;
 365     struct BootNode *bn;
 366     WORD y = 50;
 367     char text[100], *textp;
 368
 369     SetAPen(win->RPort, 1);
 370
 371     ForeachNode(&DOSBootBase->bm_ExpansionBase->MountList, bn)
 372     {
 373         struct DeviceNode *dn = bn->bn_DeviceNode;
 374         struct FileSysStartupMsg *fssm = BADDR(dn->dn_Startup);
 375         struct DosEnvec *de = NULL;
 376         struct IOStdReq *io;
 377         struct MsgPort *port;
 378         char dostype[5];
 379         UBYTE i;
 380         ULONG size;
 381         BOOL devopen, ismedia;
 382
 383         if (y >= DOSBootBase->bottomY - 20)
 384             break;
 385         if (!fssm || !fssm->fssm_Device)
 386             continue;
 387         if (fssm->fssm_Environ > (BPTR)0x64) {
 388             de = BADDR(fssm->fssm_Environ);
 389             if (de->de_TableSize < 15)
 390                 de = NULL;
 391         }
 392
 393         NewRawDoFmt("%c%10s: %4d %s-%ld", RAWFMTFUNC_STRING, text,
 394             IsBootableNode(bn) ?
 395                ((DOSBootBase->db_BootNode == bn) ? '*' : '+')
 396                : ' ',
 397             AROS_BSTR_ADDR(dn->dn_Name),
 398             bn->bn_Node.ln_Pri,
 399             AROS_BSTR_ADDR(fssm->fssm_Device),
 400             fssm->fssm_Unit);
 401         Move(win->RPort, 20, y);
 402         Text(win->RPort, text, strlen(text));
 403
 404         textp = NULL;
 405         devopen = ismedia = FALSE;
 406         if ((port = (struct MsgPort*)CreateMsgPort())) {
 407             if ((io = (struct IOStdReq*)CreateIORequest(port, sizeof(struct IOStdReq)))) {
 408                 if (!OpenDevice(AROS_BSTR_ADDR(fssm->fssm_Device), fssm->fssm_Unit, (struct IORequest*)io, fssm->fssm_Flags)) {
 409                     devopen = TRUE;
 410                     io->io_Command = TD_CHANGESTATE;
 411                     io->io_Actual = 1;
 412                     DoIO((struct IORequest*)io);
 413                     if (!io->io_Error && io->io_Actual == 0)
 414                         ismedia = TRUE;
 415                     CloseDevice((struct IORequest*)io);
 416                 }
 417                 DeleteIORequest((struct IORequest*)io);
 418             }
 419             DeleteMsgPort(port);
 420         }
 421
 422         if (de && ismedia) {
 423             for (i = 0; i < 4; i++) {
 424                 dostype[i] = (de->de_DosType >> ((3 - i) * 8)) & 0xff;
 425                 if (dostype[i] < 9)
 426                     dostype[i] += '0';
 427                 else if (dostype[i] < 32)
 428                     dostype[i] = '.';
 429             }
 430             dostype[4] = 0;
 431
 432            size = (de->de_HighCyl - de->de_LowCyl + 1) * de->de_Surfaces * de->de_BlocksPerTrack;
 433            /* try to prevent ULONG overflow */
 434            if (de->de_SizeBlock <= 128)
 435                 size /= 2;
 436             else
 437                 size *= de->de_SizeBlock / 256;
 438
 439             NewRawDoFmt("%s [%08lx] %ldk", RAWFMTFUNC_STRING, text,
 440                 dostype, de->de_DosType,
 441                 size);
 442             textp = text;
 443         } else if (!devopen) {
 444             textp = "[device open error]";
 445         } else if (!ismedia) {
 446             textp = "[no media]";
 447         }
 448         if (textp) {
 449             Move(win->RPort, 400, y);
 450             Text(win->RPort, textp, strlen(textp));
 451         }
 452
 453         y += 16;
 454
 455
 456     }
 457 }
 458
 459 static void centertext(LIBBASETYPEPTR DOSBootBase, BYTE pen, WORD y, const char *text)
 460 {
 461     struct Window *win = DOSBootBase->bm_Window;
 462     SetAPen(win->RPort, pen);
 463     Move(win->RPort, win->Width / 2 - TextLength(win->RPort, text, strlen(text)) / 2, y);
 464     Text(win->RPort, text, strlen(text));
 465 }
 466
 467 static void initPage(LIBBASETYPEPTR DOSBootBase, WORD page)
 468 {
 469     UBYTE *text;
 470
 471     if (page == PAGE_DISPLAY)
 472         text = "Display Options";
 473     else if (page == PAGE_EXPANSION)
 474         text = "Expansion Board Diagnostic";
 475     else if (page == PAGE_BOOT)
 476         text = "Boot Options";
 477     else
 478         text = "AROS Early Startup Control";
 479     centertext(DOSBootBase, 2, 10, text);
 480
 481     if (page == PAGE_BOOT)
 482         initPageBoot(DOSBootBase);
 483     else if (page == PAGE_EXPANSION)
 484         initPageExpansion(DOSBootBase);
 485
 486     if (page == PAGE_MAIN && (GfxBase->DisplayFlags & (NTSC | PAL))) {
 487         ULONG modeid = GetVPModeID(&DOSBootBase->bm_Screen->ViewPort);
 488         if (modeid != INVALID_ID && (((modeid & MONITOR_ID_MASK) == NTSC_MONITOR_ID) || ((modeid & MONITOR_ID_MASK) == PAL_MONITOR_ID))) {
 489             centertext(DOSBootBase, 1, 30, "(press a key to toggle the display between PAL and NTSC)");
 490         }
 491     }
 492 }
 493
 494 static WORD initWindow(LIBBASETYPEPTR DOSBootBase, struct BootConfig *bcfg, WORD page)
 495 {
 496     struct Gadget *first = NULL;
 497     WORD newpage = -1;
 498
 499     if ((first = createGadgets(DOSBootBase, page)) != NULL)
 500     {
 501         struct NewWindow nw =
 502         {
 503             0, 0,                            /* Left, Top */
 504             DOSBootBase->bm_Screen->Width,   /* Width, Height */
 505             DOSBootBase->bm_Screen->Height,
 506             0, 1,                            /* DetailPen, BlockPen */
 507             IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_VANILLAKEY | IDCMP_GADGETUP | IDCMP_GADGETDOWN, /* IDCMPFlags */
 508             WFLG_SMART_REFRESH | WFLG_BORDERLESS | WFLG_ACTIVATE, /* Flags */
 509             first,                           /* FirstGadget */
 510             NULL,                            /* CheckMark */
 511             NULL,                            /* Title */
 512             DOSBootBase->bm_Screen,          /* Screen */
 513             NULL,                            /* BitMap */
 514             0, 0,                            /* MinWidth, MinHeight */
 515             0, 0,                            /* MaxWidth, MaxHeight */
 516             CUSTOMSCREEN,                    /* Type */
 517         };
 518
 519         D(bug("[BootMenu] initPage: Gadgets created @ %p\n", first));
 520
 521         if ((DOSBootBase->bm_Window = OpenWindow(&nw)) != NULL)
 522         {
 523             D(bug("[BootMenu] initScreen: Window opened @ %p\n", DOSBootBase->bm_Window));
 524             D(bug("[BootMenu] initScreen: Window RastPort @ %p\n", DOSBootBase->bm_Window->RPort));
 525             D(bug("[BootMenu] initScreen: Window UserPort @ %p\n", DOSBootBase->bm_Window->UserPort));
 526             initPage(DOSBootBase, page);
 527             newpage = msgLoop(DOSBootBase, DOSBootBase->bm_Window);
 528         }
 529         CloseWindow(DOSBootBase->bm_Window);
 530     }
 531     freeGadgets(DOSBootBase, page);
 532
 533     return newpage;
 534 }
 535
 536 static BOOL initScreen(LIBBASETYPEPTR DOSBootBase, struct BootConfig *bcfg)
 537 {
 538     WORD page;
 539
 540     D(bug("[BootMenu] initScreen()\n"));
 541
 542     page = -1;
 543     DOSBootBase->bm_Screen = OpenBootScreen(DOSBootBase);
 544     if (DOSBootBase->bm_Screen)
 545     {
 546         DOSBootBase->bottomY = DOSBootBase->bm_Screen->Height - (DOSBootBase->bm_Screen->Height > 256 ? 32 : 16);
 547         D(bug("[BootMenu] initScreen: Screen opened @ %p\n",  DOSBootBase->bm_Screen));
 548
 549         page = PAGE_MAIN;
 550         do {
 551             page = initWindow(DOSBootBase, bcfg, page);
 552         } while (page != EXIT_BOOT && page != EXIT_BOOT_WNSS);
 553         CloseBootScreen(DOSBootBase->bm_Screen, DOSBootBase);
 554     }
 555     return page >= 0;
 556 }
 557
 558 /* From keyboard.device/keyboard_intern.h */
 559 #define KB_MAXKEYS     256
 560 #define KB_MATRIXSIZE  (KB_MAXKEYS/(sizeof(UBYTE)*8))
 561 #define ioStd(x) ((struct IOStdReq *)x)
 562
 563 static BOOL buttonsPressed(LIBBASETYPEPTR DOSBootBase)
 564 {
 565     BOOL success = FALSE;
 566     struct MsgPort *mp = NULL;
 567     UBYTE matrix[KB_MATRIXSIZE];
 568
 569 #ifdef mc68000
 570     /*
 571      * On m68k we may have ciaa.resource (if running on classic Amiga HW)
 572      * Let's check mouse buttons.
 573      */
 574     if (OpenResource("ciaa.resource"))
 575     {
 576         volatile UBYTE *cia = (UBYTE*)0xbfe001;
 577         volatile UWORD *potinp = (UWORD*)0xdff016;
 578
 579         /* check left + right mouse button state */
 580         if ((cia[0] & 0x40) == 0 && (potinp[0] & 0x0400) == 0)
 581             return TRUE;
 582     }
 583 #endif
 584
 585     if ((mp = CreateMsgPort()) != NULL)
 586     {
 587         struct IORequest *io = NULL;
 588         if ((io = CreateIORequest(mp, sizeof ( struct IOStdReq))) != NULL)
 589         {
 590             if (0 == OpenDevice("keyboard.device", 0, io, 0))
 591             {
 592                 D(bug("[BootMenu] buttonsPressed: Checking KBD_READMATRIX\n"));
 593                 ioStd(io)->io_Command = KBD_READMATRIX;
 594                 ioStd(io)->io_Data = matrix;
 595                 ioStd(io)->io_Length = sizeof(matrix);
 596                 DoIO(io);
 597                 if (0 == io->io_Error)
 598                 {
 599                     D(
 600                         int i;
 601                         bug("[BootMenu] buttonsPressed: Matrix : ");
 602                         for (i = 0; i < ioStd(io)->io_Actual; i ++)
 603                         {
 604                                 bug("%02x ", matrix[i]);
 605                         }
 606                         bug("\n");
 607                     );
 608                     if (matrix[RAWKEY_SPACE/8] & (1<<(RAWKEY_SPACE%8)))
 609                     {
 610                             D(bug("[BootMenu] SPACEBAR pressed\n"));
 611                             success = TRUE;
 612                     }
 613                 }
 614                 CloseDevice(io);
 615             }
 616             DeleteIORequest(io);
 617         }
 618         DeleteMsgPort(mp);
 619     }
 620     return success;
 621 }
 622
 623 int bootmenu_Init(LIBBASETYPEPTR LIBBASE, BOOL WantBootMenu)
 624 {
 625     BOOL bmi_RetVal = FALSE;
 626
 627     D(bug("[BootMenu] bootmenu_Init()\n"));
 628
 629 #ifdef INITHIDDS_KLUDGE
 630    /*
 631     * PCI hardware display drivers still need external initialization.
 632     * This urgently needs to be fixed. After fixing this kludge
 633     * will not be needed any more.
 634     */
 635     InitBootConfig(&LIBBASE->bm_BootConfig);
 636     if (!initHidds(LIBBASE))
 637         return FALSE;
 638 #endif
 639
 640     /* check keyboard if needed */
 641     if (!WantBootMenu)
 642         WantBootMenu = buttonsPressed(LIBBASE);
 643
 644     /* Bring up early startup menu if requested */
 645     if (WantBootMenu)
 646     {
 647         D(kprintf("[BootMenu] bootmenu_Init: Entering Boot Menu ...\n"));
 648         bmi_RetVal = initScreen(LIBBASE, &LIBBASE->bm_BootConfig);
 649     }
 650
 651     /* Make the user's select the top boot device */
 652     setBootDevice(LIBBASE);
 653
 654     return bmi_RetVal;
 655 }