[mirror_ubuntu-zesty-kernel.git] / arch / powerpc / mm / init_64.c

/*
 *  PowerPC version
 *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
 *
 *  Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au)
 *  and Cort Dougan (PReP) (cort@cs.nmt.edu)
 *    Copyright (C) 1996 Paul Mackerras
 *
 *  Derived from "arch/i386/mm/init.c"
 *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
 *
 *  Dave Engebretsen <engebret@us.ibm.com>
 *      Rework for PPC64 port.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version
 *  2 of the License, or (at your option) any later version.
 *
 */

#undef DEBUG

#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/mman.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/stddef.h>
#include <linux/vmalloc.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/highmem.h>
#include <linux/idr.h>
#include <linux/nodemask.h>
#include <linux/module.h>
#include <linux/poison.h>
#include <linux/memblock.h>
#include <linux/hugetlb.h>
#include <linux/slab.h>

#include <asm/pgalloc.h>
#include <asm/page.h>
#include <asm/prom.h>
#include <asm/rtas.h>
#include <asm/io.h>
#include <asm/mmu_context.h>
#include <asm/pgtable.h>
#include <asm/mmu.h>
#include <linux/uaccess.h>
#include <asm/smp.h>
#include <asm/machdep.h>
#include <asm/tlb.h>
#include <asm/eeh.h>
#include <asm/processor.h>
#include <asm/mmzone.h>
#include <asm/cputable.h>
#include <asm/sections.h>
#include <asm/iommu.h>
#include <asm/vdso.h>

#include "mmu_decl.h"

#ifdef CONFIG_PPC_STD_MMU_64
#if H_PGTABLE_RANGE > USER_VSID_RANGE
#warning Limited user VSID range means pagetable space is wasted
#endif

#if (TASK_SIZE_USER64 < H_PGTABLE_RANGE) && (TASK_SIZE_USER64 < USER_VSID_RANGE)
#warning TASK_SIZE is smaller than it needs to be.
#endif
#endif /* CONFIG_PPC_STD_MMU_64 */

phys_addr_t memstart_addr = ~0;
EXPORT_SYMBOL_GPL(memstart_addr);
phys_addr_t kernstart_addr;
EXPORT_SYMBOL_GPL(kernstart_addr);

#ifdef CONFIG_SPARSEMEM_VMEMMAP
/*
 * Given an address within the vmemmap, determine the pfn of the page that
 * represents the start of the section it is within.  Note that we have to
 * do this by hand as the proffered address may not be correctly aligned.
 * Subtraction of non-aligned pointers produces undefined results.
 */
static unsigned long __meminit vmemmap_section_start(unsigned long page)
{
	unsigned long offset = page - ((unsigned long)(vmemmap));

	/* Return the pfn of the start of the section. */
	return (offset / sizeof(struct page)) & PAGE_SECTION_MASK;
}

/*
 * Check if this vmemmap page is already initialised.  If any section
 * which overlaps this vmemmap page is initialised then this page is
 * initialised already.
 */
static int __meminit vmemmap_populated(unsigned long start, int page_size)
{
	unsigned long end = start + page_size;
	start = (unsigned long)(pfn_to_page(vmemmap_section_start(start)));

	for (; start < end; start += (PAGES_PER_SECTION * sizeof(struct page)))
		if (pfn_valid(page_to_pfn((struct page *)start)))
			return 1;

	return 0;
}

struct vmemmap_backing *vmemmap_list;
static struct vmemmap_backing *next;
static int num_left;
static int num_freed;

static __meminit struct vmemmap_backing * vmemmap_list_alloc(int node)
{
	struct vmemmap_backing *vmem_back;
	/* get from freed entries first */
	if (num_freed) {
		num_freed--;
		vmem_back = next;
		next = next->list;

		return vmem_back;
	}

	/* allocate a page when required and hand out chunks */
	if (!num_left) {
		next = vmemmap_alloc_block(PAGE_SIZE, node);
		if (unlikely(!next)) {
			WARN_ON(1);
			return NULL;
		}
		num_left = PAGE_SIZE / sizeof(struct vmemmap_backing);
	}

	num_left--;

	return next++;
}

