[linux-2.6-block.git] / arch / powerpc / mm / pgtable_64.c

/*
 *  This file contains ioremap and related functions for 64-bit machines.
 *
 *  Derived from arch/ppc64/mm/init.c
 *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
 *
 *  Modifications by Paul Mackerras (PowerMac) (paulus@samba.org)
 *  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.
 *
 */

#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/export.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/slab.h>
#include <linux/hugetlb.h>

#include <asm/pgalloc.h>
#include <asm/page.h>
#include <asm/prom.h>
#include <asm/io.h>
#include <asm/mmu_context.h>
#include <asm/pgtable.h>
#include <asm/mmu.h>
#include <asm/smp.h>
#include <asm/machdep.h>
#include <asm/tlb.h>
#include <asm/processor.h>
#include <asm/cputable.h>
#include <asm/sections.h>
#include <asm/firmware.h>
#include <asm/dma.h>

#include "mmu_decl.h"


#ifdef CONFIG_PPC_BOOK3S_64
/*
 * partition table and process table for ISA 3.0
 */
struct prtb_entry *process_tb;
struct patb_entry *partition_tb;
/*
 * page table size
 */
unsigned long __pte_index_size;
EXPORT_SYMBOL(__pte_index_size);
unsigned long __pmd_index_size;
EXPORT_SYMBOL(__pmd_index_size);
unsigned long __pud_index_size;
EXPORT_SYMBOL(__pud_index_size);
unsigned long __pgd_index_size;
EXPORT_SYMBOL(__pgd_index_size);
unsigned long __pud_cache_index;
EXPORT_SYMBOL(__pud_cache_index);
unsigned long __pte_table_size;
EXPORT_SYMBOL(__pte_table_size);
unsigned long __pmd_table_size;
EXPORT_SYMBOL(__pmd_table_size);
unsigned long __pud_table_size;
EXPORT_SYMBOL(__pud_table_size);
unsigned long __pgd_table_size;
EXPORT_SYMBOL(__pgd_table_size);
unsigned long __pmd_val_bits;
EXPORT_SYMBOL(__pmd_val_bits);
unsigned long __pud_val_bits;
EXPORT_SYMBOL(__pud_val_bits);
unsigned long __pgd_val_bits;
EXPORT_SYMBOL(__pgd_val_bits);
unsigned long __kernel_virt_start;
EXPORT_SYMBOL(__kernel_virt_start);
unsigned long __kernel_virt_size;
EXPORT_SYMBOL(__kernel_virt_size);
unsigned long __vmalloc_start;
EXPORT_SYMBOL(__vmalloc_start);
unsigned long __vmalloc_end;
EXPORT_SYMBOL(__vmalloc_end);
unsigned long __kernel_io_start;
EXPORT_SYMBOL(__kernel_io_start);
struct page *vmemmap;
EXPORT_SYMBOL(vmemmap);
unsigned long __pte_frag_nr;
EXPORT_SYMBOL(__pte_frag_nr);
unsigned long __pte_frag_size_shift;
EXPORT_SYMBOL(__pte_frag_size_shift);
unsigned long ioremap_bot;
#else /* !CONFIG_PPC_BOOK3S_64 */
unsigned long ioremap_bot = IOREMAP_BASE;
#endif

/**
 * __ioremap_at - Low level function to establish the page tables
 *                for an IO mapping
 */
void __iomem * __ioremap_at(phys_addr_t pa, void *ea, unsigned long size,
			    unsigned long flags)
{
	unsigned long i;

	/* Make sure we have the base flags */
	if ((flags & _PAGE_PRESENT) == 0)
		flags |= pgprot_val(PAGE_KERNEL);

	/* We don't support the 4K PFN hack with ioremap */
	if (flags & H_PAGE_4K_PFN)
		return NULL;

	WARN_ON(pa & ~PAGE_MASK);
	WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
	WARN_ON(size & ~PAGE_MASK);

	for (i = 0; i < size; i += PAGE_SIZE)
		if (map_kernel_page((unsigned long)ea+i, pa+i, flags))
			return NULL;

	return (void __iomem *)ea;
}

/**
 * __iounmap_from - Low level function to tear down the page tables
 *                  for an IO mapping. This is used for mappings that
 *                  are manipulated manually, like partial unmapping of
 *                  PCI IOs or ISA space.
 */
