src/arch/i386/firmware/pcbios/memmap.c

   1 /*
   2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <stdint.h>
  20 #include <errno.h>
  21 #include <realmode.h>
  22 #include <bios.h>
  23 #include <memsizes.h>
  24 #include <gpxe/memmap.h>
  25
  26 /**
  27  * @file
  28  *
  29  * Memory mapping
  30  *
  31  */
  32
  33 /** Magic value for INT 15,e820 calls */
  34 #define SMAP ( 0x534d4150 )
  35
  36 /** An INT 15,e820 memory map entry */
  37 struct e820_entry {
  38         /** Start of region */
  39         uint64_t start;
  40         /** Length of region */
  41         uint64_t len;
  42         /** Type of region */
  43         uint32_t type;
  44 } __attribute__ (( packed ));
  45
  46 #define E820_TYPE_RAM           1 /**< Normal memory */
  47 #define E820_TYPE_RESERVED      2 /**< Reserved and unavailable */
  48 #define E820_TYPE_ACPI          3 /**< ACPI reclaim memory */
  49 #define E820_TYPE_NVS           4 /**< ACPI NVS memory */
  50
  51 /** Buffer for INT 15,e820 calls */
  52 static struct e820_entry __bss16 ( e820buf );
  53 #define e820buf __use_data16 ( e820buf )
  54
  55 /**
  56  * Get size of extended memory via INT 15,e801
  57  *
  58  * @ret extmem          Extended memory size, in kB, or 0
  59  */
  60 static unsigned int extmemsize_e801 ( void ) {
  61         uint16_t extmem_1m_to_16m_k, extmem_16m_plus_64k;
  62         uint16_t confmem_1m_to_16m_k, confmem_16m_plus_64k;
  63         unsigned int flags;
  64         unsigned int extmem;
  65
  66         __asm__ __volatile__ ( REAL_CODE ( "stc\n\t"
  67                                            "int $0x15\n\t"
  68                                            "pushfw\n\t"
  69                                            "popw %w0\n\t" )
  70                                : "=r" ( flags ),
  71                                  "=a" ( extmem_1m_to_16m_k ),
  72                                  "=b" ( extmem_16m_plus_64k ),
  73                                  "=c" ( confmem_1m_to_16m_k ),
  74                                  "=d" ( confmem_16m_plus_64k )
  75                                : "a" ( 0xe801 ) );
  76
  77         if ( flags & CF ) {
  78                 DBG ( "INT 15,e801 failed with CF set\n" );
  79                 return 0;
  80         }
  81
  82         if ( ! ( extmem_1m_to_16m_k | extmem_16m_plus_64k ) ) {
  83                 DBG ( "INT 15,e801 extmem=0, using confmem\n" );
  84                 extmem_1m_to_16m_k = confmem_1m_to_16m_k;
  85                 extmem_16m_plus_64k = confmem_16m_plus_64k;
  86         }
  87
  88         extmem = ( extmem_1m_to_16m_k + ( extmem_16m_plus_64k * 64 ) );
  89         DBG ( "INT 15,e801 extended memory size %d+64*%d=%d kB "
  90               "[100000,%llx)\n", extmem_1m_to_16m_k, extmem_16m_plus_64k,
  91               extmem, ( 0x100000 + ( ( ( uint64_t ) extmem ) * 1024 ) ) );
  92         return extmem;
  93 }
  94
  95 /**
  96  * Get size of extended memory via INT 15,88
  97  *
  98  * @ret extmem          Extended memory size, in kB
  99  */
 100 static unsigned int extmemsize_88 ( void ) {
 101         uint16_t extmem;
 102
 103         /* Ignore CF; it is not reliable for this call */
 104         __asm__ __volatile__ ( REAL_CODE ( "int $0x15" )
 105                                : "=a" ( extmem ) : "a" ( 0x8800 ) );
 106
 107         DBG ( "INT 15,88 extended memory size %d kB [100000, %x)\n",
 108               extmem, ( 0x100000 + ( extmem * 1024 ) ) );
 109         return extmem;
 110 }
 111
 112 /**
 113  * Get size of extended memory
 114  *
 115  * @ret extmem          Extended memory size, in kB
 116  *
 117  * Note that this is only an approximation; for an accurate picture,
 118  * use the E820 memory map obtained via get_memmap();
 119  */
 120 unsigned int extmemsize ( void ) {
 121         unsigned int extmem;
 122
 123         /* Try INT 15,e801 first, then fall back to INT 15,88 */
 124         extmem = extmemsize_e801();
 125         if ( ! extmem )
 126                 extmem = extmemsize_88();
 127         return extmem;
 128 }
 129
 130 /**
 131  * Get e820 memory map
 132  *
 133  * @v memmap            Memory map to fill in
 134  * @ret rc              Return status code
 135  */
 136 static int meme820 ( struct memory_map *memmap ) {
 137         struct memory_region *region = memmap->regions;
 138         uint32_t next = 0;
 139         uint32_t smap;
 140         unsigned int flags;
 141         unsigned int discard_c, discard_d, discard_D;
 142
 143         do {
 144                 __asm__ __volatile__ ( REAL_CODE ( "stc\n\t"
 145                                                    "int $0x15\n\t"
 146                                                    "pushfw\n\t"
 147                                                    "popw %w0\n\t" )
 148                                        : "=r" ( flags ), "=a" ( smap ),
 149                                          "=b" ( next ), "=D" ( discard_D ),
 150                                          "=c" ( discard_c ), "=d" ( discard_d )
 151                                        : "a" ( 0xe820 ), "b" ( next ),
 152                                          "D" ( __from_data16 ( &e820buf ) ),
 153                                          "c" ( sizeof ( e820buf ) ),
 154                                          "d" ( SMAP )
 155                                        : "memory" );
 156
 157                 if ( smap != SMAP ) {
 158                         DBG ( "INT 15,e820 failed SMAP signature check\n" );
 159                         return -ENOTSUP;
 160                 }
 161
 162                 if ( flags & CF ) {
 163                         DBG ( "INT 15,e820 terminated on CF set\n" );
 164                         break;
 165                 }
 166
 167                 DBG ( "INT 15,e820 region [%llx,%llx) type %d\n",
 168                       e820buf.start, ( e820buf.start + e820buf.len ),
 169                       ( int ) e820buf.type );
 170                 if ( e820buf.type != E820_TYPE_RAM )
 171                         continue;
 172
 173                 region->start = e820buf.start;
 174                 region->end = e820buf.start + e820buf.len;
 175                 region++;
 176                 memmap->count++;
 177
 178                 if ( memmap->count >= ( sizeof ( memmap->regions ) /
 179                                         sizeof ( memmap->regions[0] ) ) ) {
 180                         DBG ( "INT 15,e820 too many regions returned\n" );
 181                         /* Not a fatal error; what we've got so far at
 182                          * least represents valid regions of memory,
 183                          * even if we couldn't get them all.
 184                          */
 185                         break;
 186                 }
 187         } while ( next != 0 );
 188
 189         return 0;
 190 }
 191
 192 /**
 193  * Get memory map
 194  *
 195  * @v memmap            Memory map to fill in
 196  */
 197 void get_memmap ( struct memory_map *memmap ) {
 198         unsigned int basemem, extmem;
 199         int rc;
 200
 201         DBG ( "Fetching system memory map\n" );
 202
 203         /* Clear memory map */
 204         memset ( memmap, 0, sizeof ( *memmap ) );
 205
 206         /* Get base and extended memory sizes */
 207         basemem = basememsize();
 208         DBG ( "FBMS base memory size %d kB [0,%x)\n",
 209               basemem, ( basemem * 1024 ) );
 210         extmem = extmemsize();
 211
 212         /* Try INT 15,e820 first */
 213         if ( ( rc = meme820 ( memmap ) ) == 0 ) {
 214                 DBG ( "Obtained system memory map via INT 15,e820\n" );
 215                 return;
 216         }
 217
 218         /* Fall back to constructing a map from basemem and extmem sizes */
 219         DBG ( "INT 15,e820 failed; constructing map\n" );
 220         memmap->regions[0].end = ( basemem * 1024 );
 221         memmap->regions[1].start = 0x100000;
 222         memmap->regions[1].end = 0x100000 + ( extmem * 1024 );
 223         memmap->count = 2;
 224 }