[deliverable/linux.git] / arch / powerpc / include / asm / highmem.h

/*
 * highmem.h: virtual kernel memory mappings for high memory
 *
 * PowerPC version, stolen from the i386 version.
 *
 * Used in CONFIG_HIGHMEM systems for memory pages which
 * are not addressable by direct kernel virtual addresses.
 *
 * Copyright (C) 1999 Gerhard Wichert, Siemens AG
 *		      Gerhard.Wichert@pdb.siemens.de
 *
 *
 * Redesigned the x86 32-bit VM architecture to deal with
 * up to 16 Terrabyte physical memory. With current x86 CPUs
 * we now support up to 64 Gigabytes physical RAM.
 *
 * Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
 */

#ifndef _ASM_HIGHMEM_H
#define _ASM_HIGHMEM_H

#ifdef __KERNEL__

#include <linux/init.h>
#include <linux/interrupt.h>
#include <asm/kmap_types.h>
#include <asm/tlbflush.h>
#include <asm/page.h>
#include <asm/fixmap.h>

extern pte_t *kmap_pte;
extern pgprot_t kmap_prot;
extern pte_t *pkmap_page_table;

/*
 * Right now we initialize only a single pte table. It can be extended
 * easily, subsequent pte tables have to be allocated in one physical
 * chunk of RAM.
 */
/*
 * We use one full pte table with 4K pages. And with 16K/64K pages pte
 * table covers enough memory (32MB and 512MB resp.) that both FIXMAP
 * and PKMAP can be placed in single pte table. We use 1024 pages for
 * PKMAP in case of 16K/64K pages.
 */
#ifdef CONFIG_PPC_4K_PAGES
#define PKMAP_ORDER	PTE_SHIFT
#else
#define PKMAP_ORDER	10
#endif
#define LAST_PKMAP	(1 << PKMAP_ORDER)
#ifndef CONFIG_PPC_4K_PAGES
#define PKMAP_BASE	(FIXADDR_START - PAGE_SIZE*(LAST_PKMAP + 1))
#else
#define PKMAP_BASE	((FIXADDR_START - PAGE_SIZE*(LAST_PKMAP + 1)) & PMD_MASK)
#endif
#define LAST_PKMAP_MASK	(LAST_PKMAP-1)
#define PKMAP_NR(virt)  ((virt-PKMAP_BASE) >> PAGE_SHIFT)
#define PKMAP_ADDR(nr)  (PKMAP_BASE + ((nr) << PAGE_SHIFT))

extern void *kmap_high(struct page *page);
extern void kunmap_high(struct page *page);

static inline void *kmap(struct page *page)
{
	might_sleep();
	if (!PageHighMem(page))
		return page_address(page);
	return kmap_high(page);
}

static inline void kunmap(struct page *page)
{
	BUG_ON(in_interrupt());
	if (!PageHighMem(page))
		return;
	kunmap_high(page);
}

/*
 * The use of kmap_atomic/kunmap_atomic is discouraged - kmap/kunmap
 * gives a more generic (and caching) interface. But kmap_atomic can
 * be used in IRQ contexts, so in some (very limited) cases we need
 * it.
 */
static inline void *kmap_atomic_prot(struct page *page, enum km_type type, pgprot_t prot)
{
	unsigned int idx;
	unsigned long vaddr;

	/* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */
	pagefault_disable();
	if (!PageHighMem(page))
		return page_address(page);

	idx = type + KM_TYPE_NR*smp_processor_id();
	vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
#ifdef CONFIG_DEBUG_HIGHMEM
	BUG_ON(!pte_none(*(kmap_pte-idx)));
#endif
	__set_pte_at(&init_mm, vaddr, kmap_pte-idx, mk_pte(page, prot), 1);
	local_flush_tlb_page(NULL, vaddr);

	return (void*) vaddr;
}

static inline void *kmap_atomic(struct page *page, enum km_type type)
{
	return kmap_atomic_prot(page, type, kmap_prot);
}