static __meminit void vmemmap_list_populate(unsigned long phys,
					    unsigned long start,
					    int node)
{
	struct vmemmap_backing *vmem_back;

	vmem_back = vmemmap_list_alloc(node);
	if (unlikely(!vmem_back)) {
		WARN_ON(1);
		return;
	}

	vmem_back->phys = phys;
	vmem_back->virt_addr = start;
	vmem_back->list = vmemmap_list;

	vmemmap_list = vmem_back;
}

int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
{
	unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;

	/* Align to the page size of the linear mapping. */
	start = _ALIGN_DOWN(start, page_size);

	pr_debug("vmemmap_populate %lx..%lx, node %d\n", start, end, node);

	for (; start < end; start += page_size) {
		void *p;
		int rc;

		if (vmemmap_populated(start, page_size))
			continue;

		p = vmemmap_alloc_block(page_size, node);
		if (!p)
			return -ENOMEM;

		vmemmap_list_populate(__pa(p), start, node);

		pr_debug("      * %016lx..%016lx allocated at %p\n",
			 start, start + page_size, p);

		rc = vmemmap_create_mapping(start, page_size, __pa(p));
		if (rc < 0) {
			pr_warning(
				"vmemmap_populate: Unable to create vmemmap mapping: %d\n",
				rc);
			return -EFAULT;
		}
	}

	return 0;
}

#ifdef CONFIG_MEMORY_HOTPLUG
static unsigned long vmemmap_list_free(unsigned long start)
{
	struct vmemmap_backing *vmem_back, *vmem_back_prev;

	vmem_back_prev = vmem_back = vmemmap_list;

	/* look for it with prev pointer recorded */
	for (; vmem_back; vmem_back = vmem_back->list) {
		if (vmem_back->virt_addr == start)
			break;
		vmem_back_prev = vmem_back;
	}

	if (unlikely(!vmem_back)) {
		WARN_ON(1);
		return 0;
	}

	/* remove it from vmemmap_list */
	if (vmem_back == vmemmap_list) /* remove head */
		vmemmap_list = vmem_back->list;
	else
		vmem_back_prev->list = vmem_back->list;

	/* next point to this freed entry */
	vmem_back->list = next;
	next = vmem_back;
	num_freed++;

	return vmem_back->phys;
}

void __ref vmemmap_free(unsigned long start, unsigned long end)
{
	unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;

	start = _ALIGN_DOWN(start, page_size);

	pr_debug("vmemmap_free %lx...%lx\n", start, end);

	for (; start < end; start += page_size) {
		unsigned long addr;

		/*
		 * the section has already be marked as invalid, so
		 * vmemmap_populated() true means some other sections still
		 * in this page, so skip it.
		 */
		if (vmemmap_populated(start, page_size))
			continue;

		addr = vmemmap_list_free(start);
		if (addr) {
			struct page *page = pfn_to_page(addr >> PAGE_SHIFT);

			if (PageReserved(page)) {
				/* allocated from bootmem */
				if (page_size < PAGE_SIZE) {
					/*
					 * this shouldn't happen, but if it is
					 * the case, leave the memory there
					 */
					WARN_ON_ONCE(1);
				} else {
					unsigned int nr_pages =
						1 << get_order(page_size);
					while (nr_pages--)
						free_reserved_page(page++);
				}
			} else
				free_pages((unsigned long)(__va(addr)),
							get_order(page_size));

			vmemmap_remove_mapping(start, page_size);
		}
	}
}
#endif
void register_page_bootmem_memmap(unsigned long section_nr,
				  struct page *start_page, unsigned long size)
{
}

/*
 * We do not have access to the sparsemem vmemmap, so we fallback to
 * walking the list of sparsemem blocks which we already maintain for
 * the sake of crashdump. In the long run, we might want to maintain
 * a tree if performance of that linear walk becomes a problem.
 *
 * realmode_pfn_to_page functions can fail due to:
 * 1) As real sparsemem blocks do not lay in RAM continously (they
 * are in virtual address space which is not available in the real mode),
 * the requested page struct can be split between blocks so get_page/put_page
 * may fail.
 * 2) When huge pages are used, the get_page/put_page API will fail
 * in real mode as the linked addresses in the page struct are virtual
 * too.
 */
