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