static inline void kunmap_atomic(void *kvaddr, enum km_type type)
{
#ifdef CONFIG_DEBUG_HIGHMEM
	unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
	enum fixed_addresses idx = type + KM_TYPE_NR*smp_processor_id();

	if (vaddr < __fix_to_virt(FIX_KMAP_END)) {
		pagefault_enable();
		return;
	}

	BUG_ON(vaddr != __fix_to_virt(FIX_KMAP_BEGIN + idx));

	/*
	 * force other mappings to Oops if they'll try to access
	 * this pte without first remap it
	 */
	pte_clear(&init_mm, vaddr, kmap_pte-idx);
	local_flush_tlb_page(NULL, vaddr);
#endif
	pagefault_enable();
}

static inline struct page *kmap_atomic_to_page(void *ptr)
{
	unsigned long idx, vaddr = (unsigned long) ptr;
	pte_t *pte;

	if (vaddr < FIXADDR_START)
		return virt_to_page(ptr);

	idx = virt_to_fix(vaddr);
	pte = kmap_pte - (idx - FIX_KMAP_BEGIN);
	return pte_page(*pte);
}

#define flush_cache_kmaps()	flush_cache_all()

#endif /* __KERNEL__ */

#endif /* _ASM_HIGHMEM_H */
Commit	Line	Data
33d71d26 KG	1	/*
	2	* highmem.h: virtual kernel memory mappings for high memory
	3	*
	4	* PowerPC version, stolen from the i386 version.
	5	*
	6	* Used in CONFIG_HIGHMEM systems for memory pages which
	7	* are not addressable by direct kernel virtual addresses.
	8	*
	9	* Copyright (C) 1999 Gerhard Wichert, Siemens AG
	10	* Gerhard.Wichert@pdb.siemens.de
	11	*
	12	*
	13	* Redesigned the x86 32-bit VM architecture to deal with
	14	* up to 16 Terrabyte physical memory. With current x86 CPUs
	15	* we now support up to 64 Gigabytes physical RAM.
	16	*
	17	* Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
	18	*/
	19
	20	#ifndef _ASM_HIGHMEM_H
	21	#define _ASM_HIGHMEM_H
	22
	23	#ifdef __KERNEL__
	24
	25	#include <linux/init.h>
	26	#include <linux/interrupt.h>
	27	#include <asm/kmap_types.h>
	28	#include <asm/tlbflush.h>
	29	#include <asm/page.h>
2c419bde	30	#include <asm/fixmap.h>
33d71d26 KG	31
	32	extern pte_t *kmap_pte;
	33	extern pgprot_t kmap_prot;
	34	extern pte_t *pkmap_page_table;
	35
	36	/*
	37	* Right now we initialize only a single pte table. It can be extended
	38	* easily, subsequent pte tables have to be allocated in one physical
	39	* chunk of RAM.
	40	*/
ca9153a3 IY	41	/*
	42	* We use one full pte table with 4K pages. And with 16K/64K pages pte
	43	* table covers enough memory (32MB and 512MB resp.) that both FIXMAP
	44	* and PKMAP can be placed in single pte table. We use 1024 pages for
	45	* PKMAP in case of 16K/64K pages.
	46	*/
	47	#ifdef CONFIG_PPC_4K_PAGES
	48	#define PKMAP_ORDER PTE_SHIFT
	49	#else
	50	#define PKMAP_ORDER 10
	51	#endif
	52	#define LAST_PKMAP (1 << PKMAP_ORDER)
	53	#ifndef CONFIG_PPC_4K_PAGES
	54	#define PKMAP_BASE (FIXADDR_START - PAGE_SIZE*(LAST_PKMAP + 1))
	55	#else
2c419bde	56	#define PKMAP_BASE ((FIXADDR_START - PAGE_SIZE*(LAST_PKMAP + 1)) & PMD_MASK)
ca9153a3 IY	57	#endif
ca9153a3 IY	58	#define LAST_PKMAP_MASK (LAST_PKMAP-1)
33d71d26 KG	59	#define PKMAP_NR(virt) ((virt-PKMAP_BASE) >> PAGE_SHIFT)
	60	#define PKMAP_ADDR(nr) (PKMAP_BASE + ((nr) << PAGE_SHIFT))
	61