struct page *realmode_pfn_to_page(unsigned long pfn)
{
	struct vmemmap_backing *vmem_back;
	struct page *page;
	unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;
	unsigned long pg_va = (unsigned long) pfn_to_page(pfn);

	for (vmem_back = vmemmap_list; vmem_back; vmem_back = vmem_back->list) {
		if (pg_va < vmem_back->virt_addr)
			continue;

		/* After vmemmap_list entry free is possible, need check all */
		if ((pg_va + sizeof(struct page)) <=
				(vmem_back->virt_addr + page_size)) {
			page = (struct page *) (vmem_back->phys + pg_va -
				vmem_back->virt_addr);
			return page;
		}
	}

	/* Probably that page struct is split between real pages */
	return NULL;
}
EXPORT_SYMBOL_GPL(realmode_pfn_to_page);

#elif defined(CONFIG_FLATMEM)

struct page *realmode_pfn_to_page(unsigned long pfn)
{
	struct page *page = pfn_to_page(pfn);
	return page;
}
EXPORT_SYMBOL_GPL(realmode_pfn_to_page);

#endif /* CONFIG_SPARSEMEM_VMEMMAP/CONFIG_FLATMEM */

#ifdef CONFIG_PPC_STD_MMU_64
static bool disable_radix;
static int __init parse_disable_radix(char *p)
{
	disable_radix = true;
	return 0;
}
early_param("disable_radix", parse_disable_radix);

void __init mmu_early_init_devtree(void)
{
	/* Disable radix mode based on kernel command line. */
	if (disable_radix)
		cur_cpu_spec->mmu_features &= ~MMU_FTR_TYPE_RADIX;

	if (early_radix_enabled())
		radix__early_init_devtree();
	else
		hash__early_init_devtree();
}
#endif /* CONFIG_PPC_STD_MMU_64 */
Commit	Line	Data
14cf11af PM	1	/*
	2	* PowerPC version
	3	* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
	4	*
	5	* Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au)
	6	* and Cort Dougan (PReP) (cort@cs.nmt.edu)
	7	* Copyright (C) 1996 Paul Mackerras
14cf11af PM	8	*
	9	* Derived from "arch/i386/mm/init.c"
	10	* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
	11	*
	12	* Dave Engebretsen <engebret@us.ibm.com>
	13	* Rework for PPC64 port.
	14	*
	15	* This program is free software; you can redistribute it and/or
	16	* modify it under the terms of the GNU General Public License
	17	* as published by the Free Software Foundation; either version
	18	* 2 of the License, or (at your option) any later version.
	19	*
	20	*/
	21
cec08e7a BH	22	#undef DEBUG
cec08e7a BH	23
14cf11af PM	24	#include <linux/signal.h>
	25	#include <linux/sched.h>
	26	#include <linux/kernel.h>
	27	#include <linux/errno.h>
	28	#include <linux/string.h>
	29	#include <linux/types.h>
	30	#include <linux/mman.h>
	31	#include <linux/mm.h>
	32	#include <linux/swap.h>
	33	#include <linux/stddef.h>
	34	#include <linux/vmalloc.h>
	35	#include <linux/init.h>
	36	#include <linux/delay.h>
14cf11af PM	37	#include <linux/highmem.h>
	38	#include <linux/idr.h>
	39	#include <linux/nodemask.h>
	40	#include <linux/module.h>
c9cf5528	41	#include <linux/poison.h>
95f72d1e	42	#include <linux/memblock.h>
a4fe3ce7	43	#include <linux/hugetlb.h>
5a0e3ad6	44	#include <linux/slab.h>
14cf11af PM	45
	46	#include <asm/pgalloc.h>
	47	#include <asm/page.h>
	48	#include <asm/prom.h>
14cf11af PM	49	#include <asm/rtas.h>
	50	#include <asm/io.h>
	51	#include <asm/mmu_context.h>
	52	#include <asm/pgtable.h>
	53	#include <asm/mmu.h>
