mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-03 17:40:04 +00:00
[Blackfin] arch: add "memmap=nn[KMG]@ss[KMG]" and "memmap=nn[KMG]$ss[KMG]" options to blackfin, based on arch/i386/kernel/e820.c
Signed-off-by: Yi Li <yi.li@analog.com> Signed-off-by: Bryan Wu <bryan.wu@analog.com>
This commit is contained in:
parent
c605999bd9
commit
856783b37a
2 changed files with 431 additions and 122 deletions
|
@ -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
|
||||
* - "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
|
||||
_rambase = (unsigned long)_stext;
|
||||
_ramstart = (unsigned long)__bss_stop;
|
||||
|
||||
#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
|
||||
|
||||
#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);
|
||||
setup_bootmem_allocator();
|
||||
|
||||
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);
|
||||
|
||||
reserve_bootmem(memory_start, bootmap_size, BOOTMEM_DEFAULT);
|
||||
/*
|
||||
* get kmalloc into gear
|
||||
*/
|
||||
paging_init();
|
||||
|
||||
/* check the size of the l1 area */
|
||||
|
|
|
@ -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();
|
||||
|
|
Loading…
Reference in a new issue