33d71d26 KG	62	extern void kmap_high(struct page page);
	63	extern void kunmap_high(struct page *page);
	64
	65	static inline void kmap(struct page page)
	66	{
	67	might_sleep();
	68	if (!PageHighMem(page))
	69	return page_address(page);
	70	return kmap_high(page);
	71	}
	72
	73	static inline void kunmap(struct page *page)
	74	{
	75	BUG_ON(in_interrupt());
	76	if (!PageHighMem(page))
	77	return;
	78	kunmap_high(page);
	79	}
	80
	81	/*
	82	* The use of kmap_atomic/kunmap_atomic is discouraged - kmap/kunmap
	83	* gives a more generic (and caching) interface. But kmap_atomic can
	84	* be used in IRQ contexts, so in some (very limited) cases we need
	85	* it.
	86	*/
2c419bde	87	static inline void kmap_atomic_prot(struct page page, enum km_type type, pgprot_t prot)
33d71d26 KG	88	{
	89	unsigned int idx;
	90	unsigned long vaddr;
	91
	92	/* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */
	93	pagefault_disable();
	94	if (!PageHighMem(page))
	95	return page_address(page);
	96
	97	idx = type + KM_TYPE_NR*smp_processor_id();
2c419bde KG	98	vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
	99	#ifdef CONFIG_DEBUG_HIGHMEM
	100	BUG_ON(!pte_none(*(kmap_pte-idx)));
33d71d26	101	#endif
8d30c14c	102	__set_pte_at(&init_mm, vaddr, kmap_pte-idx, mk_pte(page, prot), 1);
f048aace	103	local_flush_tlb_page(NULL, vaddr);
33d71d26 KG	104
	105	return (void*) vaddr;
	106	}
	107
2c419bde KG	108	static inline void kmap_atomic(struct page page, enum km_type type)
	109	{
	110	return kmap_atomic_prot(page, type, kmap_prot);
	111	}
	112
33d71d26 KG	113	static inline void kunmap_atomic(void *kvaddr, enum km_type type)
33d71d26 KG	114	{
2c419bde	115	#ifdef CONFIG_DEBUG_HIGHMEM
33d71d26	116	unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
2c419bde	117	enum fixed_addresses idx = type + KM_TYPE_NR*smp_processor_id();
33d71d26	118
2c419bde	119	if (vaddr < __fix_to_virt(FIX_KMAP_END)) {
33d71d26 KG	120	pagefault_enable();
	121	return;
	122	}
	123
2c419bde	124	BUG_ON(vaddr != __fix_to_virt(FIX_KMAP_BEGIN + idx));
33d71d26 KG	125
	126	/*
	127	* force other mappings to Oops if they'll try to access
	128	* this pte without first remap it
	129	*/
2c419bde	130	pte_clear(&init_mm, vaddr, kmap_pte-idx);
f048aace	131	local_flush_tlb_page(NULL, vaddr);
33d71d26 KG	132	#endif
	133	pagefault_enable();
	134	}
	135
	136	static inline struct page kmap_atomic_to_page(void ptr)
	137	{
	138	unsigned long idx, vaddr = (unsigned long) ptr;
2c419bde	139	pte_t *pte;
33d71d26	140
2c419bde	141	if (vaddr < FIXADDR_START)
33d71d26 KG	142	return virt_to_page(ptr);
33d71d26 KG	143
2c419bde KG	144	idx = virt_to_fix(vaddr);
	145	pte = kmap_pte - (idx - FIX_KMAP_BEGIN);
	146	return pte_page(*pte);
33d71d26 KG	147	}
	148
	149	#define flush_cache_kmaps() flush_cache_all()
	150
	151	#endif /* __KERNEL__ */
	152
	153	#endif /* _ASM_HIGHMEM_H */