Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=856783b37a958086c83ea44544d366affd0c2c4b
Commit:     856783b37a958086c83ea44544d366affd0c2c4b
Parent:     c605999bd9a90a7a9915666f4531c60928cbc368
Author:     Yi Li <[EMAIL PROTECTED]>
AuthorDate: Sat Feb 9 02:26:01 2008 +0800
Committer:  Bryan Wu <[EMAIL PROTECTED]>
CommitDate: Sat Feb 9 02:26:01 2008 +0800

    [Blackfin] arch: add "[EMAIL PROTECTED]" and "memmap=nn[KMG]$ss[KMG]" 
options to blackfin, based on arch/i386/kernel/e820.c
    
    Signed-off-by: Yi Li <[EMAIL PROTECTED]>
    Signed-off-by: Bryan Wu <[EMAIL PROTECTED]>
---
 arch/blackfin/kernel/setup.c |  541 +++++++++++++++++++++++++++++++++---------
 arch/blackfin/mm/init.c      |   12 +-
 2 files changed, 431 insertions(+), 122 deletions(-)

diff --git a/arch/blackfin/kernel/setup.c b/arch/blackfin/kernel/setup.c
index 289ea9d..2f156bf 100644
--- a/arch/blackfin/kernel/setup.c
+++ b/arch/blackfin/kernel/setup.c
@@ -34,6 +34,7 @@
 #include <linux/cpu.h>
 #include <linux/module.h>
 #include <linux/tty.h>
+#include <linux/pfn.h>
 
 #include <linux/ext2_fs.h>
 #include <linux/cramfs_fs.h>
@@ -67,6 +68,29 @@ EXPORT_SYMBOL(mtd_size);
 
 char __initdata command_line[COMMAND_LINE_SIZE];
 
+/* boot memmap, for parsing "memmap=" */
+#define BFIN_MEMMAP_MAX                128 /* number of entries in bfin_memmap 
*/
+#define BFIN_MEMMAP_RAM                1
+#define BFIN_MEMMAP_RESERVED   2
+struct bfin_memmap {
+       int nr_map;
+       struct bfin_memmap_entry {
+               unsigned long long addr; /* start of memory segment */
+               unsigned long long size;
+               unsigned long type;
+       } map[BFIN_MEMMAP_MAX];
+} bfin_memmap __initdata;
+
+/* for memmap sanitization */
+struct change_member {
+       struct bfin_memmap_entry *pentry; /* pointer to original entry */
+       unsigned long long addr; /* address for this change point */
+};
+static struct change_member change_point_list[2*BFIN_MEMMAP_MAX] __initdata;
+static struct change_member *change_point[2*BFIN_MEMMAP_MAX] __initdata;
+static struct bfin_memmap_entry *overlap_list[BFIN_MEMMAP_MAX] __initdata;
+static struct bfin_memmap_entry new_map[BFIN_MEMMAP_MAX] __initdata;
+
 void __init bf53x_cache_init(void)
 {
 #if defined(CONFIG_BFIN_DCACHE) || defined(CONFIG_BFIN_ICACHE)
@@ -123,12 +147,224 @@ void __init bf53x_relocate_l1_mem(void)
 
 }
 
