1 /* 2 * arch/sh/kernel/setup.c 3 * 4 * This file handles the architecture-dependent parts of initialization 5 * 6 * Copyright (C) 1999 Niibe Yutaka 7 * Copyright (C) 2002 - 2007 Paul Mundt 8 */ 9 #include <linux/screen_info.h> 10 #include <linux/ioport.h> 11 #include <linux/init.h> 12 #include <linux/initrd.h> 13 #include <linux/bootmem.h> 14 #include <linux/console.h> 15 #include <linux/seq_file.h> 16 #include <linux/root_dev.h> 17 #include <linux/utsname.h> 18 #include <linux/nodemask.h> 19 #include <linux/cpu.h> 20 #include <linux/pfn.h> 21 #include <linux/fs.h> 22 #include <linux/mm.h> 23 #include <linux/kexec.h> 24 #include <linux/module.h> 25 #include <linux/smp.h> 26 #include <linux/err.h> 27 #include <linux/debugfs.h> 28 #include <asm/uaccess.h> 29 #include <asm/io.h> 30 #include <asm/page.h> 31 #include <asm/elf.h> 32 #include <asm/sections.h> 33 #include <asm/irq.h> 34 #include <asm/setup.h> 35 #include <asm/clock.h> 36 #include <asm/mmu_context.h> 37 38 /* 39 * Initialize loops_per_jiffy as 10000000 (1000MIPS). 40 * This value will be used at the very early stage of serial setup. 41 * The bigger value means no problem. 42 */ 43 struct sh_cpuinfo cpu_data[NR_CPUS] __read_mostly = { 44 [0] = { 45 .type = CPU_SH_NONE, 46 .loops_per_jiffy = 10000000, 47 }, 48 }; 49 EXPORT_SYMBOL(cpu_data); 50 51 /* 52 * The machine vector. First entry in .machvec.init, or clobbered by 53 * sh_mv= on the command line, prior to .machvec.init teardown. 54 */ 55 struct sh_machine_vector sh_mv = { .mv_name = "generic", }; 56 57 #ifdef CONFIG_VT 58 struct screen_info screen_info; 59 #endif 60 61 extern int root_mountflags; 62 63 #define RAMDISK_IMAGE_START_MASK 0x07FF 64 #define RAMDISK_PROMPT_FLAG 0x8000 65 #define RAMDISK_LOAD_FLAG 0x4000 66 67 static char __initdata command_line[COMMAND_LINE_SIZE] = { 0, }; 68 69 static struct resource code_resource = { 70 .name = "Kernel code", 71 .flags = IORESOURCE_BUSY | IORESOURCE_MEM, 72 }; 73 74 static struct resource data_resource = { 75 .name = "Kernel data", 76 .flags = IORESOURCE_BUSY | IORESOURCE_MEM, 77 }; 78 79 unsigned long memory_start; 80 EXPORT_SYMBOL(memory_start); 81 unsigned long memory_end = 0; 82 EXPORT_SYMBOL(memory_end); 83 84 int l1i_cache_shape, l1d_cache_shape, l2_cache_shape; 85 86 static int __init early_parse_mem(char *p) 87 { 88 unsigned long size; 89 90 memory_start = (unsigned long)__va(__MEMORY_START); 91 size = memparse(p, &p); 92 93 if (size > __MEMORY_SIZE) { 94 static char msg[] __initdata = KERN_ERR 95 "Using mem= to increase the size of kernel memory " 96 "is not allowed.\n" 97 " Recompile the kernel with the correct value for " 98 "CONFIG_MEMORY_SIZE.\n"; 99 printk(msg); 100 return 0; 101 } 102 103 memory_end = memory_start + size; 104 105 return 0; 106 } 107 early_param("mem", early_parse_mem); 108 109 /* 110 * Register fully available low RAM pages with the bootmem allocator. 111 */ 112 static void __init register_bootmem_low_pages(void) 113 { 114 unsigned long curr_pfn, last_pfn, pages; 115 116 /* 117 * We are rounding up the start address of usable memory: 118 */ 119 curr_pfn = PFN_UP(__MEMORY_START); 120 121 /* 122 * ... and at the end of the usable range downwards: 123 */ 124 last_pfn = PFN_DOWN(__pa(memory_end)); 125 126 if (last_pfn > max_low_pfn) 127 last_pfn = max_low_pfn; 128 129 pages = last_pfn - curr_pfn; 130 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(pages)); 131 } 132 133 #ifdef CONFIG_KEXEC 134 static void __init reserve_crashkernel(void) 135 { 136 unsigned long long free_mem; 137 unsigned long long crash_size, crash_base; 138 int ret; 139 140 free_mem = ((unsigned long long)max_low_pfn - min_low_pfn) << PAGE_SHIFT; 141 142 ret = parse_crashkernel(boot_command_line, free_mem, 143 &crash_size, &crash_base); 144 if (ret == 0 && crash_size) { 145 if (crash_base <= 0) { 146 printk(KERN_INFO "crashkernel reservation failed - " 147 "you have to specify a base address\n"); 148 return; 149 } 150 151 if (reserve_bootmem(crash_base, crash_size, 152 BOOTMEM_EXCLUSIVE) < 0) { 153 printk(KERN_INFO "crashkernel reservation failed - " 154 "memory is in use\n"); 155 return; 156 } 157 158 printk(KERN_INFO "Reserving %ldMB of memory at %ldMB " 159 "for crashkernel (System RAM: %ldMB)\n", 160 (unsigned long)(crash_size >> 20), 161 (unsigned long)(crash_base >> 20), 162 (unsigned long)(free_mem >> 20)); 163 crashk_res.start = crash_base; 164 crashk_res.end = crash_base + crash_size - 1; 165 } 166 } 167 #else 168 static inline void __init reserve_crashkernel(void) 169 {} 170 #endif 171 172 void __init setup_bootmem_allocator(unsigned long free_pfn) 173 { 174 unsigned long bootmap_size; 175 176 /* 177 * Find a proper area for the bootmem bitmap. After this 178 * bootstrap step all allocations (until the page allocator 179 * is intact) must be done via bootmem_alloc(). 180 */ 181 bootmap_size = init_bootmem_node(NODE_DATA(0), free_pfn, 182 min_low_pfn, max_low_pfn); 183 184 add_active_range(0, min_low_pfn, max_low_pfn); 185 register_bootmem_low_pages(); 186 187 node_set_online(0); 188 189 /* 190 * Reserve the kernel text and 191 * Reserve the bootmem bitmap. We do this in two steps (first step 192 * was init_bootmem()), because this catches the (definitely buggy) 193 * case of us accidentally initializing the bootmem allocator with 194 * an invalid RAM area. 195 */ 196 reserve_bootmem(__MEMORY_START+PAGE_SIZE, 197 (PFN_PHYS(free_pfn)+bootmap_size+PAGE_SIZE-1)-__MEMORY_START, 198 BOOTMEM_DEFAULT); 199 200 /* 201 * reserve physical page 0 - it's a special BIOS page on many boxes, 202 * enabling clean reboots, SMP operation, laptop functions. 203 */ 204 reserve_bootmem(__MEMORY_START, PAGE_SIZE, BOOTMEM_DEFAULT); 205 206 sparse_memory_present_with_active_regions(0); 207 208 #ifdef CONFIG_BLK_DEV_INITRD 209 ROOT_DEV = Root_RAM0; 210 211 if (LOADER_TYPE && INITRD_START) { 212 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) { 213 reserve_bootmem(INITRD_START + __MEMORY_START, 214 INITRD_SIZE, BOOTMEM_DEFAULT); 215 initrd_start = INITRD_START + PAGE_OFFSET + 216 __MEMORY_START; 217 initrd_end = initrd_start + INITRD_SIZE; 218 } else { 219 printk("initrd extends beyond end of memory " 220 "(0x%08lx > 0x%08lx)\ndisabling initrd\n", 221 INITRD_START + INITRD_SIZE, 222 max_low_pfn << PAGE_SHIFT); 223 initrd_start = 0; 224 } 225 } 226 #endif 227 228 reserve_crashkernel(); 229 } 230 231 #ifndef CONFIG_NEED_MULTIPLE_NODES 232 static void __init setup_memory(void) 233 { 234 unsigned long start_pfn; 235 236 /* 237 * Partially used pages are not usable - thus 238 * we are rounding upwards: 239 */ 240 start_pfn = PFN_UP(__pa(_end)); 241 setup_bootmem_allocator(start_pfn); 242 } 243 #else 244 extern void __init setup_memory(void); 245 #endif 246 247 void __init setup_arch(char **cmdline_p) 248 { 249 enable_mmu(); 250 251 ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV); 252 253 #ifdef CONFIG_BLK_DEV_RAM 254 rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK; 255 rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0); 256 rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0); 257 #endif 258 259 if (!MOUNT_ROOT_RDONLY) 260 root_mountflags &= ~MS_RDONLY; 261 init_mm.start_code = (unsigned long) _text; 262 init_mm.end_code = (unsigned long) _etext; 263 init_mm.end_data = (unsigned long) _edata; 264 init_mm.brk = (unsigned long) _end; 265 266 code_resource.start = virt_to_phys(_text); 267 code_resource.end = virt_to_phys(_etext)-1; 268 data_resource.start = virt_to_phys(_etext); 269 data_resource.end = virt_to_phys(_edata)-1; 270 271 memory_start = (unsigned long)__va(__MEMORY_START); 272 if (!memory_end) 273 memory_end = memory_start + __MEMORY_SIZE; 274 275 #ifdef CONFIG_CMDLINE_BOOL 276 strlcpy(command_line, CONFIG_CMDLINE, sizeof(command_line)); 277 #else 278 strlcpy(command_line, COMMAND_LINE, sizeof(command_line)); 279 #endif 280 281 /* Save unparsed command line copy for /proc/cmdline */ 282 memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE); 283 *cmdline_p = command_line; 284 285 parse_early_param(); 286 287 sh_mv_setup(); 288 289 /* 290 * Find the highest page frame number we have available 291 */ 292 max_pfn = PFN_DOWN(__pa(memory_end)); 293 294 /* 295 * Determine low and high memory ranges: 296 */ 297 max_low_pfn = max_pfn; 298 min_low_pfn = __MEMORY_START >> PAGE_SHIFT; 299 300 nodes_clear(node_online_map); 301 302 /* Setup bootmem with available RAM */ 303 setup_memory(); 304 sparse_init(); 305 306 #ifdef CONFIG_DUMMY_CONSOLE 307 conswitchp = &dummy_con; 308 #endif 309 310 /* Perform the machine specific initialisation */ 311 if (likely(sh_mv.mv_setup)) 312 sh_mv.mv_setup(cmdline_p); 313 314 paging_init(); 315 316 #ifdef CONFIG_SMP 317 plat_smp_setup(); 318 #endif 319 } 320 321 static const char *cpu_name[] = { 322 [CPU_SH7203] = "SH7203", [CPU_SH7263] = "SH7263", 323 [CPU_SH7206] = "SH7206", [CPU_SH7619] = "SH7619", 324 [CPU_SH7705] = "SH7705", [CPU_SH7706] = "SH7706", 325 [CPU_SH7707] = "SH7707", [CPU_SH7708] = "SH7708", 326 [CPU_SH7709] = "SH7709", [CPU_SH7710] = "SH7710", 327 [CPU_SH7712] = "SH7712", [CPU_SH7720] = "SH7720", 328 [CPU_SH7721] = "SH7721", [CPU_SH7729] = "SH7729", 329 [CPU_SH7750] = "SH7750", [CPU_SH7750S] = "SH7750S", 330 [CPU_SH7750R] = "SH7750R", [CPU_SH7751] = "SH7751", 331 [CPU_SH7751R] = "SH7751R", [CPU_SH7760] = "SH7760", 332 [CPU_SH4_202] = "SH4-202", [CPU_SH4_501] = "SH4-501", 333 [CPU_SH7763] = "SH7763", [CPU_SH7770] = "SH7770", 334 [CPU_SH7780] = "SH7780", [CPU_SH7781] = "SH7781", 335 [CPU_SH7343] = "SH7343", [CPU_SH7785] = "SH7785", 336 [CPU_SH7722] = "SH7722", [CPU_SHX3] = "SH-X3", 337 [CPU_SH5_101] = "SH5-101", [CPU_SH5_103] = "SH5-103", 338 [CPU_MXG] = "MX-G", [CPU_SH7723] = "SH7723", 339 [CPU_SH7366] = "SH7366", [CPU_SH_NONE] = "Unknown" 340 }; 341 342 const char *get_cpu_subtype(struct sh_cpuinfo *c) 343 { 344 return cpu_name[c->type]; 345 } 346 347 #ifdef CONFIG_PROC_FS 348 /* Symbolic CPU flags, keep in sync with asm/cpu-features.h */ 349 static const char *cpu_flags[] = { 350 "none", "fpu", "p2flush", "mmuassoc", "dsp", "perfctr", 351 "ptea", "llsc", "l2", "op32", NULL 352 }; 353 354 static void show_cpuflags(struct seq_file *m, struct sh_cpuinfo *c) 355 { 356 unsigned long i; 357 358 seq_printf(m, "cpu flags\t:"); 359 360 if (!c->flags) { 361 seq_printf(m, " %s\n", cpu_flags[0]); 362 return; 363 } 364 365 for (i = 0; cpu_flags[i]; i++) 366 if ((c->flags & (1 << i))) 367 seq_printf(m, " %s", cpu_flags[i+1]); 368 369 seq_printf(m, "\n"); 370 } 371 372 static void show_cacheinfo(struct seq_file *m, const char *type, 373 struct cache_info info) 374 { 375 unsigned int cache_size; 376 377 cache_size = info.ways * info.sets * info.linesz; 378 379 seq_printf(m, "%s size\t: %2dKiB (%d-way)\n", 380 type, cache_size >> 10, info.ways); 381 } 382 383 /* 384 * Get CPU information for use by the procfs. 385 */ 386 static int show_cpuinfo(struct seq_file *m, void *v) 387 { 388 struct sh_cpuinfo *c = v; 389 unsigned int cpu = c - cpu_data; 390 391 if (!cpu_online(cpu)) 392 return 0; 393 394 if (cpu == 0) 395 seq_printf(m, "machine\t\t: %s\n", get_system_type()); 396 397 seq_printf(m, "processor\t: %d\n", cpu); 398 seq_printf(m, "cpu family\t: %s\n", init_utsname()->machine); 399 seq_printf(m, "cpu type\t: %s\n", get_cpu_subtype(c)); 400 401 show_cpuflags(m, c); 402 403 seq_printf(m, "cache type\t: "); 404 405 /* 406 * Check for what type of cache we have, we support both the 407 * unified cache on the SH-2 and SH-3, as well as the harvard 408 * style cache on the SH-4. 409 */ 410 if (c->icache.flags & SH_CACHE_COMBINED) { 411 seq_printf(m, "unified\n"); 412 show_cacheinfo(m, "cache", c->icache); 413 } else { 414 seq_printf(m, "split (harvard)\n"); 415 show_cacheinfo(m, "icache", c->icache); 416 show_cacheinfo(m, "dcache", c->dcache); 417 } 418 419 /* Optional secondary cache */ 420 if (c->flags & CPU_HAS_L2_CACHE) 421 show_cacheinfo(m, "scache", c->scache); 422 423 seq_printf(m, "bogomips\t: %lu.%02lu\n", 424 c->loops_per_jiffy/(500000/HZ), 425 (c->loops_per_jiffy/(5000/HZ)) % 100); 426 427 return 0; 428 } 429 430 static void *c_start(struct seq_file *m, loff_t *pos) 431 { 432 return *pos < NR_CPUS ? cpu_data + *pos : NULL; 433 } 434 static void *c_next(struct seq_file *m, void *v, loff_t *pos) 435 { 436 ++*pos; 437 return c_start(m, pos); 438 } 439 static void c_stop(struct seq_file *m, void *v) 440 { 441 } 442 const struct seq_operations cpuinfo_op = { 443 .start = c_start, 444 .next = c_next, 445 .stop = c_stop, 446 .show = show_cpuinfo, 447 }; 448 #endif /* CONFIG_PROC_FS */ 449 450 struct dentry *sh_debugfs_root; 451 452 static int __init sh_debugfs_init(void) 453 { 454 sh_debugfs_root = debugfs_create_dir("sh", NULL); 455 if (IS_ERR(sh_debugfs_root)) 456 return PTR_ERR(sh_debugfs_root); 457 458 return 0; 459 } 460 arch_initcall(sh_debugfs_init); 461