Commit | Line | Data |
---|---|---|
2f36fa13 | 1 | /* |
1da177e4 LT |
2 | * Handle the memory map. |
3 | * The functions here do the job until bootmem takes over. | |
8059b2a2 VP |
4 | * |
5 | * Getting sanitize_e820_map() in sync with i386 version by applying change: | |
6 | * - Provisions for empty E820 memory regions (reported by certain BIOSes). | |
7 | * Alex Achenbach <xela@slit.de>, December 2002. | |
8 | * Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> | |
9 | * | |
1da177e4 | 10 | */ |
1da177e4 LT |
11 | #include <linux/kernel.h> |
12 | #include <linux/types.h> | |
13 | #include <linux/init.h> | |
14 | #include <linux/bootmem.h> | |
15 | #include <linux/ioport.h> | |
16 | #include <linux/string.h> | |
5f5609df | 17 | #include <linux/kexec.h> |
b9491ac8 | 18 | #include <linux/module.h> |
e8eff5ac | 19 | #include <linux/mm.h> |
74dfd666 | 20 | #include <linux/pfn.h> |
4a139a7f | 21 | #include <linux/pci.h> |
b9491ac8 | 22 | |
1a91023a | 23 | #include <asm/pgtable.h> |
1da177e4 LT |
24 | #include <asm/page.h> |
25 | #include <asm/e820.h> | |
26 | #include <asm/proto.h> | |
30c82645 | 27 | #include <asm/setup.h> |
2bc0414e | 28 | #include <asm/sections.h> |
718fc13b | 29 | #include <asm/kdebug.h> |
e44b7b75 | 30 | #include <asm/trampoline.h> |
1da177e4 | 31 | |
2f36fa13 | 32 | /* |
1da177e4 LT |
33 | * PFN of last memory page. |
34 | */ | |
2f36fa13 | 35 | unsigned long end_pfn; |
1da177e4 | 36 | |
2f36fa13 | 37 | /* |
67794292 TG |
38 | * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries. |
39 | * The direct mapping extends to max_pfn_mapped, so that we can directly access | |
1da177e4 | 40 | * apertures, ACPI and other tables without having to play with fixmaps. |
2f36fa13 | 41 | */ |
67794292 | 42 | unsigned long max_pfn_mapped; |
1da177e4 | 43 | |
2f36fa13 | 44 | /* |
1da177e4 LT |
45 | * Last pfn which the user wants to use. |
46 | */ | |
caff0710 | 47 | static unsigned long __initdata end_user_pfn = MAXMEM>>PAGE_SHIFT; |
1da177e4 | 48 | |
1da177e4 LT |
49 | /* |
50 | * Find the highest page frame number we have available | |
51 | */ | |
52 | unsigned long __init e820_end_of_ram(void) | |
53 | { | |
a91eea6d | 54 | unsigned long last_pfn; |
2f36fa13 | 55 | |
a91eea6d | 56 | last_pfn = find_max_pfn_with_active_regions(); |
2f36fa13 | 57 | |
c8c034ce YL |
58 | if (last_pfn > MAXMEM>>PAGE_SHIFT) |
59 | last_pfn = MAXMEM>>PAGE_SHIFT; | |
a91eea6d TG |
60 | if (last_pfn > end_user_pfn) |
61 | last_pfn = end_user_pfn; | |
1da177e4 | 62 | |
c8c034ce | 63 | printk(KERN_INFO "last_pfn = %lu\n", last_pfn); |
a91eea6d | 64 | return last_pfn; |
1da177e4 LT |
65 | } |
66 | ||
485761bd | 67 | /* |
1da177e4 LT |
68 | * Mark e820 reserved areas as busy for the resource manager. |
69 | */ | |
3def3d6d | 70 | void __init e820_reserve_resources(void) |
1da177e4 LT |
71 | { |
72 | int i; | |
01561264 YL |
73 | struct resource *res; |
74 | ||
75 | res = alloc_bootmem_low(sizeof(struct resource) * e820.nr_map); | |
1da177e4 | 76 | for (i = 0; i < e820.nr_map; i++) { |
1da177e4 LT |
77 | switch (e820.map[i].type) { |
78 | case E820_RAM: res->name = "System RAM"; break; | |
79 | case E820_ACPI: res->name = "ACPI Tables"; break; | |
80 | case E820_NVS: res->name = "ACPI Non-volatile Storage"; break; | |
81 | default: res->name = "reserved"; | |
82 | } | |
83 | res->start = e820.map[i].addr; | |
84 | res->end = res->start + e820.map[i].size - 1; | |
85 | res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; | |
3def3d6d | 86 | insert_resource(&iomem_resource, res); |
01561264 | 87 | res++; |
1da177e4 LT |
88 | } |
89 | } | |
90 | ||
3af044e0 | 91 | /* |
a91eea6d | 92 | * Finds an active region in the address range from start_pfn to last_pfn and |
3af044e0 DR |
93 | * returns its range in ei_startpfn and ei_endpfn for the e820 entry. |
94 | */ | |
95 | static int __init e820_find_active_region(const struct e820entry *ei, | |
96 | unsigned long start_pfn, | |
a91eea6d | 97 | unsigned long last_pfn, |
3af044e0 DR |
98 | unsigned long *ei_startpfn, |
99 | unsigned long *ei_endpfn) | |
100 | { | |
101 | *ei_startpfn = round_up(ei->addr, PAGE_SIZE) >> PAGE_SHIFT; | |
102 | *ei_endpfn = round_down(ei->addr + ei->size, PAGE_SIZE) >> PAGE_SHIFT; | |
103 | ||
104 | /* Skip map entries smaller than a page */ | |
105 | if (*ei_startpfn >= *ei_endpfn) | |
106 | return 0; | |
107 | ||
3af044e0 DR |
108 | /* Skip if map is outside the node */ |
109 | if (ei->type != E820_RAM || *ei_endpfn <= start_pfn || | |
a91eea6d | 110 | *ei_startpfn >= last_pfn) |
3af044e0 DR |
111 | return 0; |
112 | ||
113 | /* Check for overlaps */ | |
114 | if (*ei_startpfn < start_pfn) | |
115 | *ei_startpfn = start_pfn; | |
a91eea6d TG |
116 | if (*ei_endpfn > last_pfn) |
117 | *ei_endpfn = last_pfn; | |
3af044e0 DR |
118 | |
119 | /* Obey end_user_pfn to save on memmap */ | |
120 | if (*ei_startpfn >= end_user_pfn) | |
121 | return 0; | |
122 | if (*ei_endpfn > end_user_pfn) | |
123 | *ei_endpfn = end_user_pfn; | |
124 | ||
125 | return 1; | |
126 | } | |
127 | ||
5cb248ab MG |
128 | /* Walk the e820 map and register active regions within a node */ |
129 | void __init | |
130 | e820_register_active_regions(int nid, unsigned long start_pfn, | |
a91eea6d | 131 | unsigned long last_pfn) |
5cb248ab | 132 | { |
3af044e0 DR |
133 | unsigned long ei_startpfn; |
134 | unsigned long ei_endpfn; | |
5cb248ab | 135 | int i; |
5cb248ab | 136 | |
3af044e0 DR |
137 | for (i = 0; i < e820.nr_map; i++) |
138 | if (e820_find_active_region(&e820.map[i], | |
a91eea6d | 139 | start_pfn, last_pfn, |
3af044e0 DR |
140 | &ei_startpfn, &ei_endpfn)) |
141 | add_active_range(nid, ei_startpfn, ei_endpfn); | |
5cb248ab MG |
142 | } |
143 | ||
a7e96629 DR |
144 | /* |
145 | * Find the hole size (in bytes) in the memory range. | |
146 | * @start: starting address of the memory range to scan | |
147 | * @end: ending address of the memory range to scan | |
148 | */ | |
149 | unsigned long __init e820_hole_size(unsigned long start, unsigned long end) | |
150 | { | |
151 | unsigned long start_pfn = start >> PAGE_SHIFT; | |
a91eea6d | 152 | unsigned long last_pfn = end >> PAGE_SHIFT; |
2f36fa13 | 153 | unsigned long ei_startpfn, ei_endpfn, ram = 0; |
a7e96629 DR |
154 | int i; |
155 | ||
156 | for (i = 0; i < e820.nr_map; i++) { | |
157 | if (e820_find_active_region(&e820.map[i], | |
a91eea6d | 158 | start_pfn, last_pfn, |
a7e96629 DR |
159 | &ei_startpfn, &ei_endpfn)) |
160 | ram += ei_endpfn - ei_startpfn; | |
161 | } | |
162 | return end - start - (ram << PAGE_SHIFT); | |
163 | } | |
164 | ||
013d23e1 | 165 | static void early_panic(char *msg) |
1da177e4 | 166 | { |
8380aabb AK |
167 | early_printk(msg); |
168 | panic(msg); | |
169 | } | |
1da177e4 | 170 | |
746ef0cd | 171 | /* We're not void only for x86 32-bit compat */ |
b25e31ce | 172 | char *__init machine_specific_memory_setup(void) |
8380aabb | 173 | { |
746ef0cd | 174 | char *who = "BIOS-e820"; |
6e9bcc79 | 175 | int new_nr; |
1da177e4 LT |
176 | /* |
177 | * Try to copy the BIOS-supplied E820-map. | |
178 | * | |
179 | * Otherwise fake a memory map; one section from 0k->640k, | |
180 | * the next section from 1mb->appropriate_mem_k | |
181 | */ | |
6e9bcc79 | 182 | new_nr = boot_params.e820_entries; |
c3965bd1 PJ |
183 | sanitize_e820_map(boot_params.e820_map, |
184 | ARRAY_SIZE(boot_params.e820_map), | |
6e9bcc79 PJ |
185 | &new_nr); |
186 | boot_params.e820_entries = new_nr; | |
30c82645 | 187 | if (copy_e820_map(boot_params.e820_map, boot_params.e820_entries) < 0) |
8380aabb | 188 | early_panic("Cannot find a valid memory map"); |
1da177e4 | 189 | printk(KERN_INFO "BIOS-provided physical RAM map:\n"); |
746ef0cd GOC |
190 | e820_print_map(who); |
191 | ||
192 | /* In case someone cares... */ | |
193 | return who; | |
1da177e4 LT |
194 | } |
195 | ||
2c8c0e6b AK |
196 | static int __init parse_memopt(char *p) |
197 | { | |
198 | if (!p) | |
199 | return -EINVAL; | |
200 | end_user_pfn = memparse(p, &p); | |
2f36fa13 | 201 | end_user_pfn >>= PAGE_SHIFT; |
2c8c0e6b | 202 | return 0; |
2f36fa13 | 203 | } |
2c8c0e6b | 204 | early_param("mem", parse_memopt); |
1da177e4 | 205 | |
2c8c0e6b | 206 | static int userdef __initdata; |
1da177e4 | 207 | |
2c8c0e6b | 208 | static int __init parse_memmap_opt(char *p) |
69cda7b1 | 209 | { |
2c8c0e6b | 210 | char *oldp; |
69cda7b1 AM |
211 | unsigned long long start_at, mem_size; |
212 | ||
2c8c0e6b AK |
213 | if (!strcmp(p, "exactmap")) { |
214 | #ifdef CONFIG_CRASH_DUMP | |
2f36fa13 TG |
215 | /* |
216 | * If we are doing a crash dump, we still need to know | |
217 | * the real mem size before original memory map is | |
2c8c0e6b AK |
218 | * reset. |
219 | */ | |
15803a43 | 220 | e820_register_active_regions(0, 0, -1UL); |
2c8c0e6b | 221 | saved_max_pfn = e820_end_of_ram(); |
15803a43 | 222 | remove_all_active_ranges(); |
2c8c0e6b | 223 | #endif |
2c8c0e6b AK |
224 | e820.nr_map = 0; |
225 | userdef = 1; | |
226 | return 0; | |
227 | } | |
228 | ||
229 | oldp = p; | |
230 | mem_size = memparse(p, &p); | |
231 | if (p == oldp) | |
232 | return -EINVAL; | |
b3ca74a2 VB |
233 | |
234 | userdef = 1; | |
69cda7b1 | 235 | if (*p == '@') { |
2c8c0e6b | 236 | start_at = memparse(p+1, &p); |
69cda7b1 AM |
237 | add_memory_region(start_at, mem_size, E820_RAM); |
238 | } else if (*p == '#') { | |
2c8c0e6b | 239 | start_at = memparse(p+1, &p); |
69cda7b1 AM |
240 | add_memory_region(start_at, mem_size, E820_ACPI); |
241 | } else if (*p == '$') { | |
2c8c0e6b | 242 | start_at = memparse(p+1, &p); |
69cda7b1 AM |
243 | add_memory_region(start_at, mem_size, E820_RESERVED); |
244 | } else { | |
245 | end_user_pfn = (mem_size >> PAGE_SHIFT); | |
246 | } | |
2c8c0e6b AK |
247 | return *p == '\0' ? 0 : -EINVAL; |
248 | } | |
249 | early_param("memmap", parse_memmap_opt); | |
250 | ||
43999d9e | 251 | void __init finish_e820_parsing(void) |
2c8c0e6b AK |
252 | { |
253 | if (userdef) { | |
6e9bcc79 | 254 | int nr = e820.nr_map; |
b3ca74a2 | 255 | |
c3965bd1 | 256 | if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0) |
b3ca74a2 VB |
257 | early_panic("Invalid user supplied memory map"); |
258 | e820.nr_map = nr; | |
259 | ||
2c8c0e6b AK |
260 | printk(KERN_INFO "user-defined physical RAM map:\n"); |
261 | e820_print_map("user"); | |
262 | } | |
69cda7b1 AM |
263 | } |
264 | ||
e820482c KA |
265 | int __init arch_get_ram_range(int slot, u64 *addr, u64 *size) |
266 | { | |
267 | int i; | |
268 | ||
269 | if (slot < 0 || slot >= e820.nr_map) | |
270 | return -1; | |
271 | for (i = slot; i < e820.nr_map; i++) { | |
272 | if (e820.map[i].type != E820_RAM) | |
273 | continue; | |
274 | break; | |
275 | } | |
276 | if (i == e820.nr_map || e820.map[i].addr > (max_pfn << PAGE_SHIFT)) | |
277 | return -1; | |
278 | *addr = e820.map[i].addr; | |
279 | *size = min_t(u64, e820.map[i].size + e820.map[i].addr, | |
280 | max_pfn << PAGE_SHIFT) - *addr; | |
281 | return i + 1; | |
282 | } |