1
2
3
4
5
6
7
8
9
10#include <linux/bootmem.h>
11#include <linux/init.h>
12#include <linux/kernel.h>
13#include <linux/lmb.h>
14#include <linux/mm.h>
15#include <linux/initrd.h>
16#include <linux/pagemap.h>
17#include <linux/pfn.h>
18#include <linux/swap.h>
19
20#include <asm/page.h>
21#include <asm/mmu_context.h>
22#include <asm/pgalloc.h>
23#include <asm/sections.h>
24#include <asm/tlb.h>
25
26#ifndef CONFIG_MMU
27unsigned int __page_offset;
28EXPORT_SYMBOL(__page_offset);
29
30#else
31DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
32
33int mem_init_done;
34static int init_bootmem_done;
35#endif
36
37char *klimit = _end;
38
39
40
41
42
43unsigned long memory_start;
44unsigned long memory_end;
45unsigned long memory_size;
46
47
48
49
50static void __init paging_init(void)
51{
52 unsigned long zones_size[MAX_NR_ZONES];
53
54
55 memset(zones_size, 0, sizeof(zones_size));
56
57
58
59
60
61 zones_size[ZONE_NORMAL] = max_mapnr;
62
63 free_area_init(zones_size);
64}
65
66void __init setup_memory(void)
67{
68 int i;
69 unsigned long map_size;
70#ifndef CONFIG_MMU
71 u32 kernel_align_start, kernel_align_size;
72
73
74 for (i = 0; i < lmb.memory.cnt; i++) {
75 memory_start = (u32) lmb.memory.region[i].base;
76 memory_end = (u32) lmb.memory.region[i].base
77 + (u32) lmb.memory.region[i].size;
78 if ((memory_start <= (u32)_text) &&
79 ((u32)_text <= memory_end)) {
80 memory_size = memory_end - memory_start;
81 PAGE_OFFSET = memory_start;
82 printk(KERN_INFO "%s: Main mem: 0x%x-0x%x, "
83 "size 0x%08x\n", __func__, (u32) memory_start,
84 (u32) memory_end, (u32) memory_size);
85 break;
86 }
87 }
88
89 if (!memory_start || !memory_end) {
90 panic("%s: Missing memory setting 0x%08x-0x%08x\n",
91 __func__, (u32) memory_start, (u32) memory_end);
92 }
93
94
95 kernel_align_start = PAGE_DOWN((u32)_text);
96
97 kernel_align_size = PAGE_UP((u32)klimit) - kernel_align_start;
98 lmb_reserve(kernel_align_start, kernel_align_size);
99 printk(KERN_INFO "%s: kernel addr=0x%08x-0x%08x size=0x%08x\n",
100 __func__, kernel_align_start, kernel_align_start
101 + kernel_align_size, kernel_align_size);
102
103#endif
104
105
106
107
108
109
110
111
112
113
114
115
116 min_low_pfn = memory_start >> PAGE_SHIFT;
117
118 num_physpages = max_mapnr = memory_size >> PAGE_SHIFT;
119 max_pfn = max_low_pfn = memory_end >> PAGE_SHIFT;
120
121 printk(KERN_INFO "%s: max_mapnr: %#lx\n", __func__, max_mapnr);
122 printk(KERN_INFO "%s: min_low_pfn: %#lx\n", __func__, min_low_pfn);
123 printk(KERN_INFO "%s: max_low_pfn: %#lx\n", __func__, max_low_pfn);
124
125
126
127
128
129
130
131
132#ifndef CONFIG_MMU
133 map_size = init_bootmem_node(NODE_DATA(0), PFN_UP(TOPHYS((u32)klimit)),
134 min_low_pfn, max_low_pfn);
135#else
136 map_size = init_bootmem_node(&contig_page_data,
137 PFN_UP(TOPHYS((u32)klimit)), min_low_pfn, max_low_pfn);
138#endif
139 lmb_reserve(PFN_UP(TOPHYS((u32)klimit)) << PAGE_SHIFT, map_size);
140
141
142 free_bootmem(memory_start, memory_size);
143
144
145 for (i = 0; i < lmb.reserved.cnt; i++) {
146 pr_debug("reserved %d - 0x%08x-0x%08x\n", i,
147 (u32) lmb.reserved.region[i].base,
148 (u32) lmb_size_bytes(&lmb.reserved, i));
149 reserve_bootmem(lmb.reserved.region[i].base,
150 lmb_size_bytes(&lmb.reserved, i) - 1, BOOTMEM_DEFAULT);
151 }
152#ifdef CONFIG_MMU
153 init_bootmem_done = 1;
154#endif
155 paging_init();
156}
157
158void free_init_pages(char *what, unsigned long begin, unsigned long end)
159{
160 unsigned long addr;
161
162 for (addr = begin; addr < end; addr += PAGE_SIZE) {
163 ClearPageReserved(virt_to_page(addr));
164 init_page_count(virt_to_page(addr));
165 memset((void *)addr, 0xcc, PAGE_SIZE);
166 free_page(addr);
167 totalram_pages++;
168 }
169 printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
170}
171
172#ifdef CONFIG_BLK_DEV_INITRD
173void free_initrd_mem(unsigned long start, unsigned long end)
174{
175 int pages = 0;
176 for (; start < end; start += PAGE_SIZE) {
177 ClearPageReserved(virt_to_page(start));
178 init_page_count(virt_to_page(start));
179 free_page(start);
180 totalram_pages++;
181 pages++;
182 }
183 printk(KERN_NOTICE "Freeing initrd memory: %dk freed\n",
184 (int)(pages * (PAGE_SIZE / 1024)));
185}
186#endif
187
188void free_initmem(void)
189{
190 free_init_pages("unused kernel memory",
191 (unsigned long)(&__init_begin),
192 (unsigned long)(&__init_end));
193}
194
195
196void show_mem(void)
197{
198 printk(KERN_NOTICE "%s\n", __func__);
199}
200
201void __init mem_init(void)
202{
203 high_memory = (void *)__va(memory_end);
204
205 totalram_pages += free_all_bootmem();
206
207 printk(KERN_INFO "Memory: %luk/%luk available\n",
208 nr_free_pages() << (PAGE_SHIFT-10),
209 num_physpages << (PAGE_SHIFT-10));
210#ifdef CONFIG_MMU
211 mem_init_done = 1;
212#endif
213}
214
215#ifndef CONFIG_MMU
216
217int ___range_ok(unsigned long addr, unsigned long size)
218{
219 return ((addr < memory_start) ||
220 ((addr + size) > memory_end));
221}
222EXPORT_SYMBOL(___range_ok);
223
224#else
225int page_is_ram(unsigned long pfn)
226{
227 return pfn < max_low_pfn;
228}
229
230
231
232
233static void mm_cmdline_setup(void)
234{
235 unsigned long maxmem = 0;
236 char *p = cmd_line;
237
238
239 p = strstr(cmd_line, "mem=");
240 if (p) {
241 p += 4;
242 maxmem = memparse(p, &p);
243 if (maxmem && memory_size > maxmem) {
244 memory_size = maxmem;
245 memory_end = memory_start + memory_size;
246 lmb.memory.region[0].size = memory_size;
247 }
248 }
249}
250
251
252
253
254static void __init mmu_init_hw(void)
255{
256
257
258
259
260
261
262
263
264
265
266
267
268 __asm__ __volatile__ ("ori r11, r0, 0x10000000;" \
269 "mts rzpr, r11;"
270 : : : "r11");
271}
272
273
274
275
276
277
278
279
280asmlinkage void __init mmu_init(void)
281{
282 unsigned int kstart, ksize;
283
284 if (!lmb.reserved.cnt) {
285 printk(KERN_EMERG "Error memory count\n");
286 machine_restart(NULL);
287 }
288
289 if ((u32) lmb.memory.region[0].size < 0x1000000) {
290 printk(KERN_EMERG "Memory must be greater than 16MB\n");
291 machine_restart(NULL);
292 }
293
294 memory_start = (u32) lmb.memory.region[0].base;
295 memory_end = (u32) lmb.memory.region[0].base +
296 (u32) lmb.memory.region[0].size;
297 memory_size = memory_end - memory_start;
298
299 mm_cmdline_setup();
300
301
302
303
304
305 kstart = __pa(CONFIG_KERNEL_START);
306
307 ksize = PAGE_ALIGN(((u32)_end - (u32)CONFIG_KERNEL_START));
308 lmb_reserve(kstart, ksize);
309
310#if defined(CONFIG_BLK_DEV_INITRD)
311
312
313
314
315
316#endif
317
318
319 mmu_init_hw();
320
321
322 mapin_ram();
323
324#ifdef HIGHMEM_START_BOOL
325 ioremap_base = HIGHMEM_START;
326#else
327 ioremap_base = 0xfe000000UL;
328#endif
329 ioremap_bot = ioremap_base;
330
331
332 mmu_context_init();
333}
334
335
336void __init *early_get_page(void)
337{
338 void *p;
339 if (init_bootmem_done) {
340 p = alloc_bootmem_pages(PAGE_SIZE);
341 } else {
342
343
344
345
346 p = __va(lmb_alloc_base(PAGE_SIZE, PAGE_SIZE,
347 memory_start + 0x2000000));
348 }
349 return p;
350}
351#endif
352