void __iounmap_at(void *ea, unsigned long size)
{
	WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
	WARN_ON(size & ~PAGE_MASK);

	unmap_kernel_range((unsigned long)ea, size);
}

void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
				unsigned long flags, void *caller)
{
	phys_addr_t paligned;
	void __iomem *ret;

	/*
	 * Choose an address to map it to.
	 * Once the imalloc system is running, we use it.
	 * Before that, we map using addresses going
	 * up from ioremap_bot.  imalloc will use
	 * the addresses from ioremap_bot through
	 * IMALLOC_END
	 * 
	 */
	paligned = addr & PAGE_MASK;
	size = PAGE_ALIGN(addr + size) - paligned;

	if ((size == 0) || (paligned == 0))
		return NULL;

	if (slab_is_available()) {
		struct vm_struct *area;

		area = __get_vm_area_caller(size, VM_IOREMAP,
					    ioremap_bot, IOREMAP_END,
					    caller);
		if (area == NULL)
			return NULL;

		area->phys_addr = paligned;
		ret = __ioremap_at(paligned, area->addr, size, flags);
		if (!ret)
			vunmap(area->addr);
	} else {
		ret = __ioremap_at(paligned, (void *)ioremap_bot, size, flags);
		if (ret)
			ioremap_bot += size;
	}

	if (ret)
		ret += addr & ~PAGE_MASK;
	return ret;
}

void __iomem * __ioremap(phys_addr_t addr, unsigned long size,
			 unsigned long flags)
{
	return __ioremap_caller(addr, size, flags, __builtin_return_address(0));
}

void __iomem * ioremap(phys_addr_t addr, unsigned long size)
{
	unsigned long flags = pgprot_val(pgprot_noncached(__pgprot(0)));
	void *caller = __builtin_return_address(0);

	if (ppc_md.ioremap)
		return ppc_md.ioremap(addr, size, flags, caller);
	return __ioremap_caller(addr, size, flags, caller);
}

void __iomem * ioremap_wc(phys_addr_t addr, unsigned long size)
{
	unsigned long flags = pgprot_val(pgprot_noncached_wc(__pgprot(0)));
	void *caller = __builtin_return_address(0);

	if (ppc_md.ioremap)
		return ppc_md.ioremap(addr, size, flags, caller);
	return __ioremap_caller(addr, size, flags, caller);
}

void __iomem * ioremap_prot(phys_addr_t addr, unsigned long size,
			     unsigned long flags)
{
	void *caller = __builtin_return_address(0);

	/* writeable implies dirty for kernel addresses */
	if (flags & _PAGE_WRITE)
		flags |= _PAGE_DIRTY;

	/* we don't want to let _PAGE_EXEC leak out */
	flags &= ~_PAGE_EXEC;
	/*
	 * Force kernel mapping.
	 */
	flags &= ~_PAGE_USER;
	flags |= _PAGE_PRIVILEGED;

	if (ppc_md.ioremap)
		return ppc_md.ioremap(addr, size, flags, caller);
	return __ioremap_caller(addr, size, flags, caller);
}


/*  
 * Unmap an IO region and remove it from imalloc'd list.
 * Access to IO memory should be serialized by driver.
 */
void __iounmap(volatile void __iomem *token)
{
	void *addr;

	if (!slab_is_available())
		return;
	
	addr = (void *) ((unsigned long __force)
			 PCI_FIX_ADDR(token) & PAGE_MASK);
	if ((unsigned long)addr < ioremap_bot) {
		printk(KERN_WARNING "Attempt to iounmap early bolted mapping"
		       " at 0x%p\n", addr);
		return;
	}
	vunmap(addr);
}

void iounmap(volatile void __iomem *token)
{
	if (ppc_md.iounmap)
		ppc_md.iounmap(token);
	else
		__iounmap(token);
}

EXPORT_SYMBOL(ioremap);
EXPORT_SYMBOL(ioremap_wc);
EXPORT_SYMBOL(ioremap_prot);
EXPORT_SYMBOL(__ioremap);
EXPORT_SYMBOL(__ioremap_at);
EXPORT_SYMBOL(iounmap);
EXPORT_SYMBOL(__iounmap);
EXPORT_SYMBOL(__iounmap_at);