7c0f6ba6	54	#include <linux/uaccess.h>
14cf11af PM	55	#include <asm/smp.h>
	56	#include <asm/machdep.h>
	57	#include <asm/tlb.h>
	58	#include <asm/eeh.h>
	59	#include <asm/processor.h>
	60	#include <asm/mmzone.h>
	61	#include <asm/cputable.h>
14cf11af	62	#include <asm/sections.h>
14cf11af	63	#include <asm/iommu.h>
14cf11af	64	#include <asm/vdso.h>
800fc3ee DG	65
800fc3ee DG	66	#include "mmu_decl.h"
14cf11af	67
94491685	68	#ifdef CONFIG_PPC_STD_MMU_64
dd1842a2	69	#if H_PGTABLE_RANGE > USER_VSID_RANGE
14cf11af PM	70	#warning Limited user VSID range means pagetable space is wasted
	71	#endif
	72
dd1842a2	73	#if (TASK_SIZE_USER64 < H_PGTABLE_RANGE) && (TASK_SIZE_USER64 < USER_VSID_RANGE)
14cf11af PM	74	#warning TASK_SIZE is smaller than it needs to be.
14cf11af PM	75	#endif
94491685	76	#endif /* CONFIG_PPC_STD_MMU_64 */
14cf11af	77
37dd2bad	78	phys_addr_t memstart_addr = ~0;
79c3095f	79	EXPORT_SYMBOL_GPL(memstart_addr);
37dd2bad	80	phys_addr_t kernstart_addr;
79c3095f	81	EXPORT_SYMBOL_GPL(kernstart_addr);
d7917ba7	82
d29eff7b AW	83	#ifdef CONFIG_SPARSEMEM_VMEMMAP
	84	/*
	85	* Given an address within the vmemmap, determine the pfn of the page that
	86	* represents the start of the section it is within. Note that we have to
	87	* do this by hand as the proffered address may not be correctly aligned.
	88	* Subtraction of non-aligned pointers produces undefined results.
	89	*/
09de9ff8	90	static unsigned long __meminit vmemmap_section_start(unsigned long page)
d29eff7b AW	91	{
	92	unsigned long offset = page - ((unsigned long)(vmemmap));
	93
	94	/* Return the pfn of the start of the section. */
	95	return (offset / sizeof(struct page)) & PAGE_SECTION_MASK;
	96	}
	97
	98	/*
	99	* Check if this vmemmap page is already initialised. If any section
	100	* which overlaps this vmemmap page is initialised then this page is
	101	* initialised already.
	102	*/
09de9ff8	103	static int __meminit vmemmap_populated(unsigned long start, int page_size)
d29eff7b AW	104	{
d29eff7b AW	105	unsigned long end = start + page_size;
16a05bff	106	start = (unsigned long)(pfn_to_page(vmemmap_section_start(start)));
d29eff7b AW	107
d29eff7b AW	108	for (; start < end; start += (PAGES_PER_SECTION * sizeof(struct page)))
16a05bff	109	if (pfn_valid(page_to_pfn((struct page *)start)))
d29eff7b AW	110	return 1;
	111
	112	return 0;
	113	}
	114
91eea67c	115	struct vmemmap_backing *vmemmap_list;
bd8cb03d LZ	116	static struct vmemmap_backing *next;
	117	static int num_left;
	118	static int num_freed;
91eea67c MN	119
	120	static __meminit struct vmemmap_backing * vmemmap_list_alloc(int node)
	121	{
bd8cb03d LZ	122	struct vmemmap_backing *vmem_back;
	123	/* get from freed entries first */
	124	if (num_freed) {
	125	num_freed--;
	126	vmem_back = next;
	127	next = next->list;
	128
	129	return vmem_back;
	130	}
91eea67c MN	131
91eea67c MN	132	/* allocate a page when required and hand out chunks */
bd8cb03d	133	if (!num_left) {
91eea67c MN	134	next = vmemmap_alloc_block(PAGE_SIZE, node);
	135	if (unlikely(!next)) {
	136	WARN_ON(1);
	137	return NULL;
	138	}
	139	num_left = PAGE_SIZE / sizeof(struct vmemmap_backing);
	140	}
	141
	142	num_left--;
	143
	144	return next++;
	145	}
	146
	147	static __meminit void vmemmap_list_populate(unsigned long phys,
	148	unsigned long start,
	149	int node)
	150	{
	151	struct vmemmap_backing *vmem_back;
	152
	153	vmem_back = vmemmap_list_alloc(node);
	154	if (unlikely(!vmem_back)) {
	155	WARN_ON(1);
	156	return;
	157	}
	158
	159	vmem_back->phys = phys;
	160	vmem_back->virt_addr = start;
	161	vmem_back->list = vmemmap_list;
	162
	163	vmemmap_list = vmem_back;
	164	}
	165
