1 /*
2 * linux/arch/cris/kernel/setup.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 * Copyright (c) 2001, 2002, 2003 Axis Communications AB
6 */
7
8 /*
9 * This file handles the architecture-dependent parts of initialization
10 */
11
12 #include <linux/errno.h>
13 #include <linux/sched.h>
14 #include <linux/kernel.h>
15 #include <linux/mm.h>
16 #include <linux/stddef.h>
17 #include <linux/unistd.h>
18 #include <linux/ptrace.h>
19 #include <linux/slab.h>
20 #include <linux/user.h>
21 #include <linux/a.out.h>
22 #include <linux/tty.h>
23 #include <linux/ioport.h>
24 #include <linux/delay.h>
25 #include <linux/config.h>
26 #include <linux/init.h>
27 #include <linux/bootmem.h>
28 #include <linux/seq_file.h>
29
30 #include <asm/segment.h>
31 #include <asm/system.h>
32 #include <asm/smp.h>
33 #include <asm/pgtable.h>
34 #include <asm/types.h>
35 #include <asm/svinto.h>
36
37 /*
38 * Setup options
39 */
40 struct drive_info_struct { char dummy[32]; } drive_info;
41 struct screen_info screen_info;
42
43 unsigned char aux_device_present;
44
45 extern int root_mountflags;
46 extern char _etext, _edata, _end;
47
48 #define COMMAND_LINE_SIZE 256
49
50 static char command_line[COMMAND_LINE_SIZE] = { 0, };
51 char saved_command_line[COMMAND_LINE_SIZE];
52
53 extern const unsigned long text_start, edata; /* set by the linker script */
54
55 extern unsigned long romfs_start, romfs_length, romfs_in_flash; /* from head.S */
56
57 /* This mainly sets up the memory area, and can be really confusing.
58 *
59 * The physical DRAM is virtually mapped into dram_start to dram_end
60 * (usually c0000000 to c0000000 + DRAM size). The physical address is
61 * given by the macro __pa().
62 *
63 * In this DRAM, the kernel code and data is loaded, in the beginning.
64 * It really starts at c0004000 to make room for some special pages -
65 * the start address is text_start. The kernel data ends at _end. After
66 * this the ROM filesystem is appended (if there is any).
67 *
68 * Between this address and dram_end, we have RAM pages usable to the
69 * boot code and the system.
70 *
71 */
72
73 void __init
setup_arch(char ** cmdline_p)74 setup_arch(char **cmdline_p)
75 {
76 extern void init_etrax_debug(void);
77 unsigned long bootmap_size;
78 unsigned long start_pfn, max_pfn;
79 unsigned long memory_start;
80
81 /* register an initial console printing routine for printk's */
82
83 init_etrax_debug();
84
85 /* we should really poll for DRAM size! */
86
87 high_memory = &dram_end;
88
89 if(romfs_in_flash || !romfs_length) {
90 /* if we have the romfs in flash, or if there is no rom filesystem,
91 * our free area starts directly after the BSS
92 */
93 memory_start = (unsigned long) &_end;
94 } else {
95 /* otherwise the free area starts after the ROM filesystem */
96 printk(KERN_INFO "ROM fs in RAM, size %lu bytes\n",
97 romfs_length);
98 memory_start = romfs_start + romfs_length;
99 }
100
101 /* process 1's initial memory region is the kernel code/data */
102
103 init_mm.start_code = (unsigned long) &text_start;
104 init_mm.end_code = (unsigned long) &_etext;
105 init_mm.end_data = (unsigned long) &_edata;
106 init_mm.brk = (unsigned long) &_end;
107
108 #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
109 #define PFN_DOWN(x) ((x) >> PAGE_SHIFT)
110 #define PFN_PHYS(x) ((x) << PAGE_SHIFT)
111
112 /* min_low_pfn points to the start of DRAM, start_pfn points
113 * to the first DRAM pages after the kernel, and max_low_pfn
114 * to the end of DRAM.
115 */
116
117 /*
118 * partially used pages are not usable - thus
119 * we are rounding upwards:
120 */
121
122 start_pfn = PFN_UP(memory_start); /* usually c0000000 + kernel + romfs */
123 max_pfn = PFN_DOWN((unsigned long)high_memory); /* usually c0000000 + dram size */
124
125 /*
126 * Initialize the boot-time allocator (start, end)
127 *
128 * We give it access to all our DRAM, but we could as well just have
129 * given it a small slice. No point in doing that though, unless we
130 * have non-contiguous memory and want the boot-stuff to be in, say,
131 * the smallest area.
132 *
133 * It will put a bitmap of the allocated pages in the beginning
134 * of the range we give it, but it won't mark the bitmaps pages
135 * as reserved. We have to do that ourselves below.
136 *
137 * We need to use init_bootmem_node instead of init_bootmem
138 * because our map starts at a quite high address (min_low_pfn).
139 */
140
141 max_low_pfn = max_pfn;
142 min_low_pfn = PAGE_OFFSET >> PAGE_SHIFT;
143
144 bootmap_size = init_bootmem_node(NODE_DATA(0), start_pfn,
145 min_low_pfn,
146 max_low_pfn);
147
148 /* And free all memory not belonging to the kernel (addr, size) */
149
150 free_bootmem(PFN_PHYS(start_pfn), PFN_PHYS(max_pfn - start_pfn));
151
152 /*
153 * Reserve the bootmem bitmap itself as well. We do this in two
154 * steps (first step was init_bootmem()) because this catches
155 * the (very unlikely) case of us accidentally initializing the
156 * bootmem allocator with an invalid RAM area.
157 *
158 * Arguments are start, size
159 */
160
161 reserve_bootmem(PFN_PHYS(start_pfn), bootmap_size);
162
163 /* paging_init() sets up the MMU and marks all pages as reserved */
164
165 paging_init();
166
167 /* We dont use a command line yet, so just re-initialize it without
168 saving anything that might be there. */
169
170 *cmdline_p = command_line;
171
172 #ifdef CONFIG_ETRAX_CMDLINE
173 strncpy(command_line, CONFIG_ETRAX_CMDLINE, COMMAND_LINE_SIZE);
174 #elif defined(CONFIG_ETRAX_ROOT_DEVICE)
175 strncpy(command_line, "root=", COMMAND_LINE_SIZE);
176 strncpy(command_line+5, CONFIG_ETRAX_ROOT_DEVICE,
177 COMMAND_LINE_SIZE-5);
178 #endif
179 command_line[COMMAND_LINE_SIZE - 1] = '\0';
180
181 /* Save command line copy for /proc/cmdline */
182
183 memcpy(saved_command_line, command_line, COMMAND_LINE_SIZE);
184 saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
185
186 /* give credit for the CRIS port */
187
188 printk(KERN_INFO "Linux/CRIS port on ETRAX 100LX (c) 2001, 2002 Axis Communications AB\n");
189
190 }
191
192 #ifdef CONFIG_PROC_FS
193 #define HAS_FPU 0x0001
194 #define HAS_MMU 0x0002
195 #define HAS_ETHERNET100 0x0004
196 #define HAS_TOKENRING 0x0008
197 #define HAS_SCSI 0x0010
198 #define HAS_ATA 0x0020
199 #define HAS_USB 0x0040
200 #define HAS_IRQ_BUG 0x0080
201 #define HAS_MMU_BUG 0x0100
202
203 static struct cpu_info {
204 char *model;
205 unsigned short cache;
206 unsigned short flags;
207 } cpu_info[] = {
208 /* The first four models will never ever run this code and are
209 only here for display. */
210 { "ETRAX 1", 0, 0 },
211 { "ETRAX 2", 0, 0 },
212 { "ETRAX 3", 0, HAS_TOKENRING },
213 { "ETRAX 4", 0, HAS_TOKENRING | HAS_SCSI },
214 { "Unknown", 0, 0 },
215 { "Unknown", 0, 0 },
216 { "Unknown", 0, 0 },
217 { "Simulator", 8, HAS_ETHERNET100 | HAS_SCSI | HAS_ATA },
218 { "ETRAX 100", 8, HAS_ETHERNET100 | HAS_SCSI | HAS_ATA | HAS_IRQ_BUG },
219 { "ETRAX 100", 8, HAS_ETHERNET100 | HAS_SCSI | HAS_ATA },
220 { "ETRAX 100LX", 8, HAS_ETHERNET100 | HAS_SCSI | HAS_ATA | HAS_USB | HAS_MMU | HAS_MMU_BUG },
221 { "ETRAX 100LX v2", 8, HAS_ETHERNET100 | HAS_SCSI | HAS_ATA | HAS_USB | HAS_MMU },
222 { "Unknown", 0, 0 } /* This entry MUST be the last */
223 };
224
show_cpuinfo(struct seq_file * m,void * v)225 static int show_cpuinfo(struct seq_file *m, void *v)
226 {
227 unsigned long revision;
228 struct cpu_info *info;
229
230 /* read the version register in the CPU and print some stuff */
231
232 revision = rdvr();
233
234 if (revision >= sizeof cpu_info/sizeof *cpu_info)
235 info = &cpu_info[sizeof cpu_info/sizeof *cpu_info - 1];
236 else
237 info = &cpu_info[revision];
238
239 return seq_printf(m,
240 "processor\t: 0\n"
241 "cpu\t\t: CRIS\n"
242 "cpu revision\t: %lu\n"
243 "cpu model\t: %s\n"
244 "cache size\t: %d kB\n"
245 "fpu\t\t: %s\n"
246 "mmu\t\t: %s\n"
247 "mmu DMA bug\t: %s\n"
248 "ethernet\t: %s Mbps\n"
249 "token ring\t: %s\n"
250 "scsi\t\t: %s\n"
251 "ata\t\t: %s\n"
252 "usb\t\t: %s\n"
253 "bogomips\t: %lu.%02lu\n",
254
255 revision,
256 info->model,
257 info->cache,
258 info->flags & HAS_FPU ? "yes" : "no",
259 info->flags & HAS_MMU ? "yes" : "no",
260 info->flags & HAS_MMU_BUG ? "yes" : "no",
261 info->flags & HAS_ETHERNET100 ? "10/100" : "10",
262 info->flags & HAS_TOKENRING ? "4/16 Mbps" : "no",
263 info->flags & HAS_SCSI ? "yes" : "no",
264 info->flags & HAS_ATA ? "yes" : "no",
265 info->flags & HAS_USB ? "yes" : "no",
266 (loops_per_jiffy * HZ + 500) / 500000,
267 ((loops_per_jiffy * HZ + 500) / 5000) % 100);
268 }
269
c_start(struct seq_file * m,loff_t * pos)270 static void *c_start(struct seq_file *m, loff_t *pos)
271 {
272 /* We only got one CPU... */
273 return *pos < 1 ? (void *)1 : NULL;
274 }
275
c_next(struct seq_file * m,void * v,loff_t * pos)276 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
277 {
278 ++*pos;
279 return NULL;
280 }
281
c_stop(struct seq_file * m,void * v)282 static void c_stop(struct seq_file *m, void *v)
283 {
284 }
285
286 struct seq_operations cpuinfo_op = {
287 start: c_start,
288 next: c_next,
289 stop: c_stop,
290 show: show_cpuinfo,
291 };
292
293 #endif /* CONFIG_PROC_FS */
294