]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - arch/x86/kernel/e820.c
Merge tag 'media/v4.1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[mirror_ubuntu-bionic-kernel.git] / arch / x86 / kernel / e820.c
CommitLineData
b79cd8f1
YL
1/*
2 * Handle the memory map.
3 * The functions here do the job until bootmem takes over.
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 *
10 */
11#include <linux/kernel.h>
12#include <linux/types.h>
13#include <linux/init.h>
93a72052 14#include <linux/crash_dump.h>
69c60c88 15#include <linux/export.h>
b79cd8f1 16#include <linux/bootmem.h>
b79cd8f1 17#include <linux/pfn.h>
bf62f398 18#include <linux/suspend.h>
976513db 19#include <linux/acpi.h>
5dfcf14d 20#include <linux/firmware-map.h>
72d7c3b3 21#include <linux/memblock.h>
d1bbdd66 22#include <linux/sort.h>
b79cd8f1 23
b79cd8f1 24#include <asm/e820.h>
a4c81cf6 25#include <asm/proto.h>
b79cd8f1
YL
26#include <asm/setup.h>
27
5dfcf14d
BW
28/*
29 * The e820 map is the map that gets modified e.g. with command line parameters
30 * and that is also registered with modifications in the kernel resource tree
31 * with the iomem_resource as parent.
32 *
33 * The e820_saved is directly saved after the BIOS-provided memory map is
34 * copied. It doesn't get modified afterwards. It's registered for the
35 * /sys/firmware/memmap interface.
36 *
37 * That memory map is not modified and is used as base for kexec. The kexec'd
38 * kernel should get the same memory map as the firmware provides. Then the
39 * user can e.g. boot the original kernel with mem=1G while still booting the
40 * next kernel with full memory.
41 */
b79cd8f1 42struct e820map e820;
5dfcf14d 43struct e820map e820_saved;
b79cd8f1
YL
44
45/* For PCI or other memory-mapped resources */
46unsigned long pci_mem_start = 0xaeedbabe;
47#ifdef CONFIG_PCI
48EXPORT_SYMBOL(pci_mem_start);
49#endif
50
51/*
52 * This function checks if any part of the range <start,end> is mapped
53 * with type.
54 */
55int
56e820_any_mapped(u64 start, u64 end, unsigned type)
57{
58 int i;
59
60 for (i = 0; i < e820.nr_map; i++) {
61 struct e820entry *ei = &e820.map[i];
62
63 if (type && ei->type != type)
64 continue;
65 if (ei->addr >= end || ei->addr + ei->size <= start)
66 continue;
67 return 1;
68 }
69 return 0;
70}
71EXPORT_SYMBOL_GPL(e820_any_mapped);
72
73/*
74 * This function checks if the entire range <start,end> is mapped with type.
75 *
76 * Note: this function only works correct if the e820 table is sorted and
77 * not-overlapping, which is the case
78 */
79int __init e820_all_mapped(u64 start, u64 end, unsigned type)
80{
81 int i;
82
83 for (i = 0; i < e820.nr_map; i++) {
84 struct e820entry *ei = &e820.map[i];
85
86 if (type && ei->type != type)
87 continue;
88 /* is the region (part) in overlap with the current region ?*/
89 if (ei->addr >= end || ei->addr + ei->size <= start)
90 continue;
91
92 /* if the region is at the beginning of <start,end> we move
93 * start to the end of the region since it's ok until there
94 */
95 if (ei->addr <= start)
96 start = ei->addr + ei->size;
97 /*
98 * if start is now at or beyond end, we're done, full
99 * coverage
100 */
101 if (start >= end)
102 return 1;
103 }
104 return 0;
105}
106
107/*
108 * Add a memory region to the kernel e820 map.
109 */
773e673d
YL
110static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size,
111 int type)
b79cd8f1 112{
773e673d 113 int x = e820x->nr_map;
b79cd8f1 114
5051fd69 115 if (x >= ARRAY_SIZE(e820x->map)) {
91eb0f67
BH
116 printk(KERN_ERR "e820: too many entries; ignoring [mem %#010llx-%#010llx]\n",
117 (unsigned long long) start,
118 (unsigned long long) (start + size - 1));
b79cd8f1
YL
119 return;
120 }
121
773e673d
YL
122 e820x->map[x].addr = start;
123 e820x->map[x].size = size;
124 e820x->map[x].type = type;
125 e820x->nr_map++;
126}
127
128void __init e820_add_region(u64 start, u64 size, int type)
129{
130 __e820_add_region(&e820, start, size, type);
b79cd8f1
YL
131}
132
c61cf4cf
YL
133static void __init e820_print_type(u32 type)
134{
135 switch (type) {
136 case E820_RAM:
137 case E820_RESERVED_KERN:
91eb0f67 138 printk(KERN_CONT "usable");
c61cf4cf
YL
139 break;
140 case E820_RESERVED:
91eb0f67 141 printk(KERN_CONT "reserved");
c61cf4cf
YL
142 break;
143 case E820_ACPI:
91eb0f67 144 printk(KERN_CONT "ACPI data");
c61cf4cf
YL
145 break;
146 case E820_NVS:
91eb0f67 147 printk(KERN_CONT "ACPI NVS");
c61cf4cf
YL
148 break;
149 case E820_UNUSABLE:
91eb0f67 150 printk(KERN_CONT "unusable");
c61cf4cf 151 break;
ec776ef6
CH
152 case E820_PRAM:
153 printk(KERN_CONT "persistent (type %u)", type);
154 break;
c61cf4cf
YL
155 default:
156 printk(KERN_CONT "type %u", type);
157 break;
158 }
159}
160
b79cd8f1
YL
161void __init e820_print_map(char *who)
162{
163 int i;
164
165 for (i = 0; i < e820.nr_map; i++) {
91eb0f67 166 printk(KERN_INFO "%s: [mem %#018Lx-%#018Lx] ", who,
b79cd8f1
YL
167 (unsigned long long) e820.map[i].addr,
168 (unsigned long long)
91eb0f67 169 (e820.map[i].addr + e820.map[i].size - 1));
c61cf4cf
YL
170 e820_print_type(e820.map[i].type);
171 printk(KERN_CONT "\n");
b79cd8f1
YL
172 }
173}
174
175/*
176 * Sanitize the BIOS e820 map.
177 *
178 * Some e820 responses include overlapping entries. The following
5b7eb2e9
PJ
179 * replaces the original e820 map with a new one, removing overlaps,
180 * and resolving conflicting memory types in favor of highest
181 * numbered type.
b79cd8f1 182 *
5b7eb2e9
PJ
183 * The input parameter biosmap points to an array of 'struct
184 * e820entry' which on entry has elements in the range [0, *pnr_map)
185 * valid, and which has space for up to max_nr_map entries.
186 * On return, the resulting sanitized e820 map entries will be in
187 * overwritten in the same location, starting at biosmap.
188 *
189 * The integer pointed to by pnr_map must be valid on entry (the
d574ffa1
WC
190 * current number of valid entries located at biosmap). If the
191 * sanitizing succeeds the *pnr_map will be updated with the new
192 * number of valid entries (something no more than max_nr_map).
5b7eb2e9
PJ
193 *
194 * The return value from sanitize_e820_map() is zero if it
195 * successfully 'sanitized' the map entries passed in, and is -1
196 * if it did nothing, which can happen if either of (1) it was
197 * only passed one map entry, or (2) any of the input map entries
198 * were invalid (start + size < start, meaning that the size was
199 * so big the described memory range wrapped around through zero.)
200 *
201 * Visually we're performing the following
202 * (1,2,3,4 = memory types)...
203 *
204 * Sample memory map (w/overlaps):
205 * ____22__________________
206 * ______________________4_
207 * ____1111________________
208 * _44_____________________
209 * 11111111________________
210 * ____________________33__
211 * ___________44___________
212 * __________33333_________
213 * ______________22________
214 * ___________________2222_
215 * _________111111111______
216 * _____________________11_
217 * _________________4______
218 *
219 * Sanitized equivalent (no overlap):
220 * 1_______________________
221 * _44_____________________
222 * ___1____________________
223 * ____22__________________
224 * ______11________________
225 * _________1______________
226 * __________3_____________
227 * ___________44___________
228 * _____________33_________
229 * _______________2________
230 * ________________1_______
231 * _________________4______
232 * ___________________2____
233 * ____________________33__
234 * ______________________4_
b79cd8f1 235 */
d1bbdd66
MD
236struct change_member {
237 struct e820entry *pbios; /* pointer to original bios entry */
238 unsigned long long addr; /* address for this change point */
239};
240
241static int __init cpcompare(const void *a, const void *b)
242{
243 struct change_member * const *app = a, * const *bpp = b;
244 const struct change_member *ap = *app, *bp = *bpp;
245
246 /*
247 * Inputs are pointers to two elements of change_point[]. If their
248 * addresses are unequal, their difference dominates. If the addresses
249 * are equal, then consider one that represents the end of its region
250 * to be greater than one that does not.
251 */
252 if (ap->addr != bp->addr)
253 return ap->addr > bp->addr ? 1 : -1;
254
255 return (ap->addr != ap->pbios->addr) - (bp->addr != bp->pbios->addr);
256}
5b7eb2e9 257
c3965bd1 258int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map,
ba639039 259 u32 *pnr_map)
b79cd8f1 260{
157fabf0
PJ
261 static struct change_member change_point_list[2*E820_X_MAX] __initdata;
262 static struct change_member *change_point[2*E820_X_MAX] __initdata;
263 static struct e820entry *overlap_list[E820_X_MAX] __initdata;
264 static struct e820entry new_bios[E820_X_MAX] __initdata;
b79cd8f1
YL
265 unsigned long current_type, last_type;
266 unsigned long long last_addr;
d1bbdd66 267 int chgidx;
b79cd8f1
YL
268 int overlap_entries;
269 int new_bios_entry;
270 int old_nr, new_nr, chg_nr;
271 int i;
272
b79cd8f1
YL
273 /* if there's only one memory region, don't bother */
274 if (*pnr_map < 2)
275 return -1;
276
277 old_nr = *pnr_map;
6e9bcc79 278 BUG_ON(old_nr > max_nr_map);
b79cd8f1
YL
279
280 /* bail out if we find any unreasonable addresses in bios map */
281 for (i = 0; i < old_nr; i++)
282 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
283 return -1;
284
285 /* create pointers for initial change-point information (for sorting) */
286 for (i = 0; i < 2 * old_nr; i++)
287 change_point[i] = &change_point_list[i];
288
289 /* record all known change-points (starting and ending addresses),
290 omitting those that are for empty memory regions */
291 chgidx = 0;
292 for (i = 0; i < old_nr; i++) {
293 if (biosmap[i].size != 0) {
294 change_point[chgidx]->addr = biosmap[i].addr;
295 change_point[chgidx++]->pbios = &biosmap[i];
296 change_point[chgidx]->addr = biosmap[i].addr +
297 biosmap[i].size;
298 change_point[chgidx++]->pbios = &biosmap[i];
299 }
300 }
301 chg_nr = chgidx;
302
303 /* sort change-point list by memory addresses (low -> high) */
706d9a9c 304 sort(change_point, chg_nr, sizeof *change_point, cpcompare, NULL);
b79cd8f1
YL
305
306 /* create a new bios memory map, removing overlaps */
307 overlap_entries = 0; /* number of entries in the overlap table */
308 new_bios_entry = 0; /* index for creating new bios map entries */
309 last_type = 0; /* start with undefined memory type */
310 last_addr = 0; /* start with 0 as last starting address */
311
312 /* loop through change-points, determining affect on the new bios map */
313 for (chgidx = 0; chgidx < chg_nr; chgidx++) {
314 /* keep track of all overlapping bios entries */
315 if (change_point[chgidx]->addr ==
316 change_point[chgidx]->pbios->addr) {
317 /*
318 * add map entry to overlap list (> 1 entry
319 * implies an overlap)
320 */
321 overlap_list[overlap_entries++] =
322 change_point[chgidx]->pbios;
323 } else {
324 /*
325 * remove entry from list (order independent,
326 * so swap with last)
327 */
328 for (i = 0; i < overlap_entries; i++) {
329 if (overlap_list[i] ==
330 change_point[chgidx]->pbios)
331 overlap_list[i] =
332 overlap_list[overlap_entries-1];
333 }
334 overlap_entries--;
335 }
336 /*
337 * if there are overlapping entries, decide which
338 * "type" to use (larger value takes precedence --
339 * 1=usable, 2,3,4,4+=unusable)
340 */
341 current_type = 0;
342 for (i = 0; i < overlap_entries; i++)
343 if (overlap_list[i]->type > current_type)
344 current_type = overlap_list[i]->type;
345 /*
346 * continue building up new bios map based on this
347 * information
348 */
ec776ef6 349 if (current_type != last_type || current_type == E820_PRAM) {
b79cd8f1
YL
350 if (last_type != 0) {
351 new_bios[new_bios_entry].size =
352 change_point[chgidx]->addr - last_addr;
353 /*
354 * move forward only if the new size
355 * was non-zero
356 */
357 if (new_bios[new_bios_entry].size != 0)
358 /*
359 * no more space left for new
360 * bios entries ?
361 */
c3965bd1 362 if (++new_bios_entry >= max_nr_map)
b79cd8f1
YL
363 break;
364 }
365 if (current_type != 0) {
366 new_bios[new_bios_entry].addr =
367 change_point[chgidx]->addr;
368 new_bios[new_bios_entry].type = current_type;
369 last_addr = change_point[chgidx]->addr;
370 }
371 last_type = current_type;
372 }
373 }
374 /* retain count for new bios entries */
375 new_nr = new_bios_entry;
376
377 /* copy new bios mapping into original location */
378 memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry));
379 *pnr_map = new_nr;
380
381 return 0;
382}
383
dc8e8120 384static int __init __append_e820_map(struct e820entry *biosmap, int nr_map)
8c5beb50
HY
385{
386 while (nr_map) {
387 u64 start = biosmap->addr;
388 u64 size = biosmap->size;
389 u64 end = start + size;
390 u32 type = biosmap->type;
391
392 /* Overflow in 64 bits? Ignore the memory map. */
393 if (start > end)
394 return -1;
395
396 e820_add_region(start, size, type);
397
398 biosmap++;
399 nr_map--;
400 }
401 return 0;
402}
403
b79cd8f1
YL
404/*
405 * Copy the BIOS e820 map into a safe place.
406 *
407 * Sanity-check it while we're at it..
408 *
409 * If we're lucky and live on a modern system, the setup code
410 * will have given us a memory map that we can use to properly
411 * set up memory. If we aren't, we'll fake a memory map.
412 */
dc8e8120 413static int __init append_e820_map(struct e820entry *biosmap, int nr_map)
b79cd8f1
YL
414{
415 /* Only one memory region (or negative)? Ignore it */
416 if (nr_map < 2)
417 return -1;
418
dc8e8120 419 return __append_e820_map(biosmap, nr_map);
b79cd8f1
YL
420}
421
773e673d 422static u64 __init __e820_update_range(struct e820map *e820x, u64 start,
fc9036ea
YL
423 u64 size, unsigned old_type,
424 unsigned new_type)
b79cd8f1 425{
78a8b35b 426 u64 end;
773e673d 427 unsigned int i;
b79cd8f1
YL
428 u64 real_updated_size = 0;
429
430 BUG_ON(old_type == new_type);
431
232b957a
YL
432 if (size > (ULLONG_MAX - start))
433 size = ULLONG_MAX - start;
434
78a8b35b 435 end = start + size;
91eb0f67
BH
436 printk(KERN_DEBUG "e820: update [mem %#010Lx-%#010Lx] ",
437 (unsigned long long) start, (unsigned long long) (end - 1));
c61cf4cf
YL
438 e820_print_type(old_type);
439 printk(KERN_CONT " ==> ");
440 e820_print_type(new_type);
441 printk(KERN_CONT "\n");
442
5c0e6f03 443 for (i = 0; i < e820x->nr_map; i++) {
fc9036ea 444 struct e820entry *ei = &e820x->map[i];
b79cd8f1 445 u64 final_start, final_end;
78a8b35b
YL
446 u64 ei_end;
447
b79cd8f1
YL
448 if (ei->type != old_type)
449 continue;
78a8b35b
YL
450
451 ei_end = ei->addr + ei->size;
452 /* totally covered by new range? */
453 if (ei->addr >= start && ei_end <= end) {
b79cd8f1
YL
454 ei->type = new_type;
455 real_updated_size += ei->size;
456 continue;
457 }
78a8b35b
YL
458
459 /* new range is totally covered? */
460 if (ei->addr < start && ei_end > end) {
461 __e820_add_region(e820x, start, size, new_type);
462 __e820_add_region(e820x, end, ei_end - end, ei->type);
463 ei->size = start - ei->addr;
464 real_updated_size += size;
465 continue;
466 }
467
b79cd8f1
YL
468 /* partially covered */
469 final_start = max(start, ei->addr);
78a8b35b 470 final_end = min(end, ei_end);
b79cd8f1
YL
471 if (final_start >= final_end)
472 continue;
5c0e6f03 473
773e673d
YL
474 __e820_add_region(e820x, final_start, final_end - final_start,
475 new_type);
5c0e6f03 476
b79cd8f1 477 real_updated_size += final_end - final_start;
976dd4dc 478
773e673d
YL
479 /*
480 * left range could be head or tail, so need to update
481 * size at first.
482 */
483 ei->size -= final_end - final_start;
976dd4dc
YL
484 if (ei->addr < final_start)
485 continue;
486 ei->addr = final_end;
b79cd8f1
YL
487 }
488 return real_updated_size;
489}
490
fc9036ea
YL
491u64 __init e820_update_range(u64 start, u64 size, unsigned old_type,
492 unsigned new_type)
493{
773e673d 494 return __e820_update_range(&e820, start, size, old_type, new_type);
fc9036ea
YL
495}
496
497static u64 __init e820_update_range_saved(u64 start, u64 size,
498 unsigned old_type, unsigned new_type)
499{
773e673d 500 return __e820_update_range(&e820_saved, start, size, old_type,
fc9036ea
YL
501 new_type);
502}
503
7a1fd986
YL
504/* make e820 not cover the range */
505u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,
506 int checktype)
507{
508 int i;
1b5576e6 509 u64 end;
7a1fd986
YL
510 u64 real_removed_size = 0;
511
232b957a
YL
512 if (size > (ULLONG_MAX - start))
513 size = ULLONG_MAX - start;
514
1b5576e6 515 end = start + size;
91eb0f67
BH
516 printk(KERN_DEBUG "e820: remove [mem %#010Lx-%#010Lx] ",
517 (unsigned long long) start, (unsigned long long) (end - 1));
9f3a5f52
YL
518 if (checktype)
519 e820_print_type(old_type);
1b5576e6
YL
520 printk(KERN_CONT "\n");
521
7a1fd986
YL
522 for (i = 0; i < e820.nr_map; i++) {
523 struct e820entry *ei = &e820.map[i];
524 u64 final_start, final_end;
9f3a5f52 525 u64 ei_end;
7a1fd986
YL
526
527 if (checktype && ei->type != old_type)
528 continue;
9f3a5f52
YL
529
530 ei_end = ei->addr + ei->size;
7a1fd986 531 /* totally covered? */
9f3a5f52 532 if (ei->addr >= start && ei_end <= end) {
7a1fd986
YL
533 real_removed_size += ei->size;
534 memset(ei, 0, sizeof(struct e820entry));
535 continue;
536 }
9f3a5f52
YL
537
538 /* new range is totally covered? */
539 if (ei->addr < start && ei_end > end) {
540 e820_add_region(end, ei_end - end, ei->type);
541 ei->size = start - ei->addr;
542 real_removed_size += size;
543 continue;
544 }
545
7a1fd986
YL
546 /* partially covered */
547 final_start = max(start, ei->addr);
9f3a5f52 548 final_end = min(end, ei_end);
7a1fd986
YL
549 if (final_start >= final_end)
550 continue;
551 real_removed_size += final_end - final_start;
552
9f3a5f52
YL
553 /*
554 * left range could be head or tail, so need to update
555 * size at first.
556 */
7a1fd986
YL
557 ei->size -= final_end - final_start;
558 if (ei->addr < final_start)
559 continue;
560 ei->addr = final_end;
561 }
562 return real_removed_size;
563}
564
b79cd8f1
YL
565void __init update_e820(void)
566{
d574ffa1 567 if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map))
b79cd8f1 568 return;
91eb0f67 569 printk(KERN_INFO "e820: modified physical RAM map:\n");
b79cd8f1
YL
570 e820_print_map("modified");
571}
fc9036ea
YL
572static void __init update_e820_saved(void)
573{
d574ffa1
WC
574 sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map),
575 &e820_saved.nr_map);
fc9036ea 576}
fd6493e1 577#define MAX_GAP_END 0x100000000ull
b79cd8f1 578/*
fd6493e1 579 * Search for a gap in the e820 memory space from start_addr to end_addr.
b79cd8f1 580 */
3381959d 581__init int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize,
fd6493e1 582 unsigned long start_addr, unsigned long long end_addr)
b79cd8f1 583{
fd6493e1 584 unsigned long long last;
3381959d 585 int i = e820.nr_map;
b79cd8f1
YL
586 int found = 0;
587
fd6493e1
AK
588 last = (end_addr && end_addr < MAX_GAP_END) ? end_addr : MAX_GAP_END;
589
b79cd8f1
YL
590 while (--i >= 0) {
591 unsigned long long start = e820.map[i].addr;
592 unsigned long long end = start + e820.map[i].size;
593
3381959d
AK
594 if (end < start_addr)
595 continue;
596
b79cd8f1
YL
597 /*
598 * Since "last" is at most 4GB, we know we'll
599 * fit in 32 bits if this condition is true
600 */
601 if (last > end) {
602 unsigned long gap = last - end;
603
3381959d
AK
604 if (gap >= *gapsize) {
605 *gapsize = gap;
606 *gapstart = end;
b79cd8f1
YL
607 found = 1;
608 }
609 }
610 if (start < last)
611 last = start;
612 }
3381959d
AK
613 return found;
614}
615
616/*
617 * Search for the biggest gap in the low 32 bits of the e820
618 * memory space. We pass this space to PCI to assign MMIO resources
619 * for hotplug or unconfigured devices in.
620 * Hopefully the BIOS let enough space left.
621 */
622__init void e820_setup_gap(void)
623{
5d423ccd 624 unsigned long gapstart, gapsize;
3381959d
AK
625 int found;
626
627 gapstart = 0x10000000;
628 gapsize = 0x400000;
fd6493e1 629 found = e820_search_gap(&gapstart, &gapsize, 0, MAX_GAP_END);
b79cd8f1
YL
630
631#ifdef CONFIG_X86_64
632 if (!found) {
c987d12f 633 gapstart = (max_pfn << PAGE_SHIFT) + 1024*1024;
ad361c98 634 printk(KERN_ERR
91eb0f67
BH
635 "e820: cannot find a gap in the 32bit address range\n"
636 "e820: PCI devices with unassigned 32bit BARs may break!\n");
b79cd8f1
YL
637 }
638#endif
639
640 /*
5d423ccd 641 * e820_reserve_resources_late protect stolen RAM already
b79cd8f1 642 */
5d423ccd 643 pci_mem_start = gapstart;
b79cd8f1
YL
644
645 printk(KERN_INFO
91eb0f67
BH
646 "e820: [mem %#010lx-%#010lx] available for PCI devices\n",
647 gapstart, gapstart + gapsize - 1);
b79cd8f1
YL
648}
649
8c5beb50
HY
650/**
651 * Because of the size limitation of struct boot_params, only first
652 * 128 E820 memory entries are passed to kernel via
653 * boot_params.e820_map, others are passed via SETUP_E820_EXT node of
654 * linked list of struct setup_data, which is parsed here.
655 */
30e46b57 656void __init parse_e820_ext(u64 phys_addr, u32 data_len)
8c5beb50 657{
8c5beb50
HY
658 int entries;
659 struct e820entry *extmap;
30e46b57 660 struct setup_data *sdata;
8c5beb50 661
30e46b57 662 sdata = early_memremap(phys_addr, data_len);
8c5beb50 663 entries = sdata->len / sizeof(struct e820entry);
8c5beb50 664 extmap = (struct e820entry *)(sdata->data);
dc8e8120 665 __append_e820_map(extmap, entries);
8c5beb50 666 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
8d4a40bc 667 early_memunmap(sdata, data_len);
91eb0f67 668 printk(KERN_INFO "e820: extended physical RAM map:\n");
8c5beb50
HY
669 e820_print_map("extended");
670}
671
bf62f398
YL
672#if defined(CONFIG_X86_64) || \
673 (defined(CONFIG_X86_32) && defined(CONFIG_HIBERNATION))
674/**
675 * Find the ranges of physical addresses that do not correspond to
676 * e820 RAM areas and mark the corresponding pages as nosave for
677 * hibernation (32 bit) or software suspend and suspend to RAM (64 bit).
678 *
679 * This function requires the e820 map to be sorted and without any
84779575 680 * overlapping entries.
bf62f398
YL
681 */
682void __init e820_mark_nosave_regions(unsigned long limit_pfn)
683{
684 int i;
84779575 685 unsigned long pfn = 0;
bf62f398 686
84779575 687 for (i = 0; i < e820.nr_map; i++) {
bf62f398
YL
688 struct e820entry *ei = &e820.map[i];
689
690 if (pfn < PFN_UP(ei->addr))
691 register_nosave_region(pfn, PFN_UP(ei->addr));
692
693 pfn = PFN_DOWN(ei->addr + ei->size);
ec776ef6 694
28bb2237 695 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
bf62f398
YL
696 register_nosave_region(PFN_UP(ei->addr), pfn);
697
698 if (pfn >= limit_pfn)
699 break;
700 }
701}
702#endif
a4c81cf6 703
b54ac6d2 704#ifdef CONFIG_ACPI
b69edc76
RW
705/**
706 * Mark ACPI NVS memory region, so that we can save/restore it during
707 * hibernation and the subsequent resume.
708 */
709static int __init e820_mark_nvs_memory(void)
710{
711 int i;
712
713 for (i = 0; i < e820.nr_map; i++) {
714 struct e820entry *ei = &e820.map[i];
715
716 if (ei->type == E820_NVS)
b54ac6d2 717 acpi_nvs_register(ei->addr, ei->size);
b69edc76
RW
718 }
719
720 return 0;
721}
722core_initcall(e820_mark_nvs_memory);
723#endif
724
2944e16b 725/*
72d7c3b3 726 * pre allocated 4k and reserved it in memblock and e820_saved
2944e16b 727 */
ab5d140b 728u64 __init early_reserve_e820(u64 size, u64 align)
2944e16b 729{
2944e16b 730 u64 addr;
2944e16b 731
ab5d140b
TH
732 addr = __memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE);
733 if (addr) {
734 e820_update_range_saved(addr, size, E820_RAM, E820_RESERVED);
91eb0f67 735 printk(KERN_INFO "e820: update e820_saved for early_reserve_e820\n");
ab5d140b 736 update_e820_saved();
61438766 737 }
2944e16b 738
2944e16b
YL
739 return addr;
740}
741
ee0c80fa
YL
742#ifdef CONFIG_X86_32
743# ifdef CONFIG_X86_PAE
744# define MAX_ARCH_PFN (1ULL<<(36-PAGE_SHIFT))
745# else
746# define MAX_ARCH_PFN (1ULL<<(32-PAGE_SHIFT))
747# endif
748#else /* CONFIG_X86_32 */
bd70e522 749# define MAX_ARCH_PFN MAXMEM>>PAGE_SHIFT
ee0c80fa
YL
750#endif
751
ee0c80fa
YL
752/*
753 * Find the highest page frame number we have available
754 */
ec776ef6 755static unsigned long __init e820_end_pfn(unsigned long limit_pfn)
ee0c80fa 756{
2dc807b3
YL
757 int i;
758 unsigned long last_pfn = 0;
ee0c80fa
YL
759 unsigned long max_arch_pfn = MAX_ARCH_PFN;
760
2dc807b3
YL
761 for (i = 0; i < e820.nr_map; i++) {
762 struct e820entry *ei = &e820.map[i];
f361a450 763 unsigned long start_pfn;
2dc807b3
YL
764 unsigned long end_pfn;
765
ec776ef6
CH
766 /*
767 * Persistent memory is accounted as ram for purposes of
768 * establishing max_pfn and mem_map.
769 */
770 if (ei->type != E820_RAM && ei->type != E820_PRAM)
c22d4c18 771 continue;
c22d4c18 772
f361a450 773 start_pfn = ei->addr >> PAGE_SHIFT;
2dc807b3 774 end_pfn = (ei->addr + ei->size) >> PAGE_SHIFT;
f361a450
YL
775
776 if (start_pfn >= limit_pfn)
777 continue;
778 if (end_pfn > limit_pfn) {
779 last_pfn = limit_pfn;
780 break;
781 }
2dc807b3
YL
782 if (end_pfn > last_pfn)
783 last_pfn = end_pfn;
784 }
ee0c80fa
YL
785
786 if (last_pfn > max_arch_pfn)
787 last_pfn = max_arch_pfn;
ee0c80fa 788
91eb0f67 789 printk(KERN_INFO "e820: last_pfn = %#lx max_arch_pfn = %#lx\n",
ee0c80fa
YL
790 last_pfn, max_arch_pfn);
791 return last_pfn;
792}
f361a450
YL
793unsigned long __init e820_end_of_ram_pfn(void)
794{
ec776ef6 795 return e820_end_pfn(MAX_ARCH_PFN);
f361a450 796}
ee0c80fa 797
f361a450
YL
798unsigned long __init e820_end_of_low_ram_pfn(void)
799{
ec776ef6 800 return e820_end_pfn(1UL << (32-PAGE_SHIFT));
f361a450 801}
ee0c80fa 802
ab4a465e
YL
803static void early_panic(char *msg)
804{
805 early_printk(msg);
806 panic(msg);
807}
808
69a7704d
YL
809static int userdef __initdata;
810
ab4a465e
YL
811/* "mem=nopentium" disables the 4MB page tables. */
812static int __init parse_memopt(char *p)
813{
814 u64 mem_size;
815
816 if (!p)
817 return -EINVAL;
818
ab4a465e 819 if (!strcmp(p, "nopentium")) {
9a6d44b9 820#ifdef CONFIG_X86_32
ab4a465e
YL
821 setup_clear_cpu_cap(X86_FEATURE_PSE);
822 return 0;
9a6d44b9
KM
823#else
824 printk(KERN_WARNING "mem=nopentium ignored! (only supported on x86_32)\n");
825 return -EINVAL;
ab4a465e 826#endif
9a6d44b9 827 }
ab4a465e 828
69a7704d 829 userdef = 1;
ab4a465e 830 mem_size = memparse(p, &p);
77eed821
KM
831 /* don't remove all of memory when handling "mem={invalid}" param */
832 if (mem_size == 0)
833 return -EINVAL;
69a7704d 834 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
611dfd78 835
ab4a465e
YL
836 return 0;
837}
838early_param("mem", parse_memopt);
839
9710f581 840static int __init parse_memmap_one(char *p)
ab4a465e
YL
841{
842 char *oldp;
843 u64 start_at, mem_size;
844
a737abd1
CG
845 if (!p)
846 return -EINVAL;
847
d6be118a 848 if (!strncmp(p, "exactmap", 8)) {
ab4a465e
YL
849#ifdef CONFIG_CRASH_DUMP
850 /*
851 * If we are doing a crash dump, we still need to know
852 * the real mem size before original memory map is
853 * reset.
854 */
f361a450 855 saved_max_pfn = e820_end_of_ram_pfn();
ab4a465e
YL
856#endif
857 e820.nr_map = 0;
858 userdef = 1;
859 return 0;
860 }
861
862 oldp = p;
863 mem_size = memparse(p, &p);
864 if (p == oldp)
865 return -EINVAL;
866
867 userdef = 1;
868 if (*p == '@') {
869 start_at = memparse(p+1, &p);
d0be6bde 870 e820_add_region(start_at, mem_size, E820_RAM);
ab4a465e
YL
871 } else if (*p == '#') {
872 start_at = memparse(p+1, &p);
d0be6bde 873 e820_add_region(start_at, mem_size, E820_ACPI);
ab4a465e
YL
874 } else if (*p == '$') {
875 start_at = memparse(p+1, &p);
d0be6bde 876 e820_add_region(start_at, mem_size, E820_RESERVED);
ec776ef6
CH
877 } else if (*p == '!') {
878 start_at = memparse(p+1, &p);
879 e820_add_region(start_at, mem_size, E820_PRAM);
7b479bec 880 } else
69a7704d 881 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
7b479bec 882
ab4a465e
YL
883 return *p == '\0' ? 0 : -EINVAL;
884}
9710f581
YL
885static int __init parse_memmap_opt(char *str)
886{
887 while (str) {
888 char *k = strchr(str, ',');
889
890 if (k)
891 *k++ = 0;
892
893 parse_memmap_one(str);
894 str = k;
895 }
896
897 return 0;
898}
ab4a465e
YL
899early_param("memmap", parse_memmap_opt);
900
901void __init finish_e820_parsing(void)
902{
903 if (userdef) {
d574ffa1
WC
904 if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map),
905 &e820.nr_map) < 0)
ab4a465e 906 early_panic("Invalid user supplied memory map");
ab4a465e 907
91eb0f67 908 printk(KERN_INFO "e820: user-defined physical RAM map:\n");
ab4a465e
YL
909 e820_print_map("user");
910 }
911}
41c094fd 912
5dfcf14d
BW
913static inline const char *e820_type_to_string(int e820_type)
914{
915 switch (e820_type) {
916 case E820_RESERVED_KERN:
917 case E820_RAM: return "System RAM";
918 case E820_ACPI: return "ACPI Tables";
919 case E820_NVS: return "ACPI Non-volatile Storage";
671eef85 920 case E820_UNUSABLE: return "Unusable memory";
ec776ef6 921 case E820_PRAM: return "Persistent RAM";
5dfcf14d
BW
922 default: return "reserved";
923 }
924}
925
41c094fd
YL
926/*
927 * Mark e820 reserved areas as busy for the resource manager.
928 */
a5444d15 929static struct resource __initdata *e820_res;
41c094fd
YL
930void __init e820_reserve_resources(void)
931{
932 int i;
58f7c988 933 struct resource *res;
a5444d15 934 u64 end;
41c094fd 935
3c1596ef 936 res = alloc_bootmem(sizeof(struct resource) * e820.nr_map);
58f7c988 937 e820_res = res;
41c094fd 938 for (i = 0; i < e820.nr_map; i++) {
b4df32f4 939 end = e820.map[i].addr + e820.map[i].size - 1;
8308c54d 940 if (end != (resource_size_t)end) {
41c094fd
YL
941 res++;
942 continue;
943 }
5dfcf14d 944 res->name = e820_type_to_string(e820.map[i].type);
b4df32f4
YL
945 res->start = e820.map[i].addr;
946 res->end = end;
947
1f987577 948 res->flags = IORESOURCE_MEM;
a5444d15
IM
949
950 /*
951 * don't register the region that could be conflicted with
952 * pci device BAR resource and insert them later in
953 * pcibios_resource_survey()
954 */
ec776ef6
CH
955 if (((e820.map[i].type != E820_RESERVED) &&
956 (e820.map[i].type != E820_PRAM)) ||
957 res->start < (1ULL<<20)) {
1f987577 958 res->flags |= IORESOURCE_BUSY;
58f7c988 959 insert_resource(&iomem_resource, res);
1f987577 960 }
41c094fd
YL
961 res++;
962 }
5dfcf14d
BW
963
964 for (i = 0; i < e820_saved.nr_map; i++) {
965 struct e820entry *entry = &e820_saved.map[i];
966 firmware_map_add_early(entry->addr,
4ed940d4 967 entry->addr + entry->size,
5dfcf14d
BW
968 e820_type_to_string(entry->type));
969 }
41c094fd
YL
970}
971
45fbe3ee
LT
972/* How much should we pad RAM ending depending on where it is? */
973static unsigned long ram_alignment(resource_size_t pos)
974{
975 unsigned long mb = pos >> 20;
976
977 /* To 64kB in the first megabyte */
978 if (!mb)
979 return 64*1024;
980
981 /* To 1MB in the first 16MB */
982 if (mb < 16)
983 return 1024*1024;
984
15b812f1
YL
985 /* To 64MB for anything above that */
986 return 64*1024*1024;
45fbe3ee
LT
987}
988
7c5371c4
YL
989#define MAX_RESOURCE_SIZE ((resource_size_t)-1)
990
58f7c988
YL
991void __init e820_reserve_resources_late(void)
992{
993 int i;
994 struct resource *res;
995
996 res = e820_res;
997 for (i = 0; i < e820.nr_map; i++) {
a5444d15 998 if (!res->parent && res->end)
1f987577 999 insert_resource_expand_to_fit(&iomem_resource, res);
58f7c988
YL
1000 res++;
1001 }
45fbe3ee
LT
1002
1003 /*
1004 * Try to bump up RAM regions to reasonable boundaries to
1005 * avoid stolen RAM:
1006 */
1007 for (i = 0; i < e820.nr_map; i++) {
7c5371c4
YL
1008 struct e820entry *entry = &e820.map[i];
1009 u64 start, end;
45fbe3ee
LT
1010
1011 if (entry->type != E820_RAM)
1012 continue;
1013 start = entry->addr + entry->size;
7c5371c4
YL
1014 end = round_up(start, ram_alignment(start)) - 1;
1015 if (end > MAX_RESOURCE_SIZE)
1016 end = MAX_RESOURCE_SIZE;
1017 if (start >= end)
45fbe3ee 1018 continue;
91eb0f67
BH
1019 printk(KERN_DEBUG
1020 "e820: reserve RAM buffer [mem %#010llx-%#010llx]\n",
1021 start, end);
7c5371c4
YL
1022 reserve_region_with_split(&iomem_resource, start, end,
1023 "RAM buffer");
45fbe3ee 1024 }
58f7c988
YL
1025}
1026
95a71a45 1027char *__init default_machine_specific_memory_setup(void)
064d25f1
YL
1028{
1029 char *who = "BIOS-e820";
ba639039 1030 u32 new_nr;
064d25f1
YL
1031 /*
1032 * Try to copy the BIOS-supplied E820-map.
1033 *
1034 * Otherwise fake a memory map; one section from 0k->640k,
1035 * the next section from 1mb->appropriate_mem_k
1036 */
1037 new_nr = boot_params.e820_entries;
1038 sanitize_e820_map(boot_params.e820_map,
1039 ARRAY_SIZE(boot_params.e820_map),
1040 &new_nr);
1041 boot_params.e820_entries = new_nr;
dc8e8120
YL
1042 if (append_e820_map(boot_params.e820_map, boot_params.e820_entries)
1043 < 0) {
95a71a45 1044 u64 mem_size;
064d25f1
YL
1045
1046 /* compare results from other methods and take the greater */
1047 if (boot_params.alt_mem_k
1048 < boot_params.screen_info.ext_mem_k) {
1049 mem_size = boot_params.screen_info.ext_mem_k;
1050 who = "BIOS-88";
1051 } else {
1052 mem_size = boot_params.alt_mem_k;
1053 who = "BIOS-e801";
1054 }
1055
1056 e820.nr_map = 0;
1057 e820_add_region(0, LOWMEMSIZE(), E820_RAM);
1058 e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
064d25f1
YL
1059 }
1060
1061 /* In case someone cares... */
1062 return who;
1063}
1064
064d25f1
YL
1065void __init setup_memory_map(void)
1066{
0be15526
YL
1067 char *who;
1068
6b18ae3e 1069 who = x86_init.resources.memory_setup();
0be15526 1070 memcpy(&e820_saved, &e820, sizeof(struct e820map));
91eb0f67 1071 printk(KERN_INFO "e820: BIOS-provided physical RAM map:\n");
0be15526 1072 e820_print_map(who);
064d25f1 1073}
72d7c3b3
YL
1074
1075void __init memblock_x86_fill(void)
1076{
1077 int i;
1078 u64 end;
1079
1080 /*
1081 * EFI may have more than 128 entries
1082 * We are safe to enable resizing, beause memblock_x86_fill()
1083 * is rather later for x86
1084 */
1aadc056 1085 memblock_allow_resize();
72d7c3b3
YL
1086
1087 for (i = 0; i < e820.nr_map; i++) {
1088 struct e820entry *ei = &e820.map[i];
1089
1090 end = ei->addr + ei->size;
1091 if (end != (resource_size_t)end)
1092 continue;
1093
1094 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
1095 continue;
1096
1097 memblock_add(ei->addr, ei->size);
1098 }
1099
6ede1fd3
YL
1100 /* throw away partial pages */
1101 memblock_trim_memory(PAGE_SIZE);
1102
72d7c3b3
YL
1103 memblock_dump_all();
1104}
6f2a7536
YL
1105
1106void __init memblock_find_dma_reserve(void)
1107{
1108#ifdef CONFIG_X86_64
6b5d41a1
TH
1109 u64 nr_pages = 0, nr_free_pages = 0;
1110 unsigned long start_pfn, end_pfn;
1111 phys_addr_t start, end;
1112 int i;
1113 u64 u;
1114
6f2a7536
YL
1115 /*
1116 * need to find out used area below MAX_DMA_PFN
1117 * need to use memblock to get free size in [0, MAX_DMA_PFN]
1118 * at first, and assume boot_mem will not take below MAX_DMA_PFN
1119 */
6b5d41a1 1120 for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, NULL) {
29258cf4
XQ
1121 start_pfn = min(start_pfn, MAX_DMA_PFN);
1122 end_pfn = min(end_pfn, MAX_DMA_PFN);
6b5d41a1
TH
1123 nr_pages += end_pfn - start_pfn;
1124 }
1125
9a28f9dc 1126 for_each_free_mem_range(u, NUMA_NO_NODE, &start, &end, NULL) {
6b5d41a1
TH
1127 start_pfn = min_t(unsigned long, PFN_UP(start), MAX_DMA_PFN);
1128 end_pfn = min_t(unsigned long, PFN_DOWN(end), MAX_DMA_PFN);
1129 if (start_pfn < end_pfn)
1130 nr_free_pages += end_pfn - start_pfn;
1131 }
1132
1133 set_dma_reserve(nr_pages - nr_free_pages);
6f2a7536
YL
1134#endif
1135}