1 files changed, 371 insertions, 113 deletions

diff --git a/arch/avr32/kernel/setup.c b/arch/avr32/kernel/setup.c
index a1a7c3c3f522..b279d66acf5f 100644
--- a/arch/avr32/kernel/setup.c
+++ b/arch/avr32/kernel/setup.c
@@ -8,12 +8,14 @@
 
 #include <linux/clk.h>
 #include <linux/init.h>
+#include <linux/initrd.h>
 #include <linux/sched.h>
 #include <linux/console.h>
 #include <linux/ioport.h>
 #include <linux/bootmem.h>
 #include <linux/fs.h>
 #include <linux/module.h>
+#include <linux/pfn.h>
 #include <linux/root_dev.h>
 #include <linux/cpu.h>
 #include <linux/kernel.h>
@@ -30,13 +32,6 @@
 extern int root_mountflags;
 
 /*
- * Bootloader-provided information about physical memory
- */
-struct tag_mem_range *mem_phys;
-struct tag_mem_range *mem_reserved;
-struct tag_mem_range *mem_ramdisk;
-
-/*
  * Initialize loops_per_jiffy as 5000000 (500MIPS).
  * Better make it too large than too small...
  */
@@ -48,48 +43,193 @@ EXPORT_SYMBOL(boot_cpu_data);
 static char __initdata command_line[COMMAND_LINE_SIZE];
 
 /*
- * Should be more than enough, but if you have a _really_ complex
- * setup, you might need to increase the size of this...
+ * Standard memory resources
  */
-static struct tag_mem_range __initdata mem_range_cache[32];
-static unsigned mem_range_next_free;
+static struct resource __initdata kernel_data = {
+        .name   = "Kernel data",
+        .start  = 0,
+        .end    = 0,
+        .flags  = IORESOURCE_MEM,
+};
+static struct resource __initdata kernel_code = {
+        .name   = "Kernel code",
+        .start  = 0,
+        .end    = 0,
+        .flags  = IORESOURCE_MEM,
+        .sibling = &kernel_data,
+};
 
 /*
- * Standard memory resources
+ * Available system RAM and reserved regions as singly linked
+ * lists. These lists are traversed using the sibling pointer in
+ * struct resource and are kept sorted at all times.
  */
