src/boot.c

   1 // 16bit code to load disk image and start system boot.
   2 //
   3 // Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
   4 // Copyright (C) 2002  MandrakeSoft S.A.
   5 //
   6 // This file may be distributed under the terms of the GNU GPLv3 license.
   7
   8 #include "util.h" // irq_enable
   9 #include "biosvar.h" // struct bregs
  10 #include "config.h" // CONFIG_*
  11 #include "cmos.h" // inb_cmos
  12 #include "ata.h" // ata_detect
  13 #include "disk.h" // cdrom_boot
  14
  15 // We need a copy of this string, but we are not actually a PnP BIOS,
  16 // so make sure it is *not* aligned, so OSes will not see it if they
  17 // scan.
  18 char pnp_string[] VISIBLE16 __attribute__((aligned (2))) = " $PnP";
  19
  20 //--------------------------------------------------------------------------
  21 // print_boot_device
  22 //   displays the boot device
  23 //--------------------------------------------------------------------------
  24
  25 static const char drivetypes[][10]={
  26     "", "Floppy","Hard Disk","CD-Rom", "Network"
  27 };
  28
  29 void
  30 printf_bootdev(u16 bootdev)
  31 {
  32     u16 type = GET_EBDA(ipl.table[bootdev].type);
  33
  34     /* NIC appears as type 0x80 */
  35     if (type == IPL_TYPE_BEV)
  36         type = 0x4;
  37     if (type == 0 || type > 0x4)
  38         BX_PANIC("Bad drive type\n");
  39     printf("%s", drivetypes[type]);
  40
  41     /* print product string if BEV */
  42     void *far_description = (void*)GET_EBDA(ipl.table[bootdev].description);
  43     if (type == 4 && far_description != 0) {
  44         char description[33];
  45         /* first 32 bytes are significant */
  46         memcpy(MAKE_FARPTR(GET_SEG(SS), &description), far_description, 32);
  47         /* terminate string */
  48         description[32] = 0;
  49         printf(" [%.s]", description);
  50     }
  51 }
  52
  53 static void
  54 print_boot_device(u16 bootdev)
  55 {
  56     printf("Booting from ");
  57     printf_bootdev(bootdev);
  58     printf("...\n");
  59 }
  60
  61 //--------------------------------------------------------------------------
  62 // print_boot_failure
  63 //   displays the reason why boot failed
  64 //--------------------------------------------------------------------------
  65 static void
  66 print_boot_failure(u16 type, u8 reason)
  67 {
  68     if (type == 0 || type > 0x3)
  69         BX_PANIC("Bad drive type\n");
  70
  71     printf("Boot failed");
  72     if (type < 4) {
  73         /* Report the reason too */
  74         if (reason==0)
  75             printf(": not a bootable disk");
  76         else
  77             printf(": could not read the boot disk");
  78     }
  79     printf("\n\n");
  80 }
  81
  82 static void
  83 try_boot(u16 seq_nr)
  84 {
  85     irq_enable();
  86
  87     SET_EBDA(ipl.sequence, seq_nr);
  88
  89     u16 bootdev = inb_cmos(CMOS_BIOS_BOOTFLAG2);
  90     bootdev |= ((inb_cmos(CMOS_BIOS_BOOTFLAG1) & 0xf0) << 4);
  91     bootdev >>= 4 * seq_nr;
  92     bootdev &= 0xf;
  93
  94     /* Read user selected device */
  95     u16 bootfirst = GET_EBDA(ipl.bootfirst);
  96     if (bootfirst != 0xFFFF) {
  97         bootdev = bootfirst;
  98         /* Reset boot sequence */
  99         SET_EBDA(ipl.bootfirst, 0xFFFF);
 100         SET_EBDA(ipl.sequence, 0xFFFF);
 101     }
 102
 103     if (bootdev == 0)
 104         BX_PANIC("No bootable device.\n");
 105
 106     /* Translate from CMOS runes to an IPL table offset by subtracting 1 */
 107     bootdev -= 1;
 108
 109     if (bootdev >= GET_EBDA(ipl.count)) {
 110         BX_INFO("Invalid boot device (0x%x)\n", bootdev);
 111         return;
 112     }
 113
 114     /* Do the loading, and set up vector as a far pointer to the boot
 115      * address, and bootdrv as the boot drive */
 116     print_boot_device(bootdev);
 117
 118     u16 type = GET_EBDA(ipl.table[bootdev].type);
 119
 120     u16 bootseg, bootip;
 121     u8 bootdrv = 0;
 122     struct bregs cr;
 123     switch(type) {
 124     case IPL_TYPE_FLOPPY: /* FDD */
 125     case IPL_TYPE_HARDDISK: /* HDD */
 126
 127         bootdrv = (type == IPL_TYPE_HARDDISK) ? 0x80 : 0x00;
 128         bootseg = 0x07c0;
 129
 130         // Read sector
 131         memset(&cr, 0, sizeof(cr));
 132         cr.dl = bootdrv;
 133         cr.es = bootseg;
 134         cr.ah = 2;
 135         cr.al = 1;
 136         cr.cl = 1;
 137         call16_int(0x13, &cr);
 138
 139         if (cr.flags & F_CF) {
 140             print_boot_failure(type, 1);
 141             return;
 142         }
 143
 144         /* Always check the signature on a HDD boot sector; on FDD,
 145          * only do the check if the CMOS doesn't tell us to skip it */
 146         if ((type != IPL_TYPE_FLOPPY)
 147             || !((inb_cmos(CMOS_BIOS_BOOTFLAG1) & 0x01))) {
 148             if (GET_FARVAR(bootseg, *(u16*)0x1fe) != 0xaa55) {
 149                 print_boot_failure(type, 0);
 150                 return;
 151             }
 152         }
 153
 154         /* Canonicalize bootseg:bootip */
 155         bootip = (bootseg & 0x0fff) << 4;
 156         bootseg &= 0xf000;
 157         break;
 158     case IPL_TYPE_CDROM: {
 159         /* CD-ROM */
 160         if (! CONFIG_CDROM_BOOT)
 161             break;
 162         u16 status = cdrom_boot();
 163         if (status) {
 164             printf("CDROM boot failure code : %04x\n", status);
 165             print_boot_failure(type, 1);
 166             return;
 167         }
 168
 169         bootdrv = GET_EBDA(cdemu.emulated_drive);
 170         bootseg = GET_EBDA(cdemu.load_segment);
 171         /* Canonicalize bootseg:bootip */
 172         bootip = (bootseg & 0x0fff) << 4;
 173         bootseg &= 0xf000;
 174         break;
 175     }
 176     case IPL_TYPE_BEV: {
 177         /* Expansion ROM with a Bootstrap Entry Vector (a far
 178          * pointer) */
 179         u32 vector = GET_EBDA(ipl.table[bootdev].vector);
 180         bootseg = vector >> 16;
 181         bootip = vector & 0xffff;
 182         break;
 183     }
 184     default:
 185         return;
 186     }
 187
 188     /* Debugging info */
 189     BX_INFO("Booting from %x:%x\n", bootseg, bootip);
 190
 191     memset(&cr, 0, sizeof(cr));
 192     cr.ip = bootip;
 193     cr.cs = bootseg;
 194     // Set the magic number in ax and the boot drive in dl.
 195     cr.dl = bootdrv;
 196     cr.ax = 0xaa55;
 197     call16(&cr);
 198 }
 199
 200 static void
 201 do_boot(u16 seq_nr)
 202 {
 203     try_boot(seq_nr);
 204
 205     // Boot failed: invoke the boot recovery function
 206     struct bregs br;
 207     memset(&br, 0, sizeof(br));
 208     call16_int(0x18, &br);
 209 }
 210
 211 // Boot Failure recovery: try the next device.
 212 void VISIBLE16
 213 handle_18()
 214 {
 215     debug_enter(NULL);
 216     u16 seq = GET_EBDA(ipl.sequence) + 1;
 217     do_boot(seq);
 218 }
 219
 220 // INT 19h Boot Load Service Entry Point
 221 void VISIBLE16
 222 handle_19()
 223 {
 224     debug_enter(NULL);
 225     do_boot(0);
 226 }