com32/mboot/mem.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2007-2009 H. Peter Anvin - All Rights Reserved
   4  *   Copyright 2009 H. Peter Anvin - All Rights Reserved
   5  *
   6  *   Permission is hereby granted, free of charge, to any person
   7  *   obtaining a copy of this software and associated documentation
   8  *   files (the "Software"), to deal in the Software without
   9  *   restriction, including without limitation the rights to use,
  10  *   copy, modify, merge, publish, distribute, sublicense, and/or
  11  *   sell copies of the Software, and to permit persons to whom
  12  *   the Software is furnished to do so, subject to the following
  13  *   conditions:
  14  *
  15  *   The above copyright notice and this permission notice shall
  16  *   be included in all copies or substantial portions of the Software.
  17  *
  18  *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  20  *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21  *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  22  *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23  *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24  *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25  *   OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  * ----------------------------------------------------------------------- */
  28
  29 /*
  30  * mem.c
  31  *
  32  * Obtain a memory map for a Multiboot OS
  33  *
  34  * This differs from the libcom32 memory map functions in that it doesn't
  35  * attempt to filter out memory regions...
  36  */
  37
  38 #include "mboot.h"
  39 #include <com32.h>
  40
  41 struct e820_entry {
  42     uint64_t start;
  43     uint64_t len;
  44     uint32_t type;
  45 };
  46
  47 #define RANGE_ALLOC_BLOCK       128
  48
  49 static int mboot_scan_memory(struct AddrRangeDesc **ardp, uint32_t * dosmem)
  50 {
  51     com32sys_t ireg, oreg;
  52     struct e820_entry *e820buf;
  53     struct AddrRangeDesc *ard;
  54     size_t ard_count, ard_space;
  55     int rv = 0;
  56
  57     /* Use INT 12h to get DOS memory */
  58     __intcall(0x12, &__com32_zero_regs, &oreg);
  59     *dosmem = oreg.eax.w[0] << 10;
  60     if (*dosmem < 32 * 1024 || *dosmem > 640 * 1024) {
  61         /* INT 12h reports nonsense... now what? */
  62         uint16_t ebda_seg = *(uint16_t *) 0x40e;
  63         if (ebda_seg >= 0x8000 && ebda_seg < 0xa000)
  64             *dosmem = ebda_seg << 4;
  65         else
  66             *dosmem = 640 * 1024;       /* Hope for the best... */
  67     }
  68
  69     e820buf = lmalloc(sizeof(*e820buf));
  70     if (!e820buf)
  71         return 0;
  72
  73     /* Allocate initial space */
  74     *ardp = ard = malloc(RANGE_ALLOC_BLOCK * sizeof *ard);
  75     if (!ard)
  76         goto out;
  77
  78     ard_count = 0;
  79     ard_space = RANGE_ALLOC_BLOCK;
  80
  81     /* First try INT 15h AX=E820h */
  82     memset(&ireg, 0, sizeof ireg);
  83     ireg.eax.l = 0xe820;
  84     ireg.edx.l = 0x534d4150;
  85     /* ireg.ebx.l    = 0; */
  86     ireg.ecx.l = sizeof(*e820buf);
  87     ireg.es = SEG(e820buf);
  88     ireg.edi.w[0] = OFFS(e820buf);
  89     memset(e820buf, 0, sizeof *e820buf);
  90
  91     do {
  92         __intcall(0x15, &ireg, &oreg);
  93
  94         if ((oreg.eflags.l & EFLAGS_CF) ||
  95             (oreg.eax.l != 0x534d4150) || (oreg.ecx.l < 20))
  96             break;
  97
  98         if (ard_count >= ard_space) {
  99             ard_space += RANGE_ALLOC_BLOCK;
 100             *ardp = ard = realloc(ard, ard_space * sizeof *ard);
 101             if (!ard) {
 102                 rv = ard_count;
 103                 goto out;
 104             }
 105         }
 106
 107         ard[ard_count].size = 20;
 108         ard[ard_count].BaseAddr = e820buf->start;
 109         ard[ard_count].Length = e820buf->len;
 110         ard[ard_count].Type = e820buf->type;
 111         ard_count++;
 112
 113         ireg.ebx.l = oreg.ebx.l;
 114     } while (oreg.ebx.l);
 115
 116     if (ard_count) {
 117         rv = ard_count;
 118         goto out;
 119     };
 120
 121     ard[0].size = 20;
 122     ard[0].BaseAddr = 0;
 123     ard[0].Length = *dosmem << 10;
 124     ard[0].Type = 1;
 125
 126     /* Next try INT 15h AX=E801h */
 127     ireg.eax.w[0] = 0xe801;
 128     __intcall(0x15, &ireg, &oreg);
 129
 130     if (!(oreg.eflags.l & EFLAGS_CF) && oreg.ecx.w[0]) {
 131         ard[1].size = 20;
 132         ard[1].BaseAddr = 1 << 20;
 133         ard[1].Length = oreg.ecx.w[0] << 10;
 134         ard[1].Type = 1;
 135
 136         if (oreg.edx.w[0]) {
 137             ard[2].size = 20;
 138             ard[2].BaseAddr = 16 << 20;
 139             ard[2].Length = oreg.edx.w[0] << 16;
 140             ard[2].Type = 1;
 141             rv = 3;
 142         } else {
 143             rv = 2;
 144         }
 145
 146         goto out;
 147     }
 148
 149     /* Finally try INT 15h AH=88h */
 150     ireg.eax.w[0] = 0x8800;
 151     if (!(oreg.eflags.l & EFLAGS_CF) && oreg.eax.w[0]) {
 152         ard[1].size = 20;
 153         ard[1].BaseAddr = 1 << 20;
 154         ard[1].Length = oreg.ecx.w[0] << 10;
 155         ard[1].Type = 1;
 156         rv = 2;
 157         goto out;
 158     }
 159
 160     rv = 1;                     /* ... problematic ... */
 161 out:
 162     lfree(e820buf);
 163     return rv;
 164 }
 165
 166 void mboot_make_memmap(void)
 167 {
 168     int i, nmap;
 169     struct AddrRangeDesc *ard;
 170     uint32_t lowmem, highmem;
 171     uint32_t highrsvd;
 172
 173     /* Always report DOS memory as "lowmem", this may be overly conservative
 174        (e.g. if we're dropping PXE), but it should be *safe*... */
 175
 176     nmap = mboot_scan_memory(&ard, &lowmem);
 177
 178     highmem = 0x100000;
 179     highrsvd = 0xfff00000;
 180
 181 again:
 182     for (i = 0; i < nmap; i++) {
 183         uint64_t start, end;
 184
 185         start = ard[i].BaseAddr;
 186         end = start + ard[i].Length;
 187
 188         if (end < start)
 189             end = ~0ULL;
 190
 191         if (start & 0xffffffff00000000ULL)
 192             continue;           /* Not interested in 64-bit memory */
 193
 194         if (start < highmem)
 195             start = highmem;
 196
 197         if (end <= start)
 198             continue;
 199
 200         if (ard[i].Type == 1 && start == highmem) {
 201             highmem = end;
 202             goto again;
 203         } else if (ard[i].Type != 1 && start < highrsvd)
 204             highrsvd = start;
 205     }
 206
 207     if (highmem > highrsvd)
 208         highmem = highrsvd;
 209
 210     mbinfo.mem_lower = lowmem >> 10;
 211     mbinfo.mem_upper = (highmem - 0x100000) >> 10;
 212     mbinfo.flags |= MB_INFO_MEMORY;
 213
 214     /* The spec says this address should be +4, but Grub disagrees */
 215     mbinfo.mmap_addr = map_data(ard, nmap * sizeof *ard, 4, false);
 216     if (mbinfo.mmap_addr) {
 217         mbinfo.mmap_length = nmap * sizeof *ard;
 218         mbinfo.flags |= MB_INFO_MEM_MAP;
 219     }
 220 }