-static struct resource mem_res[] = {
-        {
-                .name   = "Kernel code",
-                .start  = 0,
-                .end    = 0,
-                .flags  = IORESOURCE_MEM
-        },
-        {
-                .name   = "Kernel data",
-                .start  = 0,
-                .end    = 0,
-                .flags  = IORESOURCE_MEM,
-        },
-};
+static struct resource *__initdata system_ram;
+static struct resource *__initdata reserved = &kernel_code;
+
+/*
+ * We need to allocate these before the bootmem allocator is up and
+ * running, so we need this "cache". 32 entries are probably enough
+ * for all but the most insanely complex systems.
+ */
+static struct resource __initdata res_cache[32];
+static unsigned int __initdata res_cache_next_free;
+
+static void __init resource_init(void)
+{
+        struct resource *mem, *res;
+        struct resource *new;
+
+        kernel_code.start = __pa(init_mm.start_code);
+
+        for (mem = system_ram; mem; mem = mem->sibling) {
+                new = alloc_bootmem_low(sizeof(struct resource));
+                memcpy(new, mem, sizeof(struct resource));
+
+                new->sibling = NULL;
+                if (request_resource(&iomem_resource, new))
+                        printk(KERN_WARNING "Bad RAM resource %08x-%08x\n",
+                               mem->start, mem->end);
+        }
+
+        for (res = reserved; res; res = res->sibling) {
+                new = alloc_bootmem_low(sizeof(struct resource));
+                memcpy(new, res, sizeof(struct resource));
+
+                new->sibling = NULL;
+                if (insert_resource(&iomem_resource, new))
+                        printk(KERN_WARNING
+                               "Bad reserved resource %s (%08x-%08x)\n",
+                               res->name, res->start, res->end);
+        }
+}
+
+static void __init
+add_physical_memory(resource_size_t start, resource_size_t end)
+{
+        struct resource *new, *next, **pprev;
+
+        for (pprev = &system_ram, next = system_ram; next;
+             pprev = &next->sibling, next = next->sibling) {
+                if (end < next->start)
+                        break;
+                if (start <= next->end) {
+                        printk(KERN_WARNING
+                               "Warning: Physical memory map is broken\n");
+                        printk(KERN_WARNING
+                               "Warning: %08x-%08x overlaps %08x-%08x\n",
+                               start, end, next->start, next->end);
+                        return;
+                }
+        }
+
+        if (res_cache_next_free >= ARRAY_SIZE(res_cache)) {
+                printk(KERN_WARNING
+                       "Warning: Failed to add physical memory %08x-%08x\n",
+                       start, end);
+                return;
+        }
+
+        new = &res_cache[res_cache_next_free++];
+        new->start = start;
+        new->end = end;
+        new->name = "System RAM";
+        new->flags = IORESOURCE_MEM;
+
+        *pprev = new;
+}
+
+static int __init
+add_reserved_region(resource_size_t start, resource_size_t end,
+                    const char *name)
+{
+        struct resource *new, *next, **pprev;
+
+        if (end < start)
+                return -EINVAL;
+
+        if (res_cache_next_free >= ARRAY_SIZE(res_cache))
+                return -ENOMEM;
+
+        for (pprev = &reserved, next = reserved; next;
+             pprev = &next->sibling, next = next->sibling) {
+                if (end < next->start)
+                        break;
+                if (start <= next->end)
+                        return -EBUSY;
+        }
+
+        new = &res_cache[res_cache_next_free++];
+        new->start = start;
+        new->end = end;
+        new->name = name;
+        new->flags = IORESOURCE_MEM;
+
+        *pprev = new;
+
+        return 0;
+}
+
+static unsigned long __init
+find_free_region(const struct resource *mem, resource_size_t size,
+                 resource_size_t align)
+{
+        struct resource *res;
+        unsigned long target;
+
+        target = ALIGN(mem->start, align);
+        for (res = reserved; res; res = res->sibling) {
+                if ((target + size) <= res->start)
+                        break;
+                if (target <= res->end)
+                        target = ALIGN(res->end + 1, align);
+        }
+
+        if ((target + size) > (mem->end + 1))
+                return mem->end + 1;
+
+        return target;
+}
+
+static int __init
+alloc_reserved_region(resource_size_t *start, resource_size_t size,
+                      resource_size_t align, const char *name)
+{
+        struct resource *mem;
+        resource_size_t target;
+        int ret;
+
+        for (mem = system_ram; mem; mem = mem->sibling) {
+                target = find_free_region(mem, size, align);
+                if (target <= mem->end) {
+                        ret = add_reserved_region(target, target + size - 1,
+                                                  name);
+                        if (!ret)
+                                *start = target;
+                        return ret;
+                }
+        }
 
-#define kernel_code     mem_res[0]
-#define kernel_data     mem_res[1]
+        return -ENOMEM;
+}
 
 /*
  * Early framebuffer allocation. Works as follows:
  *   - If fbmem_size is zero, nothing will be allocated or reserved.
  *   - If fbmem_start is zero when setup_bootmem() is called,
- *     fbmem_size bytes will be allocated from the bootmem allocator.
+ *     a block of fbmem_size bytes will be reserved before bootmem
+ *     initialization. It will be aligned to the largest page size
+ *     that fbmem_size is a multiple of.
  *   - If fbmem_start is nonzero, an area of size fbmem_size will be
- *     reserved at the physical address fbmem_start if necessary. If
- *     the area isn't in a memory region known to the kernel, it will
- *     be left alone.
+ *     reserved at the physical address fbmem_start if possible. If
+ *     it collides with other reserved memory, a different block of
+ *     same size will be allocated, just as if fbmem_start was zero.
  *
  * Board-specific code may use these variables to set up platform data
  * for the framebuffer driver if fbmem_size is nonzero.
  */
