[Blackfin] arch: add "memmap=nn[KMG]@ss[KMG]" and "memmap=nn[KMG]$ss[KMG]"... (856783b3) · Commits · e / devices / android_kernel_xiaomi_sm6125

arch/blackfin/kernel/setup.c

+427 −114

Original line number	Diff line number	Diff line
		@@ -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[2BFIN_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
		* - "memmap=XXX[KkmM][@][$]XXX[KkmM]" 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,48 +514,15 @@ 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;

		_bfin_swrst = bfin_read_SWRST();

		if (_bfin_swrst & RESET_DOUBLE)
		printk(KERN_INFO "Recovering from Double Fault event\n");
		else if (_bfin_swrst & RESET_WDOG)
		printk(KERN_INFO "Recovering from Watchdog event\n");
		else if (_bfin_swrst & RESET_SOFTWARE)
		printk(KERN_NOTICE "Reset caused by Software reset\n");

		printk(KERN_INFO "Blackfin support (C) 2004-2007 Analog Devices, Inc.\n");
		if (bfin_compiled_revid() == 0xffff)
		printk(KERN_INFO "Compiled for ADSP-%s Rev any\n", CPU);
		else if (bfin_compiled_revid() == -1)
		printk(KERN_INFO "Compiled for ADSP-%s Rev none\n", CPU);
		else
		printk(KERN_INFO "Compiled for ADSP-%s Rev 0.%d\n", CPU, bfin_compiled_revid());
		if (bfin_revid() != bfin_compiled_revid()) {
		if (bfin_compiled_revid() == -1)
		printk(KERN_ERR "Warning: Compiled for Rev none, but running on Rev %d\n",
		bfin_revid());
		else if (bfin_compiled_revid() != 0xffff)
		printk(KERN_ERR "Warning: Compiled for Rev %d, but running on Rev %d\n",
		bfin_compiled_revid(), bfin_revid());
		}
		if (bfin_revid() < SUPPORTED_REVID)
		printk(KERN_ERR "Warning: Unsupported Chip Revision ADSP-%s Rev 0.%d detected\n",
		CPU, bfin_revid());
		printk(KERN_INFO "Blackfin Linux support by http://blackfin.uclinux.org/\n");

		printk(KERN_INFO "Processor Speed: %lu MHz core clock and %lu MHz System Clock\n",
		cclk / 1000000, sclk / 1000000);

		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);

		@@ -381,7 +543,8 @@ void __init setup_arch(char **cmdline_p)
		, _stext, _etext,
		__start_rodata, __end_rodata,
		_sdata, _edata,
		(void )&init_thread_union, (void )((int)(&init_thread_union) + 0x2000),
		(void *)&init_thread_union,
		(void *)((int)(&init_thread_union) + 0x2000),
		__init_begin, __init_end,
		__bss_start, __bss_stop,
		(void )_ramstart, (void )memory_end
		@@ -392,24 +555,174 @@ void __init setup_arch(char **cmdline_p)
		, (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
		* 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);
		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++) {
		/*
		* free the usable memory, we have to make sure we do not free
		* the bootmem bitmap so we then reserve it after freeing it :-)
		* Reserve usable memory
		*/
		free_bootmem(memory_start, memory_end - memory_start);
		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;

		reserve_bootmem(memory_start, bootmap_size, BOOTMEM_DEFAULT);
		/*
		* get kmalloc into gear
		* .. 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)
		printk(KERN_INFO "Recovering from Double Fault event\n");
		else if (_bfin_swrst & RESET_WDOG)
		printk(KERN_INFO "Recovering from Watchdog event\n");
		else if (_bfin_swrst & RESET_SOFTWARE)
		printk(KERN_NOTICE "Reset caused by Software reset\n");

		printk(KERN_INFO "Blackfin support (C) 2004-2007 Analog Devices, Inc.\n");
		if (bfin_compiled_revid() == 0xffff)
		printk(KERN_INFO "Compiled for ADSP-%s Rev any\n", CPU);
		else if (bfin_compiled_revid() == -1)
		printk(KERN_INFO "Compiled for ADSP-%s Rev none\n", CPU);
		else
		printk(KERN_INFO "Compiled for ADSP-%s Rev 0.%d\n", CPU, bfin_compiled_revid());
		if (bfin_revid() != bfin_compiled_revid()) {
		if (bfin_compiled_revid() == -1)
		printk(KERN_ERR "Warning: Compiled for Rev none, but running on Rev %d\n",
		bfin_revid());
		else if (bfin_compiled_revid() != 0xffff)
		printk(KERN_ERR "Warning: Compiled for Rev %d, but running on Rev %d\n",
		bfin_compiled_revid(), bfin_revid());
		}
		if (bfin_revid() < SUPPORTED_REVID)
		printk(KERN_ERR "Warning: Unsupported Chip Revision ADSP-%s Rev 0.%d detected\n",
		CPU, bfin_revid());
		printk(KERN_INFO "Blackfin Linux support by http://blackfin.uclinux.org/\n");

		printk(KERN_INFO "Processor Speed: %lu MHz core clock and %lu MHz System Clock\n",
		cclk / 1000000, sclk / 1000000);

		if (ANOMALY_05000273 && (cclk >> 1) <= sclk)
		printk("\n\n\nANOMALY_05000273: CCLK must be >= 2*SCLK !!!\n\n\n");

		setup_bootmem_allocator();

		paging_init();

		/* check the size of the l1 area */

arch/blackfin/mm/init.c

+4 −8

Original line number	Diff line number	Diff line
		@@ -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();