#ifndef __PAGETABLE_PUD_FOLDED
/* 4 level page table */
struct page *pgd_page(pgd_t pgd)
{
	if (pgd_huge(pgd))
		return pte_page(pgd_pte(pgd));
	return virt_to_page(pgd_page_vaddr(pgd));
}
#endif

struct page *pud_page(pud_t pud)
{
	if (pud_huge(pud))
		return pte_page(pud_pte(pud));
	return virt_to_page(pud_page_vaddr(pud));
}

/*
 * For hugepage we have pfn in the pmd, we use PTE_RPN_SHIFT bits for flags
 * For PTE page, we have a PTE_FRAG_SIZE (4K) aligned virtual address.
 */
struct page *pmd_page(pmd_t pmd)
{
	if (pmd_trans_huge(pmd) || pmd_huge(pmd) || pmd_devmap(pmd))
		return pte_page(pmd_pte(pmd));
	return virt_to_page(pmd_page_vaddr(pmd));
}

#ifdef CONFIG_STRICT_KERNEL_RWX
void mark_rodata_ro(void)
{
	if (!mmu_has_feature(MMU_FTR_KERNEL_RO)) {
		pr_warn("Warning: Unable to mark rodata read only on this CPU.\n");
		return;
	}

	if (radix_enabled())
		radix__mark_rodata_ro();
	else
		hash__mark_rodata_ro();
}

void mark_initmem_nx(void)
{
	if (radix_enabled())
		radix__mark_initmem_nx();
	else
		hash__mark_initmem_nx();
}
#endif
Commit	Line	Data
14cf11af PM	1	/*
	2	* This file contains ioremap and related functions for 64-bit machines.
	3	*
	4	* Derived from arch/ppc64/mm/init.c
	5	* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
	6	*
	7	* Modifications by Paul Mackerras (PowerMac) (paulus@samba.org)
	8	* and Cort Dougan (PReP) (cort@cs.nmt.edu)
	9	* Copyright (C) 1996 Paul Mackerras
14cf11af PM	10	*
	11	* Derived from "arch/i386/mm/init.c"
	12	* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
	13	*
	14	* Dave Engebretsen <engebret@us.ibm.com>
	15	* Rework for PPC64 port.
	16	*
	17	* This program is free software; you can redistribute it and/or
	18	* modify it under the terms of the GNU General Public License
	19	* as published by the Free Software Foundation; either version
	20	* 2 of the License, or (at your option) any later version.
	21	*
	22	*/
	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>
66b15db6	29	#include <linux/export.h>
14cf11af PM	30	#include <linux/types.h>
	31	#include <linux/mman.h>
	32	#include <linux/mm.h>
	33	#include <linux/swap.h>
	34	#include <linux/stddef.h>
	35	#include <linux/vmalloc.h>
5a0e3ad6	36	#include <linux/slab.h>
06743521	37	#include <linux/hugetlb.h>
14cf11af PM	38
	39	#include <asm/pgalloc.h>
	40	#include <asm/page.h>
	41	#include <asm/prom.h>
14cf11af PM	42	#include <asm/io.h>
	43	#include <asm/mmu_context.h>
	44	#include <asm/pgtable.h>
	45	#include <asm/mmu.h>
14cf11af PM	46	#include <asm/smp.h>
	47	#include <asm/machdep.h>
	48	#include <asm/tlb.h>
14cf11af	49	#include <asm/processor.h>
14cf11af	50	#include <asm/cputable.h>
14cf11af	51	#include <asm/sections.h>
5e203d68	52	#include <asm/firmware.h>
68cf0d64	53	#include <asm/dma.h>
800fc3ee DG	54
800fc3ee DG	55	#include "mmu_decl.h"
14cf11af	56
14cf11af	57
50de596d AK	58	#ifdef CONFIG_PPC_BOOK3S_64
	59	/*
	60	* partition table and process table for ISA 3.0
	61	*/
	62	struct prtb_entry *process_tb;
	63	struct patb_entry *partition_tb;
