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 = __com32.cs_bounce;
  53     struct AddrRangeDesc *ard;
  54     size_t ard_count, ard_space;
  55
  56     /* Use INT 12h to get DOS memory */
  57     __intcall(0x12, &__com32_zero_regs, &oreg);
  58     *dosmem = oreg.eax.w[0] << 10;
  59     if (*dosmem < 32 * 1024 || *dosmem > 640 * 1024) {
  60         /* INT 12h reports nonsense... now what? */
  61         uint16_t ebda_seg = *(uint16_t *) 0x40e;
  62         if (ebda_seg >= 0x8000 && ebda_seg < 0xa000)
  63             *dosmem = ebda_seg << 4;
  64         else
  65             *dosmem = 640 * 1024;       /* Hope for the best... */
  66     }
  67
  68     /* Allocate initial space */
  69     *ardp = ard = malloc(RANGE_ALLOC_BLOCK * sizeof *ard);
  70     if (!ard)
  71         return 0;
  72
  73     ard_count = 0;
  74     ard_space = RANGE_ALLOC_BLOCK;
  75
  76     /* First try INT 15h AX=E820h */
  77     memset(&ireg, 0, sizeof ireg);
  78     ireg.eax.l = 0xe820;
  79     ireg.edx.l = 0x534d4150;
  80     /* ireg.ebx.l    = 0; */
  81     ireg.ecx.l = sizeof(*e820buf);
  82     ireg.es = SEG(e820buf);
  83     ireg.edi.w[0] = OFFS(e820buf);
  84     memset(e820buf, 0, sizeof *e820buf);
  85
  86     do {
  87         __intcall(0x15, &ireg, &oreg);
  88
  89         if ((oreg.eflags.l & EFLAGS_CF) ||
  90             (oreg.eax.l != 0x534d4150) || (oreg.ecx.l < 20))
  91             break;
  92
  93         if (ard_count >= ard_space) {
  94             ard_space += RANGE_ALLOC_BLOCK;
  95             *ardp = ard = realloc(ard, ard_space * sizeof *ard);
  96             if (!ard)
  97                 return ard_count;
  98         }
  99
 100         ard[ard_count].size = 20;
 101         ard[ard_count].BaseAddr = e820buf->start;
 102         ard[ard_count].Length = e820buf->len;
 103         ard[ard_count].Type = e820buf->type;
 104         ard_count++;
 105
 106         ireg.ebx.l = oreg.ebx.l;
 107     } while (oreg.ebx.l);
 108
 109     if (ard_count)
 110         return ard_count;
 111
 112     ard[0].size = 20;
 113     ard[0].BaseAddr = 0;
 114     ard[0].Length = *dosmem << 10;
 115     ard[0].Type = 1;
 116
 117     /* Next try INT 15h AX=E801h */
 118     ireg.eax.w[0] = 0xe801;
 119     __intcall(0x15, &ireg, &oreg);
 120
 121     if (!(oreg.eflags.l & EFLAGS_CF) && oreg.ecx.w[0]) {
 122         ard[1].size = 20;
 123         ard[1].BaseAddr = 1 << 20;
 124         ard[1].Length = oreg.ecx.w[0] << 10;
 125         ard[1].Type = 1;
 126
 127         if (oreg.edx.w[0]) {
 128             ard[2].size = 20;
 129             ard[2].BaseAddr = 16 << 20;
 130             ard[2].Length = oreg.edx.w[0] << 16;
 131             ard[2].Type = 1;
 132             return 3;
 133         } else {
 134             return 2;
 135         }
 136     }
 137
 138     /* Finally try INT 15h AH=88h */
 139     ireg.eax.w[0] = 0x8800;
 140     if (!(oreg.eflags.l & EFLAGS_CF) && oreg.eax.w[0]) {
 141         ard[1].size = 20;
 142         ard[1].BaseAddr = 1 << 20;
 143         ard[1].Length = oreg.ecx.w[0] << 10;
 144         ard[1].Type = 1;
 145         return 2;
 146     }
 147
 148     return 1;                   /* ... problematic ... */
 149 }
 150
 151 void mboot_make_memmap(void)
 152 {
 153     int i, nmap;
 154     struct AddrRangeDesc *ard;
 155     uint32_t lowmem, highmem;
 156     uint32_t highrsvd;
 157
 158     /* Always report DOS memory as "lowmem", this may be overly conservative
 159        (e.g. if we're dropping PXE), but it should be *safe*... */
 160
 161     nmap = mboot_scan_memory(&ard, &lowmem);
 162
 163     highmem = 0x100000;
 164     highrsvd = 0xfff00000;
 165
 166 again:
 167     for (i = 0; i < nmap; i++) {
 168         uint64_t start, end;
 169
 170         start = ard[i].BaseAddr;
 171         end = start + ard[i].Length;
 172
 173         if (end < start)
 174             end = ~0ULL;
 175
 176         if (start & 0xffffffff00000000ULL)
 177             continue;           /* Not interested in 64-bit memory */
 178
 179         if (start < highmem)
 180             start = highmem;
 181
 182         if (end <= start)
 183             continue;
 184
 185         if (ard[i].Type == 1 && start == highmem) {
 186             highmem = end;
 187             goto again;
 188         } else if (ard[i].Type != 1 && start < highrsvd)
 189             highrsvd = start;
 190     }
 191
 192     if (highmem > highrsvd)
 193         highmem = highrsvd;
 194
 195     mbinfo.mem_lower = lowmem >> 10;
 196     mbinfo.mem_upper = (highmem - 0x100000) >> 10;
 197     mbinfo.flags |= MB_INFO_MEMORY;
 198
 199     /* The spec says this address should be +4, but Grub disagrees */
 200     mbinfo.mmap_addr = map_data(ard, nmap * sizeof *ard, 4, false);
 201     if (mbinfo.mmap_addr) {
 202         mbinfo.mmap_length = nmap * sizeof *ard;
 203         mbinfo.flags |= MB_INFO_MEM_MAP;
 204     }
 205 }