71b0bfe4 LZ	166	int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
	167	{
	168	unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;
	169
	170	/* Align to the page size of the linear mapping. */
	171	start = _ALIGN_DOWN(start, page_size);
	172
	173	pr_debug("vmemmap_populate %lx..%lx, node %d\n", start, end, node);
	174
	175	for (; start < end; start += page_size) {
	176	void *p;
1dace6c6	177	int rc;
71b0bfe4 LZ	178
	179	if (vmemmap_populated(start, page_size))
	180	continue;
	181
	182	p = vmemmap_alloc_block(page_size, node);
	183	if (!p)
	184	return -ENOMEM;
	185
	186	vmemmap_list_populate(__pa(p), start, node);
	187
	188	pr_debug(" * %016lx..%016lx allocated at %p\n",
	189	start, start + page_size, p);
	190
1dace6c6 DG	191	rc = vmemmap_create_mapping(start, page_size, __pa(p));
	192	if (rc < 0) {
	193	pr_warning(
	194	"vmemmap_populate: Unable to create vmemmap mapping: %d\n",
	195	rc);
	196	return -EFAULT;
	197	}
71b0bfe4 LZ	198	}
	199
	200	return 0;
	201	}
	202
	203	#ifdef CONFIG_MEMORY_HOTPLUG
bd8cb03d LZ	204	static unsigned long vmemmap_list_free(unsigned long start)
	205	{
	206	struct vmemmap_backing vmem_back, vmem_back_prev;
	207
	208	vmem_back_prev = vmem_back = vmemmap_list;
	209
	210	/* look for it with prev pointer recorded */
	211	for (; vmem_back; vmem_back = vmem_back->list) {
	212	if (vmem_back->virt_addr == start)
	213	break;
	214	vmem_back_prev = vmem_back;
	215	}
	216
	217	if (unlikely(!vmem_back)) {
	218	WARN_ON(1);
	219	return 0;
	220	}
	221
	222	/* remove it from vmemmap_list */
	223	if (vmem_back == vmemmap_list) /* remove head */
	224	vmemmap_list = vmem_back->list;
	225	else
	226	vmem_back_prev->list = vmem_back->list;
	227
	228	/* next point to this freed entry */
	229	vmem_back->list = next;
	230	next = vmem_back;
	231	num_freed++;
	232
	233	return vmem_back->phys;
	234	}
	235
71b0bfe4	236	void __ref vmemmap_free(unsigned long start, unsigned long end)
d29eff7b	237	{
cec08e7a	238	unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;
d29eff7b	239
d29eff7b AW	240	start = _ALIGN_DOWN(start, page_size);
d29eff7b AW	241
71b0bfe4	242	pr_debug("vmemmap_free %lx...%lx\n", start, end);
32a74949	243
d29eff7b	244	for (; start < end; start += page_size) {
71b0bfe4	245	unsigned long addr;
d29eff7b	246
71b0bfe4 LZ	247	/*
	248	* the section has already be marked as invalid, so
	249	* vmemmap_populated() true means some other sections still
	250	* in this page, so skip it.
	251	*/
d29eff7b AW	252	if (vmemmap_populated(start, page_size))
	253	continue;
	254
71b0bfe4 LZ	255	addr = vmemmap_list_free(start);
	256	if (addr) {
	257	struct page *page = pfn_to_page(addr >> PAGE_SHIFT);
	258
	259	if (PageReserved(page)) {
	260	/* allocated from bootmem */
	261	if (page_size < PAGE_SIZE) {
	262	/*
	263	* this shouldn't happen, but if it is
	264	* the case, leave the memory there
	265	*/
	266	WARN_ON_ONCE(1);
	267	} else {
	268	unsigned int nr_pages =
	269	1 << get_order(page_size);
	270	while (nr_pages--)
	271	free_reserved_page(page++);
	272	}
	273	} else
	274	free_pages((unsigned long)(__va(addr)),
	275	get_order(page_size));
	276
	277	vmemmap_remove_mapping(start, page_size);
	278	}
d29eff7b	279	}
0197518c	280	}
71b0bfe4	281	#endif
f7e3334a NF	282	void register_page_bootmem_memmap(unsigned long section_nr,
	283	struct page *start_page, unsigned long size)
	284	{
	285	}
