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	/* Reserve all memory below PLATFORM_DEFAULT_MEM_START, as memory
243	 * accounting doesn't work for pages below that address.
244	 *
245	 * If PLATFORM_DEFAULT_MEM_START is zero reserve page at address 0:
246	 * successfull allocations should never return NULL.
247	 */
248	if (PLATFORM_DEFAULT_MEM_START)
249		mem_reserve(0, PLATFORM_DEFAULT_MEM_START, 0);
250	else
251		mem_reserve(0, 1, 0);
252
253	sysmem_dump();
254	max_low_pfn = max_pfn = 0;
255	min_low_pfn = ~0;
256
257	for (i=0; i < sysmem.nr_banks; i++) {
258		pfn = PAGE_ALIGN(sysmem.bank[i].start) >> PAGE_SHIFT;
259		if (pfn < min_low_pfn)
260			min_low_pfn = pfn;
261		pfn = PAGE_ALIGN(sysmem.bank[i].end - 1) >> PAGE_SHIFT;
262		if (pfn > max_pfn)
263			max_pfn = pfn;
264	}
265
266	if (min_low_pfn > max_pfn)
267		panic("No memory found!\n");
268
269	max_low_pfn = max_pfn < MAX_MEM_PFN >> PAGE_SHIFT ?
270		max_pfn : MAX_MEM_PFN >> PAGE_SHIFT;
271
272	/* Find an area to use for the bootmem bitmap. */
273
274	bootmap_size = bootmem_bootmap_pages(max_low_pfn - min_low_pfn);
275	bootmap_size <<= PAGE_SHIFT;
276	bootmap_start = ~0;
277
278	for (i=0; i<sysmem.nr_banks; i++)
279		if (sysmem.bank[i].end - sysmem.bank[i].start >= bootmap_size) {
280			bootmap_start = sysmem.bank[i].start;
281			break;
282		}
283
284	if (bootmap_start == ~0UL)
285		panic("Cannot find %ld bytes for bootmap\n", bootmap_size);
286
287	/* Reserve the bootmem bitmap area */
288
289	mem_reserve(bootmap_start, bootmap_start + bootmap_size, 1);
290	bootmap_size = init_bootmem_node(NODE_DATA(0),
291					 bootmap_start >> PAGE_SHIFT,
292					 min_low_pfn,
293					 max_low_pfn);
294
295	/* Add all remaining memory pieces into the bootmem map */
296
297	for (i = 0; i < sysmem.nr_banks; i++) {
298		if (sysmem.bank[i].start >> PAGE_SHIFT < max_low_pfn) {
299			unsigned long end = min(max_low_pfn << PAGE_SHIFT,
300						sysmem.bank[i].end);
301			free_bootmem(sysmem.bank[i].start,
302				     end - sysmem.bank[i].start);
303		}
304	}
305
306}
307
308
309void __init zones_init(void)
310{
311	/* All pages are DMA-able, so we put them all in the DMA zone. */
312	unsigned long zones_size[MAX_NR_ZONES] = {
313		[ZONE_DMA] = max_low_pfn - ARCH_PFN_OFFSET,
314#ifdef CONFIG_HIGHMEM
315		[ZONE_HIGHMEM] = max_pfn - max_low_pfn,
316#endif
317	};
318	free_area_init_node(0, zones_size, ARCH_PFN_OFFSET, NULL);
319}
320
321/*
322 * Initialize memory pages.
323 */
324
325void __init mem_init(void)
326{
327#ifdef CONFIG_HIGHMEM
328	unsigned long tmp;
329
330	reset_all_zones_managed_pages();
331	for (tmp = max_low_pfn; tmp < max_pfn; tmp++)
332		free_highmem_page(pfn_to_page(tmp));
333#endif
334
335	max_mapnr = max_pfn - ARCH_PFN_OFFSET;
336	high_memory = (void *)__va(max_low_pfn << PAGE_SHIFT);
337
338	free_all_bootmem();
339
340	mem_init_print_info(NULL);
341	pr_info("virtual kernel memory layout:\n"
342#ifdef CONFIG_HIGHMEM
343		"    pkmap   : 0x%08lx - 0x%08lx  (%5lu kB)\n"
344		"    fixmap  : 0x%08lx - 0x%08lx  (%5lu kB)\n"
345#endif
346#ifdef CONFIG_MMU
347		"    vmalloc : 0x%08x - 0x%08x  (%5u MB)\n"
348#endif
349		"    lowmem  : 0x%08lx - 0x%08lx  (%5lu MB)\n",
350#ifdef CONFIG_HIGHMEM
351		PKMAP_BASE, PKMAP_BASE + LAST_PKMAP * PAGE_SIZE,
352		(LAST_PKMAP*PAGE_SIZE) >> 10,
353		FIXADDR_START, FIXADDR_TOP,
354		(FIXADDR_TOP - FIXADDR_START) >> 10,
355#endif
356#ifdef CONFIG_MMU
357		VMALLOC_START, VMALLOC_END,
358		(VMALLOC_END - VMALLOC_START) >> 20,
359		PAGE_OFFSET, PAGE_OFFSET +
360		(max_low_pfn - min_low_pfn) * PAGE_SIZE,
361#else
362		min_low_pfn * PAGE_SIZE, max_low_pfn * PAGE_SIZE,
363#endif
364		((max_low_pfn - min_low_pfn) * PAGE_SIZE) >> 20);
365}
366
367#ifdef CONFIG_BLK_DEV_INITRD
368extern int initrd_is_mapped;
369
370void free_initrd_mem(unsigned long start, unsigned long end)
371{
372	if (initrd_is_mapped)
373		free_reserved_area((void *)start, (void *)end, -1, "initrd");
374}
375#endif
376
377void free_initmem(void)
378{
379	free_initmem_default(-1);
380}
381
382static void __init parse_memmap_one(char *p)
383{
384	char *oldp;
385	unsigned long start_at, mem_size;
386
387	if (!p)
388		return;
389
390	oldp = p;
391	mem_size = memparse(p, &p);
392	if (p == oldp)
393		return;
394
395	switch (*p) {
396	case '@':
397		start_at = memparse(p + 1, &p);
398		add_sysmem_bank(start_at, start_at + mem_size);
399		break;
400
401	case '$':
402		start_at = memparse(p + 1, &p);
403		mem_reserve(start_at, start_at + mem_size, 0);
404		break;
405
406	case 0:
407		mem_reserve(mem_size, 0, 0);
408		break;
409
410	default:
411		pr_warn("Unrecognized memmap syntax: %s\n", p);
412		break;
413	}
414}
415
416static int __init parse_memmap_opt(char *str)
417{
418	while (str) {
419		char *k = strchr(str, ',');
420
421		if (k)
422			*k++ = 0;
423
424		parse_memmap_one(str);
425		str = k;
426	}
427
428	return 0;
429}
430early_param("memmap", parse_memmap_opt);
431