c41d72b01b8806cf07ddbc5a664240f0597a84b6
[linux-2.6.git] / arch / v850 / kernel / setup.c
1 /*
2  * arch/v850/kernel/setup.c -- Arch-dependent initialization functions
3  *
4  *  Copyright (C) 2001,02,03  NEC Electronics Corporation
5  *  Copyright (C) 2001,02,03  Miles Bader <miles@gnu.org>
6  *
7  * This file is subject to the terms and conditions of the GNU General
8  * Public License.  See the file COPYING in the main directory of this
9  * archive for more details.
10  *
11  * Written by Miles Bader <miles@gnu.org>
12  */
13
14 #include <linux/mm.h>
15 #include <linux/bootmem.h>
16 #include <linux/swap.h>         /* we don't have swap, but for nr_free_pages */
17 #include <linux/irq.h>
18 #include <linux/reboot.h>
19 #include <linux/personality.h>
20 #include <linux/major.h>
21 #include <linux/root_dev.h>
22 #include <linux/mtd/mtd.h>
23 #include <linux/init.h>
24
25 #include <asm/irq.h>
26 #include <asm/setup.h>
27
28 #include "mach.h"
29
30 /* These symbols are all defined in the linker map to delineate various
31    statically allocated regions of memory.  */
32
33 extern char _intv_start, _intv_end;
34 /* `kram' is only used if the kernel uses part of normal user RAM.  */
35 extern char _kram_start __attribute__ ((__weak__));
36 extern char _kram_end __attribute__ ((__weak__));
37 extern char _init_start, _init_end;
38 extern char _bootmap;
39 extern char _stext, _etext, _sdata, _edata, _sbss, _ebss;
40 /* Many platforms use an embedded root image.  */
41 extern char _root_fs_image_start __attribute__ ((__weak__));
42 extern char _root_fs_image_end __attribute__ ((__weak__));
43
44
45 char command_line[COMMAND_LINE_SIZE];
46
47 /* Memory not used by the kernel.  */
48 static unsigned long total_ram_pages;
49
50 /* System RAM.  */
51 static unsigned long ram_start = 0, ram_len = 0;
52
53
54 #define ADDR_TO_PAGE_UP(x)   ((((unsigned long)x) + PAGE_SIZE-1) >> PAGE_SHIFT)
55 #define ADDR_TO_PAGE(x)      (((unsigned long)x) >> PAGE_SHIFT)
56 #define PAGE_TO_ADDR(x)      (((unsigned long)x) << PAGE_SHIFT)
57
58 static void init_mem_alloc (unsigned long ram_start, unsigned long ram_len);
59
60 void set_mem_root (void *addr, size_t len, char *cmd_line);
61
62
63 void __init setup_arch (char **cmdline)
64 {
65         /* Keep a copy of command line */
66         *cmdline = command_line;
67         memcpy (saved_command_line, command_line, COMMAND_LINE_SIZE);
68         saved_command_line[COMMAND_LINE_SIZE - 1] = '\0';
69
70         console_verbose ();
71
72         init_mm.start_code = (unsigned long) &_stext;
73         init_mm.end_code = (unsigned long) &_etext;
74         init_mm.end_data = (unsigned long) &_edata;
75         init_mm.brk = (unsigned long) &_kram_end;
76
77         /* Find out what mem this machine has.  */
78         mach_get_physical_ram (&ram_start, &ram_len);
79         /* ... and tell the kernel about it.  */
80         init_mem_alloc (ram_start, ram_len);
81
82         printk (KERN_INFO "CPU: %s\nPlatform: %s\n",
83                 CPU_MODEL_LONG, PLATFORM_LONG);
84
85         /* do machine-specific setups.  */
86         mach_setup (cmdline);
87
88 #ifdef CONFIG_MTD
89         if (!ROOT_DEV && &_root_fs_image_end > &_root_fs_image_start)
90                 set_mem_root (&_root_fs_image_start,
91                               &_root_fs_image_end - &_root_fs_image_start,
92                               *cmdline);
93 #endif
94 }
95
96 void __init trap_init (void)
97 {
98 }
99
100 #ifdef CONFIG_MTD
101 /* Set the root filesystem to be the given memory region.
102    Some parameter may be appended to CMD_LINE.  */
103 void set_mem_root (void *addr, size_t len, char *cmd_line)
104 {
105         /* The only way to pass info to the MTD slram driver is via
106            the command line.  */
107         if (*cmd_line) {
108                 cmd_line += strlen (cmd_line);
109                 *cmd_line++ = ' ';
110         }
111         sprintf (cmd_line, "slram=root,0x%x,+0x%x", (u32)addr, (u32)len);
112
113         ROOT_DEV = MKDEV (MTD_BLOCK_MAJOR, 0);
114 }
115 #endif
116
117 \f
118 static void irq_nop (unsigned irq) { }
119 static unsigned irq_zero (unsigned irq) { return 0; }
120
121 static void nmi_end (unsigned irq)
122 {
123         if (irq != IRQ_NMI (0)) {
124                 printk (KERN_CRIT "NMI %d is unrecoverable; restarting...",
125                         irq - IRQ_NMI (0));
126                 machine_restart (0);
127         }
128 }
129
130 static struct hw_interrupt_type nmi_irq_type = {
131         "NMI",
132         irq_zero,               /* startup */
133         irq_nop,                /* shutdown */
134         irq_nop,                /* enable */
135         irq_nop,                /* disable */
136         irq_nop,                /* ack */
137         nmi_end,                /* end */
138 };
139
140 void __init init_IRQ (void)
141 {
142         init_irq_handlers (0, NUM_MACH_IRQS, 1, 0);
143         init_irq_handlers (IRQ_NMI (0), NUM_NMIS, 1, &nmi_irq_type);
144         mach_init_irqs ();
145 }
146
147 \f
148 void __init mem_init (void)
149 {
150         max_mapnr = MAP_NR (ram_start + ram_len);
151
152         num_physpages = ADDR_TO_PAGE (ram_len);
153
154         total_ram_pages = free_all_bootmem ();
155
156         printk (KERN_INFO
157                 "Memory: %luK/%luK available"
158                 " (%luK kernel code, %luK data)\n",
159                 PAGE_TO_ADDR (nr_free_pages()) / 1024,
160                 ram_len / 1024,
161                 ((unsigned long)&_etext - (unsigned long)&_stext) / 1024,
162                 ((unsigned long)&_ebss - (unsigned long)&_sdata) / 1024);
163 }
164
165 void free_initmem (void)
166 {
167         unsigned long ram_end = ram_start + ram_len;
168         unsigned long start = PAGE_ALIGN ((unsigned long)(&_init_start));
169
170         if (start >= ram_start && start < ram_end) {
171                 unsigned long addr;
172                 unsigned long end = PAGE_ALIGN ((unsigned long)(&_init_end));
173
174                 if (end > ram_end)
175                         end = ram_end;
176
177                 printk("Freeing unused kernel memory: %ldK freed\n",
178                        (end - start) / 1024);
179
180                 for (addr = start; addr < end; addr += PAGE_SIZE) {
181                         struct page *page = virt_to_page (addr);
182                         ClearPageReserved (page);
183                         set_page_count (page, 1);
184                         __free_page (page);
185                         total_ram_pages++;
186                 }
187         }
188 }
189
190 \f
191 /* Initialize the `bootmem allocator'.  RAM_START and RAM_LEN identify
192    what RAM may be used.  */
193 static void __init
194 init_bootmem_alloc (unsigned long ram_start, unsigned long ram_len)
195 {
196         /* The part of the kernel that's in the same managed RAM space
197            used for general allocation.  */
198         unsigned long kram_start = (unsigned long)&_kram_start;
199         unsigned long kram_end = (unsigned long)&_kram_end;
200         /* End of the managed RAM space.  */
201         unsigned long ram_end = ram_start + ram_len;
202         /* Address range of the interrupt vector table.  */
203         unsigned long intv_start = (unsigned long)&_intv_start;
204         unsigned long intv_end = (unsigned long)&_intv_end;
205         /* True if the interrupt vectors are in the managed RAM area.  */
206         int intv_in_ram = (intv_end > ram_start && intv_start < ram_end);
207         /* True if the interrupt vectors are inside the kernel's RAM.  */
208         int intv_in_kram = (intv_end > kram_start && intv_start < kram_end);
209         /* A pointer to an optional function that reserves platform-specific
210            memory regions.  We declare the pointer `volatile' to avoid gcc
211            turning the call into a static call (the problem is that since
212            it's a weak symbol, a static call may end up trying to reference
213            the location 0x0, which is not always reachable).  */
214         void (*volatile mrb) (void) = mach_reserve_bootmem;
215         /* The bootmem allocator's allocation bitmap.  */
216         unsigned long bootmap = (unsigned long)&_bootmap;
217         unsigned long bootmap_len;
218
219         /* Round bootmap location up to next page.  */
220         bootmap = PAGE_TO_ADDR (ADDR_TO_PAGE_UP (bootmap));
221
222         /* Initialize bootmem allocator.  */
223         bootmap_len = init_bootmem_node (NODE_DATA (0),
224                                          ADDR_TO_PAGE (bootmap),
225                                          ADDR_TO_PAGE (PAGE_OFFSET),
226                                          ADDR_TO_PAGE (ram_end));
227
228         /* Now make the RAM actually allocatable (it starts out `reserved'). */
229         free_bootmem (ram_start, ram_len);
230
231         if (kram_end > kram_start)
232                 /* Reserve the RAM part of the kernel's address space, so it
233                    doesn't get allocated.  */
234                 reserve_bootmem (kram_start, kram_end - kram_start);
235         
236         if (intv_in_ram && !intv_in_kram)
237                 /* Reserve the interrupt vector space.  */
238                 reserve_bootmem (intv_start, intv_end - intv_start);
239
240         if (bootmap >= ram_start && bootmap < ram_end)
241                 /* Reserve the bootmap space.  */
242                 reserve_bootmem (bootmap, bootmap_len);
243
244         /* Reserve the memory used by the root filesystem image if it's
245            in RAM.  */
246         if (&_root_fs_image_end > &_root_fs_image_start
247             && (unsigned long)&_root_fs_image_start >= ram_start
248             && (unsigned long)&_root_fs_image_start < ram_end)
249                 reserve_bootmem ((unsigned long)&_root_fs_image_start,
250                                  &_root_fs_image_end - &_root_fs_image_start);
251
252         /* Let the platform-dependent code reserve some too.  */
253         if (mrb)
254                 (*mrb) ();
255 }
256
257 /* Tell the kernel about what RAM it may use for memory allocation.  */
258 static void __init
259 init_mem_alloc (unsigned long ram_start, unsigned long ram_len)
260 {
261         unsigned i;
262         unsigned long zones_size[MAX_NR_ZONES];
263
264         init_bootmem_alloc (ram_start, ram_len);
265
266         for (i = 0; i < MAX_NR_ZONES; i++)
267                 zones_size[i] = 0;
268
269         /* We stuff all the memory into one area, which includes the
270            initial gap from PAGE_OFFSET to ram_start.  */
271         zones_size[ZONE_DMA]
272                 = ADDR_TO_PAGE (ram_len + (ram_start - PAGE_OFFSET));
273
274         /* The allocator is very picky about the address of the first
275            allocatable page -- it must be at least as aligned as the
276            maximum allocation -- so try to detect cases where it will get
277            confused and signal them at compile time (this is a common
278            problem when porting to a new platform with ).  There is a
279            similar runtime check in free_area_init_core.  */
280 #if ((PAGE_OFFSET >> PAGE_SHIFT) & ((1UL << (MAX_ORDER - 1)) - 1))
281 #error MAX_ORDER is too large for given PAGE_OFFSET (use CONFIG_FORCE_MAX_ZONEORDER to change it)
282 #endif
283         NODE_DATA(0)->node_mem_map = NULL;
284         free_area_init_node (0, NODE_DATA(0), zones_size,
285                              ADDR_TO_PAGE (PAGE_OFFSET), 0);
286 }