1 /* ----------------------------------------------------------------------- *
3 * Copyright 2001-2009 H. Peter Anvin - All Rights Reserved
4 * Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
5 * Portions copyright 2009-2010 Shao Miller
6 * [El Torito code, mBFT, "safe hook"]
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, Inc., 53 Temple Place Ste 330,
11 * Boston MA 02111-1307, USA; either version 2 of the License, or
12 * (at your option) any later version; incorporated herein by reference.
14 * ----------------------------------------------------------------------- */
18 #include <suffix_number.h>
25 #include "../version.h"
27 const char memdisk_version
[] = "MEMDISK " VERSION_STR
" " DATE
;
28 const char copyright
[] =
29 "Copyright " FIRSTYEAR
"-" YEAR_STR
" H. Peter Anvin et al";
31 extern const char _binary_memdisk_chs_512_bin_start
[];
32 extern const char _binary_memdisk_chs_512_bin_end
[];
33 extern const char _binary_memdisk_chs_512_bin_size
[];
34 extern const char _binary_memdisk_edd_512_bin_start
[];
35 extern const char _binary_memdisk_edd_512_bin_end
[];
36 extern const char _binary_memdisk_edd_512_bin_size
[];
37 extern const char _binary_memdisk_iso_512_bin_start
[];
38 extern const char _binary_memdisk_iso_512_bin_end
[];
39 extern const char _binary_memdisk_iso_512_bin_size
[];
40 extern const char _binary_memdisk_iso_2048_bin_start
[];
41 extern const char _binary_memdisk_iso_2048_bin_end
[];
42 extern const char _binary_memdisk_iso_2048_bin_size
[];
44 /* Pull in structures common to MEMDISK and MDISKCHK.COM */
47 /* An EDD disk packet */
49 uint8_t size
; /* Packet size */
50 uint8_t res1
; /* Reserved */
51 uint16_t count
; /* Count to transfer */
52 uint32_t buf
; /* Buffer pointer */
53 uint64_t start
; /* LBA to start from */
54 uint64_t buf64
; /* 64-bit buf pointer */
55 } __attribute__ ((packed
));
57 /* Change to 1 for El Torito debugging */
58 #define DBG_ELTORITO 0
61 extern void eltorito_dump(uint32_t);
65 * Routine to seek for a command-line item and return a pointer
66 * to the data portion, if present
69 /* Magic return values */
70 #define CMD_NOTFOUND ((char *)-1) /* Not found */
71 #define CMD_BOOL ((char *)-2) /* Found boolean option */
72 #define CMD_HASDATA(X) ((int)(X) >= 0)
74 static const char *getcmditem(const char *what
)
77 const char *wp
= what
;
80 for (p
= shdr
->cmdline
; *p
; p
++) {
82 case 0: /* Ground state */
90 case 1: /* Matching */
105 case 2: /* Mismatch, skip rest of option */
107 match
= 0; /* Next option */
112 /* Check for matching string at end of line */
113 if (match
== 1 && *wp
== '\0')
120 * Check to see if this is a gzip image
122 #define UNZIP_ALIGN 512
124 extern const char _end
[]; /* Symbol signalling end of data */
126 void unzip_if_needed(uint32_t * where_p
, uint32_t * size_p
)
128 uint32_t where
= *where_p
;
129 uint32_t size
= *size_p
;
131 uint32_t startrange
, endrange
;
132 uint32_t gzdatasize
, gzwhere
;
133 uint32_t orig_crc
, offset
;
137 /* Is it a gzip image? */
138 if (check_zip((void *)where
, size
, &zbytes
, &gzdatasize
,
139 &orig_crc
, &offset
) == 0) {
141 if (offset
+ zbytes
> size
) {
143 * Assertion failure; check_zip is supposed to guarantee this
146 die("internal error: check_zip returned nonsense\n");
150 * Find a good place to put it: search memory ranges in descending
151 * order until we find one that is legal and fits
154 for (i
= nranges
- 1; i
>= 0; i
--) {
156 * We can't use > 4G memory (32 bits only.) Truncate to 2^32-1
157 * so we don't have to deal with funny wraparound issues.
161 if (ranges
[i
].type
!= 1)
165 if (ranges
[i
].start
>= 0xFFFFFFFF)
168 startrange
= (uint32_t) ranges
[i
].start
;
170 /* Range end (0 for end means 2^64) */
171 endrange
= ((ranges
[i
+ 1].start
>= 0xFFFFFFFF ||
172 ranges
[i
+ 1].start
== 0)
173 ? 0xFFFFFFFF : (uint32_t) ranges
[i
+ 1].start
);
175 /* Make sure we don't overwrite ourselves */
176 if (startrange
< (uint32_t) _end
)
177 startrange
= (uint32_t) _end
;
179 /* Allow for alignment */
181 (ranges
[i
].start
+ (UNZIP_ALIGN
- 1)) & ~(UNZIP_ALIGN
- 1);
183 /* In case we just killed the whole range... */
184 if (startrange
>= endrange
)
188 * Must be large enough... don't rely on gzwhere for this
191 if (endrange
- startrange
< gzdatasize
)
195 * This is where the gz image would be put if we put it in this
198 gzwhere
= (endrange
- gzdatasize
) & ~(UNZIP_ALIGN
- 1);
200 /* Cast to uint64_t just in case we're flush with the top byte */
201 if ((uint64_t) where
+ size
>= gzwhere
&& where
< endrange
) {
203 * Need to move source data to avoid compressed/uncompressed
208 if (gzwhere
- startrange
< size
)
209 continue; /* Can't fit both old and new */
211 newwhere
= (gzwhere
- size
) & ~(UNZIP_ALIGN
- 1);
212 printf("Moving compressed data from 0x%08x to 0x%08x\n",
215 memmove((void *)newwhere
, (void *)where
, size
);
225 die("Not enough memory to decompress image (need 0x%08x bytes)\n",
228 printf("gzip image: decompressed addr 0x%08x, len 0x%08x: ",
231 *size_p
= gzdatasize
;
232 *where_p
= (uint32_t) unzip((void *)(where
+ offset
), zbytes
,
233 gzdatasize
, orig_crc
, (void *)target
);
238 * Figure out the "geometry" of the disk in question
241 uint32_t sectors
; /* Sector count */
242 uint32_t c
, h
, s
; /* C/H/S geometry */
243 uint32_t offset
; /* Byte offset for disk */
244 uint32_t boot_lba
; /* LBA of bootstrap code */
245 uint8_t type
; /* Type byte for INT 13h AH=08h */
246 uint8_t driveno
; /* Drive no */
247 uint8_t sector_shift
; /* Sector size as a power of 2 */
248 const char *hsrc
, *ssrc
; /* Origins of H and S geometries */
251 /* Format of a DOS partition table entry */
254 uint8_t start_h
, start_s
, start_c
;
256 uint8_t end_h
, end_s
, end_c
;
259 } __attribute__ ((packed
));
261 /* Format of a FAT filesystem superblock */
268 char bs_filsystype
[8];
269 } __attribute__ ((packed
));
271 uint8_t bs_jmpboot
[3];
273 uint16_t bpb_bytspersec
;
274 uint8_t bpb_secperclus
;
275 uint16_t bpb_rsvdseccnt
;
277 uint16_t bpb_rootentcnt
;
278 uint16_t bpb_totsec16
;
280 uint16_t bpb_fatsz16
;
281 uint16_t bpb_secpertrk
;
282 uint16_t bpb_numheads
;
283 uint32_t bpb_hiddsec
;
284 uint32_t bpb_totsec32
;
287 struct fat_extra extra
;
290 uint32_t bpb_fatsz32
;
291 uint16_t bpb_extflags
;
293 uint32_t bpb_rootclus
;
295 uint16_t bpb_bkbootsec
;
296 char bpb_reserved
[12];
297 /* Clever, eh? Same fields, different offset... */
298 struct fat_extra extra
;
299 } fat32
__attribute__ ((packed
));
301 } __attribute__ ((packed
));
303 /* Format of a DOSEMU header */
304 struct dosemu_header
{
305 uint8_t magic
[7]; /* DOSEMU\0 */
311 } __attribute__ ((packed
));
313 #define FOUR(a,b,c,d) (((a) << 24)|((b) << 16)|((c) << 8)|(d))
315 static const struct geometry
*get_disk_image_geometry(uint32_t where
,
318 static struct geometry hd_geometry
;
319 struct dosemu_header dosemu
;
320 unsigned int sectors
, xsectors
, v
;
325 printf("command line: %s\n", shdr
->cmdline
);
327 hd_geometry
.sector_shift
= 9; /* Assume floppy/HDD at first */
330 if (CMD_HASDATA(p
= getcmditem("offset")) && (v
= atou(p
)))
333 sectors
= xsectors
= (size
- offset
) >> hd_geometry
.sector_shift
;
335 hd_geometry
.hsrc
= "guess";
336 hd_geometry
.ssrc
= "guess";
337 hd_geometry
.sectors
= sectors
;
338 hd_geometry
.offset
= offset
;
340 if ((p
= getcmditem("iso")) != CMD_NOTFOUND
) {
342 eltorito_dump(where
);
344 struct edd4_bvd
*bvd
= (struct edd4_bvd
*)(where
+ 17 * 2048);
345 /* Tiny sanity check */
346 if ((bvd
->boot_rec_ind
!= 0) || (bvd
->ver
!= 1))
347 printf("El Torito BVD sanity check failed.\n");
348 struct edd4_bootcat
*boot_cat
=
349 (struct edd4_bootcat
*)(where
+ bvd
->boot_cat
* 2048);
350 /* Another tiny sanity check */
351 if ((boot_cat
->validation_entry
.platform_id
!= 0) ||
352 (boot_cat
->validation_entry
.key55
!= 0x55) ||
353 (boot_cat
->validation_entry
.keyAA
!= 0xAA))
354 printf("El Torito boot catalog sanity check failed.\n");
355 /* If we have an emulation mode, set the offset to the image */
356 if (boot_cat
->initial_entry
.media_type
)
357 hd_geometry
.offset
+= boot_cat
->initial_entry
.load_block
* 2048;
359 /* We're a no-emulation mode, so we will boot to an offset */
360 hd_geometry
.boot_lba
= boot_cat
->initial_entry
.load_block
* 4;
361 if (boot_cat
->initial_entry
.media_type
< 4) {
362 /* We're a floppy emulation mode or our params will be
363 * overwritten by the no emulation mode case
365 hd_geometry
.driveno
= 0x00;
369 switch (boot_cat
->initial_entry
.media_type
) {
370 case 0: /* No emulation */
371 hd_geometry
.driveno
= 0xE0;
372 hd_geometry
.type
= 10; /* ATAPI removable media device */
373 hd_geometry
.c
= 65535;
376 /* 2048-byte sectors, so adjust the size and count */
377 hd_geometry
.sector_shift
= 11;
379 case 1: /* 1.2 MB floppy */
381 hd_geometry
.type
= 2;
384 case 2: /* 1.44 MB floppy */
386 hd_geometry
.type
= 4;
389 case 3: /* 2.88 MB floppy */
391 hd_geometry
.type
= 6;
395 hd_geometry
.driveno
= 0x80;
396 hd_geometry
.type
= 0;
399 sectors
= (size
- hd_geometry
.offset
) >> hd_geometry
.sector_shift
;
401 /* For HDD emulation, we figure out the geometry later. Otherwise: */
403 hd_geometry
.hsrc
= hd_geometry
.ssrc
= "El Torito";
405 hd_geometry
.sectors
= sectors
;
408 /* Do we have a DOSEMU header? */
409 memcpy(&dosemu
, (char *)where
+ hd_geometry
.offset
, sizeof dosemu
);
410 if (!memcmp("DOSEMU", dosemu
.magic
, 7)) {
411 /* Always a hard disk unless overruled by command-line options */
412 hd_geometry
.driveno
= 0x80;
413 hd_geometry
.type
= 0;
414 hd_geometry
.c
= dosemu
.c
;
415 hd_geometry
.h
= dosemu
.h
;
416 hd_geometry
.s
= dosemu
.s
;
417 hd_geometry
.offset
+= dosemu
.offset
;
418 sectors
= (size
- hd_geometry
.offset
) >> hd_geometry
.sector_shift
;
420 hd_geometry
.hsrc
= hd_geometry
.ssrc
= "DOSEMU";
423 if (CMD_HASDATA(p
= getcmditem("c")) && (v
= atou(p
)))
425 if (CMD_HASDATA(p
= getcmditem("h")) && (v
= atou(p
))) {
427 hd_geometry
.hsrc
= "cmd";
429 if (CMD_HASDATA(p
= getcmditem("s")) && (v
= atou(p
))) {
431 hd_geometry
.ssrc
= "cmd";
434 if (!hd_geometry
.h
|| !hd_geometry
.s
) {
435 int h
, s
, max_h
, max_s
;
437 max_h
= hd_geometry
.h
;
438 max_s
= hd_geometry
.s
;
440 if (!(max_h
| max_s
)) {
441 /* Look for a FAT superblock and if we find something that looks
442 enough like one, use geometry from that. This takes care of
443 megafloppy images and unpartitioned hard disks. */
444 const struct fat_extra
*extra
= NULL
;
445 const struct fat_super
*fs
= (const struct fat_super
*)
446 ((char *)where
+ hd_geometry
.offset
);
448 if ((fs
->bpb_media
== 0xf0 || fs
->bpb_media
>= 0xf8) &&
449 (fs
->bs_jmpboot
[0] == 0xe9 || fs
->bs_jmpboot
[0] == 0xeb) &&
450 fs
->bpb_bytspersec
== 512 &&
451 fs
->bpb_numheads
>= 1 && fs
->bpb_numheads
<= 256 &&
452 fs
->bpb_secpertrk
>= 1 && fs
->bpb_secpertrk
<= 63) {
454 fs
->bpb_fatsz16
? &fs
->x
.fat16
.extra
: &fs
->x
.fat32
.extra
;
456 (extra
->bs_bootsig
== 0x29 && extra
->bs_filsystype
[0] == 'F'
457 && extra
->bs_filsystype
[1] == 'A'
458 && extra
->bs_filsystype
[2] == 'T'))
462 hd_geometry
.driveno
= extra
->bs_drvnum
& 0x80;
463 max_h
= fs
->bpb_numheads
;
464 max_s
= fs
->bpb_secpertrk
;
465 hd_geometry
.hsrc
= hd_geometry
.ssrc
= "FAT";
469 if (!(max_h
| max_s
)) {
470 /* No FAT filesystem found to steal geometry from... */
471 if ((sectors
< 4096 * 2) && (hd_geometry
.sector_shift
== 9)) {
473 unsigned int xsectors
= sectors
;
475 hd_geometry
.driveno
= 0; /* Assume floppy */
478 /* Assume it's a floppy drive, guess a geometry */
479 unsigned int type
, track
;
482 if (xsectors
< 320 * 2) {
486 } else if (xsectors
< 640 * 2) {
490 } else if (xsectors
< 1200 * 2) {
494 } else if (xsectors
< 1440 * 2) {
498 } else if (xsectors
< 2880 * 2) {
509 s
= xsectors
/ track
;
510 if (s
< 63 && (xsectors
% track
) == 0) {
520 hd_geometry
.hsrc
= hd_geometry
.ssrc
= "fd";
522 /* No valid floppy geometry, fake it by simulating broken
523 sectors at the end of the image... */
528 /* Assume it is a hard disk image and scan for a partition table */
529 const struct ptab_entry
*ptab
= (const struct ptab_entry
*)
530 ((char *)where
+ hd_geometry
.offset
+ (512 - 2 - 4 * 16));
532 /* Assume hard disk */
533 if (!hd_geometry
.driveno
)
534 hd_geometry
.driveno
= 0x80;
536 if (*(uint16_t *) ((char *)where
+ hd_geometry
.offset
+ 512 - 2) == 0xaa55) {
537 for (i
= 0; i
< 4; i
++) {
538 if (ptab
[i
].type
&& !(ptab
[i
].active
& 0x7f)) {
539 s
= (ptab
[i
].start_s
& 0x3f);
540 h
= ptab
[i
].start_h
+ 1;
547 s
= (ptab
[i
].end_s
& 0x3f);
548 h
= ptab
[i
].end_h
+ 1;
552 hd_geometry
.hsrc
= "MBR";
556 hd_geometry
.ssrc
= "MBR";
565 max_h
= xsectors
> 2097152 ? 255 : 64;
567 max_s
= xsectors
> 2097152 ? 63 : 32;
569 hd_geometry
.h
= max_h
;
570 hd_geometry
.s
= max_s
;
574 hd_geometry
.c
= xsectors
/ (hd_geometry
.h
* hd_geometry
.s
);
576 if ((p
= getcmditem("floppy")) != CMD_NOTFOUND
) {
577 hd_geometry
.driveno
= CMD_HASDATA(p
) ? atou(p
) & 0x7f : 0;
578 } else if ((p
= getcmditem("harddisk")) != CMD_NOTFOUND
) {
579 hd_geometry
.driveno
= CMD_HASDATA(p
) ? atou(p
) | 0x80 : 0x80;
582 if (hd_geometry
.driveno
& 0x80) {
583 hd_geometry
.type
= 0; /* Type = hard disk */
585 if (hd_geometry
.type
== 0)
586 hd_geometry
.type
= 0x10; /* ATAPI floppy, e.g. LS-120 */
589 if ((size
- hd_geometry
.offset
) & 0x1ff) {
590 puts("MEMDISK: Image has fractional end sector\n");
592 if (sectors
% (hd_geometry
.h
* hd_geometry
.s
)) {
593 puts("MEMDISK: Image seems to have fractional end cylinder\n");
595 if ((hd_geometry
.c
* hd_geometry
.h
* hd_geometry
.s
) > sectors
) {
596 puts("MEMDISK: Image appears to be truncated\n");
603 * Find a $PnP installation check structure; return (ES << 16) + DI value
605 static uint32_t pnp_install_check(void)
608 unsigned char *p
, csum
;
611 for (seg
= (uint32_t *) 0xf0000; seg
< (uint32_t *) 0x100000; seg
+= 4) {
612 if (*seg
== ('$' + ('P' << 8) + ('n' << 16) + ('P' << 24))) {
613 p
= (unsigned char *)seg
;
618 for (i
= len
; i
; i
--)
623 return (0xf000 << 16) + (uint16_t) (unsigned long)seg
;
631 * Relocate the real-mode code to a new segment
636 } __attribute__ ((packed
));
638 static void set_seg_base(uint32_t gdt_base
, int seg
, uint32_t v
)
640 *(uint16_t *) (gdt_base
+ seg
+ 2) = v
;
641 *(uint8_t *) (gdt_base
+ seg
+ 4) = v
>> 16;
642 *(uint8_t *) (gdt_base
+ seg
+ 7) = v
>> 24;
645 static void relocate_rm_code(uint32_t newbase
)
648 uint32_t oldbase
= rm_args
.rm_base
;
649 uint32_t delta
= newbase
- oldbase
;
652 memmove((void *)newbase
, (void *)oldbase
, rm_args
.rm_size
);
654 rm_args
.rm_return
+= delta
;
655 rm_args
.rm_intcall
+= delta
;
656 rm_args
.rm_bounce
+= delta
;
657 rm_args
.rm_base
+= delta
;
658 rm_args
.rm_gdt
+= delta
;
659 rm_args
.rm_pmjmp
+= delta
;
660 rm_args
.rm_rmjmp
+= delta
;
662 gdt_base
= rm_args
.rm_gdt
;
664 *(uint32_t *) (gdt_base
+ 2) = gdt_base
; /* GDT self-pointer */
666 /* Segments 0x10 and 0x18 are real-mode-based */
667 set_seg_base(gdt_base
, 0x10, rm_args
.rm_base
);
668 set_seg_base(gdt_base
, 0x18, rm_args
.rm_base
);
670 asm volatile ("lgdtl %0"::"m" (*(char *)gdt_base
));
672 *(uint32_t *) rm_args
.rm_pmjmp
+= delta
;
673 *(uint16_t *) rm_args
.rm_rmjmp
+= delta
>> 4;
675 rm_args
.rm_handle_interrupt
+= delta
;
680 static uint8_t checksum_buf(const void *buf
, int count
)
682 const uint8_t *p
= buf
;
691 static int stack_needed(void)
693 const unsigned int min_stack
= 128; /* Minimum stack size */
694 const unsigned int def_stack
= 512; /* Default stack size */
698 if (CMD_HASDATA(p
= getcmditem("stack")))
711 * Set max memory by reservation
712 * Adds reservations to data in INT15h to prevent access to the top of RAM
713 * if there's any above the point specified.
715 void setmaxmem(unsigned long long restop_ull
)
718 struct e820range
*ep
;
719 const int int15restype
= 2;
721 /* insertrange() works on uint32_t */
722 restop
= min(restop_ull
, UINT32_MAX
);
723 /* printf(" setmaxmem '%08x%08x' => %08x\n",
724 (unsigned int)(restop_ull>>32), (unsigned int)restop_ull, restop); */
726 for (ep
= ranges
; ep
->type
!= -1U; ep
++) {
727 if (ep
->type
== 1) { /* Only if available */
728 if (ep
->start
>= restop
) {
729 /* printf(" %08x -> 2\n", ep->start); */
730 ep
->type
= int15restype
;
731 } else if (ep
[1].start
> restop
) {
732 /* printf(" +%08x =2; cut %08x\n", restop, ep->start); */
733 insertrange(restop
, (ep
[1].start
- restop
), int15restype
);
740 struct real_mode_args rm_args
;
743 * Actual setup routine
744 * Returns the drive number (which is then passed in %dl to the
747 void setup(const struct real_mode_args
*rm_args_ptr
)
749 unsigned int bin_size
;
751 struct memdisk_header
*hptr
;
752 struct patch_area
*pptr
;
755 uint32_t driverptr
, driveraddr
;
758 const struct geometry
*geometry
;
759 unsigned int total_size
;
760 unsigned int cmdline_len
, stack_len
, e820_len
;
761 const struct edd4_bvd
*bvd
;
762 const struct edd4_bootcat
*boot_cat
= 0;
764 uint32_t ramdisk_image
, ramdisk_size
;
765 uint32_t boot_base
, rm_base
;
767 int do_edd
= 1; /* 0 = no, 1 = yes, default is yes */
768 int do_eltorito
= 0; /* default is no */
769 int no_bpt
; /* No valid BPT presented */
770 uint32_t boot_seg
= 0; /* Meaning 0000:7C00 */
771 uint32_t boot_len
= 512; /* One sector */
774 /* We need to copy the rm_args into their proper place */
775 memcpy(&rm_args
, rm_args_ptr
, sizeof rm_args
);
776 sti(); /* ... then interrupts are safe */
778 /* Show signs of life */
779 printf("%s %s\n", memdisk_version
, copyright
);
781 if (!shdr
->ramdisk_image
|| !shdr
->ramdisk_size
)
782 die("MEMDISK: No ramdisk image specified!\n");
784 ramdisk_image
= shdr
->ramdisk_image
;
785 ramdisk_size
= shdr
->ramdisk_size
;
787 e820map_init(); /* Initialize memory data structure */
788 get_mem(); /* Query BIOS for memory map */
789 parse_mem(); /* Parse memory map */
791 printf("Ramdisk at 0x%08x, length 0x%08x\n", ramdisk_image
, ramdisk_size
);
793 unzip_if_needed(&ramdisk_image
, &ramdisk_size
);
795 geometry
= get_disk_image_geometry(ramdisk_image
, ramdisk_size
);
797 if (getcmditem("edd") != CMD_NOTFOUND
||
798 getcmditem("ebios") != CMD_NOTFOUND
)
800 else if (getcmditem("noedd") != CMD_NOTFOUND
||
801 getcmditem("noebios") != CMD_NOTFOUND
||
802 getcmditem("cbios") != CMD_NOTFOUND
)
805 do_edd
= (geometry
->driveno
& 0x80) ? 1 : 0;
807 if (getcmditem("iso") != CMD_NOTFOUND
) {
809 do_edd
= 1; /* Mandatory */
812 /* Choose the appropriate installable memdisk hook */
814 if (geometry
->sector_shift
== 11) {
815 bin_size
= (int)&_binary_memdisk_iso_2048_bin_size
;
816 memdisk_hook
= (char *)&_binary_memdisk_iso_2048_bin_start
;
818 bin_size
= (int)&_binary_memdisk_iso_512_bin_size
;
819 memdisk_hook
= (char *)&_binary_memdisk_iso_512_bin_start
;
823 bin_size
= (int)&_binary_memdisk_edd_512_bin_size
;
824 memdisk_hook
= (char *)&_binary_memdisk_edd_512_bin_start
;
826 bin_size
= (int)&_binary_memdisk_chs_512_bin_size
;
827 memdisk_hook
= (char *)&_binary_memdisk_chs_512_bin_start
;
831 /* Reserve the ramdisk memory */
832 insertrange(ramdisk_image
, ramdisk_size
, 2);
833 parse_mem(); /* Recompute variables */
835 /* Figure out where it needs to go */
836 hptr
= (struct memdisk_header
*)memdisk_hook
;
837 pptr
= (struct patch_area
*)(memdisk_hook
+ hptr
->patch_offs
);
839 dosmem_k
= rdz_16(BIOS_BASEMEM
);
840 pptr
->mdi
.olddosmem
= dosmem_k
;
841 stddosmem
= dosmem_k
<< 10;
842 /* If INT 15 E820 and INT 12 disagree, go with the most conservative */
843 if (stddosmem
> dos_mem
)
846 pptr
->driveno
= geometry
->driveno
;
847 pptr
->drivetype
= geometry
->type
;
848 pptr
->cylinders
= geometry
->c
; /* Possible precision loss */
849 pptr
->heads
= geometry
->h
;
850 pptr
->sectors
= geometry
->s
;
851 pptr
->mdi
.disksize
= geometry
->sectors
;
852 pptr
->mdi
.diskbuf
= ramdisk_image
+ geometry
->offset
;
853 pptr
->mdi
.sector_shift
= geometry
->sector_shift
;
854 pptr
->statusptr
= (geometry
->driveno
& 0x80) ? 0x474 : 0x441;
856 pptr
->mdi
.bootloaderid
= shdr
->type_of_loader
;
858 pptr
->configflags
= CONFIG_SAFEINT
; /* Default */
859 /* Set config flags */
860 if (getcmditem("ro") != CMD_NOTFOUND
) {
861 pptr
->configflags
|= CONFIG_READONLY
;
863 if (getcmditem("raw") != CMD_NOTFOUND
) {
864 pptr
->configflags
&= ~CONFIG_MODEMASK
;
865 pptr
->configflags
|= CONFIG_RAW
;
867 if (getcmditem("bigraw") != CMD_NOTFOUND
) {
868 pptr
->configflags
&= ~CONFIG_MODEMASK
;
869 pptr
->configflags
|= CONFIG_BIGRAW
| CONFIG_RAW
;
871 if (getcmditem("int") != CMD_NOTFOUND
) {
872 pptr
->configflags
&= ~CONFIG_MODEMASK
;
873 /* pptr->configflags |= 0; */
875 if (getcmditem("safeint") != CMD_NOTFOUND
) {
876 pptr
->configflags
&= ~CONFIG_MODEMASK
;
877 pptr
->configflags
|= CONFIG_SAFEINT
;
880 printf("Disk is %s%d, %u%s K, C/H/S = %u/%u/%u (%s/%s), EDD %s, %s\n",
881 (geometry
->driveno
& 0x80) ? "hd" : "fd",
882 geometry
->driveno
& 0x7f,
883 geometry
->sectors
>> 1,
884 (geometry
->sectors
& 1) ? ".5" : "",
885 geometry
->c
, geometry
->h
, geometry
->s
,
886 geometry
->hsrc
, geometry
->ssrc
,
887 do_edd
? "on" : "off",
888 pptr
->configflags
& CONFIG_READONLY
? "ro" : "rw");
891 switch (pptr
->configflags
& CONFIG_MODEMASK
) {
893 puts("standard INT 15h");
896 puts("safe INT 15h");
901 case CONFIG_RAW
| CONFIG_BIGRAW
:
902 puts("big real mode raw");
905 printf("unknown %#x", pptr
->configflags
& CONFIG_MODEMASK
);
908 puts(" access to high memory\n");
910 /* Set up a drive parameter table */
911 if (geometry
->driveno
& 0x80) {
913 pptr
->dpt
.hd
.max_cyl
= geometry
->c
- 1;
914 pptr
->dpt
.hd
.max_head
= geometry
->h
- 1;
915 pptr
->dpt
.hd
.ctrl
= (geometry
->h
> 8) ? 0x08 : 0;
917 /* Floppy - most of these fields are bogus and mimic
918 a 1.44 MB floppy drive */
919 pptr
->dpt
.fd
.specify1
= 0xdf;
920 pptr
->dpt
.fd
.specify2
= 0x02;
921 pptr
->dpt
.fd
.delay
= 0x25;
922 pptr
->dpt
.fd
.sectors
= geometry
->s
;
923 pptr
->dpt
.fd
.bps
= 0x02;
924 pptr
->dpt
.fd
.isgap
= 0x12;
925 pptr
->dpt
.fd
.dlen
= 0xff;
926 pptr
->dpt
.fd
.fgap
= 0x6c;
927 pptr
->dpt
.fd
.ffill
= 0xf6;
928 pptr
->dpt
.fd
.settle
= 0x0f;
929 pptr
->dpt
.fd
.mstart
= 0x05;
930 pptr
->dpt
.fd
.maxtrack
= geometry
->c
- 1;
931 pptr
->dpt
.fd
.cmos
= geometry
->type
> 5 ? 5 : geometry
->type
;
933 pptr
->dpt
.fd
.old_fd_dpt
= rdz_32(BIOS_INT1E
);
936 /* Set up an EDD drive parameter table */
938 pptr
->edd_dpt
.sectors
= geometry
->sectors
;
939 /* The EDD spec has this as <= 15482880 sectors (1024x240x63);
940 this seems to make very little sense. Try for something saner. */
941 if (geometry
->c
<= 1024 && geometry
->h
<= 255 && geometry
->s
<= 63) {
942 pptr
->edd_dpt
.c
= geometry
->c
;
943 pptr
->edd_dpt
.h
= geometry
->h
;
944 pptr
->edd_dpt
.s
= geometry
->s
;
945 /* EDD-4 states that invalid geometry should be returned
946 * for INT 0x13, AH=0x48 "EDD Get Disk Parameters" call on an
947 * El Torito ODD. Check for 2048-byte sector size
949 if (geometry
->sector_shift
!= 11)
950 pptr
->edd_dpt
.flags
|= 0x0002; /* Geometry valid */
952 if (!(geometry
->driveno
& 0x80)) {
953 /* Floppy drive. Mark it as a removable device with
954 media change notification; media is present. */
955 pptr
->edd_dpt
.flags
|= 0x0014;
958 pptr
->edd_dpt
.devpath
[0] = pptr
->mdi
.diskbuf
;
959 pptr
->edd_dpt
.chksum
= -checksum_buf(&pptr
->edd_dpt
.dpikey
, 73 - 30);
963 bvd
= (struct edd4_bvd
*)(ramdisk_image
+ 17 * 2048);
965 (struct edd4_bootcat
*)(ramdisk_image
+ bvd
->boot_cat
* 2048);
966 pptr
->cd_pkt
.type
= boot_cat
->initial_entry
.media_type
; /* Cheat */
967 pptr
->cd_pkt
.driveno
= geometry
->driveno
;
968 pptr
->cd_pkt
.start
= boot_cat
->initial_entry
.load_block
;
969 boot_seg
= pptr
->cd_pkt
.load_seg
= boot_cat
->initial_entry
.load_seg
;
970 pptr
->cd_pkt
.sect_count
= boot_cat
->initial_entry
.sect_count
;
971 boot_len
= pptr
->cd_pkt
.sect_count
* 512;
972 pptr
->cd_pkt
.geom1
= (uint8_t)(pptr
->cylinders
) & 0xFF;
974 (uint8_t)(pptr
->sectors
) | (uint8_t)((pptr
->cylinders
>> 2) & 0xC0);
975 pptr
->cd_pkt
.geom3
= (uint8_t)(pptr
->heads
);
978 if ((p
= getcmditem("mem")) != CMD_NOTFOUND
) {
979 setmaxmem(suffix_number(p
));
982 /* The size is given by hptr->total_size plus the size of the E820
983 map -- 12 bytes per range; we may need as many as 2 additional
984 ranges (each insertrange() can worst-case turn 1 area into 3)
985 plus the terminating range, over what nranges currently show. */
986 total_size
= hptr
->total_size
; /* Actual memdisk code */
987 e820_len
= (nranges
+ 3) * sizeof(ranges
[0]);
988 total_size
+= e820_len
; /* E820 memory ranges */
989 cmdline_len
= strlen(shdr
->cmdline
) + 1;
990 total_size
+= cmdline_len
; /* Command line */
991 stack_len
= stack_needed();
992 total_size
+= stack_len
; /* Stack */
993 printf("Code %u, meminfo %u, cmdline %u, stack %u\n",
994 hptr
->total_size
, e820_len
, cmdline_len
, stack_len
);
995 printf("Total size needed = %u bytes, allocating %uK\n",
996 total_size
, (total_size
+ 0x3ff) >> 10);
998 if (total_size
> dos_mem
)
999 die("MEMDISK: Insufficient low memory\n");
1001 driveraddr
= stddosmem
- total_size
;
1002 driveraddr
&= ~0x3FF;
1004 printf("Old dos memory at 0x%05x (map says 0x%05x), loading at 0x%05x\n",
1005 stddosmem
, dos_mem
, driveraddr
);
1007 /* Reserve this range of memory */
1008 wrz_16(BIOS_BASEMEM
, driveraddr
>> 10);
1009 insertrange(driveraddr
, dos_mem
- driveraddr
, 2);
1012 pptr
->mem1mb
= low_mem
>> 10;
1013 pptr
->mem16mb
= high_mem
>> 16;
1014 if (low_mem
== (15 << 20)) {
1015 /* lowmem maxed out */
1016 uint32_t int1588mem
= (high_mem
>> 10) + (low_mem
>> 10);
1017 pptr
->memint1588
= (int1588mem
> 0xffff) ? 0xffff : int1588mem
;
1019 pptr
->memint1588
= low_mem
>> 10;
1022 printf("1588: 0x%04x 15E801: 0x%04x 0x%04x\n",
1023 pptr
->memint1588
, pptr
->mem1mb
, pptr
->mem16mb
);
1025 driverseg
= driveraddr
>> 4;
1026 driverptr
= driverseg
<< 16;
1028 /* Anything beyond the end is for the stack */
1029 pptr
->mystack
= (uint16_t) (stddosmem
- driveraddr
);
1031 pptr
->mdi
.oldint13
.uint32
= rdz_32(BIOS_INT13
);
1032 pptr
->mdi
.oldint15
.uint32
= rdz_32(BIOS_INT15
);
1034 /* Adjust the E820 table: if there are null ranges (type 0)
1035 at the end, change them to type end of list (-1).
1036 This is necessary for the driver to be able to report end
1037 of list correctly. */
1038 while (nranges
&& ranges
[nranges
- 1].type
== 0) {
1039 ranges
[--nranges
].type
= -1;
1042 if (getcmditem("nopassany") != CMD_NOTFOUND
) {
1043 printf("nopassany specified - we're the only drive of any kind\n");
1047 pptr
->mdi
.oldint13
.uint32
= driverptr
+ hptr
->iret_offs
;
1048 wrz_8(BIOS_EQUIP
, rdz_8(BIOS_EQUIP
) & ~0xc1);
1049 wrz_8(BIOS_HD_COUNT
, 0);
1050 } else if (getcmditem("nopass") != CMD_NOTFOUND
) {
1051 printf("nopass specified - we're the only drive\n");
1056 /* Query drive parameters of this type */
1057 memset(®s
, 0, sizeof regs
);
1059 regs
.eax
.b
[1] = 0x08;
1060 regs
.edx
.b
[0] = geometry
->driveno
& 0x80;
1061 intcall(0x13, ®s
, ®s
);
1063 /* Note: per suggestion from the Interrupt List, consider
1064 INT 13 08 to have failed if the sector count in CL is zero. */
1065 if ((regs
.eflags
.l
& 1) || !(regs
.ecx
.b
[0] & 0x3f)) {
1066 printf("INT 13 08: Failure, assuming this is the only drive\n");
1070 printf("INT 13 08: Success, count = %u, BPT = %04x:%04x\n",
1071 regs
.edx
.b
[0], regs
.es
, regs
.edi
.w
[0]);
1072 pptr
->drivecnt
= regs
.edx
.b
[0];
1073 no_bpt
= !(regs
.es
| regs
.edi
.w
[0]);
1076 /* Compare what INT 13h returned with the appropriate equipment byte */
1077 if (geometry
->driveno
& 0x80) {
1078 bios_drives
= rdz_8(BIOS_HD_COUNT
);
1080 uint8_t equip
= rdz_8(BIOS_EQUIP
);
1083 bios_drives
= (equip
>> 6) + 1;
1088 if (pptr
->drivecnt
> bios_drives
) {
1089 printf("BIOS equipment byte says count = %d, go with that\n",
1091 pptr
->drivecnt
= bios_drives
;
1095 /* Add ourselves to the drive count */
1098 /* Discontiguous drive space. There is no really good solution for this. */
1099 if (pptr
->drivecnt
<= (geometry
->driveno
& 0x7f))
1100 pptr
->drivecnt
= (geometry
->driveno
& 0x7f) + 1;
1102 /* Probe for contiguous range of BIOS drives starting with driveno */
1103 pptr
->driveshiftlimit
= probe_drive_range(geometry
->driveno
) + 1;
1104 if ((pptr
->driveshiftlimit
& 0x80) != (geometry
->driveno
& 0x80))
1105 printf("We lost the last drive in our class of drives.\n");
1106 printf("Drive probing gives drive shift limit: 0x%02x\n",
1107 pptr
->driveshiftlimit
);
1109 /* Pointer to the command line */
1110 pptr
->mdi
.cmdline
.seg_off
.offset
= bin_size
+ (nranges
+ 1) * sizeof(ranges
[0]);
1111 pptr
->mdi
.cmdline
.seg_off
.segment
= driverseg
;
1113 /* Copy driver followed by E820 table followed by command line */
1115 unsigned char *dpp
= (unsigned char *)(driverseg
<< 4);
1117 /* Adjust these pointers to point to the installed image */
1118 /* Careful about the order here... the image isn't copied yet! */
1119 pptr
= (struct patch_area
*)(dpp
+ hptr
->patch_offs
);
1120 hptr
= (struct memdisk_header
*)dpp
;
1122 /* Actually copy to low memory */
1123 dpp
= mempcpy(dpp
, memdisk_hook
, bin_size
);
1124 dpp
= mempcpy(dpp
, ranges
, (nranges
+ 1) * sizeof(ranges
[0]));
1125 dpp
= mempcpy(dpp
, shdr
->cmdline
, cmdline_len
);
1128 /* Note the previous INT 13h hook in the "safe hook" structure */
1129 hptr
->safe_hook
.old_hook
.uint32
= pptr
->mdi
.oldint13
.uint32
;
1131 /* Re-fill the "safe hook" mBFT field with the physical address */
1132 mbft
= (struct mBFT
*)(((const char *)hptr
) + hptr
->safe_hook
.mbft
);
1133 hptr
->safe_hook
.mbft
= (size_t)mbft
;
1135 /* Update various BIOS magic data areas (gotta love this shit) */
1137 if (geometry
->driveno
& 0x80) {
1138 /* Update BIOS hard disk count */
1139 uint8_t nhd
= pptr
->drivecnt
;
1145 wrz_8(BIOS_HD_COUNT
, nhd
);
1147 /* Update BIOS floppy disk count */
1148 uint8_t equip
= rdz_8(BIOS_EQUIP
);
1149 uint8_t nflop
= pptr
->drivecnt
;
1151 if (nflop
> 4) /* Limit of equipment byte */
1156 equip
|= ((nflop
- 1) << 6) | 0x01;
1158 wrz_8(BIOS_EQUIP
, equip
);
1160 /* Install DPT pointer if this was the only floppy */
1161 if (getcmditem("dpt") != CMD_NOTFOUND
||
1162 ((nflop
== 1 || no_bpt
) && getcmditem("nodpt") == CMD_NOTFOUND
)) {
1163 /* Do install a replacement DPT into INT 1Eh */
1165 hptr
->patch_offs
+ offsetof(struct patch_area
, dpt
);
1169 /* Complete the mBFT */
1170 mbft
->acpi
.signature
[0] = 'm'; /* "mBFT" */
1171 mbft
->acpi
.signature
[1] = 'B';
1172 mbft
->acpi
.signature
[2] = 'F';
1173 mbft
->acpi
.signature
[3] = 'T';
1174 mbft
->safe_hook
= (size_t)&hptr
->safe_hook
;
1175 mbft
->acpi
.checksum
= -checksum_buf(mbft
, mbft
->acpi
.length
);
1177 /* Install the interrupt handlers */
1178 printf("old: int13 = %08x int15 = %08x int1e = %08x\n",
1179 rdz_32(BIOS_INT13
), rdz_32(BIOS_INT15
), rdz_32(BIOS_INT1E
));
1181 wrz_32(BIOS_INT13
, driverptr
+ hptr
->int13_offs
);
1182 wrz_32(BIOS_INT15
, driverptr
+ hptr
->int15_offs
);
1183 if (pptr
->mdi
.dpt_ptr
)
1184 wrz_32(BIOS_INT1E
, driverptr
+ pptr
->mdi
.dpt_ptr
);
1186 printf("new: int13 = %08x int15 = %08x int1e = %08x\n",
1187 rdz_32(BIOS_INT13
), rdz_32(BIOS_INT15
), rdz_32(BIOS_INT1E
));
1189 /* Figure out entry point */
1192 shdr
->sssp
= 0x7c00;
1193 shdr
->csip
= 0x7c00;
1195 boot_base
= boot_seg
<< 4;
1196 shdr
->sssp
= boot_seg
<< 16;
1197 shdr
->csip
= boot_seg
<< 16;
1200 /* Relocate the real-mode code to below the stub */
1201 rm_base
= (driveraddr
- rm_args
.rm_size
) & ~15;
1202 if (rm_base
< boot_base
+ boot_len
)
1203 die("MEMDISK: bootstrap too large to load\n");
1205 relocate_rm_code(rm_base
);
1207 /* Reboot into the new "disk" */
1208 puts("Loading boot sector... ");
1210 memcpy((void *)boot_base
,
1211 (char *)pptr
->mdi
.diskbuf
+ geometry
->boot_lba
* 512,
1214 if (getcmditem("pause") != CMD_NOTFOUND
) {
1215 puts("press any key to boot... ");
1217 intcall(0x16, ®s
, NULL
);
1220 puts("booting...\n");
1222 /* On return the assembly code will jump to the boot vector */
1223 shdr
->esdi
= pnp_install_check();
1224 shdr
->edx
= geometry
->driveno
;