[deliverable/linux.git] / arch / m32r / mm / discontig.c

/*
 *  linux/arch/m32r/mm/discontig.c
 *
 *  Discontig memory support
 *
 *  Copyright (c) 2003  Hitoshi Yamamoto
 */

#include <linux/mm.h>
#include <linux/bootmem.h>
#include <linux/mmzone.h>
#include <linux/initrd.h>
#include <linux/nodemask.h>
#include <linux/module.h>
#include <linux/pfn.h>

#include <asm/setup.h>

extern char _end[];

struct pglist_data *node_data[MAX_NUMNODES];
EXPORT_SYMBOL(node_data);
static bootmem_data_t node_bdata[MAX_NUMNODES] __initdata;

pg_data_t m32r_node_data[MAX_NUMNODES];

/* Memory profile */
typedef struct {
	unsigned long start_pfn;
	unsigned long pages;
	unsigned long holes;
	unsigned long free_pfn;
} mem_prof_t;
static mem_prof_t mem_prof[MAX_NUMNODES];

static void __init mem_prof_init(void)
{
	unsigned long start_pfn, holes, free_pfn;
	const unsigned long zone_alignment = 1UL << (MAX_ORDER - 1);
	unsigned long ul;
	mem_prof_t *mp;

	/* Node#0 SDRAM */
	mp = &mem_prof[0];
	mp->start_pfn = PFN_UP(CONFIG_MEMORY_START);
	mp->pages = PFN_DOWN(CONFIG_MEMORY_SIZE);
	mp->holes = 0;
	mp->free_pfn = PFN_UP(__pa(_end));

	/* Node#1 internal SRAM */
	mp = &mem_prof[1];
	start_pfn = free_pfn = PFN_UP(CONFIG_IRAM_START);
	holes = 0;
	if (start_pfn & (zone_alignment - 1)) {
		ul = zone_alignment;
		while (start_pfn >= ul)
			ul += zone_alignment;

		start_pfn = ul - zone_alignment;
		holes = free_pfn - start_pfn;
	}

	mp->start_pfn = start_pfn;
	mp->pages = PFN_DOWN(CONFIG_IRAM_SIZE) + holes;
	mp->holes = holes;
	mp->free_pfn = PFN_UP(CONFIG_IRAM_START);
}

unsigned long __init setup_memory(void)
{
	unsigned long bootmap_size;
	unsigned long min_pfn;
	int nid;
	mem_prof_t *mp;

	max_low_pfn = 0;
	min_low_pfn = -1;

	mem_prof_init();

	for_each_online_node(nid) {
		mp = &mem_prof[nid];
		NODE_DATA(nid)=(pg_data_t *)&m32r_node_data[nid];
		NODE_DATA(nid)->bdata = &node_bdata[nid];
		min_pfn = mp->start_pfn;
		max_pfn = mp->start_pfn + mp->pages;
		bootmap_size = init_bootmem_node(NODE_DATA(nid), mp->free_pfn,
			mp->start_pfn, max_pfn);

		free_bootmem_node(NODE_DATA(nid), PFN_PHYS(mp->start_pfn),
			PFN_PHYS(mp->pages));

		reserve_bootmem_node(NODE_DATA(nid), PFN_PHYS(mp->start_pfn),
			PFN_PHYS(mp->free_pfn - mp->start_pfn) + bootmap_size);

		if (max_low_pfn < max_pfn)
			max_low_pfn = max_pfn;

		if (min_low_pfn > min_pfn)
			min_low_pfn = min_pfn;
	}

#ifdef CONFIG_BLK_DEV_INITRD
	if (LOADER_TYPE && INITRD_START) {
		if (INITRD_START + INITRD_SIZE <= PFN_PHYS(max_low_pfn)) {
			reserve_bootmem_node(NODE_DATA(0), INITRD_START,
				INITRD_SIZE);
			initrd_start = INITRD_START ?
				INITRD_START + PAGE_OFFSET : 0;

			initrd_end = initrd_start + INITRD_SIZE;
			printk("initrd:start[%08lx],size[%08lx]\n",
				initrd_start, INITRD_SIZE);
		} else {
			printk("initrd extends beyond end of memory "
				"(0x%08lx > 0x%08lx)\ndisabling initrd\n",
				INITRD_START + INITRD_SIZE,
				PFN_PHYS(max_low_pfn));

			initrd_start = 0;
		}
	}
#endif	/* CONFIG_BLK_DEV_INITRD */

	return max_low_pfn;
}