dd1842a2 AK	64	/*
	65	* page table size
	66	*/
	67	unsigned long __pte_index_size;
	68	EXPORT_SYMBOL(__pte_index_size);
	69	unsigned long __pmd_index_size;
	70	EXPORT_SYMBOL(__pmd_index_size);
	71	unsigned long __pud_index_size;
	72	EXPORT_SYMBOL(__pud_index_size);
	73	unsigned long __pgd_index_size;
	74	EXPORT_SYMBOL(__pgd_index_size);
fae22116 AK	75	unsigned long __pud_cache_index;
fae22116 AK	76	EXPORT_SYMBOL(__pud_cache_index);
dd1842a2 AK	77	unsigned long __pte_table_size;
	78	EXPORT_SYMBOL(__pte_table_size);
	79	unsigned long __pmd_table_size;
	80	EXPORT_SYMBOL(__pmd_table_size);
	81	unsigned long __pud_table_size;
	82	EXPORT_SYMBOL(__pud_table_size);
	83	unsigned long __pgd_table_size;
	84	EXPORT_SYMBOL(__pgd_table_size);
a2f41eb9 AK	85	unsigned long __pmd_val_bits;
	86	EXPORT_SYMBOL(__pmd_val_bits);
	87	unsigned long __pud_val_bits;
	88	EXPORT_SYMBOL(__pud_val_bits);
	89	unsigned long __pgd_val_bits;
	90	EXPORT_SYMBOL(__pgd_val_bits);
d6a9996e AK	91	unsigned long __kernel_virt_start;
	92	EXPORT_SYMBOL(__kernel_virt_start);
	93	unsigned long __kernel_virt_size;
	94	EXPORT_SYMBOL(__kernel_virt_size);
	95	unsigned long __vmalloc_start;
	96	EXPORT_SYMBOL(__vmalloc_start);
	97	unsigned long __vmalloc_end;
	98	EXPORT_SYMBOL(__vmalloc_end);
63ee9b2f ME	99	unsigned long __kernel_io_start;
63ee9b2f ME	100	EXPORT_SYMBOL(__kernel_io_start);
d6a9996e AK	101	struct page *vmemmap;
d6a9996e AK	102	EXPORT_SYMBOL(vmemmap);
5ed7ecd0 AK	103	unsigned long __pte_frag_nr;
	104	EXPORT_SYMBOL(__pte_frag_nr);
	105	unsigned long __pte_frag_size_shift;
	106	EXPORT_SYMBOL(__pte_frag_size_shift);