cd3db0c4	286
8e0861fa AK	287	/*
	288	* We do not have access to the sparsemem vmemmap, so we fallback to
	289	* walking the list of sparsemem blocks which we already maintain for
	290	* the sake of crashdump. In the long run, we might want to maintain
	291	* a tree if performance of that linear walk becomes a problem.
	292	*
	293	* realmode_pfn_to_page functions can fail due to:
	294	* 1) As real sparsemem blocks do not lay in RAM continously (they
	295	* are in virtual address space which is not available in the real mode),
	296	* the requested page struct can be split between blocks so get_page/put_page
	297	* may fail.
	298	* 2) When huge pages are used, the get_page/put_page API will fail
	299	* in real mode as the linked addresses in the page struct are virtual
	300	* too.
	301	*/
	302	struct page *realmode_pfn_to_page(unsigned long pfn)
	303	{
	304	struct vmemmap_backing *vmem_back;
	305	struct page *page;
	306	unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;
	307	unsigned long pg_va = (unsigned long) pfn_to_page(pfn);
	308
	309	for (vmem_back = vmemmap_list; vmem_back; vmem_back = vmem_back->list) {
	310	if (pg_va < vmem_back->virt_addr)
	311	continue;
	312
bd8cb03d LZ	313	/* After vmemmap_list entry free is possible, need check all */
	314	if ((pg_va + sizeof(struct page)) <=
	315	(vmem_back->virt_addr + page_size)) {
	316	page = (struct page *) (vmem_back->phys + pg_va -
8e0861fa	317	vmem_back->virt_addr);
bd8cb03d LZ	318	return page;
bd8cb03d LZ	319	}
8e0861fa AK	320	}
8e0861fa AK	321
bd8cb03d	322	/* Probably that page struct is split between real pages */
8e0861fa AK	323	return NULL;
	324	}
	325	EXPORT_SYMBOL_GPL(realmode_pfn_to_page);
	326
	327	#elif defined(CONFIG_FLATMEM)
	328
	329	struct page *realmode_pfn_to_page(unsigned long pfn)
	330	{
	331	struct page *page = pfn_to_page(pfn);
	332	return page;
	333	}
	334	EXPORT_SYMBOL_GPL(realmode_pfn_to_page);
	335
	336	#endif /* CONFIG_SPARSEMEM_VMEMMAP/CONFIG_FLATMEM */
1a01dc87 ME	337
1a01dc87 ME	338	#ifdef CONFIG_PPC_STD_MMU_64
c610ec60 ME	339	static bool disable_radix;
	340	static int __init parse_disable_radix(char *p)
	341	{
	342	disable_radix = true;
	343	return 0;
	344	}
	345	early_param("disable_radix", parse_disable_radix);
	346
1a01dc87 ME	347	void __init mmu_early_init_devtree(void)
1a01dc87 ME	348	{
c610ec60 ME	349	/* Disable radix mode based on kernel command line. */
c610ec60 ME	350	if (disable_radix)
5a25b6f5	351	cur_cpu_spec->mmu_features &= ~MMU_FTR_TYPE_RADIX;
bacf9cf8	352
b8f1b4f8	353	if (early_radix_enabled())
2537b09c ME	354	radix__early_init_devtree();
2537b09c ME	355	else
bacf9cf8	356	hash__early_init_devtree();
1a01dc87 ME	357	}
1a01dc87 ME	358	#endif /* CONFIG_PPC_STD_MMU_64 */