#define START_PFN(nid)	\
	(NODE_DATA(nid)->bdata->node_boot_start >> PAGE_SHIFT)
#define MAX_LOW_PFN(nid)	(NODE_DATA(nid)->bdata->node_low_pfn)

unsigned long __init zone_sizes_init(void)
{
	unsigned long zones_size[MAX_NR_ZONES], zholes_size[MAX_NR_ZONES];
	unsigned long low, start_pfn;
	unsigned long holes = 0;
	int nid, i;
	mem_prof_t *mp;

	for_each_online_node(nid) {
		mp = &mem_prof[nid];
		for (i = 0 ; i < MAX_NR_ZONES ; i++) {
			zones_size[i] = 0;
			zholes_size[i] = 0;
		}
		start_pfn = START_PFN(nid);
		low = MAX_LOW_PFN(nid);
		zones_size[ZONE_DMA] = low - start_pfn;
		zholes_size[ZONE_DMA] = mp->holes;
		holes += zholes_size[ZONE_DMA];

		free_area_init_node(nid, NODE_DATA(nid), zones_size,
			start_pfn, zholes_size);
	}

	/*
	 * For test
	 *  Use all area of internal RAM.
	 *  see __alloc_pages()
	 */
	NODE_DATA(1)->node_zones->pages_min = 0;
	NODE_DATA(1)->node_zones->pages_low = 0;
	NODE_DATA(1)->node_zones->pages_high = 0;

	return holes;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/m32r/mm/discontig.c
	3	*
	4	* Discontig memory support
	5	*
	6	* Copyright (c) 2003 Hitoshi Yamamoto
	7	*/
	8
1da177e4 LT	9	#include <linux/mm.h>
	10	#include <linux/bootmem.h>
	11	#include <linux/mmzone.h>
	12	#include <linux/initrd.h>
	13	#include <linux/nodemask.h>
eaaece26	14	#include <linux/module.h>
22a9835c	15	#include <linux/pfn.h>
1da177e4 LT	16
	17	#include <asm/setup.h>
	18
	19	extern char _end[];
	20
	21	struct pglist_data *node_data[MAX_NUMNODES];
eaaece26	22	EXPORT_SYMBOL(node_data);
1da177e4 LT	23	static bootmem_data_t node_bdata[MAX_NUMNODES] __initdata;
	24
	25	pg_data_t m32r_node_data[MAX_NUMNODES];
	26
	27	/* Memory profile */
	28	typedef struct {
	29	unsigned long start_pfn;
	30	unsigned long pages;
	31	unsigned long holes;
	32	unsigned long free_pfn;
	33	} mem_prof_t;
	34	static mem_prof_t mem_prof[MAX_NUMNODES];
	35
	36	static void __init mem_prof_init(void)
	37	{
	38	unsigned long start_pfn, holes, free_pfn;
	39	const unsigned long zone_alignment = 1UL << (MAX_ORDER - 1);
	40	unsigned long ul;
	41	mem_prof_t *mp;
	42
	43	/* Node#0 SDRAM */
	44	mp = &mem_prof[0];
	45	mp->start_pfn = PFN_UP(CONFIG_MEMORY_START);
	46	mp->pages = PFN_DOWN(CONFIG_MEMORY_SIZE);
	47	mp->holes = 0;
	48	mp->free_pfn = PFN_UP(__pa(_end));
	49
	50	/* Node#1 internal SRAM */
	51	mp = &mem_prof[1];
	52	start_pfn = free_pfn = PFN_UP(CONFIG_IRAM_START);
	53	holes = 0;
	54	if (start_pfn & (zone_alignment - 1)) {
	55	ul = zone_alignment;
	56	while (start_pfn >= ul)
	57	ul += zone_alignment;
	58
	59	start_pfn = ul - zone_alignment;
	60	holes = free_pfn - start_pfn;
	61	}
	62
	63	mp->start_pfn = start_pfn;
	64	mp->pages = PFN_DOWN(CONFIG_IRAM_SIZE) + holes;
	65	mp->holes = holes;
	66	mp->free_pfn = PFN_UP(CONFIG_IRAM_START);
	67	}
	68
	69	unsigned long __init setup_memory(void)
	70	{
	71	unsigned long bootmap_size;
	72	unsigned long min_pfn;
	73	int nid;
	74	mem_prof_t *mp;
	75
	76	max_low_pfn = 0;
	77	min_low_pfn = -1;
	78
	79	mem_prof_init();
	80
	81	for_each_online_node(nid) {
	82	mp = &mem_prof[nid];
	83	NODE_DATA(nid)=(pg_data_t *)&m32r_node_data[nid];
	84	NODE_DATA(nid)->bdata = &node_bdata[nid];
	85	min_pfn = mp->start_pfn;
	86	max_pfn = mp->start_pfn + mp->pages;
87	bootmap_size = init_bootmem_node(NODE_DATA(nid), mp->free_pfn,
88	mp->start_pfn, max_pfn);
89
90	free_bootmem_node(NODE_DATA(nid), PFN_PHYS(mp->start_pfn),
91	PFN_PHYS(mp->pages));
92
93	reserve_bootmem_node(NODE_DATA(nid), PFN_PHYS(mp->start_pfn),
94	PFN_PHYS(mp->free_pfn - mp->start_pfn) + bootmap_size);
95
96	if (max_low_pfn < max_pfn)
97	max_low_pfn = max_pfn;
98
99	if (min_low_pfn > min_pfn)
100	min_low_pfn = min_pfn;
101	}
102
103	#ifdef CONFIG_BLK_DEV_INITRD
104	if (LOADER_TYPE && INITRD_START) {
105	if (INITRD_START + INITRD_SIZE <= PFN_PHYS(max_low_pfn)) {
106	reserve_bootmem_node(NODE_DATA(0), INITRD_START,
107	INITRD_SIZE);
108	initrd_start = INITRD_START ?
109	INITRD_START + PAGE_OFFSET : 0;
110
111	initrd_end = initrd_start + INITRD_SIZE;
112	printk("initrd:start[%08lx],size[%08lx]\n",
113	initrd_start, INITRD_SIZE);
114	} else {
115	printk("initrd extends beyond end of memory "
116	"(0x%08lx > 0x%08lx)\ndisabling initrd\n",
117	INITRD_START + INITRD_SIZE,
118	PFN_PHYS(max_low_pfn));
119
120	initrd_start = 0;
121	}
122	}
123	#endif /* CONFIG_BLK_DEV_INITRD */
124
125	return max_low_pfn;
126	}
127
128	#define START_PFN(nid) \
129	(NODE_DATA(nid)->bdata->node_boot_start >> PAGE_SHIFT)
130	#define MAX_LOW_PFN(nid) (NODE_DATA(nid)->bdata->node_low_pfn)
131
132	unsigned long __init zone_sizes_init(void)
133	{
134	unsigned long zones_size[MAX_NR_ZONES], zholes_size[MAX_NR_ZONES];
135	unsigned long low, start_pfn;
136	unsigned long holes = 0;
137	int nid, i;
138	mem_prof_t *mp;
139
1da177e4 LT	140	for_each_online_node(nid) {
	141	mp = &mem_prof[nid];
	142	for (i = 0 ; i < MAX_NR_ZONES ; i++) {
	143	zones_size[i] = 0;
	144	zholes_size[i] = 0;
	145	}
	146	start_pfn = START_PFN(nid);
	147	low = MAX_LOW_PFN(nid);
	148	zones_size[ZONE_DMA] = low - start_pfn;
	149	zholes_size[ZONE_DMA] = mp->holes;
	150	holes += zholes_size[ZONE_DMA];
	151
	152	free_area_init_node(nid, NODE_DATA(nid), zones_size,
	153	start_pfn, zholes_size);
	154	}
	155
	156	/*
	157	* For test
	158	* Use all area of internal RAM.
	159	* see __alloc_pages()
	160	*/
	161	NODE_DATA(1)->node_zones->pages_min = 0;
	162	NODE_DATA(1)->node_zones->pages_low = 0;
	163	NODE_DATA(1)->node_zones->pages_high = 0;
	164
	165	return holes;
	166	}
	167