-static unsigned long __initdata fbmem_start;
-static unsigned long __initdata fbmem_size;
+resource_size_t __initdata fbmem_start;
+resource_size_t __initdata fbmem_size;
 
 /*
  * "fbmem=xxx[kKmM]" allocates the specified amount of boot memory for
@@ -103,48 +243,42 @@ static unsigned long __initdata fbmem_size;
  */
 static int __init early_parse_fbmem(char *p)
 {
+        int ret;
+        unsigned long align;
+
         fbmem_size = memparse(p, &p);
-        if (*p == '@')
+        if (*p == '@') {
                 fbmem_start = memparse(p, &p);
-        return 0;
-}
-early_param("fbmem", early_parse_fbmem);
-
-static inline void __init resource_init(void)
-{
-        struct tag_mem_range *region;
-
-        kernel_code.start = __pa(init_mm.start_code);
-        kernel_code.end = __pa(init_mm.end_code - 1);
-        kernel_data.start = __pa(init_mm.end_code);
-        kernel_data.end = __pa(init_mm.brk - 1);
-
-        for (region = mem_phys; region; region = region->next) {
-                struct resource *res;
-                unsigned long phys_start, phys_end;
-
-                if (region->size == 0)
-                        continue;
-
-                phys_start = region->addr;
-                phys_end = phys_start + region->size - 1;
-
-                res = alloc_bootmem_low(sizeof(*res));
-                res->name = "System RAM";
-                res->start = phys_start;
-                res->end = phys_end;
-                res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
-
-                request_resource (&iomem_resource, res);
+                ret = add_reserved_region(fbmem_start,
+                                          fbmem_start + fbmem_size - 1,
+                                          "Framebuffer");
+                if (ret) {
+                        printk(KERN_WARNING
+                               "Failed to reserve framebuffer memory\n");
+                        fbmem_start = 0;
+                }
+        }
 
-                if (kernel_code.start >= res->start &&
-                    kernel_code.end <= res->end)
-                        request_resource (res, &kernel_code);
-                if (kernel_data.start >= res->start &&
-                    kernel_data.end <= res->end)
-                        request_resource (res, &kernel_data);
+        if (!fbmem_start) {
+                if ((fbmem_size & 0x000fffffUL) == 0)
+                        align = 0x100000;       /* 1 MiB */
+                else if ((fbmem_size & 0x0000ffffUL) == 0)
+                        align = 0x10000;        /* 64 KiB */
+                else
+                        align = 0x1000;         /* 4 KiB */
+
+                ret = alloc_reserved_region(&fbmem_start, fbmem_size,
+                                            align, "Framebuffer");
+                if (ret) {
+                        printk(KERN_WARNING
+                               "Failed to allocate framebuffer memory\n");
+                        fbmem_size = 0;
+                }
         }
+
+        return 0;
 }
+early_param("fbmem", early_parse_fbmem);
 
 static int __init parse_tag_core(struct tag *tag)
 {
@@ -157,11 +291,9 @@ static int __init parse_tag_core(struct tag *tag)
 }
 __tagtable(ATAG_CORE, parse_tag_core);
 
-static int __init parse_tag_mem_range(struct tag *tag,
-                                      struct tag_mem_range **root)
+static int __init parse_tag_mem(struct tag *tag)
 {
-        struct tag_mem_range *cur, **pprev;
-        struct tag_mem_range *new;
+        unsigned long start, end;
 
         /*
          * Ignore zero-sized entries. If we're running standalone, the
@@ -171,34 +303,53 @@ static int __init parse_tag_mem_range(struct tag *tag,
         if (tag->u.mem_range.size == 0)
                 return 0;
 
-        /*
-         * Copy the data so the bootmem init code doesn't need to care
-         * about it.
-         */
-        if (mem_range_next_free >= ARRAY_SIZE(mem_range_cache))
-                panic("Physical memory map too complex!\n");
+        start = tag->u.mem_range.addr;
+        end = tag->u.mem_range.addr + tag->u.mem_range.size - 1;
+
+        add_physical_memory(start, end);
+        return 0;
+}
+__tagtable(ATAG_MEM, parse_tag_mem);
+
+static int __init parse_tag_rdimg(struct tag *tag)
+{
+#ifdef CONFIG_INITRD
+        struct tag_mem_range *mem = &tag->u.mem_range;
+        int ret;
 
-        new = &mem_range_cache[mem_range_next_free++];
-        *new = tag->u.mem_range;
+        if (initrd_start) {
+                printk(KERN_WARNING
+                       "Warning: Only the first initrd image will be used\n");
+                return 0;
+        }
 
-        pprev = root;
-        cur = *root;
-        while (cur) {
-                pprev = &cur->next;
-                cur = cur->next;
+        ret = add_reserved_region(mem->start, mem->start + mem->size - 1,
+                                  "initrd");
+        if (ret) {
+                printk(KERN_WARNING
+                       "Warning: Failed to reserve initrd memory\n");
+                return ret;
         }
 
-        *pprev = new;
-        new->next = NULL;
+        initrd_start = (unsigned long)__va(mem->addr);
+        initrd_end = initrd_start + mem->size;
+#else
+        printk(KERN_WARNING "RAM disk image present, but "
+               "no initrd support in kernel, ignoring\n");
+#endif
 
         return 0;
 }
+__tagtable(ATAG_RDIMG, parse_tag_rdimg);
 
-static int __init parse_tag_mem(struct tag *tag)
+static int __init parse_tag_rsvd_mem(struct tag *tag)
 {
-        return parse_tag_mem_range(tag, &mem_phys);
+        struct tag_mem_range *mem = &tag->u.mem_range;
+
+        return add_reserved_region(mem->addr, mem->addr + mem->size - 1,
+                                   "Reserved");
 }
-__tagtable(ATAG_MEM, parse_tag_mem);
+__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem);
 
 static int __init parse_tag_cmdline(struct tag *tag)
 {
@@ -207,12 +358,6 @@ static int __init parse_tag_cmdline(struct tag *tag)
 }
 __tagtable(ATAG_CMDLINE, parse_tag_cmdline);
 
-static int __init parse_tag_rdimg(struct tag *tag)
-{
-        return parse_tag_mem_range(tag, &mem_ramdisk);
-}
-__tagtable(ATAG_RDIMG, parse_tag_rdimg);
-
 static int __init parse_tag_clock(struct tag *tag)
 {
         /*
@@ -223,12 +368,6 @@ static int __init parse_tag_clock(struct tag *tag)
 }
 __tagtable(ATAG_CLOCK, parse_tag_clock);
 
-static int __init parse_tag_rsvd_mem(struct tag *tag)
-{
-        return parse_tag_mem_range(tag, &mem_reserved);
-}
-__tagtable(ATAG_RSVD_MEM, parse_tag_rsvd_mem);
-
 /*
  * Scan the tag table for this tag, and call its parse function. The
  * tag table is built by the linker from all the __tagtable
@@ -260,10 +399,137 @@ static void __init parse_tags(struct tag *t)
                                t->hdr.tag);
 }
 
+/*
+ * Find a free memory region large enough for storing the
+ * bootmem bitmap.
+ */
+static unsigned long __init
+find_bootmap_pfn(const struct resource *mem)
+{
+        unsigned long bootmap_pages, bootmap_len;
+        unsigned long node_pages = PFN_UP(mem->end - mem->start + 1);
+        unsigned long bootmap_start;
+
+        bootmap_pages = bootmem_bootmap_pages(node_pages);
+        bootmap_len = bootmap_pages << PAGE_SHIFT;
+
+        /*
+         * Find a large enough region without reserved pages for
+         * storing the bootmem bitmap. We can take advantage of the
+         * fact that all lists have been sorted.
+         *
+         * We have to check that we don't collide with any reserved
+         * regions, which includes the kernel image and any RAMDISK
+         * images.
+         */
+        bootmap_start = find_free_region(mem, bootmap_len, PAGE_SIZE);
+
+        return bootmap_start >> PAGE_SHIFT;
+}
+
+#define MAX_LOWMEM      HIGHMEM_START
+#define MAX_LOWMEM_PFN  PFN_DOWN(MAX_LOWMEM)
+
+static void __init setup_bootmem(void)
+{
+        unsigned bootmap_size;
+        unsigned long first_pfn, bootmap_pfn, pages;
+        unsigned long max_pfn, max_low_pfn;
+        unsigned node = 0;
+        struct resource *res;
+
+        printk(KERN_INFO "Physical memory:\n");
+        for (res = system_ram; res; res = res->sibling)
+                printk("  %08x-%08x\n", res->start, res->end);
+        printk(KERN_INFO "Reserved memory:\n");
+        for (res = reserved; res; res = res->sibling)
+                printk("  %08x-%08x: %s\n",
+                       res->start, res->end, res->name);
+
+        nodes_clear(node_online_map);
+
+        if (system_ram->sibling)
+                printk(KERN_WARNING "Only using first memory bank\n");
+
+        for (res = system_ram; res; res = NULL) {
+                first_pfn = PFN_UP(res->start);
+                max_low_pfn = max_pfn = PFN_DOWN(res->end + 1);
+                bootmap_pfn = find_bootmap_pfn(res);
+                if (bootmap_pfn > max_pfn)
+                        panic("No space for bootmem bitmap!\n");
+
+                if (max_low_pfn > MAX_LOWMEM_PFN) {
+                        max_low_pfn = MAX_LOWMEM_PFN;
+#ifndef CONFIG_HIGHMEM
+                        /*
+                         * Lowmem is memory that can be addressed
+                         * directly through P1/P2
+                         */
+                        printk(KERN_WARNING
+                               "Node %u: Only %ld MiB of memory will be used.\n",
+                               node, MAX_LOWMEM >> 20);
+                        printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
+#else
+#error HIGHMEM is not supported by AVR32 yet
+#endif
+                }
+
+                /* Initialize the boot-time allocator with low memory only. */
+                bootmap_size = init_bootmem_node(NODE_DATA(node), bootmap_pfn,
+                                                 first_pfn, max_low_pfn);
+
+                /*
+                 * Register fully available RAM pages with the bootmem
+                 * allocator.
+                 */
+                pages = max_low_pfn - first_pfn;
+                free_bootmem_node (NODE_DATA(node), PFN_PHYS(first_pfn),
+                                   PFN_PHYS(pages));
+
+                /* Reserve space for the bootmem bitmap... */
+                reserve_bootmem_node(NODE_DATA(node),
+                                     PFN_PHYS(bootmap_pfn),
+                                     bootmap_size);
+
+                /* ...and any other reserved regions. */
+                for (res = reserved; res; res = res->sibling) {
+                        if (res->start > PFN_PHYS(max_pfn))
+                                break;
+
+                        /*
+                         * resource_init will complain about partial
+                         * overlaps, so we'll just ignore such
+                         * resources for now.
+                         */
+                        if (res->start >= PFN_PHYS(first_pfn)
+                            && res->end < PFN_PHYS(max_pfn))
+                                reserve_bootmem_node(
+                                        NODE_DATA(node), res->start,
+                                        res->end - res->start + 1);
+                }
+
+                node_set_online(node);
+        }
+}
+
 void __init setup_arch (char **cmdline_p)
 {
         struct clk *cpu_clk;
 
+        init_mm.start_code = (unsigned long)_text;
+        init_mm.end_code = (unsigned long)_etext;
+        init_mm.end_data = (unsigned long)_edata;
+        init_mm.brk = (unsigned long)_end;
+
+        /*
+         * Include .init section to make allocations easier. It will
+         * be removed before the resource is actually requested.
+         */
+        kernel_code.start = __pa(__init_begin);
+        kernel_code.end = __pa(init_mm.end_code - 1);
+        kernel_data.start = __pa(init_mm.end_code);
+        kernel_data.end = __pa(init_mm.brk - 1);
+
         parse_tags(bootloader_tags);
 
         setup_processor();
@@ -289,24 +555,16 @@ void __init setup_arch (char **cmdline_p)
                        ((cpu_hz + 500) / 1000) % 1000);
         }
 
-        init_mm.start_code = (unsigned long) &_text;
-        init_mm.end_code = (unsigned long) &_etext;
-        init_mm.end_data = (unsigned long) &_edata;
-        init_mm.brk = (unsigned long) &_end;
-
         strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
         *cmdline_p = command_line;
         parse_early_param();
 
         setup_bootmem();
 
-        board_setup_fbmem(fbmem_start, fbmem_size);
-
 #ifdef CONFIG_VT
         conswitchp = &dummy_con;
 #endif
 
         paging_init();
-
         resource_init();
 }