sh: Fix up the SH7203 build.
[linux-2.6] / arch / sh / kernel / setup.c
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 <linux/crash_dump.h>
29 #include <linux/mmzone.h>
30 #include <linux/clk.h>
31 #include <linux/delay.h>
32 #include <asm/uaccess.h>
33 #include <asm/io.h>
34 #include <asm/page.h>
35 #include <asm/elf.h>
36 #include <asm/sections.h>
37 #include <asm/irq.h>
38 #include <asm/setup.h>
39 #include <asm/clock.h>
40 #include <asm/mmu_context.h>
41
42 /*
43  * Initialize loops_per_jiffy as 10000000 (1000MIPS).
44  * This value will be used at the very early stage of serial setup.
45  * The bigger value means no problem.
46  */
47 struct sh_cpuinfo cpu_data[NR_CPUS] __read_mostly = {
48         [0] = {
49                 .type                   = CPU_SH_NONE,
50                 .loops_per_jiffy        = 10000000,
51         },
52 };
53 EXPORT_SYMBOL(cpu_data);
54
55 /*
56  * The machine vector. First entry in .machvec.init, or clobbered by
57  * sh_mv= on the command line, prior to .machvec.init teardown.
58  */
59 struct sh_machine_vector sh_mv = { .mv_name = "generic", };
60 EXPORT_SYMBOL(sh_mv);
61
62 #ifdef CONFIG_VT
63 struct screen_info screen_info;
64 #endif
65
66 extern int root_mountflags;
67
68 #define RAMDISK_IMAGE_START_MASK        0x07FF
69 #define RAMDISK_PROMPT_FLAG             0x8000
70 #define RAMDISK_LOAD_FLAG               0x4000
71
72 static char __initdata command_line[COMMAND_LINE_SIZE] = { 0, };
73
74 static struct resource code_resource = {
75         .name = "Kernel code",
76         .flags = IORESOURCE_BUSY | IORESOURCE_MEM,
77 };
78
79 static struct resource data_resource = {
80         .name = "Kernel data",
81         .flags = IORESOURCE_BUSY | IORESOURCE_MEM,
82 };
83
84 static struct resource bss_resource = {
85         .name   = "Kernel bss",
86         .flags  = IORESOURCE_BUSY | IORESOURCE_MEM,
87 };
88
89 unsigned long memory_start;
90 EXPORT_SYMBOL(memory_start);
91 unsigned long memory_end = 0;
92 EXPORT_SYMBOL(memory_end);
93
94 static struct resource mem_resources[MAX_NUMNODES];
95
96 int l1i_cache_shape, l1d_cache_shape, l2_cache_shape;
97
98 static int __init early_parse_mem(char *p)
99 {
100         unsigned long size;
101
102         memory_start = (unsigned long)__va(__MEMORY_START);
103         size = memparse(p, &p);
104
105         if (size > __MEMORY_SIZE) {
106                 static char msg[] __initdata = KERN_ERR
107                         "Using mem= to increase the size of kernel memory "
108                         "is not allowed.\n"
109                         "  Recompile the kernel with the correct value for "
110                         "CONFIG_MEMORY_SIZE.\n";
111                 printk(msg);
112                 return 0;
113         }
114
115         memory_end = memory_start + size;
116
117         return 0;
118 }
119 early_param("mem", early_parse_mem);
120
121 /*
122  * Register fully available low RAM pages with the bootmem allocator.
123  */
124 static void __init register_bootmem_low_pages(void)
125 {
126         unsigned long curr_pfn, last_pfn, pages;
127
128         /*
129          * We are rounding up the start address of usable memory:
130          */
131         curr_pfn = PFN_UP(__MEMORY_START);
132
133         /*
134          * ... and at the end of the usable range downwards:
135          */
136         last_pfn = PFN_DOWN(__pa(memory_end));
137
138         if (last_pfn > max_low_pfn)
139                 last_pfn = max_low_pfn;
140
141         pages = last_pfn - curr_pfn;
142         free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(pages));
143 }
144
145 #ifdef CONFIG_KEXEC
146 static void __init reserve_crashkernel(void)
147 {
148         unsigned long long free_mem;
149         unsigned long long crash_size, crash_base;
150         void *vp;
151         int ret;
152
153         free_mem = ((unsigned long long)max_low_pfn - min_low_pfn) << PAGE_SHIFT;
154
155         ret = parse_crashkernel(boot_command_line, free_mem,
156                         &crash_size, &crash_base);
157         if (ret == 0 && crash_size) {
158                 if (crash_base <= 0) {
159                         vp = alloc_bootmem_nopanic(crash_size); 
160                         if (!vp) {
161                                 printk(KERN_INFO "crashkernel allocation "
162                                        "failed\n");
163                                 return;
164                         }
165                         crash_base = __pa(vp);
166                 } else if (reserve_bootmem(crash_base, crash_size,
167                                         BOOTMEM_EXCLUSIVE) < 0) {
168                         printk(KERN_INFO "crashkernel reservation failed - "
169                                         "memory is in use\n");
170                         return;
171                 }
172
173                 printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
174                                 "for crashkernel (System RAM: %ldMB)\n",
175                                 (unsigned long)(crash_size >> 20),
176                                 (unsigned long)(crash_base >> 20),
177                                 (unsigned long)(free_mem >> 20));
178                 crashk_res.start = crash_base;
179                 crashk_res.end   = crash_base + crash_size - 1;
180                 insert_resource(&iomem_resource, &crashk_res);
181         }
182 }
183 #else
184 static inline void __init reserve_crashkernel(void)
185 {}
186 #endif
187
188 #ifndef CONFIG_GENERIC_CALIBRATE_DELAY
189 void __cpuinit calibrate_delay(void)
190 {
191         struct clk *clk = clk_get(NULL, "cpu_clk");
192
193         if (IS_ERR(clk))
194                 panic("Need a sane CPU clock definition!");
195
196         loops_per_jiffy = (clk_get_rate(clk) >> 1) / HZ;
197
198         printk(KERN_INFO "Calibrating delay loop (skipped)... "
199                          "%lu.%02lu BogoMIPS PRESET (lpj=%lu)\n",
200                          loops_per_jiffy/(500000/HZ),
201                          (loops_per_jiffy/(5000/HZ)) % 100,
202                          loops_per_jiffy);
203 }
204 #endif
205
206 void __init __add_active_range(unsigned int nid, unsigned long start_pfn,
207                                                 unsigned long end_pfn)
208 {
209         struct resource *res = &mem_resources[nid];
210
211         WARN_ON(res->name); /* max one active range per node for now */
212
213         res->name = "System RAM";
214         res->start = start_pfn << PAGE_SHIFT;
215         res->end = (end_pfn << PAGE_SHIFT) - 1;
216         res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
217         if (request_resource(&iomem_resource, res)) {
218                 pr_err("unable to request memory_resource 0x%lx 0x%lx\n",
219                        start_pfn, end_pfn);
220                 return;
221         }
222
223         /*
224          *  We don't know which RAM region contains kernel data,
225          *  so we try it repeatedly and let the resource manager
226          *  test it.
227          */
228         request_resource(res, &code_resource);
229         request_resource(res, &data_resource);
230         request_resource(res, &bss_resource);
231
232         add_active_range(nid, start_pfn, end_pfn);
233 }
234
235 void __init setup_bootmem_allocator(unsigned long free_pfn)
236 {
237         unsigned long bootmap_size;
238
239         /*
240          * Find a proper area for the bootmem bitmap. After this
241          * bootstrap step all allocations (until the page allocator
242          * is intact) must be done via bootmem_alloc().
243          */
244         bootmap_size = init_bootmem_node(NODE_DATA(0), free_pfn,
245                                          min_low_pfn, max_low_pfn);
246
247         __add_active_range(0, min_low_pfn, max_low_pfn);
248         register_bootmem_low_pages();
249
250         node_set_online(0);
251
252         /*
253          * Reserve the kernel text and
254          * Reserve the bootmem bitmap. We do this in two steps (first step
255          * was init_bootmem()), because this catches the (definitely buggy)
256          * case of us accidentally initializing the bootmem allocator with
257          * an invalid RAM area.
258          */
259         reserve_bootmem(__MEMORY_START + CONFIG_ZERO_PAGE_OFFSET,
260                         (PFN_PHYS(free_pfn) + bootmap_size + PAGE_SIZE - 1) -
261                         (__MEMORY_START + CONFIG_ZERO_PAGE_OFFSET),
262                         BOOTMEM_DEFAULT);
263
264         /*
265          * reserve physical page 0 - it's a special BIOS page on many boxes,
266          * enabling clean reboots, SMP operation, laptop functions.
267          */
268         reserve_bootmem(__MEMORY_START, CONFIG_ZERO_PAGE_OFFSET,
269                         BOOTMEM_DEFAULT);
270
271         sparse_memory_present_with_active_regions(0);
272
273 #ifdef CONFIG_BLK_DEV_INITRD
274         ROOT_DEV = Root_RAM0;
275
276         if (LOADER_TYPE && INITRD_START) {
277                 unsigned long initrd_start_phys = INITRD_START + __MEMORY_START;
278
279                 if (initrd_start_phys + INITRD_SIZE <= PFN_PHYS(max_low_pfn)) {
280                         reserve_bootmem(initrd_start_phys, INITRD_SIZE,
281                                         BOOTMEM_DEFAULT);
282                         initrd_start = (unsigned long)__va(initrd_start_phys);
283                         initrd_end = initrd_start + INITRD_SIZE;
284                 } else {
285                         printk("initrd extends beyond end of memory "
286                                "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
287                                initrd_start_phys + INITRD_SIZE,
288                                (unsigned long)PFN_PHYS(max_low_pfn));
289                         initrd_start = 0;
290                 }
291         }
292 #endif
293
294         reserve_crashkernel();
295 }
296
297 #ifndef CONFIG_NEED_MULTIPLE_NODES
298 static void __init setup_memory(void)
299 {
300         unsigned long start_pfn;
301
302         /*
303          * Partially used pages are not usable - thus
304          * we are rounding upwards:
305          */
306         start_pfn = PFN_UP(__pa(_end));
307         setup_bootmem_allocator(start_pfn);
308 }
309 #else
310 extern void __init setup_memory(void);
311 #endif
312
313 /*
314  * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
315  * is_kdump_kernel() to determine if we are booting after a panic. Hence
316  * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
317  */
318 #ifdef CONFIG_CRASH_DUMP
319 /* elfcorehdr= specifies the location of elf core header
320  * stored by the crashed kernel.
321  */
322 static int __init parse_elfcorehdr(char *arg)
323 {
324         if (!arg)
325                 return -EINVAL;
326         elfcorehdr_addr = memparse(arg, &arg);
327         return 0;
328 }
329 early_param("elfcorehdr", parse_elfcorehdr);
330 #endif
331
332 void __init setup_arch(char **cmdline_p)
333 {
334         enable_mmu();
335
336         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
337
338         printk(KERN_NOTICE "Boot params:\n"
339                            "... MOUNT_ROOT_RDONLY - %08lx\n"
340                            "... RAMDISK_FLAGS     - %08lx\n"
341                            "... ORIG_ROOT_DEV     - %08lx\n"
342                            "... LOADER_TYPE       - %08lx\n"
343                            "... INITRD_START      - %08lx\n"
344                            "... INITRD_SIZE       - %08lx\n",
345                            MOUNT_ROOT_RDONLY, RAMDISK_FLAGS,
346                            ORIG_ROOT_DEV, LOADER_TYPE,
347                            INITRD_START, INITRD_SIZE);
348
349 #ifdef CONFIG_BLK_DEV_RAM
350         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
351         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
352         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
353 #endif
354
355         if (!MOUNT_ROOT_RDONLY)
356                 root_mountflags &= ~MS_RDONLY;
357         init_mm.start_code = (unsigned long) _text;
358         init_mm.end_code = (unsigned long) _etext;
359         init_mm.end_data = (unsigned long) _edata;
360         init_mm.brk = (unsigned long) _end;
361
362         code_resource.start = virt_to_phys(_text);
363         code_resource.end = virt_to_phys(_etext)-1;
364         data_resource.start = virt_to_phys(_etext);
365         data_resource.end = virt_to_phys(_edata)-1;
366         bss_resource.start = virt_to_phys(__bss_start);
367         bss_resource.end = virt_to_phys(_ebss)-1;
368
369         memory_start = (unsigned long)__va(__MEMORY_START);
370         if (!memory_end)
371                 memory_end = memory_start + __MEMORY_SIZE;
372
373 #ifdef CONFIG_CMDLINE_BOOL
374         strlcpy(command_line, CONFIG_CMDLINE, sizeof(command_line));
375 #else
376         strlcpy(command_line, COMMAND_LINE, sizeof(command_line));
377 #endif
378
379         /* Save unparsed command line copy for /proc/cmdline */
380         memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
381         *cmdline_p = command_line;
382
383         parse_early_param();
384
385         sh_mv_setup();
386
387         /*
388          * Find the highest page frame number we have available
389          */
390         max_pfn = PFN_DOWN(__pa(memory_end));
391
392         /*
393          * Determine low and high memory ranges:
394          */
395         max_low_pfn = max_pfn;
396         min_low_pfn = __MEMORY_START >> PAGE_SHIFT;
397
398         nodes_clear(node_online_map);
399
400         /* Setup bootmem with available RAM */
401         setup_memory();
402         sparse_init();
403
404 #ifdef CONFIG_DUMMY_CONSOLE
405         conswitchp = &dummy_con;
406 #endif
407
408         /* Perform the machine specific initialisation */
409         if (likely(sh_mv.mv_setup))
410                 sh_mv.mv_setup(cmdline_p);
411
412         paging_init();
413
414 #ifdef CONFIG_SMP
415         plat_smp_setup();
416 #endif
417 }
418
419 static const char *cpu_name[] = {
420         [CPU_SH7203]    = "SH7203",     [CPU_SH7263]    = "SH7263",
421         [CPU_SH7206]    = "SH7206",     [CPU_SH7619]    = "SH7619",
422         [CPU_SH7705]    = "SH7705",     [CPU_SH7706]    = "SH7706",
423         [CPU_SH7707]    = "SH7707",     [CPU_SH7708]    = "SH7708",
424         [CPU_SH7709]    = "SH7709",     [CPU_SH7710]    = "SH7710",
425         [CPU_SH7712]    = "SH7712",     [CPU_SH7720]    = "SH7720",
426         [CPU_SH7721]    = "SH7721",     [CPU_SH7729]    = "SH7729",
427         [CPU_SH7750]    = "SH7750",     [CPU_SH7750S]   = "SH7750S",
428         [CPU_SH7750R]   = "SH7750R",    [CPU_SH7751]    = "SH7751",
429         [CPU_SH7751R]   = "SH7751R",    [CPU_SH7760]    = "SH7760",
430         [CPU_SH4_202]   = "SH4-202",    [CPU_SH4_501]   = "SH4-501",
431         [CPU_SH7763]    = "SH7763",     [CPU_SH7770]    = "SH7770",
432         [CPU_SH7780]    = "SH7780",     [CPU_SH7781]    = "SH7781",
433         [CPU_SH7343]    = "SH7343",     [CPU_SH7785]    = "SH7785",
434         [CPU_SH7722]    = "SH7722",     [CPU_SHX3]      = "SH-X3",
435         [CPU_SH5_101]   = "SH5-101",    [CPU_SH5_103]   = "SH5-103",
436         [CPU_MXG]       = "MX-G",       [CPU_SH7723]    = "SH7723",
437         [CPU_SH7366]    = "SH7366",     [CPU_SH_NONE]   = "Unknown"
438 };
439
440 const char *get_cpu_subtype(struct sh_cpuinfo *c)
441 {
442         return cpu_name[c->type];
443 }
444 EXPORT_SYMBOL(get_cpu_subtype);
445
446 #ifdef CONFIG_PROC_FS
447 /* Symbolic CPU flags, keep in sync with asm/cpu-features.h */
448 static const char *cpu_flags[] = {
449         "none", "fpu", "p2flush", "mmuassoc", "dsp", "perfctr",
450         "ptea", "llsc", "l2", "op32", NULL
451 };
452
453 static void show_cpuflags(struct seq_file *m, struct sh_cpuinfo *c)
454 {
455         unsigned long i;
456
457         seq_printf(m, "cpu flags\t:");
458
459         if (!c->flags) {
460                 seq_printf(m, " %s\n", cpu_flags[0]);
461                 return;
462         }
463
464         for (i = 0; cpu_flags[i]; i++)
465                 if ((c->flags & (1 << i)))
466                         seq_printf(m, " %s", cpu_flags[i+1]);
467
468         seq_printf(m, "\n");
469 }
470
471 static void show_cacheinfo(struct seq_file *m, const char *type,
472                            struct cache_info info)
473 {
474         unsigned int cache_size;
475
476         cache_size = info.ways * info.sets * info.linesz;
477
478         seq_printf(m, "%s size\t: %2dKiB (%d-way)\n",
479                    type, cache_size >> 10, info.ways);
480 }
481
482 /*
483  *      Get CPU information for use by the procfs.
484  */
485 static int show_cpuinfo(struct seq_file *m, void *v)
486 {
487         struct sh_cpuinfo *c = v;
488         unsigned int cpu = c - cpu_data;
489
490         if (!cpu_online(cpu))
491                 return 0;
492
493         if (cpu == 0)
494                 seq_printf(m, "machine\t\t: %s\n", get_system_type());
495
496         seq_printf(m, "processor\t: %d\n", cpu);
497         seq_printf(m, "cpu family\t: %s\n", init_utsname()->machine);
498         seq_printf(m, "cpu type\t: %s\n", get_cpu_subtype(c));
499         if (c->cut_major == -1)
500                 seq_printf(m, "cut\t\t: unknown\n");
501         else if (c->cut_minor == -1)
502                 seq_printf(m, "cut\t\t: %d.x\n", c->cut_major);
503         else
504                 seq_printf(m, "cut\t\t: %d.%d\n", c->cut_major, c->cut_minor);
505
506         show_cpuflags(m, c);
507
508         seq_printf(m, "cache type\t: ");
509
510         /*
511          * Check for what type of cache we have, we support both the
512          * unified cache on the SH-2 and SH-3, as well as the harvard
513          * style cache on the SH-4.
514          */
515         if (c->icache.flags & SH_CACHE_COMBINED) {
516                 seq_printf(m, "unified\n");
517                 show_cacheinfo(m, "cache", c->icache);
518         } else {
519                 seq_printf(m, "split (harvard)\n");
520                 show_cacheinfo(m, "icache", c->icache);
521                 show_cacheinfo(m, "dcache", c->dcache);
522         }
523
524         /* Optional secondary cache */
525         if (c->flags & CPU_HAS_L2_CACHE)
526                 show_cacheinfo(m, "scache", c->scache);
527
528         seq_printf(m, "bogomips\t: %lu.%02lu\n",
529                      c->loops_per_jiffy/(500000/HZ),
530                      (c->loops_per_jiffy/(5000/HZ)) % 100);
531
532         return 0;
533 }
534
535 static void *c_start(struct seq_file *m, loff_t *pos)
536 {
537         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
538 }
539 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
540 {
541         ++*pos;
542         return c_start(m, pos);
543 }
544 static void c_stop(struct seq_file *m, void *v)
545 {
546 }
547 const struct seq_operations cpuinfo_op = {
548         .start  = c_start,
549         .next   = c_next,
550         .stop   = c_stop,
551         .show   = show_cpuinfo,
552 };
553 #endif /* CONFIG_PROC_FS */
554
555 struct dentry *sh_debugfs_root;
556
557 static int __init sh_debugfs_init(void)
558 {
559         sh_debugfs_root = debugfs_create_dir("sh", NULL);
560         if (!sh_debugfs_root)
561                 return -ENOMEM;
562         if (IS_ERR(sh_debugfs_root))
563                 return PTR_ERR(sh_debugfs_root);
564
565         return 0;
566 }
567 arch_initcall(sh_debugfs_init);