Merge with /pub/scm/linux/kernel/git/sfrench/cifs-2.6.git/
[linux-2.6] / arch / sh64 / kernel / setup.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * arch/sh64/kernel/setup.c
7  *
8  * sh64 Arch Support
9  *
10  * This file handles the architecture-dependent parts of initialization
11  *
12  * Copyright (C) 2000, 2001  Paolo Alberelli
13  * Copyright (C) 2003, 2004  Paul Mundt
14  *
15  * benedict.gaster@superh.com:   2nd May 2002
16  *    Modified to use the empty_zero_page to pass command line arguments.
17  *
18  * benedict.gaster@superh.com:   3rd May 2002
19  *    Added support for ramdisk, removing statically linked romfs at the same time.
20  *
21  * lethal@linux-sh.org:          15th May 2003
22  *    Added generic procfs cpuinfo reporting. Make boards just export their name.
23  *
24  * lethal@linux-sh.org:          25th May 2003
25  *    Added generic get_cpu_subtype() for subtype reporting from cpu_data->type.
26  *
27  */
28 #include <linux/errno.h>
29 #include <linux/rwsem.h>
30 #include <linux/sched.h>
31 #include <linux/kernel.h>
32 #include <linux/mm.h>
33 #include <linux/stddef.h>
34 #include <linux/unistd.h>
35 #include <linux/ptrace.h>
36 #include <linux/slab.h>
37 #include <linux/user.h>
38 #include <linux/a.out.h>
39 #include <linux/tty.h>
40 #include <linux/ioport.h>
41 #include <linux/delay.h>
42 #include <linux/config.h>
43 #include <linux/init.h>
44 #include <linux/seq_file.h>
45 #include <linux/blkdev.h>
46 #include <linux/bootmem.h>
47 #include <linux/console.h>
48 #include <linux/root_dev.h>
49 #include <linux/cpu.h>
50 #include <linux/initrd.h>
51 #include <asm/processor.h>
52 #include <asm/page.h>
53 #include <asm/pgtable.h>
54 #include <asm/platform.h>
55 #include <asm/uaccess.h>
56 #include <asm/system.h>
57 #include <asm/io.h>
58 #include <asm/sections.h>
59 #include <asm/setup.h>
60 #include <asm/smp.h>
61
62 #ifdef CONFIG_VT
63 #include <linux/console.h>
64 #endif
65
66 struct screen_info screen_info;
67
68 #ifdef CONFIG_BLK_DEV_RAM
69 extern int rd_doload;           /* 1 = load ramdisk, 0 = don't load */
70 extern int rd_prompt;           /* 1 = prompt for ramdisk, 0 = don't prompt */
71 extern int rd_image_start;      /* starting block # of image */
72 #endif
73
74 extern int root_mountflags;
75 extern char *get_system_type(void);
76 extern void platform_setup(void);
77 extern void platform_monitor(void);
78 extern void platform_reserve(void);
79 extern int sh64_cache_init(void);
80 extern int sh64_tlb_init(void);
81
82 #define RAMDISK_IMAGE_START_MASK        0x07FF
83 #define RAMDISK_PROMPT_FLAG             0x8000
84 #define RAMDISK_LOAD_FLAG               0x4000
85
86 static char command_line[COMMAND_LINE_SIZE] = { 0, };
87 unsigned long long memory_start = CONFIG_MEMORY_START;
88 unsigned long long memory_end = CONFIG_MEMORY_START + (CONFIG_MEMORY_SIZE_IN_MB * 1024 * 1024);
89
90 struct sh_cpuinfo boot_cpu_data;
91
92 static inline void parse_mem_cmdline (char ** cmdline_p)
93 {
94         char c = ' ', *to = command_line, *from = COMMAND_LINE;
95         int len = 0;
96
97         /* Save unparsed command line copy for /proc/cmdline */
98         memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
99         saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
100
101         for (;;) {
102           /*
103            * "mem=XXX[kKmM]" defines a size of memory.
104            */
105                 if (c == ' ' && !memcmp(from, "mem=", 4)) {
106                       if (to != command_line)
107                         to--;
108                       {
109                         unsigned long mem_size;
110
111                         mem_size = memparse(from+4, &from);
112                         memory_end = memory_start + mem_size;
113                       }
114                 }
115                 c = *(from++);
116                 if (!c)
117                   break;
118                 if (COMMAND_LINE_SIZE <= ++len)
119                   break;
120                 *(to++) = c;
121         }
122         *to = '\0';
123
124         *cmdline_p = command_line;
125 }
126
127 static void __init sh64_cpu_type_detect(void)
128 {
129         extern unsigned long long peek_real_address_q(unsigned long long addr);
130         unsigned long long cir;
131         /* Do peeks in real mode to avoid having to set up a mapping for the
132            WPC registers.  On SH5-101 cut2, such a mapping would be exposed to
133            an address translation erratum which would make it hard to set up
134            correctly. */
135         cir = peek_real_address_q(0x0d000008);
136
137         if ((cir & 0xffff) == 0x5103) {
138                 boot_cpu_data.type = CPU_SH5_103;
139         } else if (((cir >> 32) & 0xffff) == 0x51e2) {
140                 /* CPU.VCR aliased at CIR address on SH5-101 */
141                 boot_cpu_data.type = CPU_SH5_101;
142         } else {
143                 boot_cpu_data.type = CPU_SH_NONE;
144         }
145 }
146
147 void __init setup_arch(char **cmdline_p)
148 {
149         unsigned long bootmap_size, i;
150         unsigned long first_pfn, start_pfn, last_pfn, pages;
151
152 #ifdef CONFIG_EARLY_PRINTK
153         extern void enable_early_printk(void);
154
155         /*
156          * Setup Early SCIF console
157          */
158         enable_early_printk();
159 #endif
160
161         /*
162          * Setup TLB mappings
163          */
164         sh64_tlb_init();
165
166         /*
167          * Caches are already initialized by the time we get here, so we just
168          * fill in cpu_data info for the caches.
169          */
170         sh64_cache_init();
171
172         platform_setup();
173         platform_monitor();
174
175         sh64_cpu_type_detect();
176
177         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
178
179 #ifdef CONFIG_BLK_DEV_RAM
180         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
181         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
182         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
183 #endif
184
185         if (!MOUNT_ROOT_RDONLY)
186                 root_mountflags &= ~MS_RDONLY;
187         init_mm.start_code = (unsigned long) _text;
188         init_mm.end_code = (unsigned long) _etext;
189         init_mm.end_data = (unsigned long) _edata;
190         init_mm.brk = (unsigned long) _end;
191
192         code_resource.start = __pa(_text);
193         code_resource.end = __pa(_etext)-1;
194         data_resource.start = __pa(_etext);
195         data_resource.end = __pa(_edata)-1;
196
197         parse_mem_cmdline(cmdline_p);
198
199         /*
200          * Find the lowest and highest page frame numbers we have available
201          */
202         first_pfn = PFN_DOWN(memory_start);
203         last_pfn = PFN_DOWN(memory_end);
204         pages = last_pfn - first_pfn;
205
206         /*
207          * Partially used pages are not usable - thus
208          * we are rounding upwards:
209          */
210         start_pfn = PFN_UP(__pa(_end));
211
212         /*
213          * Find a proper area for the bootmem bitmap. After this
214          * bootstrap step all allocations (until the page allocator
215          * is intact) must be done via bootmem_alloc().
216          */
217         bootmap_size = init_bootmem_node(NODE_DATA(0), start_pfn,
218                                          first_pfn,
219                                          last_pfn);
220         /*
221          * Round it up.
222          */
223         bootmap_size = PFN_PHYS(PFN_UP(bootmap_size));
224
225         /*
226          * Register fully available RAM pages with the bootmem allocator.
227          */
228         free_bootmem_node(NODE_DATA(0), PFN_PHYS(first_pfn), PFN_PHYS(pages));
229
230         /*
231          * Reserve all kernel sections + bootmem bitmap + a guard page.
232          */
233         reserve_bootmem_node(NODE_DATA(0), PFN_PHYS(first_pfn),
234                         (PFN_PHYS(start_pfn) + bootmap_size + PAGE_SIZE) - PFN_PHYS(first_pfn));
235
236         /*
237          * Reserve platform dependent sections
238          */
239         platform_reserve();
240
241 #ifdef CONFIG_BLK_DEV_INITRD
242         if (LOADER_TYPE && INITRD_START) {
243                 if (INITRD_START + INITRD_SIZE <= (PFN_PHYS(last_pfn))) {
244                         reserve_bootmem_node(NODE_DATA(0), INITRD_START + __MEMORY_START, INITRD_SIZE);
245
246                         initrd_start =
247                           (long) INITRD_START ? INITRD_START + PAGE_OFFSET +  __MEMORY_START : 0;
248
249                         initrd_end = initrd_start + INITRD_SIZE;
250                 } else {
251                         printk("initrd extends beyond end of memory "
252                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
253                                     (long) INITRD_START + INITRD_SIZE,
254                                     PFN_PHYS(last_pfn));
255                         initrd_start = 0;
256                 }
257         }
258 #endif
259
260         /*
261          * Claim all RAM, ROM, and I/O resources.
262          */
263
264         /* Kernel RAM */
265         request_resource(&iomem_resource, &code_resource);
266         request_resource(&iomem_resource, &data_resource);
267
268         /* Other KRAM space */
269         for (i = 0; i < STANDARD_KRAM_RESOURCES - 2; i++)
270                 request_resource(&iomem_resource,
271                                  &platform_parms.kram_res_p[i]);
272
273         /* XRAM space */
274         for (i = 0; i < STANDARD_XRAM_RESOURCES; i++)
275                 request_resource(&iomem_resource,
276                                  &platform_parms.xram_res_p[i]);
277
278         /* ROM space */
279         for (i = 0; i < STANDARD_ROM_RESOURCES; i++)
280                 request_resource(&iomem_resource,
281                                  &platform_parms.rom_res_p[i]);
282
283         /* I/O space */
284         for (i = 0; i < STANDARD_IO_RESOURCES; i++)
285                 request_resource(&ioport_resource,
286                                  &platform_parms.io_res_p[i]);
287
288
289 #ifdef CONFIG_VT
290 #if defined(CONFIG_VGA_CONSOLE)
291         conswitchp = &vga_con;
292 #elif defined(CONFIG_DUMMY_CONSOLE)
293         conswitchp = &dummy_con;
294 #endif
295 #endif
296
297         printk("Hardware FPU: %s\n", fpu_in_use ? "enabled" : "disabled");
298
299         paging_init();
300 }
301
302 void __xchg_called_with_bad_pointer(void)
303 {
304         printk(KERN_EMERG "xchg() called with bad pointer !\n");
305 }
306
307 static struct cpu cpu[1];
308
309 static int __init topology_init(void)
310 {
311         return register_cpu(cpu, 0, NULL);
312 }
313
314 subsys_initcall(topology_init);
315
316 /*
317  *      Get CPU information
318  */
319 static const char *cpu_name[] = {
320         [CPU_SH5_101]   = "SH5-101",
321         [CPU_SH5_103]   = "SH5-103",
322         [CPU_SH_NONE]   = "Unknown",
323 };
324
325 const char *get_cpu_subtype(void)
326 {
327         return cpu_name[boot_cpu_data.type];
328 }
329
330 #ifdef CONFIG_PROC_FS
331 static int show_cpuinfo(struct seq_file *m,void *v)
332 {
333         unsigned int cpu = smp_processor_id();
334
335         if (!cpu)
336                 seq_printf(m, "machine\t\t: %s\n", get_system_type());
337
338         seq_printf(m, "processor\t: %d\n", cpu);
339         seq_printf(m, "cpu family\t: SH-5\n");
340         seq_printf(m, "cpu type\t: %s\n", get_cpu_subtype());
341
342         seq_printf(m, "icache size\t: %dK-bytes\n",
343                    (boot_cpu_data.icache.ways *
344                     boot_cpu_data.icache.sets *
345                     boot_cpu_data.icache.linesz) >> 10);
346         seq_printf(m, "dcache size\t: %dK-bytes\n",
347                    (boot_cpu_data.dcache.ways *
348                     boot_cpu_data.dcache.sets *
349                     boot_cpu_data.dcache.linesz) >> 10);
350         seq_printf(m, "itlb entries\t: %d\n", boot_cpu_data.itlb.entries);
351         seq_printf(m, "dtlb entries\t: %d\n", boot_cpu_data.dtlb.entries);
352
353 #define PRINT_CLOCK(name, value) \
354         seq_printf(m, name " clock\t: %d.%02dMHz\n", \
355                      ((value) / 1000000), ((value) % 1000000)/10000)
356
357         PRINT_CLOCK("cpu", boot_cpu_data.cpu_clock);
358         PRINT_CLOCK("bus", boot_cpu_data.bus_clock);
359         PRINT_CLOCK("module", boot_cpu_data.module_clock);
360
361         seq_printf(m, "bogomips\t: %lu.%02lu\n\n",
362                      (loops_per_jiffy*HZ+2500)/500000,
363                      ((loops_per_jiffy*HZ+2500)/5000) % 100);
364
365         return 0;
366 }
367
368 static void *c_start(struct seq_file *m, loff_t *pos)
369 {
370         return (void*)(*pos == 0);
371 }
372 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
373 {
374         return NULL;
375 }
376 static void c_stop(struct seq_file *m, void *v)
377 {
378 }
379 struct seq_operations cpuinfo_op = {
380         .start  = c_start,
381         .next   = c_next,
382         .stop   = c_stop,
383         .show   = show_cpuinfo,
384 };
385 #endif /* CONFIG_PROC_FS */