d6a9996e AK	107	unsigned long ioremap_bot;
d6a9996e AK	108	#else /* !CONFIG_PPC_BOOK3S_64 */
78f1dbde	109	unsigned long ioremap_bot = IOREMAP_BASE;
d6a9996e	110	#endif
a245067e	111
3d5134ee BH	112	/**
	113	* __ioremap_at - Low level function to establish the page tables
	114	* for an IO mapping
	115	*/
	116	void __iomem * __ioremap_at(phys_addr_t pa, void *ea, unsigned long size,
14cf11af PM	117	unsigned long flags)
	118	{
	119	unsigned long i;
	120
a1f242ff	121	/* Make sure we have the base flags */
14cf11af PM	122	if ((flags & _PAGE_PRESENT) == 0)
	123	flags \|= pgprot_val(PAGE_KERNEL);
	124
a1f242ff	125	/* We don't support the 4K PFN hack with ioremap */
945537df	126	if (flags & H_PAGE_4K_PFN)
a1f242ff BH	127	return NULL;
a1f242ff BH	128
3d5134ee BH	129	WARN_ON(pa & ~PAGE_MASK);
	130	WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
	131	WARN_ON(size & ~PAGE_MASK);
	132
14cf11af	133	for (i = 0; i < size; i += PAGE_SIZE)
a245067e	134	if (map_kernel_page((unsigned long)ea+i, pa+i, flags))
14cf11af PM	135	return NULL;
14cf11af PM	136
3d5134ee BH	137	return (void __iomem *)ea;
	138	}
	139
	140	/**
	141	* __iounmap_from - Low level function to tear down the page tables
	142	* for an IO mapping. This is used for mappings that
	143	* are manipulated manually, like partial unmapping of
	144	* PCI IOs or ISA space.
	145	*/
	146	void __iounmap_at(void *ea, unsigned long size)
	147	{
	148	WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
	149	WARN_ON(size & ~PAGE_MASK);
	150
	151	unmap_kernel_range((unsigned long)ea, size);
14cf11af PM	152	}
14cf11af PM	153
1cdab55d BH	154	void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
1cdab55d BH	155	unsigned long flags, void *caller)
14cf11af	156	{
3d5134ee	157	phys_addr_t paligned;
14cf11af PM	158	void __iomem *ret;
	159
	160	/*
	161	* Choose an address to map it to.
	162	* Once the imalloc system is running, we use it.
	163	* Before that, we map using addresses going
	164	* up from ioremap_bot. imalloc will use
	165	* the addresses from ioremap_bot through
	166	* IMALLOC_END
	167	*
	168	*/
3d5134ee BH	169	paligned = addr & PAGE_MASK;
3d5134ee BH	170	size = PAGE_ALIGN(addr + size) - paligned;
14cf11af	171
3d5134ee	172	if ((size == 0) \|\| (paligned == 0))
14cf11af PM	173	return NULL;
14cf11af PM	174
f691fa10	175	if (slab_is_available()) {
14cf11af	176	struct vm_struct *area;
3d5134ee	177
1cdab55d BH	178	area = __get_vm_area_caller(size, VM_IOREMAP,
	179	ioremap_bot, IOREMAP_END,
	180	caller);
14cf11af PM	181	if (area == NULL)
14cf11af PM	182	return NULL;
7a9d1256 ME	183
7a9d1256 ME	184	area->phys_addr = paligned;
3d5134ee	185	ret = __ioremap_at(paligned, area->addr, size, flags);
14cf11af	186	if (!ret)
3d5134ee	187	vunmap(area->addr);
14cf11af	188	} else {
3d5134ee	189	ret = __ioremap_at(paligned, (void *)ioremap_bot, size, flags);
14cf11af PM	190	if (ret)
	191	ioremap_bot += size;
	192	}
3d5134ee BH	193
	194	if (ret)
	195	ret += addr & ~PAGE_MASK;
14cf11af PM	196	return ret;
	197	}
	198
1cdab55d BH	199	void __iomem * __ioremap(phys_addr_t addr, unsigned long size,
	200	unsigned long flags)
	201	{
	202	return __ioremap_caller(addr, size, flags, __builtin_return_address(0));
	203	}
4cb3cee0	204
68a64357	205	void __iomem * ioremap(phys_addr_t addr, unsigned long size)
4cb3cee0	206	{
72176dd0	207	unsigned long flags = pgprot_val(pgprot_noncached(__pgprot(0)));
1cdab55d	208	void *caller = __builtin_return_address(0);
4cb3cee0 BH	209
4cb3cee0 BH	210	if (ppc_md.ioremap)
1cdab55d BH	211	return ppc_md.ioremap(addr, size, flags, caller);
1cdab55d BH	212	return __ioremap_caller(addr, size, flags, caller);
4cb3cee0 BH	213	}
4cb3cee0 BH	214
be135f40 AB	215	void __iomem * ioremap_wc(phys_addr_t addr, unsigned long size)
be135f40 AB	216	{
72176dd0	217	unsigned long flags = pgprot_val(pgprot_noncached_wc(__pgprot(0)));
be135f40 AB	218	void *caller = __builtin_return_address(0);
	219
	220	if (ppc_md.ioremap)
	221	return ppc_md.ioremap(addr, size, flags, caller);
	222	return __ioremap_caller(addr, size, flags, caller);
	223	}
	224
40f1ce7f	225	void __iomem * ioremap_prot(phys_addr_t addr, unsigned long size,
4cb3cee0 BH	226	unsigned long flags)
4cb3cee0 BH	227	{
1cdab55d BH	228	void *caller = __builtin_return_address(0);
1cdab55d BH	229
a1f242ff	230	/* writeable implies dirty for kernel addresses */
c7d54842	231	if (flags & _PAGE_WRITE)
a1f242ff BH	232	flags \|= _PAGE_DIRTY;
a1f242ff BH	233
ac29c640 AK	234	/* we don't want to let _PAGE_EXEC leak out */
	235	flags &= ~_PAGE_EXEC;
	236	/*
	237	* Force kernel mapping.
	238	*/
ac29c640	239	flags &= ~_PAGE_USER;
812fadcb	240	flags \|= _PAGE_PRIVILEGED;
55052eec	241
4cb3cee0	242	if (ppc_md.ioremap)
1cdab55d BH	243	return ppc_md.ioremap(addr, size, flags, caller);
1cdab55d BH	244	return __ioremap_caller(addr, size, flags, caller);
4cb3cee0 BH	245	}
	246
	247