+/* add_memory_region to memmap */
+static void __init add_memory_region(unsigned long long start,
+                             unsigned long long size, int type)
+{
+       int i;
+
+       i = bfin_memmap.nr_map;
+
+       if (i == BFIN_MEMMAP_MAX) {
+               printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
+               return;
+       }
+
+       bfin_memmap.map[i].addr = start;
+       bfin_memmap.map[i].size = size;
+       bfin_memmap.map[i].type = type;
+       bfin_memmap.nr_map++;
+}
+
+/*
+ * Sanitize the boot memmap, removing overlaps.
+ */
+static int __init sanitize_memmap(struct bfin_memmap_entry *map, int *pnr_map)
+{
+       struct change_member *change_tmp;
+       unsigned long current_type, last_type;
+       unsigned long long last_addr;
+       int chgidx, still_changing;
+       int overlap_entries;
+       int new_entry;
+       int old_nr, new_nr, chg_nr;
+       int i;
+
+       /*
+               Visually we're performing the following (1,2,3,4 = memory types)
+
+               Sample memory map (w/overlaps):
+                  ____22__________________
+                  ______________________4_
+                  ____1111________________
+                  _44_____________________
+                  11111111________________
+                  ____________________33__
+                  ___________44___________
+                  __________33333_________
+                  ______________22________
+                  ___________________2222_
+                  _________111111111______
+                  _____________________11_
+                  _________________4______
+
+               Sanitized equivalent (no overlap):
+                  1_______________________
+                  _44_____________________
+                  ___1____________________
+                  ____22__________________
+                  ______11________________
+                  _________1______________
+                  __________3_____________
+                  ___________44___________
+                  _____________33_________
+                  _______________2________
+                  ________________1_______
+                  _________________4______
+                  ___________________2____
+                  ____________________33__
+                  ______________________4_
+       */
+       /* if there's only one memory region, don't bother */
+       if (*pnr_map < 2)
+               return -1;
+
+       old_nr = *pnr_map;
+
+       /* bail out if we find any unreasonable addresses in memmap */
+       for (i = 0; i < old_nr; i++)
+               if (map[i].addr + map[i].size < map[i].addr)
+                       return -1;
+
+       /* create pointers for initial change-point information (for sorting) */
+       for (i = 0; i < 2*old_nr; i++)
+               change_point[i] = &change_point_list[i];
+
+       /* record all known change-points (starting and ending addresses),
+          omitting those that are for empty memory regions */
+       chgidx = 0;
+       for (i = 0; i < old_nr; i++)    {
+               if (map[i].size != 0) {
+                       change_point[chgidx]->addr = map[i].addr;
+                       change_point[chgidx++]->pentry = &map[i];
+                       change_point[chgidx]->addr = map[i].addr + map[i].size;
+                       change_point[chgidx++]->pentry = &map[i];
+               }
+       }
+       chg_nr = chgidx;        /* true number of change-points */
+
+       /* sort change-point list by memory addresses (low -> high) */
+       still_changing = 1;
+       while (still_changing)  {
+               still_changing = 0;
+               for (i = 1; i < chg_nr; i++)  {
+                       /* if <current_addr> > <last_addr>, swap */
+                       /* or, if current=<start_addr> & last=<end_addr>, swap 
*/
+                       if ((change_point[i]->addr < change_point[i-1]->addr) ||
+                               ((change_point[i]->addr == 
change_point[i-1]->addr) &&
+                                (change_point[i]->addr == 
change_point[i]->pentry->addr) &&
+                                (change_point[i-1]->addr != 
change_point[i-1]->pentry->addr))
+                          ) {
+                               change_tmp = change_point[i];
+                               change_point[i] = change_point[i-1];
+                               change_point[i-1] = change_tmp;
+                               still_changing = 1;
+                       }
+               }
+       }
+
+       /* create a new memmap, removing overlaps */
+       overlap_entries = 0;     /* number of entries in the overlap table */
+       new_entry = 0;   /* index for creating new memmap entries */
+       last_type = 0;           /* start with undefined memory type */
+       last_addr = 0;           /* start with 0 as last starting address */
+       /* loop through change-points, determining affect on the new memmap */
+       for (chgidx = 0; chgidx < chg_nr; chgidx++) {
+               /* keep track of all overlapping memmap entries */
+               if (change_point[chgidx]->addr == 
change_point[chgidx]->pentry->addr) {
+                       /* add map entry to overlap list (> 1 entry implies an 
overlap) */
+                       overlap_list[overlap_entries++] = 
change_point[chgidx]->pentry;
+               } else {
+                       /* remove entry from list (order independent, so swap 
with last) */
+                       for (i = 0; i < overlap_entries; i++) {
+                               if (overlap_list[i] == 
change_point[chgidx]->pentry)
+                                       overlap_list[i] = 
overlap_list[overlap_entries-1];
+                       }
+                       overlap_entries--;
+               }
+               /* if there are overlapping entries, decide which "type" to use 
*/
+               /* (larger value takes precedence -- 1=usable, 
2,3,4,4+=unusable) */
+               current_type = 0;
+               for (i = 0; i < overlap_entries; i++)
+                       if (overlap_list[i]->type > current_type)
+                               current_type = overlap_list[i]->type;
+               /* continue building up new memmap based on this information */
+               if (current_type != last_type)  {
+                       if (last_type != 0) {
+                               new_map[new_entry].size =
+                                       change_point[chgidx]->addr - last_addr;
+                               /* move forward only if the new size was 
non-zero */
+                               if (new_map[new_entry].size != 0)
+                                       if (++new_entry >= BFIN_MEMMAP_MAX)
+                                               break;  /* no more space left 
for new entries */
+                       }
+                       if (current_type != 0) {
+                               new_map[new_entry].addr = 
change_point[chgidx]->addr;
+                               new_map[new_entry].type = current_type;
+                               last_addr = change_point[chgidx]->addr;
+                       }
+                       last_type = current_type;
+               }
+       }
+       new_nr = new_entry;   /* retain count for new entries */
+
+       /* copy new  mapping into original location */
+       memcpy(map, new_map, new_nr*sizeof(struct bfin_memmap_entry));
+       *pnr_map = new_nr;
+
+       return 0;
+}
+
+static void __init print_memory_map(char *who)
+{
+       int i;
+
+       for (i = 0; i < bfin_memmap.nr_map; i++) {
+               printk(KERN_DEBUG " %s: %016Lx - %016Lx ", who,
+                       bfin_memmap.map[i].addr,
+                       bfin_memmap.map[i].addr + bfin_memmap.map[i].size);
+               switch (bfin_memmap.map[i].type) {
+               case BFIN_MEMMAP_RAM:
+                               printk("(usable)\n");
+                               break;
+               case BFIN_MEMMAP_RESERVED:
+                               printk("(reserved)\n");
+                               break;
+               default:        printk("type %lu\n", bfin_memmap.map[i].type);
+                               break;
+               }
+       }
+}
+
+static __init int parse_memmap(char *arg)
+{
+       unsigned long long start_at, mem_size;
+
+       if (!arg)
+               return -EINVAL;
+
+       mem_size = memparse(arg, &arg);
+       if (*arg == '@') {
+               start_at = memparse(arg+1, &arg);
+               add_memory_region(start_at, mem_size, BFIN_MEMMAP_RAM);
+       } else if (*arg == '$') {
+               start_at = memparse(arg+1, &arg);
+               add_memory_region(start_at, mem_size, BFIN_MEMMAP_RESERVED);
+       }
+
+       return 0;
+}
+
 /*
  * Initial parsing of the command line.  Currently, we support:
  *  - Controlling the linux memory size: mem=xxx[KMG]
  *  - Controlling the physical memory size: max_mem=xxx[KMG][$][#]
  *       $ -> reserved memory is dcacheable
  *       # -> reserved memory is icacheable
+ *  - "[EMAIL PROTECTED]" defines a memory region
+ *       @ from <start> to <start>+<mem>, type RAM
+ *       $ from <start> to <start>+<mem>, type RESERVED
+ *
  */
 static __init void parse_cmdline_early(char *cmdline_p)
 {
@@ -136,7 +372,6 @@ static __init void parse_cmdline_early(char *cmdline_p)
        unsigned int memsize;
        for (;;) {
                if (c == ' ') {
-
                        if (!memcmp(to, "mem=", 4)) {
                                to += 4;
                                memsize = memparse(to, &to);
@@ -162,6 +397,9 @@ static __init void parse_cmdline_early(char *cmdline_p)
                        } else if (!memcmp(to, "earlyprintk=", 12)) {
                                to += 12;
                                setup_early_printk(to);
+                       } else if (!memcmp(to, "memmap=", 7)) {
+                               to += 7;
+                               parse_memmap(to);
                        }
                }
                c = *(to++);
@@ -170,75 +408,32 @@ static __init void parse_cmdline_early(char *cmdline_p)
        }
 }
 
