1 /* -*- linux-c -*- ------------------------------------------------------- * 2 * 3 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright 2007 rPath, Inc. - All Rights Reserved 5 * Copyright 2009 Intel Corporation; author H. Peter Anvin 6 * 7 * This file is part of the Linux kernel, and is made available under 8 * the terms of the GNU General Public License version 2. 9 * 10 * ----------------------------------------------------------------------- */ 11 12 /* 13 * Memory detection code 14 */ 15 16 #include "boot.h" 17 18 #define SMAP 0x534d4150 /* ASCII "SMAP" */ 19 20 static int detect_memory_e820(void) 21 { 22 int count = 0; 23 struct biosregs ireg, oreg; 24 struct boot_e820_entry *desc = boot_params.e820_table; 25 static struct boot_e820_entry buf; /* static so it is zeroed */ 26 27 initregs(&ireg); 28 ireg.ax = 0xe820; 29 ireg.cx = sizeof(buf); 30 ireg.edx = SMAP; 31 ireg.di = (size_t)&buf; 32 33 /* 34 * Note: at least one BIOS is known which assumes that the 35 * buffer pointed to by one e820 call is the same one as 36 * the previous call, and only changes modified fields. Therefore, 37 * we use a temporary buffer and copy the results entry by entry. 38 * 39 * This routine deliberately does not try to account for 40 * ACPI 3+ extended attributes. This is because there are 41 * BIOSes in the field which report zero for the valid bit for 42 * all ranges, and we don't currently make any use of the 43 * other attribute bits. Revisit this if we see the extended 44 * attribute bits deployed in a meaningful way in the future. 45 */ 46 47 do { 48 intcall(0x15, &ireg, &oreg); 49 ireg.ebx = oreg.ebx; /* for next iteration... */ 50 51 /* BIOSes which terminate the chain with CF = 1 as opposed 52 to %ebx = 0 don't always report the SMAP signature on 53 the final, failing, probe. */ 54 if (oreg.eflags & X86_EFLAGS_CF) 55 break; 56 57 /* Some BIOSes stop returning SMAP in the middle of 58 the search loop. We don't know exactly how the BIOS 59 screwed up the map at that point, we might have a 60 partial map, the full map, or complete garbage, so 61 just return failure. */ 62 if (oreg.eax != SMAP) { 63 count = 0; 64 break; 65 } 66 67 *desc++ = buf; 68 count++; 69 } while (ireg.ebx && count < ARRAY_SIZE(boot_params.e820_table)); 70 71 return boot_params.e820_entries = count; 72 } 73 74 static int detect_memory_e801(void) 75 { 76 struct biosregs ireg, oreg; 77 78 initregs(&ireg); 79 ireg.ax = 0xe801; 80 intcall(0x15, &ireg, &oreg); 81 82 if (oreg.eflags & X86_EFLAGS_CF) 83 return -1; 84 85 /* Do we really need to do this? */ 86 if (oreg.cx || oreg.dx) { 87 oreg.ax = oreg.cx; 88 oreg.bx = oreg.dx; 89 } 90 91 if (oreg.ax > 15*1024) { 92 return -1; /* Bogus! */ 93 } else if (oreg.ax == 15*1024) { 94 boot_params.alt_mem_k = (oreg.bx << 6) + oreg.ax; 95 } else { 96 /* 97 * This ignores memory above 16MB if we have a memory 98 * hole there. If someone actually finds a machine 99 * with a memory hole at 16MB and no support for 100 * 0E820h they should probably generate a fake e820 101 * map. 102 */ 103 boot_params.alt_mem_k = oreg.ax; 104 } 105 106 return 0; 107 } 108 109 static int detect_memory_88(void) 110 { 111 struct biosregs ireg, oreg; 112 113 initregs(&ireg); 114 ireg.ah = 0x88; 115 intcall(0x15, &ireg, &oreg); 116 117 boot_params.screen_info.ext_mem_k = oreg.ax; 118 119 return -(oreg.eflags & X86_EFLAGS_CF); /* 0 or -1 */ 120 } 121 122 int detect_memory(void) 123 { 124 int err = -1; 125 126 if (detect_memory_e820() > 0) 127 err = 0; 128 129 if (!detect_memory_e801()) 130 err = 0; 131 132 if (!detect_memory_88()) 133 err = 0; 134 135 return err; 136 } 137