arch/x86/kernel/e820_32.c

   1 #include <linux/kernel.h>
   2 #include <linux/types.h>
   3 #include <linux/init.h>
   4 #include <linux/bootmem.h>
   5 #include <linux/ioport.h>
   6 #include <linux/string.h>
   7 #include <linux/kexec.h>
   8 #include <linux/module.h>
   9 #include <linux/mm.h>
  10 #include <linux/pfn.h>
  11 #include <linux/uaccess.h>
  12
  13 #include <asm/pgtable.h>
  14 #include <asm/page.h>
  15 #include <asm/e820.h>
  16 #include <asm/setup.h>
  17
  18 static struct resource system_rom_resource = {
  19         .name   = "System ROM",
  20         .start  = 0xf0000,
  21         .end    = 0xfffff,
  22         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  23 };
  24
  25 static struct resource extension_rom_resource = {
  26         .name   = "Extension ROM",
  27         .start  = 0xe0000,
  28         .end    = 0xeffff,
  29         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  30 };
  31
  32 static struct resource adapter_rom_resources[] = { {
  33         .name   = "Adapter ROM",
  34         .start  = 0xc8000,
  35         .end    = 0,
  36         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  37 }, {
  38         .name   = "Adapter ROM",
  39         .start  = 0,
  40         .end    = 0,
  41         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  42 }, {
  43         .name   = "Adapter ROM",
  44         .start  = 0,
  45         .end    = 0,
  46         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  47 }, {
  48         .name   = "Adapter ROM",
  49         .start  = 0,
  50         .end    = 0,
  51         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  52 }, {
  53         .name   = "Adapter ROM",
  54         .start  = 0,
  55         .end    = 0,
  56         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  57 }, {
  58         .name   = "Adapter ROM",
  59         .start  = 0,
  60         .end    = 0,
  61         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  62 } };
  63
  64 static struct resource video_rom_resource = {
  65         .name   = "Video ROM",
  66         .start  = 0xc0000,
  67         .end    = 0xc7fff,
  68         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  69 };
  70
  71 #define ROMSIGNATURE 0xaa55
  72
  73 static int __init romsignature(const unsigned char *rom)
  74 {
  75         const unsigned short * const ptr = (const unsigned short *)rom;
  76         unsigned short sig;
  77
  78         return probe_kernel_address(ptr, sig) == 0 && sig == ROMSIGNATURE;
  79 }
  80
  81 static int __init romchecksum(const unsigned char *rom, unsigned long length)
  82 {
  83         unsigned char sum, c;
  84
  85         for (sum = 0; length && probe_kernel_address(rom++, c) == 0; length--)
  86                 sum += c;
  87         return !length && !sum;
  88 }
  89
  90 static void __init probe_roms(void)
  91 {
  92         const unsigned char *rom;
  93         unsigned long start, length, upper;
  94         unsigned char c;
  95         int i;
  96
  97         /* video rom */
  98         upper = adapter_rom_resources[0].start;
  99         for (start = video_rom_resource.start; start < upper; start += 2048) {
 100                 rom = isa_bus_to_virt(start);
 101                 if (!romsignature(rom))
 102                         continue;
 103
 104                 video_rom_resource.start = start;
 105
 106                 if (probe_kernel_address(rom + 2, c) != 0)
 107                         continue;
 108
 109                 /* 0 < length <= 0x7f * 512, historically */
 110                 length = c * 512;
 111
 112                 /* if checksum okay, trust length byte */
 113                 if (length && romchecksum(rom, length))
 114                         video_rom_resource.end = start + length - 1;
 115
 116                 request_resource(&iomem_resource, &video_rom_resource);
 117                 break;
 118         }
 119
 120         start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
 121         if (start < upper)
 122                 start = upper;
 123
 124         /* system rom */
 125         request_resource(&iomem_resource, &system_rom_resource);
 126         upper = system_rom_resource.start;
 127
 128         /* check for extension rom (ignore length byte!) */
 129         rom = isa_bus_to_virt(extension_rom_resource.start);
 130         if (romsignature(rom)) {
 131                 length = extension_rom_resource.end - extension_rom_resource.start + 1;
 132                 if (romchecksum(rom, length)) {
 133                         request_resource(&iomem_resource, &extension_rom_resource);
 134                         upper = extension_rom_resource.start;
 135                 }
 136         }
 137
 138         /* check for adapter roms on 2k boundaries */
 139         for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
 140                 rom = isa_bus_to_virt(start);
 141                 if (!romsignature(rom))
 142                         continue;
 143
 144                 if (probe_kernel_address(rom + 2, c) != 0)
 145                         continue;
 146
 147                 /* 0 < length <= 0x7f * 512, historically */
 148                 length = c * 512;
 149
 150                 /* but accept any length that fits if checksum okay */
 151                 if (!length || start + length > upper || !romchecksum(rom, length))
 152                         continue;
 153
 154                 adapter_rom_resources[i].start = start;
 155                 adapter_rom_resources[i].end = start + length - 1;
 156                 request_resource(&iomem_resource, &adapter_rom_resources[i]);
 157
 158                 start = adapter_rom_resources[i++].end & ~2047UL;
 159         }
 160 }
 161
 162 /*
 163  * Request address space for all standard RAM and ROM resources
 164  * and also for regions reported as reserved by the e820.
 165  */
 166 void __init init_iomem_resources(struct resource *code_resource,
 167                 struct resource *data_resource,
 168                 struct resource *bss_resource)
 169 {
 170         int i;
 171
 172         probe_roms();
 173         for (i = 0; i < e820.nr_map; i++) {
 174                 struct resource *res;
 175 #ifndef CONFIG_RESOURCES_64BIT
 176                 if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
 177                         continue;
 178 #endif
 179                 res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
 180                 switch (e820.map[i].type) {
 181                 case E820_RAM:  res->name = "System RAM"; break;
 182                 case E820_ACPI: res->name = "ACPI Tables"; break;
 183                 case E820_NVS:  res->name = "ACPI Non-volatile Storage"; break;
 184                 default:        res->name = "reserved";
 185                 }
 186                 res->start = e820.map[i].addr;
 187                 res->end = res->start + e820.map[i].size - 1;
 188                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 189                 if (request_resource(&iomem_resource, res)) {
 190                         kfree(res);
 191                         continue;
 192                 }
 193                 if (e820.map[i].type == E820_RAM) {
 194                         /*
 195                          *  We don't know which RAM region contains kernel data,
 196                          *  so we try it repeatedly and let the resource manager
 197                          *  test it.
 198                          */
 199                         request_resource(res, code_resource);
 200                         request_resource(res, data_resource);
 201                         request_resource(res, bss_resource);
 202 #ifdef CONFIG_KEXEC
 203                         if (crashk_res.start != crashk_res.end)
 204                                 request_resource(res, &crashk_res);
 205 #endif
 206                 }
 207         }
 208 }
 209
 210 /*
 211  * Find the highest page frame number we have available
 212  */
 213 void __init find_max_pfn(void)
 214 {
 215         int i;
 216
 217         max_pfn = 0;
 218
 219         for (i = 0; i < e820.nr_map; i++) {
 220                 unsigned long start, end;
 221                 /* RAM? */
 222                 if (e820.map[i].type != E820_RAM)
 223                         continue;
 224                 start = PFN_UP(e820.map[i].addr);
 225                 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 226                 if (start >= end)
 227                         continue;
 228                 if (end > max_pfn)
 229                         max_pfn = end;
 230         }
 231 }
 232
 233 /*
 234  * Register fully available low RAM pages with the bootmem allocator.
 235  */
 236 void __init register_bootmem_low_pages(unsigned long max_low_pfn)
 237 {
 238         int i;
 239
 240         for (i = 0; i < e820.nr_map; i++) {
 241                 unsigned long curr_pfn, last_pfn, size;
 242                 /*
 243                  * Reserve usable low memory
 244                  */
 245                 if (e820.map[i].type != E820_RAM)
 246                         continue;
 247                 /*
 248                  * We are rounding up the start address of usable memory:
 249                  */
 250                 curr_pfn = PFN_UP(e820.map[i].addr);
 251                 if (curr_pfn >= max_low_pfn)
 252                         continue;
 253                 /*
 254                  * ... and at the end of the usable range downwards:
 255                  */
 256                 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 257
 258                 if (last_pfn > max_low_pfn)
 259                         last_pfn = max_low_pfn;
 260
 261                 /*
 262                  * .. finally, did all the rounding and playing
 263                  * around just make the area go away?
 264                  */
 265                 if (last_pfn <= curr_pfn)
 266                         continue;
 267
 268                 size = last_pfn - curr_pfn;
 269                 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
 270         }
 271 }
 272
 273 void __init limit_regions(unsigned long long size)
 274 {
 275         unsigned long long current_addr;
 276         int i;
 277
 278         e820_print_map("limit_regions start");
 279         for (i = 0; i < e820.nr_map; i++) {
 280                 current_addr = e820.map[i].addr + e820.map[i].size;
 281                 if (current_addr < size)
 282                         continue;
 283
 284                 if (e820.map[i].type != E820_RAM)
 285                         continue;
 286
 287                 if (e820.map[i].addr >= size) {
 288                         /*
 289                          * This region starts past the end of the
 290                          * requested size, skip it completely.
 291                          */
 292                         e820.nr_map = i;
 293                 } else {
 294                         e820.nr_map = i + 1;
 295                         e820.map[i].size -= current_addr - size;
 296                 }
 297                 e820_print_map("limit_regions endfor");
 298                 return;
 299         }
 300         e820_print_map("limit_regions endfunc");
 301 }
 302
 303 /* Overridden in paravirt.c if CONFIG_PARAVIRT */
 304 char * __init __attribute__((weak)) memory_setup(void)
 305 {
 306         return machine_specific_memory_setup();
 307 }
 308
 309 void __init setup_memory_map(void)
 310 {
 311         printk(KERN_INFO "BIOS-provided physical RAM map:\n");
 312         e820_print_map(memory_setup());
 313 }
 314
 315 static int __initdata user_defined_memmap;
 316
 317 /*
 318  * "mem=nopentium" disables the 4MB page tables.
 319  * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
 320  * to <mem>, overriding the bios size.
 321  * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
 322  * <start> to <start>+<mem>, overriding the bios size.
 323  *
 324  * HPA tells me bootloaders need to parse mem=, so no new
 325  * option should be mem=  [also see Documentation/i386/boot.txt]
 326  */
 327 static int __init parse_mem(char *arg)
 328 {
 329         if (!arg)
 330                 return -EINVAL;
 331
 332         if (strcmp(arg, "nopentium") == 0) {
 333                 setup_clear_cpu_cap(X86_FEATURE_PSE);
 334         } else {
 335                 /* If the user specifies memory size, we
 336                  * limit the BIOS-provided memory map to
 337                  * that size. exactmap can be used to specify
 338                  * the exact map. mem=number can be used to
 339                  * trim the existing memory map.
 340                  */
 341                 unsigned long long mem_size;
 342
 343                 mem_size = memparse(arg, &arg);
 344                 limit_regions(mem_size);
 345                 user_defined_memmap = 1;
 346         }
 347         return 0;
 348 }
 349 early_param("mem", parse_mem);
 350
 351 static int __init parse_memmap(char *arg)
 352 {
 353         if (!arg)
 354                 return -EINVAL;
 355
 356         if (strcmp(arg, "exactmap") == 0) {
 357 #ifdef CONFIG_CRASH_DUMP
 358                 /* If we are doing a crash dump, we
 359                  * still need to know the real mem
 360                  * size before original memory map is
 361                  * reset.
 362                  */
 363                 find_max_pfn();
 364                 saved_max_pfn = max_pfn;
 365 #endif
 366                 e820.nr_map = 0;
 367                 user_defined_memmap = 1;
 368         } else {
 369                 /* If the user specifies memory size, we
 370                  * limit the BIOS-provided memory map to
 371                  * that size. exactmap can be used to specify
 372                  * the exact map. mem=number can be used to
 373                  * trim the existing memory map.
 374                  */
 375                 unsigned long long start_at, mem_size;
 376
 377                 mem_size = memparse(arg, &arg);
 378                 if (*arg == '@') {
 379                         start_at = memparse(arg+1, &arg);
 380                         add_memory_region(start_at, mem_size, E820_RAM);
 381                 } else if (*arg == '#') {
 382                         start_at = memparse(arg+1, &arg);
 383                         add_memory_region(start_at, mem_size, E820_ACPI);
 384                 } else if (*arg == '$') {
 385                         start_at = memparse(arg+1, &arg);
 386                         add_memory_region(start_at, mem_size, E820_RESERVED);
 387                 } else {
 388                         limit_regions(mem_size);
 389                         user_defined_memmap = 1;
 390                 }
 391         }
 392         return 0;
 393 }
 394 early_param("memmap", parse_memmap);
 395
 396 void __init finish_e820_parsing(void)
 397 {
 398         if (user_defined_memmap) {
 399                 printk(KERN_INFO "user-defined physical RAM map:\n");
 400                 e820_print_map("user");
 401         }
 402 }
 403