Kevin O'Connor | f13b008 | 2008-08-17 11:26:42 -0400 | [diff] [blame] | 1 | // Code to load disk image and start system boot. |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 2 | // |
Kevin O'Connor | cadaf0e | 2010-07-26 23:47:26 -0400 | [diff] [blame] | 3 | // Copyright (C) 2008-2010 Kevin O'Connor <kevin@koconnor.net> |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 4 | // Copyright (C) 2002 MandrakeSoft S.A. |
| 5 | // |
Kevin O'Connor | b1b7c2a | 2009-01-15 20:52:58 -0500 | [diff] [blame] | 6 | // This file may be distributed under the terms of the GNU LGPLv3 license. |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 7 | |
Kevin O'Connor | 10ad799 | 2009-10-24 11:06:08 -0400 | [diff] [blame] | 8 | #include "util.h" // dprintf |
Kevin O'Connor | 9521e26 | 2008-07-04 13:04:29 -0400 | [diff] [blame] | 9 | #include "biosvar.h" // GET_EBDA |
Kevin O'Connor | 38fcbfe | 2008-02-25 22:30:47 -0500 | [diff] [blame] | 10 | #include "config.h" // CONFIG_* |
Kevin O'Connor | 180a959 | 2008-03-04 22:50:53 -0500 | [diff] [blame] | 11 | #include "disk.h" // cdrom_boot |
Kevin O'Connor | 9521e26 | 2008-07-04 13:04:29 -0400 | [diff] [blame] | 12 | #include "bregs.h" // struct bregs |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 13 | #include "boot.h" // func defs |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 14 | #include "cmos.h" // inb_cmos |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 15 | #include "paravirt.h" // romfile_loadfile |
Kevin O'Connor | c659fde | 2008-12-28 23:43:20 -0500 | [diff] [blame] | 16 | |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 17 | |
| 18 | /**************************************************************** |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 19 | * Boot priority ordering |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 20 | ****************************************************************/ |
| 21 | |
Kevin O'Connor | 3da2c1c | 2010-12-29 11:37:41 -0500 | [diff] [blame] | 22 | static char **Bootorder; |
| 23 | static int BootorderCount; |
| 24 | |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 25 | static void |
| 26 | loadBootOrder(void) |
| 27 | { |
| 28 | char *f = romfile_loadfile("bootorder", NULL); |
| 29 | if (!f) |
| 30 | return; |
| 31 | |
| 32 | int i; |
Kevin O'Connor | 3da2c1c | 2010-12-29 11:37:41 -0500 | [diff] [blame] | 33 | BootorderCount = 1; |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 34 | while (f[i]) { |
| 35 | if (f[i] == '\n') |
Kevin O'Connor | 3da2c1c | 2010-12-29 11:37:41 -0500 | [diff] [blame] | 36 | BootorderCount++; |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 37 | i++; |
| 38 | } |
Kevin O'Connor | 3da2c1c | 2010-12-29 11:37:41 -0500 | [diff] [blame] | 39 | Bootorder = malloc_tmphigh(BootorderCount*sizeof(char*)); |
| 40 | if (!Bootorder) { |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 41 | warn_noalloc(); |
| 42 | free(f); |
| 43 | return; |
| 44 | } |
| 45 | |
| 46 | dprintf(3, "boot order:\n"); |
| 47 | i = 0; |
| 48 | do { |
Kevin O'Connor | 3da2c1c | 2010-12-29 11:37:41 -0500 | [diff] [blame] | 49 | Bootorder[i] = f; |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 50 | f = strchr(f, '\n'); |
| 51 | if (f) { |
| 52 | *f = '\0'; |
| 53 | f++; |
Kevin O'Connor | 3da2c1c | 2010-12-29 11:37:41 -0500 | [diff] [blame] | 54 | dprintf(3, "%d: %s\n", i, Bootorder[i]); |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 55 | i++; |
| 56 | } |
| 57 | } while(f); |
| 58 | } |
| 59 | |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 60 | int bootprio_find_pci_device(int bdf) |
| 61 | { |
| 62 | return -1; |
| 63 | } |
| 64 | |
| 65 | int bootprio_find_ata_device(int bdf, int chanid, int slave) |
| 66 | { |
| 67 | return -1; |
| 68 | } |
| 69 | |
| 70 | int bootprio_find_fdc_device(int bfd, int port, int fdid) |
| 71 | { |
| 72 | return -1; |
| 73 | } |
| 74 | |
| 75 | int bootprio_find_pci_rom(int bdf, int instance) |
| 76 | { |
| 77 | return -1; |
| 78 | } |
| 79 | |
| 80 | int bootprio_find_named_rom(const char *name, int instance) |
| 81 | { |
| 82 | return -1; |
| 83 | } |
| 84 | |
| 85 | |
| 86 | /**************************************************************** |
| 87 | * Boot setup |
| 88 | ****************************************************************/ |
| 89 | |
Kevin O'Connor | baaadb6 | 2010-12-29 11:18:04 -0500 | [diff] [blame] | 90 | static int CheckFloppySig = 1; |
| 91 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 92 | #define DEFAULT_PRIO 9999 |
| 93 | |
| 94 | static int DefaultFloppyPrio = 101; |
| 95 | static int DefaultCDPrio = 102; |
| 96 | static int DefaultHDPrio = 103; |
| 97 | static int DefaultBEVPrio = 104; |
| 98 | |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 99 | void |
Kevin O'Connor | 1ca05b0 | 2010-01-03 17:43:37 -0500 | [diff] [blame] | 100 | boot_setup(void) |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 101 | { |
| 102 | if (! CONFIG_BOOT) |
| 103 | return; |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 104 | |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 105 | SET_EBDA(boot_sequence, 0xffff); |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 106 | |
| 107 | if (!CONFIG_COREBOOT) { |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 108 | // On emulators, get boot order from nvram. |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 109 | if (inb_cmos(CMOS_BIOS_BOOTFLAG1) & 1) |
Kevin O'Connor | baaadb6 | 2010-12-29 11:18:04 -0500 | [diff] [blame] | 110 | CheckFloppySig = 0; |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 111 | u32 bootorder = (inb_cmos(CMOS_BIOS_BOOTFLAG2) |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 112 | | ((inb_cmos(CMOS_BIOS_BOOTFLAG1) & 0xf0) << 4)); |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 113 | DefaultFloppyPrio = DefaultCDPrio = DefaultHDPrio |
| 114 | = DefaultBEVPrio = DEFAULT_PRIO; |
| 115 | int i; |
| 116 | for (i=101; i<104; i++) { |
| 117 | u32 val = bootorder & 0x0f; |
| 118 | bootorder >>= 4; |
| 119 | switch (val) { |
| 120 | case 1: DefaultFloppyPrio = i; break; |
| 121 | case 2: DefaultHDPrio = i; break; |
| 122 | case 3: DefaultCDPrio = i; break; |
| 123 | case 4: DefaultBEVPrio = i; break; |
| 124 | } |
| 125 | } |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 126 | } |
Gleb Natapov | b9a7591 | 2010-12-23 11:29:38 +0200 | [diff] [blame] | 127 | |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 128 | loadBootOrder(); |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 129 | } |
| 130 | |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 131 | |
| 132 | /**************************************************************** |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 133 | * BootList handling |
Kevin O'Connor | d1a1746 | 2010-12-24 11:17:03 -0500 | [diff] [blame] | 134 | ****************************************************************/ |
| 135 | |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 136 | struct bootentry_s { |
| 137 | int type; |
| 138 | union { |
| 139 | u32 data; |
| 140 | struct segoff_s vector; |
| 141 | struct drive_s *drive; |
| 142 | }; |
| 143 | int priority; |
| 144 | const char *description; |
| 145 | struct bootentry_s *next; |
| 146 | }; |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 147 | static struct bootentry_s *BootList; |
| 148 | |
Kevin O'Connor | 7bb1584 | 2010-12-29 11:25:14 -0500 | [diff] [blame] | 149 | #define IPL_TYPE_FLOPPY 0x01 |
| 150 | #define IPL_TYPE_HARDDISK 0x02 |
| 151 | #define IPL_TYPE_CDROM 0x03 |
| 152 | #define IPL_TYPE_CBFS 0x20 |
| 153 | #define IPL_TYPE_BEV 0x80 |
| 154 | #define IPL_TYPE_BCV 0x81 |
| 155 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 156 | static void |
| 157 | bootentry_add(int type, int prio, u32 data, const char *desc) |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 158 | { |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 159 | if (! CONFIG_BOOT) |
| 160 | return; |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 161 | struct bootentry_s *be = malloc_tmp(sizeof(*be)); |
| 162 | if (!be) { |
| 163 | warn_noalloc(); |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 164 | return; |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 165 | } |
| 166 | be->type = type; |
| 167 | be->priority = prio; |
| 168 | be->data = data; |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame^] | 169 | be->description = desc ?: "?"; |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 170 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 171 | // Add entry in sorted order. |
| 172 | struct bootentry_s **pprev; |
| 173 | for (pprev = &BootList; *pprev; pprev = &(*pprev)->next) { |
| 174 | struct bootentry_s *pos = *pprev; |
| 175 | if (be->priority < pos->priority) |
| 176 | break; |
| 177 | if (be->priority > pos->priority) |
| 178 | continue; |
| 179 | if (be->type < pos->type) |
| 180 | break; |
| 181 | if (be->type > pos->type) |
| 182 | continue; |
| 183 | if (be->type <= IPL_TYPE_CDROM |
| 184 | && (be->drive->type < pos->drive->type |
| 185 | || (be->drive->type == pos->drive->type |
| 186 | && be->drive->cntl_id < pos->drive->cntl_id))) |
| 187 | break; |
| 188 | } |
| 189 | be->next = *pprev; |
| 190 | *pprev = be; |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 191 | } |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 192 | |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 193 | // Return the given priority if it's set - defaultprio otherwise. |
| 194 | static inline int defPrio(int priority, int defaultprio) { |
| 195 | return (priority < 0) ? defaultprio : priority; |
| 196 | } |
| 197 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 198 | // Add a BEV vector for a given pnp compatible option rom. |
Gleb Natapov | 4c90a20 | 2010-12-07 13:50:54 +0200 | [diff] [blame] | 199 | void |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 200 | boot_add_bev(u16 seg, u16 bev, u16 desc, int prio) |
Gleb Natapov | 4c90a20 | 2010-12-07 13:50:54 +0200 | [diff] [blame] | 201 | { |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 202 | bootentry_add(IPL_TYPE_BEV, defPrio(prio, DefaultBEVPrio) |
| 203 | , SEGOFF(seg, bev).segoff |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 204 | , desc ? MAKE_FLATPTR(seg, desc) : "Unknown"); |
| 205 | DefaultBEVPrio = DEFAULT_PRIO; |
Gleb Natapov | 4c90a20 | 2010-12-07 13:50:54 +0200 | [diff] [blame] | 206 | } |
| 207 | |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 208 | // Add a bcv entry for an expansion card harddrive or legacy option rom |
| 209 | void |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 210 | boot_add_bcv(u16 seg, u16 ip, u16 desc, int prio) |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 211 | { |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 212 | bootentry_add(IPL_TYPE_BCV, defPrio(prio, DEFAULT_PRIO) |
| 213 | , SEGOFF(seg, ip).segoff |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 214 | , desc ? MAKE_FLATPTR(seg, desc) : "Legacy option rom"); |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 215 | } |
| 216 | |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 217 | void |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame^] | 218 | boot_add_floppy(struct drive_s *drive_g, const char *desc, int prio) |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 219 | { |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 220 | bootentry_add(IPL_TYPE_FLOPPY, defPrio(prio, DefaultFloppyPrio) |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame^] | 221 | , (u32)drive_g, desc); |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 222 | } |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 223 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 224 | void |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame^] | 225 | boot_add_hd(struct drive_s *drive_g, const char *desc, int prio) |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 226 | { |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 227 | bootentry_add(IPL_TYPE_HARDDISK, defPrio(prio, DefaultHDPrio) |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame^] | 228 | , (u32)drive_g, desc); |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | void |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame^] | 232 | boot_add_cd(struct drive_s *drive_g, const char *desc, int prio) |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 233 | { |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 234 | bootentry_add(IPL_TYPE_CDROM, defPrio(prio, DefaultCDPrio) |
Kevin O'Connor | ca2bc1c | 2010-12-29 21:41:19 -0500 | [diff] [blame^] | 235 | , (u32)drive_g, desc); |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 236 | } |
| 237 | |
| 238 | // Add a CBFS payload entry |
| 239 | void |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 240 | boot_add_cbfs(void *data, const char *desc, int prio) |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 241 | { |
Kevin O'Connor | 031ef55 | 2010-12-27 19:26:57 -0500 | [diff] [blame] | 242 | bootentry_add(IPL_TYPE_CBFS, defPrio(prio, DEFAULT_PRIO), (u32)data, desc); |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 243 | } |
| 244 | |
| 245 | |
| 246 | /**************************************************************** |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 247 | * Boot menu and BCV execution |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 248 | ****************************************************************/ |
| 249 | |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 250 | // Show IPL option menu. |
| 251 | static void |
Kevin O'Connor | 1ca05b0 | 2010-01-03 17:43:37 -0500 | [diff] [blame] | 252 | interactive_bootmenu(void) |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 253 | { |
Kevin O'Connor | e7cc764 | 2009-10-04 10:05:16 -0400 | [diff] [blame] | 254 | if (! CONFIG_BOOTMENU || ! qemu_cfg_show_boot_menu()) |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 255 | return; |
| 256 | |
| 257 | while (get_keystroke(0) >= 0) |
| 258 | ; |
| 259 | |
| 260 | printf("Press F12 for boot menu.\n\n"); |
| 261 | |
Kevin O'Connor | 9a01a9c | 2010-08-25 21:07:48 -0400 | [diff] [blame] | 262 | enable_bootsplash(); |
Kevin O'Connor | 217d363 | 2009-04-29 22:00:21 -0400 | [diff] [blame] | 263 | int scan_code = get_keystroke(CONFIG_BOOTMENU_WAIT); |
Kevin O'Connor | 9a01a9c | 2010-08-25 21:07:48 -0400 | [diff] [blame] | 264 | disable_bootsplash(); |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 265 | if (scan_code != 0x86) |
| 266 | /* not F12 */ |
| 267 | return; |
| 268 | |
| 269 | while (get_keystroke(0) >= 0) |
| 270 | ; |
| 271 | |
| 272 | printf("Select boot device:\n\n"); |
Kevin O'Connor | e438b0c | 2010-05-01 12:20:33 -0400 | [diff] [blame] | 273 | wait_threads(); |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 274 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 275 | // Show menu items |
| 276 | struct bootentry_s *pos = BootList; |
| 277 | int maxmenu = 0; |
| 278 | while (pos) { |
| 279 | char desc[60]; |
| 280 | maxmenu++; |
| 281 | printf("%d. %s\n", maxmenu |
| 282 | , strtcpy(desc, pos->description, ARRAY_SIZE(desc))); |
| 283 | pos = pos->next; |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 284 | } |
| 285 | |
Kevin O'Connor | 551caa2 | 2010-12-29 13:25:18 -0500 | [diff] [blame] | 286 | // Get key press |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 287 | for (;;) { |
| 288 | scan_code = get_keystroke(1000); |
Kevin O'Connor | 551caa2 | 2010-12-29 13:25:18 -0500 | [diff] [blame] | 289 | if (scan_code >= 1 && scan_code <= maxmenu+1) |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 290 | break; |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 291 | } |
| 292 | printf("\n"); |
Kevin O'Connor | 551caa2 | 2010-12-29 13:25:18 -0500 | [diff] [blame] | 293 | if (scan_code == 0x01) |
| 294 | // ESC |
| 295 | return; |
| 296 | |
| 297 | // Find entry and make top priority. |
| 298 | int choice = scan_code - 1; |
| 299 | struct bootentry_s **pprev = &BootList; |
| 300 | while (--choice) |
| 301 | pprev = &(*pprev)->next; |
| 302 | pos = *pprev; |
| 303 | *pprev = pos->next; |
| 304 | pos->next = BootList; |
| 305 | BootList = pos; |
| 306 | pos->priority = 0; |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 307 | } |
| 308 | |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 309 | // BEV (Boot Execution Vector) list |
Kevin O'Connor | 7bb1584 | 2010-12-29 11:25:14 -0500 | [diff] [blame] | 310 | struct bev_s { |
| 311 | int type; |
| 312 | u32 vector; |
| 313 | }; |
| 314 | static struct bev_s BEV[20]; |
| 315 | static int BEVCount; |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 316 | static int HaveHDBoot, HaveFDBoot; |
| 317 | |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 318 | static void |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 319 | add_bev(int type, u32 vector) |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 320 | { |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 321 | if (type == IPL_TYPE_HARDDISK && HaveHDBoot++) |
| 322 | return; |
| 323 | if (type == IPL_TYPE_FLOPPY && HaveFDBoot++) |
| 324 | return; |
Kevin O'Connor | 7bb1584 | 2010-12-29 11:25:14 -0500 | [diff] [blame] | 325 | if (BEVCount >= ARRAY_SIZE(BEV)) |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 326 | return; |
Kevin O'Connor | 7bb1584 | 2010-12-29 11:25:14 -0500 | [diff] [blame] | 327 | struct bev_s *bev = &BEV[BEVCount++]; |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 328 | bev->type = type; |
| 329 | bev->vector = vector; |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 330 | } |
| 331 | |
| 332 | // Prepare for boot - show menu and run bcvs. |
| 333 | void |
Kevin O'Connor | 1ca05b0 | 2010-01-03 17:43:37 -0500 | [diff] [blame] | 334 | boot_prep(void) |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 335 | { |
Kevin O'Connor | e438b0c | 2010-05-01 12:20:33 -0400 | [diff] [blame] | 336 | if (! CONFIG_BOOT) { |
| 337 | wait_threads(); |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 338 | return; |
Kevin O'Connor | e438b0c | 2010-05-01 12:20:33 -0400 | [diff] [blame] | 339 | } |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 340 | |
Kevin O'Connor | a5826b5 | 2009-10-24 17:57:29 -0400 | [diff] [blame] | 341 | // XXX - show available drives? |
| 342 | |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 343 | // Allow user to modify BCV/IPL order. |
| 344 | interactive_bootmenu(); |
Kevin O'Connor | e438b0c | 2010-05-01 12:20:33 -0400 | [diff] [blame] | 345 | wait_threads(); |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 346 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 347 | // Map drives and populate BEV list |
| 348 | struct bootentry_s *pos = BootList; |
| 349 | while (pos) { |
| 350 | switch (pos->type) { |
| 351 | case IPL_TYPE_BCV: |
| 352 | call_bcv(pos->vector.seg, pos->vector.offset); |
| 353 | add_bev(IPL_TYPE_HARDDISK, 0); |
| 354 | break; |
| 355 | case IPL_TYPE_FLOPPY: |
| 356 | map_floppy_drive(pos->drive); |
| 357 | add_bev(IPL_TYPE_FLOPPY, 0); |
| 358 | break; |
| 359 | case IPL_TYPE_HARDDISK: |
| 360 | map_hd_drive(pos->drive); |
| 361 | add_bev(IPL_TYPE_HARDDISK, 0); |
| 362 | break; |
| 363 | case IPL_TYPE_CDROM: |
| 364 | map_cd_drive(pos->drive); |
| 365 | // NO BREAK |
| 366 | default: |
| 367 | add_bev(pos->type, pos->data); |
| 368 | break; |
| 369 | } |
| 370 | pos = pos->next; |
| 371 | } |
Kevin O'Connor | afd0520 | 2009-08-16 12:21:44 -0400 | [diff] [blame] | 372 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 373 | // If nothing added a floppy/hd boot - add it manually. |
| 374 | add_bev(IPL_TYPE_FLOPPY, 0); |
| 375 | add_bev(IPL_TYPE_HARDDISK, 0); |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 376 | } |
| 377 | |
Kevin O'Connor | 9f4e1d9 | 2009-02-08 15:44:08 -0500 | [diff] [blame] | 378 | |
| 379 | /**************************************************************** |
| 380 | * Boot code (int 18/19) |
| 381 | ****************************************************************/ |
| 382 | |
Kevin O'Connor | 0a92412 | 2009-02-08 19:43:47 -0500 | [diff] [blame] | 383 | // Jump to a bootup entry point. |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 384 | static void |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 385 | call_boot_entry(struct segoff_s bootsegip, u8 bootdrv) |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 386 | { |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 387 | dprintf(1, "Booting from %04x:%04x\n", bootsegip.seg, bootsegip.offset); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 388 | struct bregs br; |
| 389 | memset(&br, 0, sizeof(br)); |
Kevin O'Connor | f8e800d | 2009-09-24 21:01:16 -0400 | [diff] [blame] | 390 | br.flags = F_IF; |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 391 | br.code = bootsegip; |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 392 | // Set the magic number in ax and the boot drive in dl. |
| 393 | br.dl = bootdrv; |
| 394 | br.ax = 0xaa55; |
| 395 | call16(&br); |
| 396 | } |
| 397 | |
| 398 | // Boot from a disk (either floppy or harddrive) |
| 399 | static void |
| 400 | boot_disk(u8 bootdrv, int checksig) |
| 401 | { |
| 402 | u16 bootseg = 0x07c0; |
| 403 | |
| 404 | // Read sector |
| 405 | struct bregs br; |
| 406 | memset(&br, 0, sizeof(br)); |
Kevin O'Connor | f8e800d | 2009-09-24 21:01:16 -0400 | [diff] [blame] | 407 | br.flags = F_IF; |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 408 | br.dl = bootdrv; |
| 409 | br.es = bootseg; |
| 410 | br.ah = 2; |
| 411 | br.al = 1; |
| 412 | br.cl = 1; |
| 413 | call16_int(0x13, &br); |
| 414 | |
| 415 | if (br.flags & F_CF) { |
| 416 | printf("Boot failed: could not read the boot disk\n\n"); |
| 417 | return; |
| 418 | } |
| 419 | |
| 420 | if (checksig) { |
| 421 | struct mbr_s *mbr = (void*)0; |
| 422 | if (GET_FARVAR(bootseg, mbr->signature) != MBR_SIGNATURE) { |
| 423 | printf("Boot failed: not a bootable disk\n\n"); |
| 424 | return; |
| 425 | } |
| 426 | } |
| 427 | |
| 428 | /* Canonicalize bootseg:bootip */ |
| 429 | u16 bootip = (bootseg & 0x0fff) << 4; |
| 430 | bootseg &= 0xf000; |
| 431 | |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 432 | call_boot_entry(SEGOFF(bootseg, bootip), bootdrv); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 433 | } |
| 434 | |
| 435 | // Boot from a CD-ROM |
| 436 | static void |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 437 | boot_cdrom(struct drive_s *drive_g) |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 438 | { |
| 439 | if (! CONFIG_CDROM_BOOT) |
| 440 | return; |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 441 | printf("Booting from DVD/CD...\n"); |
Gleb Natapov | 4c90a20 | 2010-12-07 13:50:54 +0200 | [diff] [blame] | 442 | |
Gleb Natapov | 4c90a20 | 2010-12-07 13:50:54 +0200 | [diff] [blame] | 443 | int status = cdrom_boot(drive_g); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 444 | if (status) { |
Kevin O'Connor | ecbcf77 | 2010-12-29 13:26:01 -0500 | [diff] [blame] | 445 | printf("Boot failed: Could not read from CDROM (code %04x)\n", status); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 446 | return; |
| 447 | } |
| 448 | |
| 449 | u16 ebda_seg = get_ebda_seg(); |
Kevin O'Connor | 669e644 | 2009-08-11 22:36:30 -0400 | [diff] [blame] | 450 | u8 bootdrv = GET_EBDA2(ebda_seg, cdemu.emulated_extdrive); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 451 | u16 bootseg = GET_EBDA2(ebda_seg, cdemu.load_segment); |
| 452 | /* Canonicalize bootseg:bootip */ |
| 453 | u16 bootip = (bootseg & 0x0fff) << 4; |
| 454 | bootseg &= 0xf000; |
| 455 | |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 456 | call_boot_entry(SEGOFF(bootseg, bootip), bootdrv); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 457 | } |
| 458 | |
Kevin O'Connor | e8f00ee | 2009-07-04 04:04:36 -0400 | [diff] [blame] | 459 | // Boot from a CBFS payload |
Kevin O'Connor | 6782344 | 2009-04-13 14:14:51 -0400 | [diff] [blame] | 460 | static void |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 461 | boot_cbfs(struct cbfs_file *file) |
Kevin O'Connor | 6782344 | 2009-04-13 14:14:51 -0400 | [diff] [blame] | 462 | { |
Kevin O'Connor | d9c9361 | 2010-03-20 11:00:45 -0400 | [diff] [blame] | 463 | if (!CONFIG_COREBOOT || !CONFIG_COREBOOT_FLASH) |
Kevin O'Connor | 6782344 | 2009-04-13 14:14:51 -0400 | [diff] [blame] | 464 | return; |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 465 | printf("Booting from CBFS...\n"); |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 466 | cbfs_run_payload(file); |
Kevin O'Connor | 6782344 | 2009-04-13 14:14:51 -0400 | [diff] [blame] | 467 | } |
| 468 | |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 469 | // Boot from a BEV entry on an optionrom. |
| 470 | static void |
| 471 | boot_rom(u32 vector) |
| 472 | { |
| 473 | printf("Booting from ROM...\n"); |
| 474 | struct segoff_s so; |
| 475 | so.segoff = vector; |
| 476 | call_boot_entry(so, 0); |
| 477 | } |
| 478 | |
| 479 | // Determine next boot method and attempt a boot using it. |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 480 | static void |
| 481 | do_boot(u16 seq_nr) |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 482 | { |
Kevin O'Connor | 4096702 | 2008-07-21 22:23:05 -0400 | [diff] [blame] | 483 | if (! CONFIG_BOOT) |
Kevin O'Connor | e07e18e | 2009-02-08 17:07:29 -0500 | [diff] [blame] | 484 | panic("Boot support not compiled in.\n"); |
Kevin O'Connor | 4096702 | 2008-07-21 22:23:05 -0400 | [diff] [blame] | 485 | |
Kevin O'Connor | 7bb1584 | 2010-12-29 11:25:14 -0500 | [diff] [blame] | 486 | if (seq_nr >= BEVCount) { |
Kevin O'Connor | ff8c141 | 2009-04-18 17:02:41 -0400 | [diff] [blame] | 487 | printf("No bootable device.\n"); |
| 488 | // Loop with irqs enabled - this allows ctrl+alt+delete to work. |
| 489 | for (;;) |
Kevin O'Connor | 9c447c3 | 2010-05-23 10:24:22 -0400 | [diff] [blame] | 490 | wait_irq(); |
Kevin O'Connor | 38fcbfe | 2008-02-25 22:30:47 -0500 | [diff] [blame] | 491 | } |
Kevin O'Connor | 38fcbfe | 2008-02-25 22:30:47 -0500 | [diff] [blame] | 492 | |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 493 | // Boot the given BEV type. |
Kevin O'Connor | 7bb1584 | 2010-12-29 11:25:14 -0500 | [diff] [blame] | 494 | struct bev_s *ie = &BEV[seq_nr]; |
Kevin O'Connor | cadaf0e | 2010-07-26 23:47:26 -0400 | [diff] [blame] | 495 | switch (ie->type) { |
Kevin O'Connor | f13b008 | 2008-08-17 11:26:42 -0400 | [diff] [blame] | 496 | case IPL_TYPE_FLOPPY: |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 497 | printf("Booting from Floppy...\n"); |
Kevin O'Connor | baaadb6 | 2010-12-29 11:18:04 -0500 | [diff] [blame] | 498 | boot_disk(0x00, CheckFloppySig); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 499 | break; |
Kevin O'Connor | f13b008 | 2008-08-17 11:26:42 -0400 | [diff] [blame] | 500 | case IPL_TYPE_HARDDISK: |
Kevin O'Connor | 72eee3e | 2010-12-27 19:07:49 -0500 | [diff] [blame] | 501 | printf("Booting from Hard Disk...\n"); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 502 | boot_disk(0x80, 1); |
Kevin O'Connor | 38fcbfe | 2008-02-25 22:30:47 -0500 | [diff] [blame] | 503 | break; |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 504 | case IPL_TYPE_CDROM: |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 505 | boot_cdrom((void*)ie->vector); |
Kevin O'Connor | 6782344 | 2009-04-13 14:14:51 -0400 | [diff] [blame] | 506 | break; |
| 507 | case IPL_TYPE_CBFS: |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 508 | boot_cbfs((void*)ie->vector); |
Kevin O'Connor | 71f036d | 2009-02-08 16:57:22 -0500 | [diff] [blame] | 509 | break; |
| 510 | case IPL_TYPE_BEV: |
Kevin O'Connor | f13a180 | 2010-12-29 11:52:33 -0500 | [diff] [blame] | 511 | boot_rom(ie->vector); |
Kevin O'Connor | 38fcbfe | 2008-02-25 22:30:47 -0500 | [diff] [blame] | 512 | break; |
Kevin O'Connor | 180a959 | 2008-03-04 22:50:53 -0500 | [diff] [blame] | 513 | } |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 514 | |
Kevin O'Connor | 38fcbfe | 2008-02-25 22:30:47 -0500 | [diff] [blame] | 515 | // Boot failed: invoke the boot recovery function |
Kevin O'Connor | 7af49bf | 2008-03-09 13:46:13 -0400 | [diff] [blame] | 516 | struct bregs br; |
| 517 | memset(&br, 0, sizeof(br)); |
Kevin O'Connor | f8e800d | 2009-09-24 21:01:16 -0400 | [diff] [blame] | 518 | br.flags = F_IF; |
Kevin O'Connor | 7af49bf | 2008-03-09 13:46:13 -0400 | [diff] [blame] | 519 | call16_int(0x18, &br); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 520 | } |
| 521 | |
| 522 | // Boot Failure recovery: try the next device. |
Kevin O'Connor | 52a300f | 2009-12-26 23:32:57 -0500 | [diff] [blame] | 523 | void VISIBLE32FLAT |
Kevin O'Connor | 1ca05b0 | 2010-01-03 17:43:37 -0500 | [diff] [blame] | 524 | handle_18(void) |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 525 | { |
Kevin O'Connor | 61d6b06 | 2008-06-21 12:15:10 -0400 | [diff] [blame] | 526 | debug_serial_setup(); |
Kevin O'Connor | 15c1f22 | 2008-06-12 22:59:43 -0400 | [diff] [blame] | 527 | debug_enter(NULL, DEBUG_HDL_18); |
Kevin O'Connor | 0881537 | 2008-12-29 21:16:31 -0500 | [diff] [blame] | 528 | u16 ebda_seg = get_ebda_seg(); |
| 529 | u16 seq = GET_EBDA2(ebda_seg, boot_sequence) + 1; |
| 530 | SET_EBDA2(ebda_seg, boot_sequence, seq); |
Kevin O'Connor | 7af49bf | 2008-03-09 13:46:13 -0400 | [diff] [blame] | 531 | do_boot(seq); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 532 | } |
| 533 | |
| 534 | // INT 19h Boot Load Service Entry Point |
Kevin O'Connor | 52a300f | 2009-12-26 23:32:57 -0500 | [diff] [blame] | 535 | void VISIBLE32FLAT |
Kevin O'Connor | 1ca05b0 | 2010-01-03 17:43:37 -0500 | [diff] [blame] | 536 | handle_19(void) |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 537 | { |
Kevin O'Connor | 61d6b06 | 2008-06-21 12:15:10 -0400 | [diff] [blame] | 538 | debug_serial_setup(); |
Kevin O'Connor | 15c1f22 | 2008-06-12 22:59:43 -0400 | [diff] [blame] | 539 | debug_enter(NULL, DEBUG_HDL_19); |
Kevin O'Connor | 0881537 | 2008-12-29 21:16:31 -0500 | [diff] [blame] | 540 | SET_EBDA(boot_sequence, 0); |
Kevin O'Connor | 7af49bf | 2008-03-09 13:46:13 -0400 | [diff] [blame] | 541 | do_boot(0); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 542 | } |