-void __init setup_arch(char **cmdline_p)
+/*
+ * Setup memory defaults from user config.
+ * The physical memory layout looks like:
+ *
+ *  [_rambase, _ramstart]:             kernel image
+ *  [memory_start, memory_end]:                dynamic memory managed by kernel
+ *  [memory_end, _ramend]:             reserved memory
+ *     [meory_mtd_start(memory_end),
+ *             memory_mtd_start + mtd_size]:   rootfs (if any)
+ *     [_ramend - DMA_UNCACHED_REGION,
+ *             _ramend]:                       uncached DMA region
+ *  [_ramend, physical_mem_end]:       memory not managed by kernel
+ *
+ */
+static __init void  memory_setup(void)
 {
-       int bootmap_size;
-       unsigned long l1_length, sclk, cclk;
-#ifdef CONFIG_MTD_UCLINUX
-       unsigned long mtd_phys = 0;
-#endif
-
-#ifdef CONFIG_DUMMY_CONSOLE
-       conswitchp = &dummy_con;
-#endif
-
-#if defined(CONFIG_CMDLINE_BOOL)
-       strncpy(&command_line[0], CONFIG_CMDLINE, sizeof(command_line));
-       command_line[sizeof(command_line) - 1] = 0;
-#endif
-
-       /* Keep a copy of command line */
-       *cmdline_p = &command_line[0];
-       memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
-       boot_command_line[COMMAND_LINE_SIZE - 1] = '\0';
-
-       /* setup memory defaults from the user config */
-       physical_mem_end = 0;
-       _ramend = CONFIG_MEM_SIZE * 1024 * 1024;
-
-       parse_cmdline_early(&command_line[0]);
-
-       cclk = get_cclk();
-       sclk = get_sclk();
-
-#if !defined(CONFIG_BFIN_KERNEL_CLOCK)
-       if (ANOMALY_05000273 && cclk == sclk)
-               panic("ANOMALY 05000273, SCLK can not be same as CCLK");
-#endif
+       _rambase = (unsigned long)_stext;
+       _ramstart = (unsigned long)__bss_stop;
 
-#ifdef BF561_FAMILY
-       if (ANOMALY_05000266) {
-               bfin_read_IMDMA_D0_IRQ_STATUS();
-               bfin_read_IMDMA_D1_IRQ_STATUS();
+       if (DMA_UNCACHED_REGION > (_ramend - _ramstart)) {
+               console_init();
+               panic("DMA region exceeds memory limit: %lu.\n",
+                       _ramend - _ramstart);
        }
-#endif
-
-       printk(KERN_INFO "Hardware Trace ");
-       if (bfin_read_TBUFCTL() & 0x1 )
-               printk("Active ");
-       else
-               printk("Off ");
-       if (bfin_read_TBUFCTL() & 0x2)
-               printk("and Enabled\n");
-       else
-       printk("and Disabled\n");
-
-
-#if defined(CONFIG_CHR_DEV_FLASH) || defined(CONFIG_BLK_DEV_FLASH)
-       /* we need to initialize the Flashrom device here since we might
-        * do things with flash early on in the boot
-        */
-       flash_probe();
-#endif
-
-       if (physical_mem_end == 0)
-               physical_mem_end = _ramend;
-
-       /* by now the stack is part of the init task */
        memory_end = _ramend - DMA_UNCACHED_REGION;
 
-       _ramstart = (unsigned long)__bss_stop;
-       _rambase = (unsigned long)_stext;
 #ifdef CONFIG_MPU
        /* Round up to multiple of 4MB.  */
        memory_start = (_ramstart + 0x3fffff) & ~0x3fffff;
@@ -319,13 +514,178 @@ void __init setup_arch(char **cmdline_p)
 #endif
 
 #if !defined(CONFIG_MTD_UCLINUX)
-       memory_end -= SIZE_4K; /*In case there is no valid CPLB behind 
memory_end make sure we don't get to close*/
+       /*In case there is no valid CPLB behind memory_end make sure we don't 
get to close*/
+       memory_end -= SIZE_4K;
 #endif
+
        init_mm.start_code = (unsigned long)_stext;
        init_mm.end_code = (unsigned long)_etext;
        init_mm.end_data = (unsigned long)_edata;
        init_mm.brk = (unsigned long)0;
 
+       printk(KERN_INFO "Board Memory: %ldMB\n", physical_mem_end >> 20);
+       printk(KERN_INFO "Kernel Managed Memory: %ldMB\n", _ramend >> 20);
+
+       printk( KERN_INFO "Memory map:\n"
+               KERN_INFO "  text      = 0x%p-0x%p\n"
+               KERN_INFO "  rodata    = 0x%p-0x%p\n"
+               KERN_INFO "  data      = 0x%p-0x%p\n"
+               KERN_INFO "    stack   = 0x%p-0x%p\n"
+               KERN_INFO "  init      = 0x%p-0x%p\n"
+               KERN_INFO "  bss       = 0x%p-0x%p\n"
+               KERN_INFO "  available = 0x%p-0x%p\n"
+#ifdef CONFIG_MTD_UCLINUX
+               KERN_INFO "  rootfs    = 0x%p-0x%p\n"
+#endif
+#if DMA_UNCACHED_REGION > 0
+               KERN_INFO "  DMA Zone  = 0x%p-0x%p\n"
+#endif
+               , _stext, _etext,
+               __start_rodata, __end_rodata,
+               _sdata, _edata,
+               (void *)&init_thread_union,
+               (void *)((int)(&init_thread_union) + 0x2000),
+              __init_begin, __init_end,
+              __bss_start, __bss_stop,
+              (void *)_ramstart, (void *)memory_end
+#ifdef CONFIG_MTD_UCLINUX
+               , (void *)memory_mtd_start, (void *)(memory_mtd_start + 
mtd_size)
+#endif
+#if DMA_UNCACHED_REGION > 0
+               , (void *)(_ramend - DMA_UNCACHED_REGION), (void *)(_ramend)
+#endif
+               );
+}
+
+static __init void setup_bootmem_allocator(void)
+{
+       int bootmap_size;
+       int i;
+       unsigned long min_pfn, max_pfn;
+       unsigned long curr_pfn, last_pfn, size;
+
+       /* mark memory between memory_start and memory_end usable */
+       add_memory_region(memory_start,
+               memory_end - memory_start, BFIN_MEMMAP_RAM);
+       /* sanity check for overlap */
+       sanitize_memmap(bfin_memmap.map, &bfin_memmap.nr_map);
+       print_memory_map("boot memmap");
+
+       min_pfn = PAGE_OFFSET >> PAGE_SHIFT;
+       max_pfn = memory_end >> PAGE_SHIFT;
+
+       /*
+        * give all the memory to the bootmap allocator,  tell it to put the
+        * boot mem_map at the start of memory.
+        */
+       bootmap_size = init_bootmem_node(NODE_DATA(0),
+                       memory_start >> PAGE_SHIFT,     /* map goes here */
+                       min_pfn, max_pfn);
+
+       /* register the memmap regions with the bootmem allocator */
+       for (i = 0; i < bfin_memmap.nr_map; i++) {
+               /*
+                * Reserve usable memory
+                */
+               if (bfin_memmap.map[i].type != BFIN_MEMMAP_RAM)
+                       continue;
+               /*
+                * We are rounding up the start address of usable memory:
+                */
+               curr_pfn = PFN_UP(bfin_memmap.map[i].addr);
+               if (curr_pfn >= max_pfn)
+                       continue;
+               /*
+                * ... and at the end of the usable range downwards:
+                */
+               last_pfn = PFN_DOWN(bfin_memmap.map[i].addr +
+                                        bfin_memmap.map[i].size);
+
+               if (last_pfn > max_pfn)
+                       last_pfn = max_pfn;
+
+               /*
+                * .. finally, did all the rounding and playing
+                * around just make the area go away?
+                */
+               if (last_pfn <= curr_pfn)
+                       continue;
+
+               size = last_pfn - curr_pfn;
+               free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
+       }
+
+       /* reserve memory before memory_start, including bootmap */
+       reserve_bootmem(PAGE_OFFSET,
+               memory_start + bootmap_size + PAGE_SIZE - 1 - PAGE_OFFSET,
+               BOOTMEM_DEFAULT);
+}
+
+void __init setup_arch(char **cmdline_p)
+{
+       unsigned long l1_length, sclk, cclk;
+#ifdef CONFIG_MTD_UCLINUX
+       unsigned long mtd_phys = 0;
+#endif
+
+#ifdef CONFIG_DUMMY_CONSOLE
+       conswitchp = &dummy_con;
+#endif
+
+#if defined(CONFIG_CMDLINE_BOOL)
+       strncpy(&command_line[0], CONFIG_CMDLINE, sizeof(command_line));
+       command_line[sizeof(command_line) - 1] = 0;
+#endif
+
+       /* Keep a copy of command line */
+       *cmdline_p = &command_line[0];
+       memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
+       boot_command_line[COMMAND_LINE_SIZE - 1] = '\0';
+
+       /* setup memory defaults from the user config */
+       physical_mem_end = 0;
+       _ramend = CONFIG_MEM_SIZE * 1024 * 1024;
+
+       memset(&bfin_memmap, 0, sizeof(bfin_memmap));
+
+       parse_cmdline_early(&command_line[0]);
+
+       if (physical_mem_end == 0)
+               physical_mem_end = _ramend;
+
+       memory_setup();
+
+       cclk = get_cclk();
+       sclk = get_sclk();
+
+#if !defined(CONFIG_BFIN_KERNEL_CLOCK)
+       if (ANOMALY_05000273 && cclk == sclk)
+               panic("ANOMALY 05000273, SCLK can not be same as CCLK");
+#endif
+
+#ifdef BF561_FAMILY
+       if (ANOMALY_05000266) {
+               bfin_read_IMDMA_D0_IRQ_STATUS();
+               bfin_read_IMDMA_D1_IRQ_STATUS();
+       }
+#endif
+       printk(KERN_INFO "Hardware Trace ");
+       if (bfin_read_TBUFCTL() & 0x1)
+               printk("Active ");
+       else
+               printk("Off ");
+       if (bfin_read_TBUFCTL() & 0x2)
+               printk("and Enabled\n");
+       else
+       printk("and Disabled\n");
+
+#if defined(CONFIG_CHR_DEV_FLASH) || defined(CONFIG_BLK_DEV_FLASH)
+       /* we need to initialize the Flashrom device here since we might
+        * do things with flash early on in the boot
+        */
+       flash_probe();
+#endif
+
        _bfin_swrst = bfin_read_SWRST();
 
        if (_bfin_swrst & RESET_DOUBLE)
@@ -361,55 +721,8 @@ void __init setup_arch(char **cmdline_p)
        if (ANOMALY_05000273 && (cclk >> 1) <= sclk)
                printk("\n\n\nANOMALY_05000273: CCLK must be >= 2*SCLK 
!!!\n\n\n");
 
-       printk(KERN_INFO "Board Memory: %ldMB\n", physical_mem_end >> 20);
-       printk(KERN_INFO "Kernel Managed Memory: %ldMB\n", _ramend >> 20);
-
-       printk(KERN_INFO "Memory map:\n"
-              KERN_INFO "  text      = 0x%p-0x%p\n"
-              KERN_INFO "  rodata    = 0x%p-0x%p\n"
-              KERN_INFO "  data      = 0x%p-0x%p\n"
-              KERN_INFO "    stack   = 0x%p-0x%p\n"
-              KERN_INFO "  init      = 0x%p-0x%p\n"
-              KERN_INFO "  bss       = 0x%p-0x%p\n"
-              KERN_INFO "  available = 0x%p-0x%p\n"
-#ifdef CONFIG_MTD_UCLINUX
-              KERN_INFO "  rootfs    = 0x%p-0x%p\n"
-#endif
-#if DMA_UNCACHED_REGION > 0
-              KERN_INFO "  DMA Zone  = 0x%p-0x%p\n"
-#endif
-              , _stext, _etext,
-              __start_rodata, __end_rodata,
-              _sdata, _edata,
-              (void *)&init_thread_union, (void *)((int)(&init_thread_union) + 
0x2000),
-              __init_begin, __init_end,
-              __bss_start, __bss_stop,
-              (void *)_ramstart, (void *)memory_end
-#ifdef CONFIG_MTD_UCLINUX
-              , (void *)memory_mtd_start, (void *)(memory_mtd_start + mtd_size)
-#endif
-#if DMA_UNCACHED_REGION > 0
-              , (void *)(_ramend - DMA_UNCACHED_REGION), (void *)(_ramend)
-#endif
-              );
-
-       /*
-        * give all the memory to the bootmap allocator,  tell it to put the
-        * boot mem_map at the start of memory
-        */
-       bootmap_size = init_bootmem_node(NODE_DATA(0), memory_start >> 
PAGE_SHIFT,      /* map goes here */
-                                        PAGE_OFFSET >> PAGE_SHIFT,
-                                        memory_end >> PAGE_SHIFT);
-       /*
-        * free the usable memory,  we have to make sure we do not free
-        * the bootmem bitmap so we then reserve it after freeing it :-)
-        */
-       free_bootmem(memory_start, memory_end - memory_start);
+       setup_bootmem_allocator();
 
-       reserve_bootmem(memory_start, bootmap_size, BOOTMEM_DEFAULT);
-       /*
-        * get kmalloc into gear
-        */
        paging_init();
 
        /* check the size of the l1 area */
diff --git a/arch/blackfin/mm/init.c b/arch/blackfin/mm/init.c
index eb1a12a..1f516c5 100644
--- a/arch/blackfin/mm/init.c
+++ b/arch/blackfin/mm/init.c
@@ -138,8 +138,7 @@ void __init mem_init(void)
 
        start_mem = PAGE_ALIGN(start_mem);
        max_mapnr = num_physpages = MAP_NR(high_memory);
-       printk(KERN_INFO "Kernel managed physical pages: %lu\n",
-               num_physpages);
+       printk(KERN_DEBUG "Kernel managed physical pages: %lu\n", 
num_physpages);
 
        /* This will put all memory onto the freelists. */
        totalram_pages = free_all_bootmem();
@@ -153,8 +152,7 @@ void __init mem_init(void)
        /* do not count in kernel image between _rambase and _ramstart */
        reservedpages -= (_ramstart - _rambase) >> PAGE_SHIFT;
 #if (defined(CONFIG_BFIN_ICACHE) && ANOMALY_05000263)
-       reservedpages += (_ramend - memory_end - DMA_UNCACHED_REGION) >>
-                               PAGE_SHIFT;
+       reservedpages += (_ramend - memory_end - DMA_UNCACHED_REGION) >> 
PAGE_SHIFT;
 #endif
 
        codek = (_etext - _stext) >> 10;
@@ -163,11 +161,9 @@ void __init mem_init(void)
 
        printk(KERN_INFO
             "Memory available: %luk/%luk RAM, "
-               "(%uk init code, %uk kernel code, "
-               "%uk data, %uk dma, %uk reserved)\n",
+               "(%uk init code, %uk kernel code, %uk data, %uk dma, %uk 
reserved)\n",
                (unsigned long) freepages << (PAGE_SHIFT-10), _ramend >> 10,
-               initk, codek, datak, DMA_UNCACHED_REGION >> 10,
-               (reservedpages << (PAGE_SHIFT-10)));
+               initk, codek, datak, DMA_UNCACHED_REGION >> 10, (reservedpages 
<< (PAGE_SHIFT-10)));
 
        /* Initialize the blackfin L1 Memory. */
        l1sram_init();
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to