setup.c revision 99d95bbd48f43dafdcd0540eb0da26c5655d7f33
1/* 2 * arch/blackfin/kernel/setup.c 3 * 4 * Copyright 2004-2006 Analog Devices Inc. 5 * 6 * Enter bugs at http://blackfin.uclinux.org/ 7 * 8 * Licensed under the GPL-2 or later. 9 */ 10 11#include <linux/delay.h> 12#include <linux/console.h> 13#include <linux/bootmem.h> 14#include <linux/seq_file.h> 15#include <linux/cpu.h> 16#include <linux/module.h> 17#include <linux/tty.h> 18#include <linux/pfn.h> 19 20#include <linux/ext2_fs.h> 21#include <linux/cramfs_fs.h> 22#include <linux/romfs_fs.h> 23 24#include <asm/cplb.h> 25#include <asm/cacheflush.h> 26#include <asm/blackfin.h> 27#include <asm/cplbinit.h> 28#include <asm/div64.h> 29#include <asm/fixed_code.h> 30#include <asm/early_printk.h> 31 32static DEFINE_PER_CPU(struct cpu, cpu_devices); 33 34u16 _bfin_swrst; 35EXPORT_SYMBOL(_bfin_swrst); 36 37unsigned long memory_start, memory_end, physical_mem_end; 38unsigned long _rambase, _ramstart, _ramend; 39unsigned long reserved_mem_dcache_on; 40unsigned long reserved_mem_icache_on; 41EXPORT_SYMBOL(memory_start); 42EXPORT_SYMBOL(memory_end); 43EXPORT_SYMBOL(physical_mem_end); 44EXPORT_SYMBOL(_ramend); 45 46#ifdef CONFIG_MTD_UCLINUX 47unsigned long memory_mtd_end, memory_mtd_start, mtd_size; 48unsigned long _ebss; 49EXPORT_SYMBOL(memory_mtd_end); 50EXPORT_SYMBOL(memory_mtd_start); 51EXPORT_SYMBOL(mtd_size); 52#endif 53 54char __initdata command_line[COMMAND_LINE_SIZE]; 55 56/* boot memmap, for parsing "memmap=" */ 57#define BFIN_MEMMAP_MAX 128 /* number of entries in bfin_memmap */ 58#define BFIN_MEMMAP_RAM 1 59#define BFIN_MEMMAP_RESERVED 2 60struct bfin_memmap { 61 int nr_map; 62 struct bfin_memmap_entry { 63 unsigned long long addr; /* start of memory segment */ 64 unsigned long long size; 65 unsigned long type; 66 } map[BFIN_MEMMAP_MAX]; 67} bfin_memmap __initdata; 68 69/* for memmap sanitization */ 70struct change_member { 71 struct bfin_memmap_entry *pentry; /* pointer to original entry */ 72 unsigned long long addr; /* address for this change point */ 73}; 74static struct change_member change_point_list[2*BFIN_MEMMAP_MAX] __initdata; 75static struct change_member *change_point[2*BFIN_MEMMAP_MAX] __initdata; 76static struct bfin_memmap_entry *overlap_list[BFIN_MEMMAP_MAX] __initdata; 77static struct bfin_memmap_entry new_map[BFIN_MEMMAP_MAX] __initdata; 78 79void __init bf53x_cache_init(void) 80{ 81#if defined(CONFIG_BFIN_DCACHE) || defined(CONFIG_BFIN_ICACHE) 82 generate_cpl_tables(); 83#endif 84 85#ifdef CONFIG_BFIN_ICACHE 86 bfin_icache_init(); 87 printk(KERN_INFO "Instruction Cache Enabled\n"); 88#endif 89 90#ifdef CONFIG_BFIN_DCACHE 91 bfin_dcache_init(); 92 printk(KERN_INFO "Data Cache Enabled" 93# if defined CONFIG_BFIN_WB 94 " (write-back)" 95# elif defined CONFIG_BFIN_WT 96 " (write-through)" 97# endif 98 "\n"); 99#endif 100} 101 102void __init bf53x_relocate_l1_mem(void) 103{ 104 unsigned long l1_code_length; 105 unsigned long l1_data_a_length; 106 unsigned long l1_data_b_length; 107 108 l1_code_length = _etext_l1 - _stext_l1; 109 if (l1_code_length > L1_CODE_LENGTH) 110 panic("L1 Instruction SRAM Overflow\n"); 111 /* cannot complain as printk is not available as yet. 112 * But we can continue booting and complain later! 113 */ 114 115 /* Copy _stext_l1 to _etext_l1 to L1 instruction SRAM */ 116 dma_memcpy(_stext_l1, _l1_lma_start, l1_code_length); 117 118 l1_data_a_length = _ebss_l1 - _sdata_l1; 119 if (l1_data_a_length > L1_DATA_A_LENGTH) 120 panic("L1 Data SRAM Bank A Overflow\n"); 121 122 /* Copy _sdata_l1 to _ebss_l1 to L1 data bank A SRAM */ 123 dma_memcpy(_sdata_l1, _l1_lma_start + l1_code_length, l1_data_a_length); 124 125 l1_data_b_length = _ebss_b_l1 - _sdata_b_l1; 126 if (l1_data_b_length > L1_DATA_B_LENGTH) 127 panic("L1 Data SRAM Bank B Overflow\n"); 128 129 /* Copy _sdata_b_l1 to _ebss_b_l1 to L1 data bank B SRAM */ 130 dma_memcpy(_sdata_b_l1, _l1_lma_start + l1_code_length + 131 l1_data_a_length, l1_data_b_length); 132} 133 134/* add_memory_region to memmap */ 135static void __init add_memory_region(unsigned long long start, 136 unsigned long long size, int type) 137{ 138 int i; 139 140 i = bfin_memmap.nr_map; 141 142 if (i == BFIN_MEMMAP_MAX) { 143 printk(KERN_ERR "Ooops! Too many entries in the memory map!\n"); 144 return; 145 } 146 147 bfin_memmap.map[i].addr = start; 148 bfin_memmap.map[i].size = size; 149 bfin_memmap.map[i].type = type; 150 bfin_memmap.nr_map++; 151} 152 153/* 154 * Sanitize the boot memmap, removing overlaps. 155 */ 156static int __init sanitize_memmap(struct bfin_memmap_entry *map, int *pnr_map) 157{ 158 struct change_member *change_tmp; 159 unsigned long current_type, last_type; 160 unsigned long long last_addr; 161 int chgidx, still_changing; 162 int overlap_entries; 163 int new_entry; 164 int old_nr, new_nr, chg_nr; 165 int i; 166 167 /* 168 Visually we're performing the following (1,2,3,4 = memory types) 169 170 Sample memory map (w/overlaps): 171 ____22__________________ 172 ______________________4_ 173 ____1111________________ 174 _44_____________________ 175 11111111________________ 176 ____________________33__ 177 ___________44___________ 178 __________33333_________ 179 ______________22________ 180 ___________________2222_ 181 _________111111111______ 182 _____________________11_ 183 _________________4______ 184 185 Sanitized equivalent (no overlap): 186 1_______________________ 187 _44_____________________ 188 ___1____________________ 189 ____22__________________ 190 ______11________________ 191 _________1______________ 192 __________3_____________ 193 ___________44___________ 194 _____________33_________ 195 _______________2________ 196 ________________1_______ 197 _________________4______ 198 ___________________2____ 199 ____________________33__ 200 ______________________4_ 201 */ 202 /* if there's only one memory region, don't bother */ 203 if (*pnr_map < 2) 204 return -1; 205 206 old_nr = *pnr_map; 207 208 /* bail out if we find any unreasonable addresses in memmap */ 209 for (i = 0; i < old_nr; i++) 210 if (map[i].addr + map[i].size < map[i].addr) 211 return -1; 212 213 /* create pointers for initial change-point information (for sorting) */ 214 for (i = 0; i < 2*old_nr; i++) 215 change_point[i] = &change_point_list[i]; 216 217 /* record all known change-points (starting and ending addresses), 218 omitting those that are for empty memory regions */ 219 chgidx = 0; 220 for (i = 0; i < old_nr; i++) { 221 if (map[i].size != 0) { 222 change_point[chgidx]->addr = map[i].addr; 223 change_point[chgidx++]->pentry = &map[i]; 224 change_point[chgidx]->addr = map[i].addr + map[i].size; 225 change_point[chgidx++]->pentry = &map[i]; 226 } 227 } 228 chg_nr = chgidx; /* true number of change-points */ 229 230 /* sort change-point list by memory addresses (low -> high) */ 231 still_changing = 1; 232 while (still_changing) { 233 still_changing = 0; 234 for (i = 1; i < chg_nr; i++) { 235 /* if <current_addr> > <last_addr>, swap */ 236 /* or, if current=<start_addr> & last=<end_addr>, swap */ 237 if ((change_point[i]->addr < change_point[i-1]->addr) || 238 ((change_point[i]->addr == change_point[i-1]->addr) && 239 (change_point[i]->addr == change_point[i]->pentry->addr) && 240 (change_point[i-1]->addr != change_point[i-1]->pentry->addr)) 241 ) { 242 change_tmp = change_point[i]; 243 change_point[i] = change_point[i-1]; 244 change_point[i-1] = change_tmp; 245 still_changing = 1; 246 } 247 } 248 } 249 250 /* create a new memmap, removing overlaps */ 251 overlap_entries = 0; /* number of entries in the overlap table */ 252 new_entry = 0; /* index for creating new memmap entries */ 253 last_type = 0; /* start with undefined memory type */ 254 last_addr = 0; /* start with 0 as last starting address */ 255 /* loop through change-points, determining affect on the new memmap */ 256 for (chgidx = 0; chgidx < chg_nr; chgidx++) { 257 /* keep track of all overlapping memmap entries */ 258 if (change_point[chgidx]->addr == change_point[chgidx]->pentry->addr) { 259 /* add map entry to overlap list (> 1 entry implies an overlap) */ 260 overlap_list[overlap_entries++] = change_point[chgidx]->pentry; 261 } else { 262 /* remove entry from list (order independent, so swap with last) */ 263 for (i = 0; i < overlap_entries; i++) { 264 if (overlap_list[i] == change_point[chgidx]->pentry) 265 overlap_list[i] = overlap_list[overlap_entries-1]; 266 } 267 overlap_entries--; 268 } 269 /* if there are overlapping entries, decide which "type" to use */ 270 /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */ 271 current_type = 0; 272 for (i = 0; i < overlap_entries; i++) 273 if (overlap_list[i]->type > current_type) 274 current_type = overlap_list[i]->type; 275 /* continue building up new memmap based on this information */ 276 if (current_type != last_type) { 277 if (last_type != 0) { 278 new_map[new_entry].size = 279 change_point[chgidx]->addr - last_addr; 280 /* move forward only if the new size was non-zero */ 281 if (new_map[new_entry].size != 0) 282 if (++new_entry >= BFIN_MEMMAP_MAX) 283 break; /* no more space left for new entries */ 284 } 285 if (current_type != 0) { 286 new_map[new_entry].addr = change_point[chgidx]->addr; 287 new_map[new_entry].type = current_type; 288 last_addr = change_point[chgidx]->addr; 289 } 290 last_type = current_type; 291 } 292 } 293 new_nr = new_entry; /* retain count for new entries */ 294 295 /* copy new mapping into original location */ 296 memcpy(map, new_map, new_nr*sizeof(struct bfin_memmap_entry)); 297 *pnr_map = new_nr; 298 299 return 0; 300} 301 302static void __init print_memory_map(char *who) 303{ 304 int i; 305 306 for (i = 0; i < bfin_memmap.nr_map; i++) { 307 printk(KERN_DEBUG " %s: %016Lx - %016Lx ", who, 308 bfin_memmap.map[i].addr, 309 bfin_memmap.map[i].addr + bfin_memmap.map[i].size); 310 switch (bfin_memmap.map[i].type) { 311 case BFIN_MEMMAP_RAM: 312 printk("(usable)\n"); 313 break; 314 case BFIN_MEMMAP_RESERVED: 315 printk("(reserved)\n"); 316 break; 317 default: printk("type %lu\n", bfin_memmap.map[i].type); 318 break; 319 } 320 } 321} 322 323static __init int parse_memmap(char *arg) 324{ 325 unsigned long long start_at, mem_size; 326 327 if (!arg) 328 return -EINVAL; 329 330 mem_size = memparse(arg, &arg); 331 if (*arg == '@') { 332 start_at = memparse(arg+1, &arg); 333 add_memory_region(start_at, mem_size, BFIN_MEMMAP_RAM); 334 } else if (*arg == '$') { 335 start_at = memparse(arg+1, &arg); 336 add_memory_region(start_at, mem_size, BFIN_MEMMAP_RESERVED); 337 } 338 339 return 0; 340} 341 342/* 343 * Initial parsing of the command line. Currently, we support: 344 * - Controlling the linux memory size: mem=xxx[KMG] 345 * - Controlling the physical memory size: max_mem=xxx[KMG][$][#] 346 * $ -> reserved memory is dcacheable 347 * # -> reserved memory is icacheable 348 * - "memmap=XXX[KkmM][@][$]XXX[KkmM]" defines a memory region 349 * @ from <start> to <start>+<mem>, type RAM 350 * $ from <start> to <start>+<mem>, type RESERVED 351 * 352 */ 353static __init void parse_cmdline_early(char *cmdline_p) 354{ 355 char c = ' ', *to = cmdline_p; 356 unsigned int memsize; 357 for (;;) { 358 if (c == ' ') { 359 if (!memcmp(to, "mem=", 4)) { 360 to += 4; 361 memsize = memparse(to, &to); 362 if (memsize) 363 _ramend = memsize; 364 365 } else if (!memcmp(to, "max_mem=", 8)) { 366 to += 8; 367 memsize = memparse(to, &to); 368 if (memsize) { 369 physical_mem_end = memsize; 370 if (*to != ' ') { 371 if (*to == '$' 372 || *(to + 1) == '$') 373 reserved_mem_dcache_on = 374 1; 375 if (*to == '#' 376 || *(to + 1) == '#') 377 reserved_mem_icache_on = 378 1; 379 } 380 } 381 } else if (!memcmp(to, "earlyprintk=", 12)) { 382 to += 12; 383 setup_early_printk(to); 384 } else if (!memcmp(to, "memmap=", 7)) { 385 to += 7; 386 parse_memmap(to); 387 } 388 } 389 c = *(to++); 390 if (!c) 391 break; 392 } 393} 394 395/* 396 * Setup memory defaults from user config. 397 * The physical memory layout looks like: 398 * 399 * [_rambase, _ramstart]: kernel image 400 * [memory_start, memory_end]: dynamic memory managed by kernel 401 * [memory_end, _ramend]: reserved memory 402 * [meory_mtd_start(memory_end), 403 * memory_mtd_start + mtd_size]: rootfs (if any) 404 * [_ramend - DMA_UNCACHED_REGION, 405 * _ramend]: uncached DMA region 406 * [_ramend, physical_mem_end]: memory not managed by kernel 407 * 408 */ 409static __init void memory_setup(void) 410{ 411#ifdef CONFIG_MTD_UCLINUX 412 unsigned long mtd_phys = 0; 413#endif 414 415 _rambase = (unsigned long)_stext; 416 _ramstart = (unsigned long)_end; 417 418 if (DMA_UNCACHED_REGION > (_ramend - _ramstart)) { 419 console_init(); 420 panic("DMA region exceeds memory limit: %lu.\n", 421 _ramend - _ramstart); 422 } 423 memory_end = _ramend - DMA_UNCACHED_REGION; 424 425#ifdef CONFIG_MPU 426 /* Round up to multiple of 4MB. */ 427 memory_start = (_ramstart + 0x3fffff) & ~0x3fffff; 428#else 429 memory_start = PAGE_ALIGN(_ramstart); 430#endif 431 432#if defined(CONFIG_MTD_UCLINUX) 433 /* generic memory mapped MTD driver */ 434 memory_mtd_end = memory_end; 435 436 mtd_phys = _ramstart; 437 mtd_size = PAGE_ALIGN(*((unsigned long *)(mtd_phys + 8))); 438 439# if defined(CONFIG_EXT2_FS) || defined(CONFIG_EXT3_FS) 440 if (*((unsigned short *)(mtd_phys + 0x438)) == EXT2_SUPER_MAGIC) 441 mtd_size = 442 PAGE_ALIGN(*((unsigned long *)(mtd_phys + 0x404)) << 10); 443# endif 444 445# if defined(CONFIG_CRAMFS) 446 if (*((unsigned long *)(mtd_phys)) == CRAMFS_MAGIC) 447 mtd_size = PAGE_ALIGN(*((unsigned long *)(mtd_phys + 0x4))); 448# endif 449 450# if defined(CONFIG_ROMFS_FS) 451 if (((unsigned long *)mtd_phys)[0] == ROMSB_WORD0 452 && ((unsigned long *)mtd_phys)[1] == ROMSB_WORD1) 453 mtd_size = 454 PAGE_ALIGN(be32_to_cpu(((unsigned long *)mtd_phys)[2])); 455# if (defined(CONFIG_BFIN_ICACHE) && ANOMALY_05000263) 456 /* Due to a Hardware Anomaly we need to limit the size of usable 457 * instruction memory to max 60MB, 56 if HUNT_FOR_ZERO is on 458 * 05000263 - Hardware loop corrupted when taking an ICPLB exception 459 */ 460# if (defined(CONFIG_DEBUG_HUNT_FOR_ZERO)) 461 if (memory_end >= 56 * 1024 * 1024) 462 memory_end = 56 * 1024 * 1024; 463# else 464 if (memory_end >= 60 * 1024 * 1024) 465 memory_end = 60 * 1024 * 1024; 466# endif /* CONFIG_DEBUG_HUNT_FOR_ZERO */ 467# endif /* ANOMALY_05000263 */ 468# endif /* CONFIG_ROMFS_FS */ 469 470 memory_end -= mtd_size; 471 472 if (mtd_size == 0) { 473 console_init(); 474 panic("Don't boot kernel without rootfs attached.\n"); 475 } 476 477 /* Relocate MTD image to the top of memory after the uncached memory area */ 478 dma_memcpy((char *)memory_end, _end, mtd_size); 479 480 memory_mtd_start = memory_end; 481 _ebss = memory_mtd_start; /* define _ebss for compatible */ 482#endif /* CONFIG_MTD_UCLINUX */ 483 484#if (defined(CONFIG_BFIN_ICACHE) && ANOMALY_05000263) 485 /* Due to a Hardware Anomaly we need to limit the size of usable 486 * instruction memory to max 60MB, 56 if HUNT_FOR_ZERO is on 487 * 05000263 - Hardware loop corrupted when taking an ICPLB exception 488 */ 489#if (defined(CONFIG_DEBUG_HUNT_FOR_ZERO)) 490 if (memory_end >= 56 * 1024 * 1024) 491 memory_end = 56 * 1024 * 1024; 492#else 493 if (memory_end >= 60 * 1024 * 1024) 494 memory_end = 60 * 1024 * 1024; 495#endif /* CONFIG_DEBUG_HUNT_FOR_ZERO */ 496 printk(KERN_NOTICE "Warning: limiting memory to %liMB due to hardware anomaly 05000263\n", memory_end >> 20); 497#endif /* ANOMALY_05000263 */ 498 499#ifdef CONFIG_MPU 500 page_mask_nelts = ((_ramend >> PAGE_SHIFT) + 31) / 32; 501 page_mask_order = get_order(3 * page_mask_nelts * sizeof(long)); 502#endif 503 504#if !defined(CONFIG_MTD_UCLINUX) 505 /*In case there is no valid CPLB behind memory_end make sure we don't get to close*/ 506 memory_end -= SIZE_4K; 507#endif 508 509 init_mm.start_code = (unsigned long)_stext; 510 init_mm.end_code = (unsigned long)_etext; 511 init_mm.end_data = (unsigned long)_edata; 512 init_mm.brk = (unsigned long)0; 513 514 printk(KERN_INFO "Board Memory: %ldMB\n", physical_mem_end >> 20); 515 printk(KERN_INFO "Kernel Managed Memory: %ldMB\n", _ramend >> 20); 516 517 printk(KERN_INFO "Memory map:\n" 518 KERN_INFO " fixedcode = 0x%p-0x%p\n" 519 KERN_INFO " text = 0x%p-0x%p\n" 520 KERN_INFO " rodata = 0x%p-0x%p\n" 521 KERN_INFO " bss = 0x%p-0x%p\n" 522 KERN_INFO " data = 0x%p-0x%p\n" 523 KERN_INFO " stack = 0x%p-0x%p\n" 524 KERN_INFO " init = 0x%p-0x%p\n" 525 KERN_INFO " available = 0x%p-0x%p\n" 526#ifdef CONFIG_MTD_UCLINUX 527 KERN_INFO " rootfs = 0x%p-0x%p\n" 528#endif 529#if DMA_UNCACHED_REGION > 0 530 KERN_INFO " DMA Zone = 0x%p-0x%p\n" 531#endif 532 , (void *)FIXED_CODE_START, (void *)FIXED_CODE_END, 533 _stext, _etext, 534 __start_rodata, __end_rodata, 535 __bss_start, __bss_stop, 536 _sdata, _edata, 537 (void *)&init_thread_union, 538 (void *)((int)(&init_thread_union) + 0x2000), 539 __init_begin, __init_end, 540 (void *)_ramstart, (void *)memory_end 541#ifdef CONFIG_MTD_UCLINUX 542 , (void *)memory_mtd_start, (void *)(memory_mtd_start + mtd_size) 543#endif 544#if DMA_UNCACHED_REGION > 0 545 , (void *)(_ramend - DMA_UNCACHED_REGION), (void *)(_ramend) 546#endif 547 ); 548} 549 550/* 551 * Find the lowest, highest page frame number we have available 552 */ 553void __init find_min_max_pfn(void) 554{ 555 int i; 556 557 max_pfn = 0; 558 min_low_pfn = memory_end; 559 560 for (i = 0; i < bfin_memmap.nr_map; i++) { 561 unsigned long start, end; 562 /* RAM? */ 563 if (bfin_memmap.map[i].type != BFIN_MEMMAP_RAM) 564 continue; 565 start = PFN_UP(bfin_memmap.map[i].addr); 566 end = PFN_DOWN(bfin_memmap.map[i].addr + 567 bfin_memmap.map[i].size); 568 if (start >= end) 569 continue; 570 if (end > max_pfn) 571 max_pfn = end; 572 if (start < min_low_pfn) 573 min_low_pfn = start; 574 } 575} 576 577static __init void setup_bootmem_allocator(void) 578{ 579 int bootmap_size; 580 int i; 581 unsigned long start_pfn, end_pfn; 582 unsigned long curr_pfn, last_pfn, size; 583 584 /* mark memory between memory_start and memory_end usable */ 585 add_memory_region(memory_start, 586 memory_end - memory_start, BFIN_MEMMAP_RAM); 587 /* sanity check for overlap */ 588 sanitize_memmap(bfin_memmap.map, &bfin_memmap.nr_map); 589 print_memory_map("boot memmap"); 590 591 /* intialize globals in linux/bootmem.h */ 592 find_min_max_pfn(); 593 /* pfn of the last usable page frame */ 594 if (max_pfn > memory_end >> PAGE_SHIFT) 595 max_pfn = memory_end >> PAGE_SHIFT; 596 /* pfn of last page frame directly mapped by kernel */ 597 max_low_pfn = max_pfn; 598 /* pfn of the first usable page frame after kernel image*/ 599 if (min_low_pfn < memory_start >> PAGE_SHIFT) 600 min_low_pfn = memory_start >> PAGE_SHIFT; 601 602 start_pfn = PAGE_OFFSET >> PAGE_SHIFT; 603 end_pfn = memory_end >> PAGE_SHIFT; 604 605 /* 606 * give all the memory to the bootmap allocator, tell it to put the 607 * boot mem_map at the start of memory. 608 */ 609 bootmap_size = init_bootmem_node(NODE_DATA(0), 610 memory_start >> PAGE_SHIFT, /* map goes here */ 611 start_pfn, end_pfn); 612 613 /* register the memmap regions with the bootmem allocator */ 614 for (i = 0; i < bfin_memmap.nr_map; i++) { 615 /* 616 * Reserve usable memory 617 */ 618 if (bfin_memmap.map[i].type != BFIN_MEMMAP_RAM) 619 continue; 620 /* 621 * We are rounding up the start address of usable memory: 622 */ 623 curr_pfn = PFN_UP(bfin_memmap.map[i].addr); 624 if (curr_pfn >= end_pfn) 625 continue; 626 /* 627 * ... and at the end of the usable range downwards: 628 */ 629 last_pfn = PFN_DOWN(bfin_memmap.map[i].addr + 630 bfin_memmap.map[i].size); 631 632 if (last_pfn > end_pfn) 633 last_pfn = end_pfn; 634 635 /* 636 * .. finally, did all the rounding and playing 637 * around just make the area go away? 638 */ 639 if (last_pfn <= curr_pfn) 640 continue; 641 642 size = last_pfn - curr_pfn; 643 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size)); 644 } 645 646 /* reserve memory before memory_start, including bootmap */ 647 reserve_bootmem(PAGE_OFFSET, 648 memory_start + bootmap_size + PAGE_SIZE - 1 - PAGE_OFFSET, 649 BOOTMEM_DEFAULT); 650} 651 652#define EBSZ_TO_MEG(ebsz) \ 653({ \ 654 int meg = 0; \ 655 switch (ebsz & 0xf) { \ 656 case 0x1: meg = 16; break; \ 657 case 0x3: meg = 32; break; \ 658 case 0x5: meg = 64; break; \ 659 case 0x7: meg = 128; break; \ 660 case 0x9: meg = 256; break; \ 661 case 0xb: meg = 512; break; \ 662 } \ 663 meg; \ 664}) 665static inline int __init get_mem_size(void) 666{ 667#if defined(EBIU_SDBCTL) 668# if defined(BF561_FAMILY) 669 int ret = 0; 670 u32 sdbctl = bfin_read_EBIU_SDBCTL(); 671 ret += EBSZ_TO_MEG(sdbctl >> 0); 672 ret += EBSZ_TO_MEG(sdbctl >> 8); 673 ret += EBSZ_TO_MEG(sdbctl >> 16); 674 ret += EBSZ_TO_MEG(sdbctl >> 24); 675 return ret; 676# else 677 return EBSZ_TO_MEG(bfin_read_EBIU_SDBCTL()); 678# endif 679#elif defined(EBIU_DDRCTL1) 680 u32 ddrctl = bfin_read_EBIU_DDRCTL1(); 681 int ret = 0; 682 switch (ddrctl & 0xc0000) { 683 case DEVSZ_64: ret = 64 / 8; 684 case DEVSZ_128: ret = 128 / 8; 685 case DEVSZ_256: ret = 256 / 8; 686 case DEVSZ_512: ret = 512 / 8; 687 } 688 switch (ddrctl & 0x30000) { 689 case DEVWD_4: ret *= 2; 690 case DEVWD_8: ret *= 2; 691 case DEVWD_16: break; 692 } 693 return ret; 694#endif 695 BUG(); 696} 697 698void __init setup_arch(char **cmdline_p) 699{ 700 unsigned long sclk, cclk; 701 702#ifdef CONFIG_DUMMY_CONSOLE 703 conswitchp = &dummy_con; 704#endif 705 706#if defined(CONFIG_CMDLINE_BOOL) 707 strncpy(&command_line[0], CONFIG_CMDLINE, sizeof(command_line)); 708 command_line[sizeof(command_line) - 1] = 0; 709#endif 710 711 /* Keep a copy of command line */ 712 *cmdline_p = &command_line[0]; 713 memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE); 714 boot_command_line[COMMAND_LINE_SIZE - 1] = '\0'; 715 716 /* setup memory defaults from the user config */ 717 physical_mem_end = 0; 718 _ramend = get_mem_size() * 1024 * 1024; 719 720 memset(&bfin_memmap, 0, sizeof(bfin_memmap)); 721 722 parse_cmdline_early(&command_line[0]); 723 724 if (physical_mem_end == 0) 725 physical_mem_end = _ramend; 726 727 memory_setup(); 728 729 cclk = get_cclk(); 730 sclk = get_sclk(); 731 732#if !defined(CONFIG_BFIN_KERNEL_CLOCK) 733 if (ANOMALY_05000273 && cclk == sclk) 734 panic("ANOMALY 05000273, SCLK can not be same as CCLK"); 735#endif 736 737#ifdef BF561_FAMILY 738 if (ANOMALY_05000266) { 739 bfin_read_IMDMA_D0_IRQ_STATUS(); 740 bfin_read_IMDMA_D1_IRQ_STATUS(); 741 } 742#endif 743 printk(KERN_INFO "Hardware Trace "); 744 if (bfin_read_TBUFCTL() & 0x1) 745 printk("Active "); 746 else 747 printk("Off "); 748 if (bfin_read_TBUFCTL() & 0x2) 749 printk("and Enabled\n"); 750 else 751 printk("and Disabled\n"); 752 753#if defined(CONFIG_CHR_DEV_FLASH) || defined(CONFIG_BLK_DEV_FLASH) 754 /* we need to initialize the Flashrom device here since we might 755 * do things with flash early on in the boot 756 */ 757 flash_probe(); 758#endif 759 760 _bfin_swrst = bfin_read_SWRST(); 761 762 if (_bfin_swrst & RESET_DOUBLE) 763 printk(KERN_INFO "Recovering from Double Fault event\n"); 764 else if (_bfin_swrst & RESET_WDOG) 765 printk(KERN_INFO "Recovering from Watchdog event\n"); 766 else if (_bfin_swrst & RESET_SOFTWARE) 767 printk(KERN_NOTICE "Reset caused by Software reset\n"); 768 769 printk(KERN_INFO "Blackfin support (C) 2004-2008 Analog Devices, Inc.\n"); 770 if (bfin_compiled_revid() == 0xffff) 771 printk(KERN_INFO "Compiled for ADSP-%s Rev any\n", CPU); 772 else if (bfin_compiled_revid() == -1) 773 printk(KERN_INFO "Compiled for ADSP-%s Rev none\n", CPU); 774 else 775 printk(KERN_INFO "Compiled for ADSP-%s Rev 0.%d\n", CPU, bfin_compiled_revid()); 776 if (bfin_revid() != bfin_compiled_revid()) { 777 if (bfin_compiled_revid() == -1) 778 printk(KERN_ERR "Warning: Compiled for Rev none, but running on Rev %d\n", 779 bfin_revid()); 780 else if (bfin_compiled_revid() != 0xffff) 781 printk(KERN_ERR "Warning: Compiled for Rev %d, but running on Rev %d\n", 782 bfin_compiled_revid(), bfin_revid()); 783 } 784 if (bfin_revid() < SUPPORTED_REVID) 785 printk(KERN_ERR "Warning: Unsupported Chip Revision ADSP-%s Rev 0.%d detected\n", 786 CPU, bfin_revid()); 787 printk(KERN_INFO "Blackfin Linux support by http://blackfin.uclinux.org/\n"); 788 789 printk(KERN_INFO "Processor Speed: %lu MHz core clock and %lu MHz System Clock\n", 790 cclk / 1000000, sclk / 1000000); 791 792 if (ANOMALY_05000273 && (cclk >> 1) <= sclk) 793 printk("\n\n\nANOMALY_05000273: CCLK must be >= 2*SCLK !!!\n\n\n"); 794 795 setup_bootmem_allocator(); 796 797 paging_init(); 798 799 /* Copy atomic sequences to their fixed location, and sanity check that 800 these locations are the ones that we advertise to userspace. */ 801 memcpy((void *)FIXED_CODE_START, &fixed_code_start, 802 FIXED_CODE_END - FIXED_CODE_START); 803 BUG_ON((char *)&sigreturn_stub - (char *)&fixed_code_start 804 != SIGRETURN_STUB - FIXED_CODE_START); 805 BUG_ON((char *)&atomic_xchg32 - (char *)&fixed_code_start 806 != ATOMIC_XCHG32 - FIXED_CODE_START); 807 BUG_ON((char *)&atomic_cas32 - (char *)&fixed_code_start 808 != ATOMIC_CAS32 - FIXED_CODE_START); 809 BUG_ON((char *)&atomic_add32 - (char *)&fixed_code_start 810 != ATOMIC_ADD32 - FIXED_CODE_START); 811 BUG_ON((char *)&atomic_sub32 - (char *)&fixed_code_start 812 != ATOMIC_SUB32 - FIXED_CODE_START); 813 BUG_ON((char *)&atomic_ior32 - (char *)&fixed_code_start 814 != ATOMIC_IOR32 - FIXED_CODE_START); 815 BUG_ON((char *)&atomic_and32 - (char *)&fixed_code_start 816 != ATOMIC_AND32 - FIXED_CODE_START); 817 BUG_ON((char *)&atomic_xor32 - (char *)&fixed_code_start 818 != ATOMIC_XOR32 - FIXED_CODE_START); 819 BUG_ON((char *)&safe_user_instruction - (char *)&fixed_code_start 820 != SAFE_USER_INSTRUCTION - FIXED_CODE_START); 821 822 init_exception_vectors(); 823 bf53x_cache_init(); 824} 825 826static int __init topology_init(void) 827{ 828 int cpu; 829 830 for_each_possible_cpu(cpu) { 831 struct cpu *c = &per_cpu(cpu_devices, cpu); 832 833 register_cpu(c, cpu); 834 } 835 836 return 0; 837} 838 839subsys_initcall(topology_init); 840 841static u_long get_vco(void) 842{ 843 u_long msel; 844 u_long vco; 845 846 msel = (bfin_read_PLL_CTL() >> 9) & 0x3F; 847 if (0 == msel) 848 msel = 64; 849 850 vco = CONFIG_CLKIN_HZ; 851 vco >>= (1 & bfin_read_PLL_CTL()); /* DF bit */ 852 vco = msel * vco; 853 return vco; 854} 855 856/* Get the Core clock */ 857u_long get_cclk(void) 858{ 859 u_long csel, ssel; 860 if (bfin_read_PLL_STAT() & 0x1) 861 return CONFIG_CLKIN_HZ; 862 863 ssel = bfin_read_PLL_DIV(); 864 csel = ((ssel >> 4) & 0x03); 865 ssel &= 0xf; 866 if (ssel && ssel < (1 << csel)) /* SCLK > CCLK */ 867 return get_vco() / ssel; 868 return get_vco() >> csel; 869} 870EXPORT_SYMBOL(get_cclk); 871 872/* Get the System clock */ 873u_long get_sclk(void) 874{ 875 u_long ssel; 876 877 if (bfin_read_PLL_STAT() & 0x1) 878 return CONFIG_CLKIN_HZ; 879 880 ssel = (bfin_read_PLL_DIV() & 0xf); 881 if (0 == ssel) { 882 printk(KERN_WARNING "Invalid System Clock\n"); 883 ssel = 1; 884 } 885 886 return get_vco() / ssel; 887} 888EXPORT_SYMBOL(get_sclk); 889 890unsigned long sclk_to_usecs(unsigned long sclk) 891{ 892 u64 tmp = USEC_PER_SEC * (u64)sclk; 893 do_div(tmp, get_sclk()); 894 return tmp; 895} 896EXPORT_SYMBOL(sclk_to_usecs); 897 898unsigned long usecs_to_sclk(unsigned long usecs) 899{ 900 u64 tmp = get_sclk() * (u64)usecs; 901 do_div(tmp, USEC_PER_SEC); 902 return tmp; 903} 904EXPORT_SYMBOL(usecs_to_sclk); 905 906/* 907 * Get CPU information for use by the procfs. 908 */ 909static int show_cpuinfo(struct seq_file *m, void *v) 910{ 911 char *cpu, *mmu, *fpu, *vendor, *cache; 912 uint32_t revid; 913 914 u_long cclk = 0, sclk = 0; 915 u_int dcache_size = 0, dsup_banks = 0; 916 917 cpu = CPU; 918 mmu = "none"; 919 fpu = "none"; 920 revid = bfin_revid(); 921 922 cclk = get_cclk(); 923 sclk = get_sclk(); 924 925 switch (bfin_read_CHIPID() & CHIPID_MANUFACTURE) { 926 case 0xca: 927 vendor = "Analog Devices"; 928 break; 929 default: 930 vendor = "unknown"; 931 break; 932 } 933 934 seq_printf(m, "processor\t: %d\n" 935 "vendor_id\t: %s\n" 936 "cpu family\t: 0x%x\n" 937 "model name\t: ADSP-%s %lu(MHz CCLK) %lu(MHz SCLK) (%s)\n" 938 "stepping\t: %d\n", 939 0, 940 vendor, 941 (bfin_read_CHIPID() & CHIPID_FAMILY), 942 cpu, cclk/1000000, sclk/1000000, 943#ifdef CONFIG_MPU 944 "mpu on", 945#else 946 "mpu off", 947#endif 948 revid); 949 950 seq_printf(m, "cpu MHz\t\t: %lu.%03lu/%lu.%03lu\n", 951 cclk/1000000, cclk%1000000, 952 sclk/1000000, sclk%1000000); 953 seq_printf(m, "bogomips\t: %lu.%02lu\n" 954 "Calibration\t: %lu loops\n", 955 (loops_per_jiffy * HZ) / 500000, 956 ((loops_per_jiffy * HZ) / 5000) % 100, 957 (loops_per_jiffy * HZ)); 958 959 /* Check Cache configutation */ 960 switch (bfin_read_DMEM_CONTROL() & (1 << DMC0_P | 1 << DMC1_P)) { 961 case ACACHE_BSRAM: 962 cache = "dbank-A/B\t: cache/sram"; 963 dcache_size = 16; 964 dsup_banks = 1; 965 break; 966 case ACACHE_BCACHE: 967 cache = "dbank-A/B\t: cache/cache"; 968 dcache_size = 32; 969 dsup_banks = 2; 970 break; 971 case ASRAM_BSRAM: 972 cache = "dbank-A/B\t: sram/sram"; 973 dcache_size = 0; 974 dsup_banks = 0; 975 break; 976 default: 977 cache = "unknown"; 978 dcache_size = 0; 979 dsup_banks = 0; 980 break; 981 } 982 983 /* Is it turned on? */ 984 if (!((bfin_read_DMEM_CONTROL()) & (ENDCPLB | DMC_ENABLE))) 985 dcache_size = 0; 986 987 seq_printf(m, "cache size\t: %d KB(L1 icache) " 988 "%d KB(L1 dcache-%s) %d KB(L2 cache)\n", 989 BFIN_ICACHESIZE / 1024, dcache_size, 990#if defined CONFIG_BFIN_WB 991 "wb" 992#elif defined CONFIG_BFIN_WT 993 "wt" 994#endif 995 "", 0); 996 997 seq_printf(m, "%s\n", cache); 998 999 seq_printf(m, "icache setup\t: %d Sub-banks/%d Ways, %d Lines/Way\n", 1000 BFIN_ISUBBANKS, BFIN_IWAYS, BFIN_ILINES); 1001 seq_printf(m, 1002 "dcache setup\t: %d Super-banks/%d Sub-banks/%d Ways, %d Lines/Way\n", 1003 dsup_banks, BFIN_DSUBBANKS, BFIN_DWAYS, 1004 BFIN_DLINES); 1005#ifdef CONFIG_BFIN_ICACHE_LOCK 1006 switch (read_iloc()) { 1007 case WAY0_L: 1008 seq_printf(m, "Way0 Locked-Down\n"); 1009 break; 1010 case WAY1_L: 1011 seq_printf(m, "Way1 Locked-Down\n"); 1012 break; 1013 case WAY01_L: 1014 seq_printf(m, "Way0,Way1 Locked-Down\n"); 1015 break; 1016 case WAY2_L: 1017 seq_printf(m, "Way2 Locked-Down\n"); 1018 break; 1019 case WAY02_L: 1020 seq_printf(m, "Way0,Way2 Locked-Down\n"); 1021 break; 1022 case WAY12_L: 1023 seq_printf(m, "Way1,Way2 Locked-Down\n"); 1024 break; 1025 case WAY012_L: 1026 seq_printf(m, "Way0,Way1 & Way2 Locked-Down\n"); 1027 break; 1028 case WAY3_L: 1029 seq_printf(m, "Way3 Locked-Down\n"); 1030 break; 1031 case WAY03_L: 1032 seq_printf(m, "Way0,Way3 Locked-Down\n"); 1033 break; 1034 case WAY13_L: 1035 seq_printf(m, "Way1,Way3 Locked-Down\n"); 1036 break; 1037 case WAY013_L: 1038 seq_printf(m, "Way 0,Way1,Way3 Locked-Down\n"); 1039 break; 1040 case WAY32_L: 1041 seq_printf(m, "Way3,Way2 Locked-Down\n"); 1042 break; 1043 case WAY320_L: 1044 seq_printf(m, "Way3,Way2,Way0 Locked-Down\n"); 1045 break; 1046 case WAY321_L: 1047 seq_printf(m, "Way3,Way2,Way1 Locked-Down\n"); 1048 break; 1049 case WAYALL_L: 1050 seq_printf(m, "All Ways are locked\n"); 1051 break; 1052 default: 1053 seq_printf(m, "No Ways are locked\n"); 1054 } 1055#endif 1056 seq_printf(m, "board name\t: %s\n", bfin_board_name); 1057 seq_printf(m, "board memory\t: %ld kB (0x%p -> 0x%p)\n", 1058 physical_mem_end >> 10, (void *)0, (void *)physical_mem_end); 1059 seq_printf(m, "kernel memory\t: %d kB (0x%p -> 0x%p)\n", 1060 ((int)memory_end - (int)_stext) >> 10, 1061 _stext, 1062 (void *)memory_end); 1063 1064 return 0; 1065} 1066 1067static void *c_start(struct seq_file *m, loff_t *pos) 1068{ 1069 return *pos < NR_CPUS ? ((void *)0x12345678) : NULL; 1070} 1071 1072static void *c_next(struct seq_file *m, void *v, loff_t *pos) 1073{ 1074 ++*pos; 1075 return c_start(m, pos); 1076} 1077 1078static void c_stop(struct seq_file *m, void *v) 1079{ 1080} 1081 1082const struct seq_operations cpuinfo_op = { 1083 .start = c_start, 1084 .next = c_next, 1085 .stop = c_stop, 1086 .show = show_cpuinfo, 1087}; 1088 1089void __init cmdline_init(const char *r0) 1090{ 1091 if (r0) 1092 strncpy(command_line, r0, COMMAND_LINE_SIZE); 1093} 1094