1/*
2 * arch/xtensa/mm/init.c
3 *
4 * Derived from MIPS, PPC.
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License.  See the file "COPYING" in the main directory of this archive
8 * for more details.
9 *
10 * Copyright (C) 2001 - 2005 Tensilica Inc.
11 * Copyright (C) 2014 Cadence Design Systems Inc.
12 *
13 * Chris Zankel	<chris@zankel.net>
14 * Joe Taylor	<joe@tensilica.com, joetylr@yahoo.com>
15 * Marc Gauthier
16 * Kevin Chea
17 */
18
19#include <linux/kernel.h>
20#include <linux/errno.h>
21#include <linux/bootmem.h>
22#include <linux/gfp.h>
23#include <linux/highmem.h>
24#include <linux/swap.h>
25#include <linux/mman.h>
26#include <linux/nodemask.h>
27#include <linux/mm.h>
28
29#include <asm/bootparam.h>
30#include <asm/page.h>
31#include <asm/sections.h>
32#include <asm/sysmem.h>
33
34struct sysmem_info sysmem __initdata;
35
36static void __init sysmem_dump(void)
37{
38	unsigned i;
39
40	pr_debug("Sysmem:\n");
41	for (i = 0; i < sysmem.nr_banks; ++i)
42		pr_debug("  0x%08lx - 0x%08lx (%ldK)\n",
43			 sysmem.bank[i].start, sysmem.bank[i].end,
44			 (sysmem.bank[i].end - sysmem.bank[i].start) >> 10);
45}
46
47/*
48 * Find bank with maximal .start such that bank.start <= start
49 */
50static inline struct meminfo * __init find_bank(unsigned long start)
51{
52	unsigned i;
53	struct meminfo *it = NULL;
54
55	for (i = 0; i < sysmem.nr_banks; ++i)
56		if (sysmem.bank[i].start <= start)
57			it = sysmem.bank + i;
58		else
59			break;
60	return it;
61}
62
63/*
64 * Move all memory banks starting at 'from' to a new place at 'to',
65 * adjust nr_banks accordingly.
66 * Both 'from' and 'to' must be inside the sysmem.bank.
67 *
68 * Returns: 0 (success), -ENOMEM (not enough space in the sysmem.bank).
69 */
70static int __init move_banks(struct meminfo *to, struct meminfo *from)
71{
72	unsigned n = sysmem.nr_banks - (from - sysmem.bank);
73
74	if (to > from && to - from + sysmem.nr_banks > SYSMEM_BANKS_MAX)
75		return -ENOMEM;
76	if (to != from)
77		memmove(to, from, n * sizeof(struct meminfo));
78	sysmem.nr_banks += to - from;
79	return 0;
80}
81
82/*
83 * Add new bank to sysmem. Resulting sysmem is the union of bytes of the
84 * original sysmem and the new bank.
85 *
86 * Returns: 0 (success), < 0 (error)
87 */
88int __init add_sysmem_bank(unsigned long start, unsigned long end)
89{
90	unsigned i;
91	struct meminfo *it = NULL;
92	unsigned long sz;
93	unsigned long bank_sz = 0;
94
95	if (start == end ||
96	    (start < end) != (PAGE_ALIGN(start) < (end & PAGE_MASK))) {
97		pr_warn("Ignoring small memory bank 0x%08lx size: %ld bytes\n",
98			start, end - start);
99		return -EINVAL;
100	}
101
102	start = PAGE_ALIGN(start);
103	end &= PAGE_MASK;
104	sz = end - start;
105
106	it = find_bank(start);
107
108	if (it)
109		bank_sz = it->end - it->start;
110
111	if (it && bank_sz >= start - it->start) {
112		if (end - it->start > bank_sz)
113			it->end = end;
114		else
115			return 0;
116	} else {
117		if (!it)
118			it = sysmem.bank;
119		else
120			++it;
121
122		if (it - sysmem.bank < sysmem.nr_banks &&
123		    it->start - start <= sz) {
124			it->start = start;
125			if (it->end - it->start < sz)
126				it->end = end;
127			else
128				return 0;
129		} else {
130			if (move_banks(it + 1, it) < 0) {
131				pr_warn("Ignoring memory bank 0x%08lx size %ld bytes\n",
132					start, end - start);
133				return -EINVAL;
134			}
135			it->start = start;
136			it->end = end;
137			return 0;
138		}
139	}
140	sz = it->end - it->start;
141	for (i = it + 1 - sysmem.bank; i < sysmem.nr_banks; ++i)
142		if (sysmem.bank[i].start - it->start <= sz) {
143			if (sz < sysmem.bank[i].end - it->start)
144				it->end = sysmem.bank[i].end;
145		} else {
146			break;
147		}
148
149	move_banks(it + 1, sysmem.bank + i);
150	return 0;
151}
152
153/*
154 * mem_reserve(start, end, must_exist)
155 *
156 * Reserve some memory from the memory pool.
157 * If must_exist is set and a part of the region being reserved does not exist
158 * memory map is not altered.
159 *
160 * Parameters:
161 *  start	Start of region,
162 *  end		End of region,
163 *  must_exist	Must exist in memory pool.
164 *
165 * Returns:
166 *  0 (success)
167 *  < 0 (error)
168 */
169
170int __init mem_reserve(unsigned long start, unsigned long end, int must_exist)
171{
172	struct meminfo *it;
173	struct meminfo *rm = NULL;
174	unsigned long sz;
175	unsigned long bank_sz = 0;
176
177	start = start & PAGE_MASK;
178	end = PAGE_ALIGN(end);
179	sz = end - start;
180	if (!sz)
181		return -EINVAL;
182
183	it = find_bank(start);
184
185	if (it)
186		bank_sz = it->end - it->start;
187
188	if ((!it || end - it->start > bank_sz) && must_exist) {
189		pr_warn("mem_reserve: [0x%0lx, 0x%0lx) not in any region!\n",
190			start, end);
191		return -EINVAL;
192	}
193
194	if (it && start - it->start <= bank_sz) {
195		if (start == it->start) {
196			if (end - it->start < bank_sz) {
197				it->start = end;
198				return 0;
199			} else {
200				rm = it;
201			}
202		} else {
203			it->end = start;
204			if (end - it->start < bank_sz)
205				return add_sysmem_bank(end,
206						       it->start + bank_sz);
207			++it;
208		}
209	}
210
211	if (!it)
212		it = sysmem.bank;
213
214	for (; it < sysmem.bank + sysmem.nr_banks; ++it) {
215		if (it->end - start <= sz) {
216			if (!rm)
217				rm = it;
218		} else {
219			if (it->start - start < sz)
220				it->start = end;
221			break;
222		}
223	}
224
225	if (rm)
226		move_banks(rm, it);
227
228	return 0;
229}
230
231
232/*
233 * Initialize the bootmem system and give it all low memory we have available.
234 */
235
236void __init bootmem_init(void)
237{
238	unsigned long pfn;
239	unsigned long bootmap_start, bootmap_size;
240	int i;
241
242	sysmem_dump();
243	max_low_pfn = max_pfn = 0;
244	min_low_pfn = ~0;
245
246	for (i=0; i < sysmem.nr_banks; i++) {
247		pfn = PAGE_ALIGN(sysmem.bank[i].start) >> PAGE_SHIFT;
248		if (pfn < min_low_pfn)
249			min_low_pfn = pfn;
250		pfn = PAGE_ALIGN(sysmem.bank[i].end - 1) >> PAGE_SHIFT;
251		if (pfn > max_pfn)
252			max_pfn = pfn;
253	}
254
255	if (min_low_pfn > max_pfn)
256		panic("No memory found!\n");
257
258	max_low_pfn = max_pfn < MAX_MEM_PFN >> PAGE_SHIFT ?
259		max_pfn : MAX_MEM_PFN >> PAGE_SHIFT;
260
261	/* Find an area to use for the bootmem bitmap. */
262
263	bootmap_size = bootmem_bootmap_pages(max_low_pfn - min_low_pfn);
264	bootmap_size <<= PAGE_SHIFT;
265	bootmap_start = ~0;
266
267	for (i=0; i<sysmem.nr_banks; i++)
268		if (sysmem.bank[i].end - sysmem.bank[i].start >= bootmap_size) {
269			bootmap_start = sysmem.bank[i].start;
270			break;
271		}
272
273	if (bootmap_start == ~0UL)
274		panic("Cannot find %ld bytes for bootmap\n", bootmap_size);
275
276	/* Reserve the bootmem bitmap area */
277
278	mem_reserve(bootmap_start, bootmap_start + bootmap_size, 1);
279	bootmap_size = init_bootmem_node(NODE_DATA(0),
280					 bootmap_start >> PAGE_SHIFT,
281					 min_low_pfn,
282					 max_low_pfn);
283
284	/* Add all remaining memory pieces into the bootmem map */
285
286	for (i = 0; i < sysmem.nr_banks; i++) {
287		if (sysmem.bank[i].start >> PAGE_SHIFT < max_low_pfn) {
288			unsigned long end = min(max_low_pfn << PAGE_SHIFT,
289						sysmem.bank[i].end);
290			free_bootmem(sysmem.bank[i].start,
291				     end - sysmem.bank[i].start);
292		}
293	}
294
295}
296
297
298void __init zones_init(void)
299{
300	/* All pages are DMA-able, so we put them all in the DMA zone. */
301	unsigned long zones_size[MAX_NR_ZONES] = {
302		[ZONE_DMA] = max_low_pfn - ARCH_PFN_OFFSET,
303#ifdef CONFIG_HIGHMEM
304		[ZONE_HIGHMEM] = max_pfn - max_low_pfn,
305#endif
306	};
307	free_area_init_node(0, zones_size, ARCH_PFN_OFFSET, NULL);
308}
309
310/*
311 * Initialize memory pages.
312 */
313
314void __init mem_init(void)
315{
316#ifdef CONFIG_HIGHMEM
317	unsigned long tmp;
318
319	reset_all_zones_managed_pages();
320	for (tmp = max_low_pfn; tmp < max_pfn; tmp++)
321		free_highmem_page(pfn_to_page(tmp));
322#endif
323
324	max_mapnr = max_pfn - ARCH_PFN_OFFSET;
325	high_memory = (void *)__va(max_low_pfn << PAGE_SHIFT);
326
327	free_all_bootmem();
328
329	mem_init_print_info(NULL);
330	pr_info("virtual kernel memory layout:\n"
331#ifdef CONFIG_HIGHMEM
332		"    pkmap   : 0x%08lx - 0x%08lx  (%5lu kB)\n"
333		"    fixmap  : 0x%08lx - 0x%08lx  (%5lu kB)\n"
334#endif
335		"    vmalloc : 0x%08x - 0x%08x  (%5u MB)\n"
336		"    lowmem  : 0x%08x - 0x%08lx  (%5lu MB)\n",
337#ifdef CONFIG_HIGHMEM
338		PKMAP_BASE, PKMAP_BASE + LAST_PKMAP * PAGE_SIZE,
339		(LAST_PKMAP*PAGE_SIZE) >> 10,
340		FIXADDR_START, FIXADDR_TOP,
341		(FIXADDR_TOP - FIXADDR_START) >> 10,
342#endif
343		VMALLOC_START, VMALLOC_END,
344		(VMALLOC_END - VMALLOC_START) >> 20,
345		PAGE_OFFSET, PAGE_OFFSET +
346		(max_low_pfn - min_low_pfn) * PAGE_SIZE,
347		((max_low_pfn - min_low_pfn) * PAGE_SIZE) >> 20);
348}
349
350#ifdef CONFIG_BLK_DEV_INITRD
351extern int initrd_is_mapped;
352
353void free_initrd_mem(unsigned long start, unsigned long end)
354{
355	if (initrd_is_mapped)
356		free_reserved_area((void *)start, (void *)end, -1, "initrd");
357}
358#endif
359
360void free_initmem(void)
361{
362	free_initmem_default(-1);
363}
364
365static void __init parse_memmap_one(char *p)
366{
367	char *oldp;
368	unsigned long start_at, mem_size;
369
370	if (!p)
371		return;
372
373	oldp = p;
374	mem_size = memparse(p, &p);
375	if (p == oldp)
376		return;
377
378	switch (*p) {
379	case '@':
380		start_at = memparse(p + 1, &p);
381		add_sysmem_bank(start_at, start_at + mem_size);
382		break;
383
384	case '$':
385		start_at = memparse(p + 1, &p);
386		mem_reserve(start_at, start_at + mem_size, 0);
387		break;
388
389	case 0:
390		mem_reserve(mem_size, 0, 0);
391		break;
392
393	default:
394		pr_warn("Unrecognized memmap syntax: %s\n", p);
395		break;
396	}
397}
398
399static int __init parse_memmap_opt(char *str)
400{
401	while (str) {
402		char *k = strchr(str, ',');
403
404		if (k)
405			*k++ = 0;
406
407		parse_memmap_one(str);
408		str = k;
409	}
410
411	return 0;
412}
413early_param("memmap", parse_memmap_opt);
414