arch/avr32/mm/init.c

   1 /*
   2  * Copyright (C) 2004-2006 Atmel Corporation
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/mm.h>
  11 #include <linux/swap.h>
  12 #include <linux/init.h>
  13 #include <linux/initrd.h>
  14 #include <linux/mmzone.h>
  15 #include <linux/bootmem.h>
  16 #include <linux/pagemap.h>
  17 #include <linux/pfn.h>
  18 #include <linux/nodemask.h>
  19
  20 #include <asm/page.h>
  21 #include <asm/mmu_context.h>
  22 #include <asm/tlb.h>
  23 #include <asm/io.h>
  24 #include <asm/dma.h>
  25 #include <asm/setup.h>
  26 #include <asm/sections.h>
  27
  28 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  29
  30 pgd_t swapper_pg_dir[PTRS_PER_PGD];
  31
  32 struct page *empty_zero_page;
  33
  34 /*
  35  * Cache of MMU context last used.
  36  */
  37 unsigned long mmu_context_cache = NO_CONTEXT;
  38
  39 #define START_PFN       (NODE_DATA(0)->bdata->node_boot_start >> PAGE_SHIFT)
  40 #define MAX_LOW_PFN     (NODE_DATA(0)->bdata->node_low_pfn)
  41
  42 void show_mem(void)
  43 {
  44         int total = 0, reserved = 0, cached = 0;
  45         int slab = 0, free = 0, shared = 0;
  46         pg_data_t *pgdat;
  47
  48         printk("Mem-info:\n");
  49         show_free_areas();
  50
  51         for_each_online_pgdat(pgdat) {
  52                 struct page *page, *end;
  53
  54                 page = pgdat->node_mem_map;
  55                 end = page + pgdat->node_spanned_pages;
  56
  57                 do {
  58                         total++;
  59                         if (PageReserved(page))
  60                                 reserved++;
  61                         else if (PageSwapCache(page))
  62                                 cached++;
  63                         else if (PageSlab(page))
  64                                 slab++;
  65                         else if (!page_count(page))
  66                                 free++;
  67                         else
  68                                 shared += page_count(page) - 1;
  69                         page++;
  70                 } while (page < end);
  71         }
  72
  73         printk ("%d pages of RAM\n", total);
  74         printk ("%d free pages\n", free);
  75         printk ("%d reserved pages\n", reserved);
  76         printk ("%d slab pages\n", slab);
  77         printk ("%d pages shared\n", shared);
  78         printk ("%d pages swap cached\n", cached);
  79 }
  80
  81 static void __init print_memory_map(const char *what,
  82                                     struct tag_mem_range *mem)
  83 {
  84         printk ("%s:\n", what);
  85         for (; mem; mem = mem->next) {
  86                 printk ("  %08lx - %08lx\n",
  87                         (unsigned long)mem->addr,
  88                         (unsigned long)(mem->addr + mem->size));
  89         }
  90 }
  91
  92 #define MAX_LOWMEM      HIGHMEM_START
  93 #define MAX_LOWMEM_PFN  PFN_DOWN(MAX_LOWMEM)
  94
  95 /*
  96  * Sort a list of memory regions in-place by ascending address.
  97  *
  98  * We're using bubble sort because we only have singly linked lists
  99  * with few elements.
 100  */
 101 static void __init sort_mem_list(struct tag_mem_range **pmem)
 102 {
 103         int done;
 104         struct tag_mem_range **a, **b;
 105
 106         if (!*pmem)
 107                 return;
 108
 109         do {
 110                 done = 1;
 111                 a = pmem, b = &(*pmem)->next;
 112                 while (*b) {
 113                         if ((*a)->addr > (*b)->addr) {
 114                                 struct tag_mem_range *tmp;
 115                                 tmp = (*b)->next;
 116                                 (*b)->next = *a;
 117                                 *a = *b;
 118                                 *b = tmp;
 119                                 done = 0;
 120                         }
 121                         a = &(*a)->next;
 122                         b = &(*a)->next;
 123                 }
 124         } while (!done);
 125 }
 126
 127 /*
 128  * Find a free memory region large enough for storing the
 129  * bootmem bitmap.
 130  */
 131 static unsigned long __init
 132 find_bootmap_pfn(const struct tag_mem_range *mem)
 133 {
 134         unsigned long bootmap_pages, bootmap_len;
 135         unsigned long node_pages = PFN_UP(mem->size);
 136         unsigned long bootmap_addr = mem->addr;
 137         struct tag_mem_range *reserved = mem_reserved;
 138         struct tag_mem_range *ramdisk = mem_ramdisk;
 139         unsigned long kern_start = virt_to_phys(_stext);
 140         unsigned long kern_end = virt_to_phys(_end);
 141
 142         bootmap_pages = bootmem_bootmap_pages(node_pages);
 143         bootmap_len = bootmap_pages << PAGE_SHIFT;
 144
 145         /*
 146          * Find a large enough region without reserved pages for
 147          * storing the bootmem bitmap. We can take advantage of the
 148          * fact that all lists have been sorted.
 149          *
 150          * We have to check explicitly reserved regions as well as the
 151          * kernel image and any RAMDISK images...
 152          *
 153          * Oh, and we have to make sure we don't overwrite the taglist
 154          * since we're going to use it until the bootmem allocator is
 155          * fully up and running.
 156          */
 157         while (1) {
 158                 if ((bootmap_addr < kern_end) &&
 159                     ((bootmap_addr + bootmap_len) > kern_start))
 160                         bootmap_addr = kern_end;
 161
 162                 while (reserved &&
 163                        (bootmap_addr >= (reserved->addr + reserved->size)))
 164                         reserved = reserved->next;
 165
 166                 if (reserved &&
 167                     ((bootmap_addr + bootmap_len) >= reserved->addr)) {
 168                         bootmap_addr = reserved->addr + reserved->size;
 169                         continue;
 170                 }
 171
 172                 while (ramdisk &&
 173                        (bootmap_addr >= (ramdisk->addr + ramdisk->size)))
 174                         ramdisk = ramdisk->next;
 175
 176                 if (!ramdisk ||
 177                     ((bootmap_addr + bootmap_len) < ramdisk->addr))
 178                         break;
 179
 180                 bootmap_addr = ramdisk->addr + ramdisk->size;
 181         }
 182
 183         if ((PFN_UP(bootmap_addr) + bootmap_len) >= (mem->addr + mem->size))
 184                 return ~0UL;
 185
 186         return PFN_UP(bootmap_addr);
 187 }
 188
 189 void __init setup_bootmem(void)
 190 {
 191         unsigned bootmap_size;
 192         unsigned long first_pfn, bootmap_pfn, pages;
 193         unsigned long max_pfn, max_low_pfn;
 194         unsigned long kern_start = virt_to_phys(_stext);
 195         unsigned long kern_end = virt_to_phys(_end);
 196         unsigned node = 0;
 197         struct tag_mem_range *bank, *res;
 198
 199         sort_mem_list(&mem_phys);
 200         sort_mem_list(&mem_reserved);
 201
 202         print_memory_map("Physical memory", mem_phys);
 203         print_memory_map("Reserved memory", mem_reserved);
 204
 205         nodes_clear(node_online_map);
 206
 207         if (mem_ramdisk) {
 208 #ifdef CONFIG_BLK_DEV_INITRD
 209                 initrd_start = (unsigned long)__va(mem_ramdisk->addr);
 210                 initrd_end = initrd_start + mem_ramdisk->size;
 211
 212                 print_memory_map("RAMDISK images", mem_ramdisk);
 213                 if (mem_ramdisk->next)
 214                         printk(KERN_WARNING
 215                                "Warning: Only the first RAMDISK image "
 216                                "will be used\n");
 217                 sort_mem_list(&mem_ramdisk);
 218 #else
 219                 printk(KERN_WARNING "RAM disk image present, but "
 220                        "no initrd support in kernel!\n");
 221 #endif
 222         }
 223
 224         if (mem_phys->next)
 225                 printk(KERN_WARNING "Only using first memory bank\n");
 226
 227         for (bank = mem_phys; bank; bank = NULL) {
 228                 first_pfn = PFN_UP(bank->addr);
 229                 max_low_pfn = max_pfn = PFN_DOWN(bank->addr + bank->size);
 230                 bootmap_pfn = find_bootmap_pfn(bank);
 231                 if (bootmap_pfn > max_pfn)
 232                         panic("No space for bootmem bitmap!\n");
 233
 234                 if (max_low_pfn > MAX_LOWMEM_PFN) {
 235                         max_low_pfn = MAX_LOWMEM_PFN;
 236 #ifndef CONFIG_HIGHMEM
 237                         /*
 238                          * Lowmem is memory that can be addressed
 239                          * directly through P1/P2
 240                          */
 241                         printk(KERN_WARNING
 242                                "Node %u: Only %ld MiB of memory will be used.\n",
 243                                node, MAX_LOWMEM >> 20);
 244                         printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
 245 #else
 246 #error HIGHMEM is not supported by AVR32 yet
 247 #endif
 248                 }
 249
 250                 /* Initialize the boot-time allocator with low memory only. */
 251                 bootmap_size = init_bootmem_node(NODE_DATA(node), bootmap_pfn,
 252                                                  first_pfn, max_low_pfn);
 253
 254                 printk("Node %u: bdata = %p, bdata->node_bootmem_map = %p\n",
 255                        node, NODE_DATA(node)->bdata,
 256                        NODE_DATA(node)->bdata->node_bootmem_map);
 257
 258                 /*
 259                  * Register fully available RAM pages with the bootmem
 260                  * allocator.
 261                  */
 262                 pages = max_low_pfn - first_pfn;
 263                 free_bootmem_node (NODE_DATA(node), PFN_PHYS(first_pfn),
 264                                    PFN_PHYS(pages));
 265
 266                 /*
 267                  * Reserve space for the kernel image (if present in
 268                  * this node)...
 269                  */
 270                 if ((kern_start >= PFN_PHYS(first_pfn)) &&
 271                     (kern_start < PFN_PHYS(max_pfn))) {
 272                         printk("Node %u: Kernel image %08lx - %08lx\n",
 273                                node, kern_start, kern_end);
 274                         reserve_bootmem_node(NODE_DATA(node), kern_start,
 275                                              kern_end - kern_start);
 276                 }
 277
 278                 /* ...the bootmem bitmap... */
 279                 reserve_bootmem_node(NODE_DATA(node),
 280                                      PFN_PHYS(bootmap_pfn),
 281                                      bootmap_size);
 282
 283                 /* ...any RAMDISK images... */
 284                 for (res = mem_ramdisk; res; res = res->next) {
 285                         if (res->addr > PFN_PHYS(max_pfn))
 286                                 break;
 287
 288                         if (res->addr >= PFN_PHYS(first_pfn)) {
 289                                 printk("Node %u: RAMDISK %08lx - %08lx\n",
 290                                        node,
 291                                        (unsigned long)res->addr,
 292                                        (unsigned long)(res->addr + res->size));
 293                                 reserve_bootmem_node(NODE_DATA(node),
 294                                                      res->addr, res->size);
 295                         }
 296                 }
 297
 298                 /* ...and any other reserved regions. */
 299                 for (res = mem_reserved; res; res = res->next) {
 300                         if (res->addr > PFN_PHYS(max_pfn))
 301                                 break;
 302
 303                         if (res->addr >= PFN_PHYS(first_pfn)) {
 304                                 printk("Node %u: Reserved %08lx - %08lx\n",
 305                                        node,
 306                                        (unsigned long)res->addr,
 307                                        (unsigned long)(res->addr + res->size));
 308                                 reserve_bootmem_node(NODE_DATA(node),
 309                                                      res->addr, res->size);
 310                         }
 311                 }
 312
 313                 node_set_online(node);
 314         }
 315 }
 316
 317 /*
 318  * paging_init() sets up the page tables
 319  *
 320  * This routine also unmaps the page at virtual kernel address 0, so
 321  * that we can trap those pesky NULL-reference errors in the kernel.
 322  */
 323 void __init paging_init(void)
 324 {
 325         extern unsigned long _evba;
 326         void *zero_page;
 327         int nid;
 328
 329         /*
 330          * Make sure we can handle exceptions before enabling
 331          * paging. Not that we should ever _get_ any exceptions this
 332          * early, but you never know...
 333          */
 334         printk("Exception vectors start at %p\n", &_evba);
 335         sysreg_write(EVBA, (unsigned long)&_evba);
 336
 337         /*
 338          * Since we are ready to handle exceptions now, we should let
 339          * the CPU generate them...
 340          */
 341         __asm__ __volatile__ ("csrf %0" : : "i"(SR_EM_BIT));
 342
 343         /*
 344          * Allocate the zero page. The allocator will panic if it
 345          * can't satisfy the request, so no need to check.
 346          */
 347         zero_page = alloc_bootmem_low_pages_node(NODE_DATA(0),
 348                                                  PAGE_SIZE);
 349
 350         {
 351                 pgd_t *pg_dir;
 352                 int i;
 353
 354                 pg_dir = swapper_pg_dir;
 355                 sysreg_write(PTBR, (unsigned long)pg_dir);
 356
 357                 for (i = 0; i < PTRS_PER_PGD; i++)
 358                         pgd_val(pg_dir[i]) = 0;
 359
 360                 enable_mmu();
 361                 printk ("CPU: Paging enabled\n");
 362         }
 363
 364         for_each_online_node(nid) {
 365                 pg_data_t *pgdat = NODE_DATA(nid);
 366                 unsigned long zones_size[MAX_NR_ZONES];
 367                 unsigned long low, start_pfn;
 368
 369                 start_pfn = pgdat->bdata->node_boot_start;
 370                 start_pfn >>= PAGE_SHIFT;
 371                 low = pgdat->bdata->node_low_pfn;
 372
 373                 memset(zones_size, 0, sizeof(zones_size));
 374                 zones_size[ZONE_NORMAL] = low - start_pfn;
 375
 376                 printk("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
 377                        nid, start_pfn, low);
 378
 379                 free_area_init_node(nid, pgdat, zones_size, start_pfn, NULL);
 380
 381                 printk("Node %u: mem_map starts at %p\n",
 382                        pgdat->node_id, pgdat->node_mem_map);
 383         }
 384
 385         mem_map = NODE_DATA(0)->node_mem_map;
 386
 387         memset(zero_page, 0, PAGE_SIZE);
 388         empty_zero_page = virt_to_page(zero_page);
 389         flush_dcache_page(empty_zero_page);
 390 }
 391
 392 void __init mem_init(void)
 393 {
 394         int codesize, reservedpages, datasize, initsize;
 395         int nid, i;
 396
 397         reservedpages = 0;
 398         high_memory = NULL;
 399
 400         /* this will put all low memory onto the freelists */
 401         for_each_online_node(nid) {
 402                 pg_data_t *pgdat = NODE_DATA(nid);
 403                 unsigned long node_pages = 0;
 404                 void *node_high_memory;
 405
 406                 num_physpages += pgdat->node_present_pages;
 407
 408                 if (pgdat->node_spanned_pages != 0)
 409                         node_pages = free_all_bootmem_node(pgdat);
 410
 411                 totalram_pages += node_pages;
 412
 413                 for (i = 0; i < node_pages; i++)
 414                         if (PageReserved(pgdat->node_mem_map + i))
 415                                 reservedpages++;
 416
 417                 node_high_memory = (void *)((pgdat->node_start_pfn
 418                                              + pgdat->node_spanned_pages)
 419                                             << PAGE_SHIFT);
 420                 if (node_high_memory > high_memory)
 421                         high_memory = node_high_memory;
 422         }
 423
 424         max_mapnr = MAP_NR(high_memory);
 425
 426         codesize = (unsigned long)_etext - (unsigned long)_text;
 427         datasize = (unsigned long)_edata - (unsigned long)_data;
 428         initsize = (unsigned long)__init_end - (unsigned long)__init_begin;
 429
 430         printk ("Memory: %luk/%luk available (%dk kernel code, "
 431                 "%dk reserved, %dk data, %dk init)\n",
 432                 (unsigned long)nr_free_pages() << (PAGE_SHIFT - 10),
 433                 totalram_pages << (PAGE_SHIFT - 10),
 434                 codesize >> 10,
 435                 reservedpages << (PAGE_SHIFT - 10),
 436                 datasize >> 10,
 437                 initsize >> 10);
 438 }
 439
 440 static inline void free_area(unsigned long addr, unsigned long end, char *s)
 441 {
 442         unsigned int size = (end - addr) >> 10;
 443
 444         for (; addr < end; addr += PAGE_SIZE) {
 445                 struct page *page = virt_to_page(addr);
 446                 ClearPageReserved(page);
 447                 init_page_count(page);
 448                 free_page(addr);
 449                 totalram_pages++;
 450         }
 451
 452         if (size && s)
 453                 printk(KERN_INFO "Freeing %s memory: %dK (%lx - %lx)\n",
 454                        s, size, end - (size << 10), end);
 455 }
 456
 457 void free_initmem(void)
 458 {
 459         free_area((unsigned long)__init_begin, (unsigned long)__init_end,
 460                   "init");
 461 }
 462
 463 #ifdef CONFIG_BLK_DEV_INITRD
 464
 465 static int keep_initrd;
 466
 467 void free_initrd_mem(unsigned long start, unsigned long end)
 468 {
 469         if (!keep_initrd)
 470                 free_area(start, end, "initrd");
 471 }
 472
 473 static int __init keepinitrd_setup(char *__unused)
 474 {
 475         keep_initrd = 1;
 476         return 1;
 477 }
 478
 479 __setup("keepinitrd", keepinitrd_setup);
 480 #endif