From 77a65075a676d15daf81ad18b984090bbb76d838 Mon Sep 17 00:00:00 2001 From: Michael Brown Date: Wed, 24 May 2006 01:37:46 +0000 Subject: [PATCH] Replaced memsizes.c with smaller memmap.c, taking advantage of __data16, and creating a memory map that's easier to work with than the E820 map. --- src/arch/i386/firmware/pcbios/memmap.c | 214 +++++++++++++++++++++ src/arch/i386/firmware/pcbios/memsizes.c | 235 ----------------------- src/arch/i386/include/memmap.h | 23 +++ src/arch/i386/include/memsizes.h | 2 + 4 files changed, 239 insertions(+), 235 deletions(-) create mode 100644 src/arch/i386/firmware/pcbios/memmap.c delete mode 100644 src/arch/i386/firmware/pcbios/memsizes.c create mode 100644 src/arch/i386/include/memmap.h diff --git a/src/arch/i386/firmware/pcbios/memmap.c b/src/arch/i386/firmware/pcbios/memmap.c new file mode 100644 index 000000000..3e508fb1f --- /dev/null +++ b/src/arch/i386/firmware/pcbios/memmap.c @@ -0,0 +1,214 @@ +/* + * Copyright (C) 2006 Michael Brown . + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include + +/** + * @file + * + * Memory mapping + * + */ + +/** Magic value for INT 15,e820 calls */ +#define SMAP ( 0x534d4150 ) + +/** An INT 15,e820 memory map entry */ +struct e820_entry { + /** Start of region */ + uint64_t start; + /** Length of region */ + uint64_t len; + /** Type of region */ + uint32_t type; +} __attribute__ (( packed )); + +#define E820_TYPE_RAM 1 /**< Normal memory */ +#define E820_TYPE_RESERVED 2 /**< Reserved and unavailable */ +#define E820_TYPE_ACPI 3 /**< ACPI reclaim memory */ +#define E820_TYPE_NVS 4 /**< ACPI NVS memory */ + +/** Buffer for INT 15,e820 calls */ +static struct e820_entry __data16 ( e820buf ); +#define e820buf __use_data16 ( e820buf ) + +/** + * Get size of base memory from BIOS free base memory counter + * + * @ret basemem Base memory size, in kB + */ +static unsigned int basememsize ( void ) { + uint16_t basemem; + + get_real ( basemem, BDA_SEG, 0x0013 ); + DBG ( "Base memory size %dkB\n", basemem ); + return basemem; +} + +/** + * Get size of extended memory via INT 15,e801 + * + * @ret extmem Extended memory size, in kB, or 0 + */ +static unsigned int extmemsize_e801 ( void ) { + uint16_t extmem_1m_to_16m_k, extmem_16m_plus_64k; + uint16_t confmem_1m_to_16m_k, confmem_16m_plus_64k; + unsigned int flags; + unsigned int extmem; + + REAL_EXEC ( rm_mem_e801, + "int $0x15\n\t" + "pushfw\n\t" + "popw %w0\n\t", + 5, + OUT_CONSTRAINTS ( "=r" ( flags ), + "=a" ( extmem_1m_to_16m_k ), + "=b" ( extmem_16m_plus_64k ), + "=c" ( confmem_1m_to_16m_k ), + "=d" ( confmem_16m_plus_64k ) ), + IN_CONSTRAINTS ( "a" ( 0xe801 ) ), + CLOBBER ( "cc" ) ); + + if ( flags & CF ) + return 0; + + if ( ! ( extmem_1m_to_16m_k | extmem_16m_plus_64k ) ) { + extmem_1m_to_16m_k = confmem_1m_to_16m_k; + extmem_16m_plus_64k = confmem_16m_plus_64k; + } + + extmem = ( extmem_1m_to_16m_k + ( extmem_16m_plus_64k * 64 ) ); + DBG ( "Extended memory size %d+64*%d=%d kB\n", + extmem_1m_to_16m_k, extmem_16m_plus_64k, extmem ); + return extmem; +} + +/** + * Get size of extended memory via INT 15,88 + * + * @ret extmem Extended memory size, in kB + */ +static unsigned int extmemsize_88 ( void ) { + uint16_t extmem; + + REAL_EXEC ( rm_mem_88, + "int $0x15\n\t" + "jnc 1f\n\t" + "xorw %%ax, %%ax\n\t" + "\n1:\n\t", + 1, + OUT_CONSTRAINTS ( "=a" ( extmem ) ), + IN_CONSTRAINTS ( "a" ( 0x8800 ) ), + CLOBBER ( "cc" ) ); + + DBG ( "Extended memory size %d kB\n", extmem ); + return extmem; +} + +/** + * Get size of extended memory + * + * @ret extmem Extended memory size, in kB + */ +static unsigned int extmemsize ( void ) { + unsigned int extmem; + + /* Try INT 15,e801 first, then fall back to INT 15,88 */ + extmem = extmemsize_e801(); + if ( ! extmem ) + extmem = extmemsize_88(); + return extmem; +} + +/** + * Get e820 memory map + * + * @v memmap Memory map to fill in + * @v entries Maximum number of entries in memory map + * @ret rc Return status code + */ +static int meme820 ( struct memory_region *memmap, unsigned int entries ) { + unsigned int index = 0; + uint32_t next = 0; + uint32_t smap; + unsigned int flags; + unsigned int discard_c, discard_d, discard_D; + + do { + REAL_EXEC ( rm_mem_e820, + "int $0x15\n\t" + "pushfw\n\t" + "popw %w0\n\t", + 6, + OUT_CONSTRAINTS ( "=r" ( flags ), + "=a" ( smap ), + "=b" ( next ), + "=D" ( discard_D ), + "=c" ( discard_c ), + "=d" ( discard_d ) ), + IN_CONSTRAINTS ( "a" ( 0xe820 ), + "b" ( next ), + "D" ( &__from_data16 ( e820buf )), + "c" ( sizeof ( e820buf ) ), + "d" ( SMAP ) ), + CLOBBER ( "memory" ) ); + if ( smap != SMAP ) + return -ENOTSUP; + if ( flags & CF ) + break; + DBG ( "E820 region [%llx,%llx) type %d\n", e820buf.start, + ( e820buf.start + e820buf.len ), ( int ) e820buf.type ); + if ( e820buf.type != E820_TYPE_RAM ) + continue; + memmap[index].start = e820buf.start; + memmap[index].end = e820buf.start + e820buf.len; + index++; + } while ( ( index < entries ) && ( next != 0 ) ); + return 0; +} + +/** + * Get memory map + * + * @v memmap Memory map to fill in + * @v entries Maximum number of entries in memory map (minimum 2) + */ +void get_memmap ( struct memory_region *memmap, unsigned int entries ) { + unsigned int basemem, extmem; + int rc; + + /* Clear memory map */ + memset ( memmap, 0, ( entries * sizeof ( *memmap ) ) ); + + /* Get base and extended memory sizes */ + basemem = basememsize(); + extmem = extmemsize(); + + /* Try INT 15,e820 first */ + if ( ( rc = meme820 ( memmap, entries ) ) == 0 ) + return; + + /* Fall back to constructing a map from basemem and extmem sizes */ + memmap[0].end = ( basemem * 1024 ); + memmap[1].start = 0x100000; + memmap[1].end = 0x100000 + ( extmem * 1024 ); +} diff --git a/src/arch/i386/firmware/pcbios/memsizes.c b/src/arch/i386/firmware/pcbios/memsizes.c deleted file mode 100644 index 4cce53d7f..000000000 --- a/src/arch/i386/firmware/pcbios/memsizes.c +++ /dev/null @@ -1,235 +0,0 @@ -#include "stdint.h" -#include "stddef.h" -#include "realmode.h" -#include -#include "etherboot.h" -#include "memsizes.h" - -#define CF ( 1 << 0 ) - -/* by Eric Biederman */ - -struct meminfo meminfo; - -/************************************************************************** -BASEMEMSIZE - Get size of the conventional (base) memory -**************************************************************************/ -static unsigned short basememsize ( void ) { - uint16_t int12_basememsize, fbms_basememsize; - uint16_t basememsize; - - /* There are two methods for retrieving the base memory size: - * INT 12 and the BIOS FBMS counter at 40:13. We read both - * and use the smaller value, to be paranoid. - * - * We then store the smaller value in the BIOS FBMS counter so - * that other code (e.g. basemem.c) can rely on it and not - * have to use INT 12. This is especially important because - * basemem.c functions can be called in a context in which - * there is no real-mode stack (e.g. when trying to allocate - * memory for a real-mode stack...) - */ - - REAL_EXEC ( rm_basememsize, - "int $0x12\n\t", - 1, - OUT_CONSTRAINTS ( "=a" ( int12_basememsize ) ), - IN_CONSTRAINTS (), - CLOBBER ( "ebx", "ecx", "edx", "ebp", "esi", "edi" ) ); - - get_real ( fbms_basememsize, 0x40, 0x13 ); - - basememsize = ( int12_basememsize < fbms_basememsize ? - int12_basememsize : fbms_basememsize ); - - put_real ( basememsize, 0x40, 0x13 ); - - return basememsize; -} - -/************************************************************************** -MEMSIZE - Determine size of extended memory, in kB -**************************************************************************/ -static unsigned int memsize ( void ) { - uint16_t extmem_1m_to_16m_k, extmem_16m_plus_64k; - uint16_t confmem_1m_to_16m_k, confmem_16m_plus_64k; - uint16_t flags; - int memsize; - - /* Try INT 15,e801 first - * - * Some buggy BIOSes don't clear/set carry on pass/error of - * e801h memory size call or merely pass cx,dx through without - * changing them, so we set carry and zero cx,dx before call. - */ - REAL_EXEC ( rm_mem_e801, - "stc\n\t" - "int $0x15\n\t" - "pushfw\n\t" /* flags -> %di */ - "popw %%di\n\t", - 5, - OUT_CONSTRAINTS ( "=a" ( extmem_1m_to_16m_k ), - "=b" ( extmem_16m_plus_64k ), - "=c" ( confmem_1m_to_16m_k ), - "=d" ( confmem_16m_plus_64k ), - "=D" ( flags ) ), - IN_CONSTRAINTS ( "a" ( 0xe801 ), - "c" ( 0 ), - "d" ( 0 ) ), - CLOBBER ( "ebp", "esi" ) ); - - if ( ! ( flags & CF ) ) { - /* INT 15,e801 succeeded */ - if ( confmem_1m_to_16m_k || confmem_16m_plus_64k ) { - /* Use confmem (cx,dx) values */ - memsize = confmem_1m_to_16m_k + - ( confmem_16m_plus_64k << 6 ); - } else { - /* Use extmem (ax,bx) values */ - memsize = extmem_1m_to_16m_k + - ( extmem_16m_plus_64k << 6 ); - } - } else { - /* INT 15,e801 failed; fall back to INT 15,88 - * - * CF is apparently unreliable and should be ignored. - */ - REAL_EXEC ( rm_mem_88, - "int $0x15\n\t", - 1, - OUT_CONSTRAINTS ( "=a" ( extmem_1m_to_16m_k ) ), - IN_CONSTRAINTS ( "a" ( 0x88 << 8 ) ), - CLOBBER ( "ebx", "ecx", "edx", - "ebp", "esi", "edi" ) ); - memsize = extmem_1m_to_16m_k; - } - - return memsize; -} - -/************************************************************************** -MEME820 - Retrieve the E820 BIOS memory map -**************************************************************************/ -#define SMAP ( 0x534d4150 ) /* "SMAP" */ -static int meme820 ( struct e820entry *buf, int count ) { - int index; - uint16_t basemem_entry; - uint32_t smap, next; - uint16_t flags; - uint32_t discard_c, discard_d; - - index = 0; - next = 0; - do { - basemem_entry = BASEMEM_PARAMETER_INIT ( buf[index] ); - REAL_EXEC ( rm_mem_e820, - "int $0x15\n\t" - "pushfw\n\t" /* flags -> %di */ - "popw %%di\n\t", - 5, - OUT_CONSTRAINTS ( "=a" ( smap ), - "=b" ( next ), - "=c" ( discard_c ), - "=d" ( discard_d ), - "=D" ( flags ) ), - IN_CONSTRAINTS ( "a" ( 0xe820 ), - "b" ( next ), - "c" ( sizeof (struct e820entry) ), - "d" ( SMAP ), - "D" ( basemem_entry ) ), - CLOBBER ( "ebp", "esi" ) ); - BASEMEM_PARAMETER_DONE ( buf[index] ); - if ( smap != SMAP ) return 0; - if ( flags & CF ) break; - index++; - } while ( ( index < count ) && ( next != 0 ) ); - - return index; -} - -/************************************************************************** -GET_MEMSIZES - Retrieve the system memory map via any available means -**************************************************************************/ -void get_memsizes ( void ) { - /* Ensure we don't stomp bios data structutres. - * the interrupt table: 0x000 - 0x3ff - * the bios data area: 0x400 - 0x502 - * Dos variables: 0x502 - 0x5ff - */ - static const unsigned min_addr = 0x600; - unsigned i; - unsigned basemem; - - /* Retrieve memory information from the BIOS */ - meminfo.basememsize = basememsize(); - basemem = meminfo.basememsize << 10; - meminfo.memsize = memsize(); -#ifndef IGNORE_E820_MAP - meminfo.map_count = meme820 ( meminfo.map, E820MAX ); -#else - meminfo.map_count = 0; -#endif - - /* If we don't have an e820 memory map fake it */ - if ( meminfo.map_count == 0 ) { - meminfo.map_count = 2; - meminfo.map[0].addr = 0; - meminfo.map[0].size = meminfo.basememsize << 10; - meminfo.map[0].type = E820_RAM; - meminfo.map[1].addr = 1024*1024; - meminfo.map[1].size = meminfo.memsize << 10; - meminfo.map[1].type = E820_RAM; - } - - /* Scrub the e820 map */ - for ( i = 0; i < meminfo.map_count; i++ ) { - if ( meminfo.map[i].type != E820_RAM ) { - continue; - } - - /* Reserve the bios data structures */ - if ( meminfo.map[i].addr < min_addr ) { - unsigned long delta; - delta = min_addr - meminfo.map[i].addr; - if ( delta > meminfo.map[i].size ) { - delta = meminfo.map[i].size; - } - meminfo.map[i].addr = min_addr; - meminfo.map[i].size -= delta; - } - - /* Ensure the returned e820 map is in sync with the - * actual memory state - */ - if ( ( meminfo.map[i].addr < 0xa0000 ) && - (( meminfo.map[i].addr+meminfo.map[i].size ) > basemem )){ - if ( meminfo.map[i].addr <= basemem ) { - meminfo.map[i].size = basemem - - meminfo.map[i].addr; - } else { - meminfo.map[i].addr = basemem; - meminfo.map[i].size = 0; - } - } - } - -#ifdef DEBUG_MEMSIZES - printf ( "basememsize %d\n", meminfo.basememsize ); - printf ( "memsize %d\n", meminfo.memsize ); - printf ( "Memory regions(%d):\n", meminfo.map_count ); - for ( i = 0; i < meminfo.map_count; i++ ) { - unsigned long long r_start, r_end; - r_start = meminfo.map[i].addr; - r_end = r_start + meminfo.map[i].size; - printf ( "[%X%X, %X%X) type %d\n", - ( unsigned long ) ( r_start >> 32 ), - ( unsigned long ) r_start, - ( unsigned long ) ( r_end >> 32 ), - ( unsigned long ) r_end, - meminfo.map[i].type ); - } -#endif - -} - -INIT_FN ( INIT_MEMSIZES, get_memsizes, NULL, NULL ); diff --git a/src/arch/i386/include/memmap.h b/src/arch/i386/include/memmap.h new file mode 100644 index 000000000..19492247f --- /dev/null +++ b/src/arch/i386/include/memmap.h @@ -0,0 +1,23 @@ +#ifndef _MEMMAP_H +#define _MEMMAP_H + +#include + +/** + * @file + * + * Memory mapping + * + */ + +/** A usable memory region */ +struct memory_region { + /** Physical start address */ + uint64_t start; + /** Physical end address */ + uint64_t end; +}; + +extern void get_memmap ( struct memory_region *memmap, unsigned int entries ); + +#endif /* _MEMMAP_H */ diff --git a/src/arch/i386/include/memsizes.h b/src/arch/i386/include/memsizes.h index a5bb3f2df..e64009ea7 100644 --- a/src/arch/i386/include/memsizes.h +++ b/src/arch/i386/include/memsizes.h @@ -1,6 +1,8 @@ #ifndef MEMSIZES_H #define MEMSIZES_H +#warning "This header is no longer functional; use memmap.h instead" + /* * These structures seem to be very i386 (and, in fact, PCBIOS) * specific, so I've moved them out of etherboot.h.