14cf11af PM	248	/*
	249	* Unmap an IO region and remove it from imalloc'd list.
	250	* Access to IO memory should be serialized by driver.
14cf11af	251	*/
68a64357	252	void __iounmap(volatile void __iomem *token)
14cf11af PM	253	{
	254	void *addr;
	255
f691fa10	256	if (!slab_is_available())
14cf11af PM	257	return;
14cf11af PM	258
3d5134ee BH	259	addr = (void *) ((unsigned long __force)
	260	PCI_FIX_ADDR(token) & PAGE_MASK);
	261	if ((unsigned long)addr < ioremap_bot) {
	262	printk(KERN_WARNING "Attempt to iounmap early bolted mapping"
	263	" at 0x%p\n", addr);
	264	return;
	265	}
	266	vunmap(addr);
14cf11af PM	267	}
14cf11af PM	268
68a64357	269	void iounmap(volatile void __iomem *token)
4cb3cee0 BH	270	{
	271	if (ppc_md.iounmap)
	272	ppc_md.iounmap(token);
	273	else
	274	__iounmap(token);
	275	}
	276
14cf11af	277	EXPORT_SYMBOL(ioremap);
be135f40	278	EXPORT_SYMBOL(ioremap_wc);
40f1ce7f	279	EXPORT_SYMBOL(ioremap_prot);
14cf11af	280	EXPORT_SYMBOL(__ioremap);
a302cb9d	281	EXPORT_SYMBOL(__ioremap_at);
14cf11af	282	EXPORT_SYMBOL(iounmap);
4cb3cee0	283	EXPORT_SYMBOL(__iounmap);
a302cb9d	284	EXPORT_SYMBOL(__iounmap_at);
5c1f6ee9	285
06743521 AK	286	#ifndef __PAGETABLE_PUD_FOLDED
	287	/* 4 level page table */
	288	struct page *pgd_page(pgd_t pgd)
	289	{
	290	if (pgd_huge(pgd))
	291	return pte_page(pgd_pte(pgd));
	292	return virt_to_page(pgd_page_vaddr(pgd));
	293	}
	294	#endif
	295
	296	struct page *pud_page(pud_t pud)
	297	{
	298	if (pud_huge(pud))
	299	return pte_page(pud_pte(pud));
	300	return virt_to_page(pud_page_vaddr(pud));
	301	}
	302
074c2eae AK	303	/*
	304	* For hugepage we have pfn in the pmd, we use PTE_RPN_SHIFT bits for flags
	305	* For PTE page, we have a PTE_FRAG_SIZE (4K) aligned virtual address.
	306	*/
	307	struct page *pmd_page(pmd_t pmd)
	308	{
ebd31197	309	if (pmd_trans_huge(pmd) \|\| pmd_huge(pmd) \|\| pmd_devmap(pmd))
e34aa03c	310	return pte_page(pmd_pte(pmd));
074c2eae AK	311	return virt_to_page(pmd_page_vaddr(pmd));
	312	}
	313
cd65d697 BS	314	#ifdef CONFIG_STRICT_KERNEL_RWX
	315	void mark_rodata_ro(void)
	316	{
	317	if (!mmu_has_feature(MMU_FTR_KERNEL_RO)) {
	318	pr_warn("Warning: Unable to mark rodata read only on this CPU.\n");
	319	return;
	320	}
	321
7614ff32 BS	322	if (radix_enabled())
	323	radix__mark_rodata_ro();
	324	else
cd65d697 BS	325	hash__mark_rodata_ro();
cd65d697 BS	326	}
029d9252 ME	327
	328	void mark_initmem_nx(void)
	329	{
	330	if (radix_enabled())
	331	radix__mark_initmem_nx();
	332	else
	333	hash__mark_initmem_nx();
	334	}
cd65d697	335	#endif