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" // GET_EBDA
  10 #include "config.h" // CONFIG_*
  11 #include "ata.h" // ata_detect
  12 #include "disk.h" // cdrom_boot
  13 #include "bregs.h" // struct bregs
  14
  15 //--------------------------------------------------------------------------
  16 // print_boot_device
  17 //   displays the boot device
  18 //--------------------------------------------------------------------------
  19
  20 static const char drivetypes[][10]={
  21     "", "Floppy", "Hard Disk", "CD-Rom", "Network"
  22 };
  23
  24 void
  25 printf_bootdev(u16 bootdev)
  26 {
  27     u16 type = GET_EBDA(ipl.table[bootdev].type);
  28
  29     /* NIC appears as type 0x80 */
  30     if (type == IPL_TYPE_BEV)
  31         type = 0x4;
  32     if (type == 0 || type > 0x4)
  33         BX_PANIC("Bad drive type\n");
  34     printf("%s", drivetypes[type]);
  35
  36     /* print product string if BEV */
  37     void *far_description = (void*)GET_EBDA(ipl.table[bootdev].description);
  38     if (type == 4 && far_description != 0) {
  39         char description[33];
  40         /* first 32 bytes are significant */
  41         memcpy(MAKE_FARPTR(GET_SEG(SS), &description), far_description, 32);
  42         /* terminate string */
  43         description[32] = 0;
  44         printf(" [%.s]", description);
  45     }
  46 }
  47
  48 static void
  49 print_boot_device(u16 bootdev)
  50 {
  51     printf("Booting from ");
  52     printf_bootdev(bootdev);
  53     printf("...\n");
  54 }
  55
  56 //--------------------------------------------------------------------------
  57 // print_boot_failure
  58 //   displays the reason why boot failed
  59 //--------------------------------------------------------------------------
  60 static void
  61 print_boot_failure(u16 type, u8 reason)
  62 {
  63     if (type == 0 || type > 0x3)
  64         BX_PANIC("Bad drive type\n");
  65
  66     printf("Boot failed");
  67     if (type < 4) {
  68         /* Report the reason too */
  69         if (reason==0)
  70             printf(": not a bootable disk");
  71         else
  72             printf(": could not read the boot disk");
  73     }
  74     printf("\n\n");
  75 }
  76
  77 static void
  78 try_boot(u16 seq_nr)
  79 {
  80     SET_EBDA(ipl.sequence, seq_nr);
  81
  82     u32 bootdev = GET_EBDA(ipl.bootorder);
  83     bootdev >>= 4 * seq_nr;
  84     bootdev &= 0xf;
  85
  86     if (bootdev == 0)
  87         BX_PANIC("No bootable device.\n");
  88
  89     /* Translate bootdev to an IPL table offset by subtracting 1 */
  90     bootdev -= 1;
  91
  92     if (bootdev >= GET_EBDA(ipl.count)) {
  93         dprintf(1, "Invalid boot device (0x%x)\n", bootdev);
  94         return;
  95     }
  96
  97     /* Do the loading, and set up vector as a far pointer to the boot
  98      * address, and bootdrv as the boot drive */
  99     print_boot_device(bootdev);
 100
 101     u16 type = GET_EBDA(ipl.table[bootdev].type);
 102
 103     u16 bootseg, bootip;
 104     u8 bootdrv = 0;
 105     struct bregs cr;
 106     switch(type) {
 107     case IPL_TYPE_FLOPPY: /* FDD */
 108     case IPL_TYPE_HARDDISK: /* HDD */
 109
 110         bootdrv = (type == IPL_TYPE_HARDDISK) ? 0x80 : 0x00;
 111         bootseg = 0x07c0;
 112
 113         // Read sector
 114         memset(&cr, 0, sizeof(cr));
 115         cr.dl = bootdrv;
 116         cr.es = bootseg;
 117         cr.ah = 2;
 118         cr.al = 1;
 119         cr.cl = 1;
 120         call16_int(0x13, &cr);
 121
 122         if (cr.flags & F_CF) {
 123             print_boot_failure(type, 1);
 124             return;
 125         }
 126
 127         /* Always check the signature on a HDD boot sector; on FDD,
 128          * only do the check if configured for it */
 129         if (type != IPL_TYPE_FLOPPY || GET_EBDA(ipl.checkfloppysig)) {
 130             if (GET_FARVAR(bootseg, *(u16*)0x1fe) != 0xaa55) {
 131                 print_boot_failure(type, 0);
 132                 return;
 133             }
 134         }
 135
 136         /* Canonicalize bootseg:bootip */
 137         bootip = (bootseg & 0x0fff) << 4;
 138         bootseg &= 0xf000;
 139         break;
 140     case IPL_TYPE_CDROM: {
 141         /* CD-ROM */
 142         if (! CONFIG_CDROM_BOOT)
 143             break;
 144         int status = cdrom_boot();
 145         if (status) {
 146             printf("CDROM boot failure code : %04x\n", status);
 147             print_boot_failure(type, 1);
 148             return;
 149         }
 150
 151         bootdrv = GET_EBDA(cdemu.emulated_drive);
 152         bootseg = GET_EBDA(cdemu.load_segment);
 153         /* Canonicalize bootseg:bootip */
 154         bootip = (bootseg & 0x0fff) << 4;
 155         bootseg &= 0xf000;
 156         break;
 157     }
 158     case IPL_TYPE_BEV: {
 159         /* Expansion ROM with a Bootstrap Entry Vector (a far
 160          * pointer) */
 161         u32 vector = GET_EBDA(ipl.table[bootdev].vector);
 162         bootseg = vector >> 16;
 163         bootip = vector & 0xffff;
 164         break;
 165     }
 166     default:
 167         return;
 168     }
 169
 170     /* Debugging info */
 171     dprintf(1, "Booting from %x:%x\n", bootseg, bootip);
 172
 173     memset(&cr, 0, sizeof(cr));
 174     cr.ip = bootip;
 175     cr.cs = bootseg;
 176     // Set the magic number in ax and the boot drive in dl.
 177     cr.dl = bootdrv;
 178     cr.ax = 0xaa55;
 179     call16(&cr);
 180 }
 181
 182 static void
 183 do_boot(u16 seq_nr)
 184 {
 185     try_boot(seq_nr);
 186
 187     // Boot failed: invoke the boot recovery function
 188     struct bregs br;
 189     memset(&br, 0, sizeof(br));
 190     call16_int(0x18, &br);
 191 }
 192
 193 // Boot Failure recovery: try the next device.
 194 void VISIBLE32
 195 handle_18()
 196 {
 197     debug_serial_setup();
 198     debug_enter(NULL, DEBUG_HDL_18);
 199     u16 seq = GET_EBDA(ipl.sequence) + 1;
 200     do_boot(seq);
 201 }
 202
 203 // INT 19h Boot Load Service Entry Point
 204 void VISIBLE32
 205 handle_19()
 206 {
 207     debug_serial_setup();
 208     debug_enter(NULL, DEBUG_HDL_19);
 209     do_boot(0);
 210 }
 211
 212 // Ughh - some older gcc compilers have a bug which causes VISIBLE32
 213 // functions to not be exported as a global variables.
 214 asm(".global handle_18, handle_19");