[deliverable/linux.git] / include / asm-arm / memory.h

/*
 *  linux/include/asm-arm/memory.h
 *
 *  Copyright (C) 2000-2002 Russell King
 *  modification for nommu, Hyok S. Choi, 2004
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *  Note: this file should not be included by non-asm/.h files
 */
#ifndef __ASM_ARM_MEMORY_H
#define __ASM_ARM_MEMORY_H

/*
 * Allow for constants defined here to be used from assembly code
 * by prepending the UL suffix only with actual C code compilation.
 */
#ifndef __ASSEMBLY__
#define UL(x) (x##UL)
#else
#define UL(x) (x)
#endif

#include <linux/compiler.h>
#include <asm/arch/memory.h>
#include <asm/sizes.h>

#ifdef CONFIG_MMU

#ifndef TASK_SIZE
/*
 * TASK_SIZE - the maximum size of a user space task.
 * TASK_UNMAPPED_BASE - the lower boundary of the mmap VM area
 */
#define TASK_SIZE		UL(0xbf000000)
#define TASK_UNMAPPED_BASE	UL(0x40000000)
#endif

/*
 * The maximum size of a 26-bit user space task.
 */
#define TASK_SIZE_26		UL(0x04000000)

/*
 * Page offset: 3GB
 */
#ifndef PAGE_OFFSET
#define PAGE_OFFSET		UL(0xc0000000)
#endif

/*
 * The module space lives between the addresses given by TASK_SIZE
 * and PAGE_OFFSET - it must be within 32MB of the kernel text.
 */
#define MODULE_END		(PAGE_OFFSET)
#define MODULE_START		(MODULE_END - 16*1048576)

#if TASK_SIZE > MODULE_START
#error Top of user space clashes with start of module space
#endif

/*
 * The XIP kernel gets mapped at the bottom of the module vm area.
 * Since we use sections to map it, this macro replaces the physical address
 * with its virtual address while keeping offset from the base section.
 */
#define XIP_VIRT_ADDR(physaddr)  (MODULE_START + ((physaddr) & 0x000fffff))

/*
 * Allow 16MB-aligned ioremap pages
 */
#define IOREMAP_MAX_ORDER	24

#else /* CONFIG_MMU */

/*
 * The limitation of user task size can grow up to the end of free ram region.
 * It is difficult to define and perhaps will never meet the original meaning
 * of this define that was meant to.
 * Fortunately, there is no reference for this in noMMU mode, for now.
 */
#ifndef TASK_SIZE
#define TASK_SIZE		(CONFIG_DRAM_SIZE)
#endif

#ifndef TASK_UNMAPPED_BASE
#define TASK_UNMAPPED_BASE	UL(0x00000000)
#endif

#ifndef PHYS_OFFSET
#define PHYS_OFFSET 		(CONFIG_DRAM_BASE)
#endif

#ifndef END_MEM
#define END_MEM     		(CONFIG_DRAM_BASE + CONFIG_DRAM_SIZE)
#endif

#ifndef PAGE_OFFSET
#define PAGE_OFFSET		(PHYS_OFFSET)
#endif

/*
 * The module can be at any place in ram in nommu mode.
 */
#define MODULE_END		(END_MEM)
#define MODULE_START		(PHYS_OFFSET)

#endif /* !CONFIG_MMU */

/*
 * Size of DMA-consistent memory region.  Must be multiple of 2M,
 * between 2MB and 14MB inclusive.
 */
#ifndef CONSISTENT_DMA_SIZE
#define CONSISTENT_DMA_SIZE SZ_2M
#endif

/*
 * Physical vs virtual RAM address space conversion.  These are
 * private definitions which should NOT be used outside memory.h
 * files.  Use virt_to_phys/phys_to_virt/__pa/__va instead.
 */
#ifndef __virt_to_phys
#define __virt_to_phys(x)	((x) - PAGE_OFFSET + PHYS_OFFSET)
#define __phys_to_virt(x)	((x) - PHYS_OFFSET + PAGE_OFFSET)
#endif

/*
 * Convert a physical address to a Page Frame Number and back
 */
#define	__phys_to_pfn(paddr)	((paddr) >> PAGE_SHIFT)
#define	__pfn_to_phys(pfn)	((pfn) << PAGE_SHIFT)

#ifndef __ASSEMBLY__

/*
 * The DMA mask corresponding to the maximum bus address allocatable
 * using GFP_DMA.  The default here places no restriction on DMA
 * allocations.  This must be the smallest DMA mask in the system,
 * so a successful GFP_DMA allocation will always satisfy this.
 */
#ifndef ISA_DMA_THRESHOLD
#define ISA_DMA_THRESHOLD	(0xffffffffULL)
#endif

#ifndef arch_adjust_zones
#define arch_adjust_zones(node,size,holes) do { } while (0)
#endif

/*
 * PFNs are used to describe any physical page; this means
 * PFN 0 == physical address 0.
 *
 * This is the PFN of the first RAM page in the kernel
 * direct-mapped view.  We assume this is the first page
 * of RAM in the mem_map as well.
 */
#define PHYS_PFN_OFFSET	(PHYS_OFFSET >> PAGE_SHIFT)

/*
 * These are *only* valid on the kernel direct mapped RAM memory.
 * Note: Drivers should NOT use these.  They are the wrong
 * translation for translating DMA addresses.  Use the driver
 * DMA support - see dma-mapping.h.
 */
static inline unsigned long virt_to_phys(void *x)
{
	return __virt_to_phys((unsigned long)(x));
}

static inline void *phys_to_virt(unsigned long x)
{
	return (void *)(__phys_to_virt((unsigned long)(x)));
}

/*
 * Drivers should NOT use these either.
 */
#define __pa(x)			__virt_to_phys((unsigned long)(x))
#define __va(x)			((void *)__phys_to_virt((unsigned long)(x)))
#define pfn_to_kaddr(pfn)	__va((pfn) << PAGE_SHIFT)

/*
 * Virtual <-> DMA view memory address translations
 * Again, these are *only* valid on the kernel direct mapped RAM
 * memory.  Use of these is *deprecated* (and that doesn't mean
 * use the __ prefixed forms instead.)  See dma-mapping.h.
 */
static inline __deprecated unsigned long virt_to_bus(void *x)
{
	return __virt_to_bus((unsigned long)x);
}

static inline __deprecated void *bus_to_virt(unsigned long x)
{
	return (void *)__bus_to_virt(x);
}

/*
 * Conversion between a struct page and a physical address.
 *
 * Note: when converting an unknown physical address to a
 * struct page, the resulting pointer must be validated
 * using VALID_PAGE().  It must return an invalid struct page
 * for any physical address not corresponding to a system
 * RAM address.
 *
 *  page_to_pfn(page)	convert a struct page * to a PFN number
 *  pfn_to_page(pfn)	convert a _valid_ PFN number to struct page *
 *  pfn_valid(pfn)	indicates whether a PFN number is valid
 *
 *  virt_to_page(k)	convert a _valid_ virtual address to struct page *
 *  virt_addr_valid(k)	indicates whether a virtual address is valid
 */
#ifndef CONFIG_DISCONTIGMEM

#define ARCH_PFN_OFFSET		PHYS_PFN_OFFSET

#ifndef CONFIG_SPARSEMEM
#define pfn_valid(pfn)		((pfn) >= PHYS_PFN_OFFSET && (pfn) < (PHYS_PFN_OFFSET + max_mapnr))
#endif

#define virt_to_page(kaddr)	pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
#define virt_addr_valid(kaddr)	((unsigned long)(kaddr) >= PAGE_OFFSET && (unsigned long)(kaddr) < (unsigned long)high_memory)

#define PHYS_TO_NID(addr)	(0)

#else /* CONFIG_DISCONTIGMEM */

/*
 * This is more complex.  We have a set of mem_map arrays spread
 * around in memory.
 */
#include <linux/numa.h>

#define arch_pfn_to_nid(pfn)	PFN_TO_NID(pfn)
#define arch_local_page_offset(pfn, nid) LOCAL_MAP_NR((pfn) << PAGE_SHIFT)

#define pfn_valid(pfn)						\
	({							\
		unsigned int nid = PFN_TO_NID(pfn);		\
		int valid = nid < MAX_NUMNODES;			\
		if (valid) {					\
			pg_data_t *node = NODE_DATA(nid);	\
			valid = (pfn - node->node_start_pfn) <	\
				node->node_spanned_pages;	\
		}						\
		valid;						\
	})

#define virt_to_page(kaddr)					\
	(ADDR_TO_MAPBASE(kaddr) + LOCAL_MAP_NR(kaddr))

#define virt_addr_valid(kaddr)	(KVADDR_TO_NID(kaddr) < MAX_NUMNODES)

/*
 * Common discontigmem stuff.
 *  PHYS_TO_NID is used by the ARM kernel/setup.c
 */
#define PHYS_TO_NID(addr)	PFN_TO_NID((addr) >> PAGE_SHIFT)

/*
 * Given a kaddr, ADDR_TO_MAPBASE finds the owning node of the memory
 * and returns the mem_map of that node.
 */
#define ADDR_TO_MAPBASE(kaddr)	NODE_MEM_MAP(KVADDR_TO_NID(kaddr))

/*
 * Given a page frame number, find the owning node of the memory
 * and returns the mem_map of that node.
 */
#define PFN_TO_MAPBASE(pfn)	NODE_MEM_MAP(PFN_TO_NID(pfn))

#ifdef NODE_MEM_SIZE_BITS
#define NODE_MEM_SIZE_MASK	((1 << NODE_MEM_SIZE_BITS) - 1)

/*
 * Given a kernel address, find the home node of the underlying memory.
 */
#define KVADDR_TO_NID(addr) \
	(((unsigned long)(addr) - PAGE_OFFSET) >> NODE_MEM_SIZE_BITS)

/*
 * Given a page frame number, convert it to a node id.
 */
#define PFN_TO_NID(pfn) \
	(((pfn) - PHYS_PFN_OFFSET) >> (NODE_MEM_SIZE_BITS - PAGE_SHIFT))

/*
 * Given a kaddr, LOCAL_MEM_MAP finds the owning node of the memory
 * and returns the index corresponding to the appropriate page in the
 * node's mem_map.
 */
#define LOCAL_MAP_NR(addr) \
	(((unsigned long)(addr) & NODE_MEM_SIZE_MASK) >> PAGE_SHIFT)

#endif /* NODE_MEM_SIZE_BITS */

#endif /* !CONFIG_DISCONTIGMEM */

/*
 * For BIO.  "will die".  Kill me when bio_to_phys() and bvec_to_phys() die.
 */
#define page_to_phys(page)	(page_to_pfn(page) << PAGE_SHIFT)

/*
 * Optional device DMA address remapping. Do _not_ use directly!
 * We should really eliminate virt_to_bus() here - it's deprecated.
 */
#ifndef __arch_page_to_dma
#define page_to_dma(dev, page)		((dma_addr_t)__virt_to_bus((unsigned long)page_address(page)))
#define dma_to_virt(dev, addr)		((void *)__bus_to_virt(addr))
#define virt_to_dma(dev, addr)		((dma_addr_t)__virt_to_bus((unsigned long)(addr)))
#else
#define page_to_dma(dev, page)		(__arch_page_to_dma(dev, page))
#define dma_to_virt(dev, addr)		(__arch_dma_to_virt(dev, addr))
#define virt_to_dma(dev, addr)		(__arch_virt_to_dma(dev, addr))
#endif

/*
 * Optional coherency support.  Currently used only by selected
 * Intel XSC3-based systems.
 */
#ifndef arch_is_coherent
#define arch_is_coherent()		0
#endif

#endif

#include <asm-generic/memory_model.h>

#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/include/asm-arm/memory.h
	3	*
	4	* Copyright (C) 2000-2002 Russell King
002547b4	5	* modification for nommu, Hyok S. Choi, 2004
1da177e4 LT	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* Note: this file should not be included by non-asm/.h files
	12	*/
	13	#ifndef __ASM_ARM_MEMORY_H
	14	#define __ASM_ARM_MEMORY_H
	15
f09b9979 NP	16	/*
	17	* Allow for constants defined here to be used from assembly code
	18	* by prepending the UL suffix only with actual C code compilation.
	19	*/
	20	#ifndef __ASSEMBLY__
	21	#define UL(x) (x##UL)
	22	#else
	23	#define UL(x) (x)
	24	#endif
	25
1da177e4 LT	26	#include <linux/compiler.h>
1da177e4 LT	27	#include <asm/arch/memory.h>
37134cd5	28	#include <asm/sizes.h>
1da177e4	29
002547b4 RK	30	#ifdef CONFIG_MMU
002547b4 RK	31
1da177e4 LT	32	#ifndef TASK_SIZE
	33	/*
	34	* TASK_SIZE - the maximum size of a user space task.
	35	* TASK_UNMAPPED_BASE - the lower boundary of the mmap VM area
	36	*/
f09b9979 NP	37	#define TASK_SIZE UL(0xbf000000)
f09b9979 NP	38	#define TASK_UNMAPPED_BASE UL(0x40000000)
1da177e4 LT	39	#endif
	40
	41	/*
	42	* The maximum size of a 26-bit user space task.
	43	*/
f09b9979	44	#define TASK_SIZE_26 UL(0x04000000)
1da177e4 LT	45
	46	/*
	47	* Page offset: 3GB
	48	*/
	49	#ifndef PAGE_OFFSET
f09b9979	50	#define PAGE_OFFSET UL(0xc0000000)
1da177e4 LT	51	#endif
1da177e4 LT	52
002547b4 RK	53	/*
	54	* The module space lives between the addresses given by TASK_SIZE
	55	* and PAGE_OFFSET - it must be within 32MB of the kernel text.
	56	*/
	57	#define MODULE_END (PAGE_OFFSET)
	58	#define MODULE_START (MODULE_END - 16*1048576)
	59
	60	#if TASK_SIZE > MODULE_START
	61	#error Top of user space clashes with start of module space
	62	#endif
	63
	64	/*
	65	* The XIP kernel gets mapped at the bottom of the module vm area.
	66	* Since we use sections to map it, this macro replaces the physical address
	67	* with its virtual address while keeping offset from the base section.
	68	*/
	69	#define XIP_VIRT_ADDR(physaddr) (MODULE_START + ((physaddr) & 0x000fffff))
	70
ff0daca5	71	/*
a069c896	72	* Allow 16MB-aligned ioremap pages
ff0daca5	73	*/
a069c896	74	#define IOREMAP_MAX_ORDER 24
ff0daca5	75
002547b4 RK	76	#else /* CONFIG_MMU */
	77
	78	/*
	79	* The limitation of user task size can grow up to the end of free ram region.
	80	* It is difficult to define and perhaps will never meet the original meaning
	81	* of this define that was meant to.
	82	* Fortunately, there is no reference for this in noMMU mode, for now.
	83	*/
	84	#ifndef TASK_SIZE
	85	#define TASK_SIZE (CONFIG_DRAM_SIZE)
	86	#endif
	87
	88	#ifndef TASK_UNMAPPED_BASE
	89	#define TASK_UNMAPPED_BASE UL(0x00000000)
	90	#endif
	91
	92	#ifndef PHYS_OFFSET
	93	#define PHYS_OFFSET (CONFIG_DRAM_BASE)
	94	#endif
	95
	96	#ifndef END_MEM
	97	#define END_MEM (CONFIG_DRAM_BASE + CONFIG_DRAM_SIZE)
	98	#endif
	99
	100	#ifndef PAGE_OFFSET
	101	#define PAGE_OFFSET (PHYS_OFFSET)
	102	#endif
	103
	104	/*
	105	* The module can be at any place in ram in nommu mode.
	106	*/
	107	#define MODULE_END (END_MEM)
	108	#define MODULE_START (PHYS_OFFSET)
	109
	110	#endif /* !CONFIG_MMU */
	111
37134cd5 KH	112	/*
	113	* Size of DMA-consistent memory region. Must be multiple of 2M,
	114	* between 2MB and 14MB inclusive.
	115	*/
	116	#ifndef CONSISTENT_DMA_SIZE
	117	#define CONSISTENT_DMA_SIZE SZ_2M
	118	#endif
	119
1da177e4 LT	120	/*
	121	* Physical vs virtual RAM address space conversion. These are
	122	* private definitions which should NOT be used outside memory.h
	123	* files. Use virt_to_phys/phys_to_virt/__pa/__va instead.
	124	*/
	125	#ifndef __virt_to_phys
	126	#define __virt_to_phys(x) ((x) - PAGE_OFFSET + PHYS_OFFSET)
	127	#define __phys_to_virt(x) ((x) - PHYS_OFFSET + PAGE_OFFSET)
	128	#endif
	129
9d4ae727 DS	130	/*
	131	* Convert a physical address to a Page Frame Number and back
	132	*/
	133	#define __phys_to_pfn(paddr) ((paddr) >> PAGE_SHIFT)
	134	#define __pfn_to_phys(pfn) ((pfn) << PAGE_SHIFT)
	135
1da177e4 LT	136	#ifndef __ASSEMBLY__
	137
	138	/*
	139	* The DMA mask corresponding to the maximum bus address allocatable
	140	* using GFP_DMA. The default here places no restriction on DMA
	141	* allocations. This must be the smallest DMA mask in the system,
	142	* so a successful GFP_DMA allocation will always satisfy this.
	143	*/
	144	#ifndef ISA_DMA_THRESHOLD
	145	#define ISA_DMA_THRESHOLD (0xffffffffULL)
	146	#endif
	147
	148	#ifndef arch_adjust_zones
	149	#define arch_adjust_zones(node,size,holes) do { } while (0)
	150	#endif
	151
	152	/*
	153	* PFNs are used to describe any physical page; this means
	154	* PFN 0 == physical address 0.
	155	*
	156	* This is the PFN of the first RAM page in the kernel
	157	* direct-mapped view. We assume this is the first page
	158	* of RAM in the mem_map as well.
	159	*/
	160	#define PHYS_PFN_OFFSET (PHYS_OFFSET >> PAGE_SHIFT)
	161
	162	/*
	163	* These are only valid on the kernel direct mapped RAM memory.
	164	* Note: Drivers should NOT use these. They are the wrong
	165	* translation for translating DMA addresses. Use the driver
	166	* DMA support - see dma-mapping.h.
	167	*/
	168	static inline unsigned long virt_to_phys(void *x)
	169	{
	170	return __virt_to_phys((unsigned long)(x));
	171	}
	172
	173	static inline void *phys_to_virt(unsigned long x)
	174	{
	175	return (void *)(__phys_to_virt((unsigned long)(x)));
	176	}
	177
	178	/*
	179	* Drivers should NOT use these either.
	180	*/
	181	#define __pa(x) __virt_to_phys((unsigned long)(x))
	182	#define __va(x) ((void *)__phys_to_virt((unsigned long)(x)))
31a5539e	183	#define pfn_to_kaddr(pfn) __va((pfn) << PAGE_SHIFT)
1da177e4 LT	184
	185	/*
	186	* Virtual <-> DMA view memory address translations
	187	* Again, these are only valid on the kernel direct mapped RAM
	188	* memory. Use of these is deprecated (and that doesn't mean
	189	* use the __ prefixed forms instead.) See dma-mapping.h.
	190	*/
	191	static inline __deprecated unsigned long virt_to_bus(void *x)
	192	{
	193	return __virt_to_bus((unsigned long)x);
	194	}
	195
	196	static inline __deprecated void *bus_to_virt(unsigned long x)
	197	{
	198	return (void *)__bus_to_virt(x);
	199	}
	200
	201	/*
	202	* Conversion between a struct page and a physical address.
	203	*
	204	* Note: when converting an unknown physical address to a
	205	* struct page, the resulting pointer must be validated
	206	* using VALID_PAGE(). It must return an invalid struct page
	207	* for any physical address not corresponding to a system
	208	* RAM address.
	209	*
	210	* page_to_pfn(page) convert a struct page * to a PFN number
	211	* pfn_to_page(pfn) convert a _valid_ PFN number to struct page *
	212	* pfn_valid(pfn) indicates whether a PFN number is valid
	213	*
	214	* virt_to_page(k) convert a _valid_ virtual address to struct page *
	215	* virt_addr_valid(k) indicates whether a virtual address is valid
	216	*/
	217	#ifndef CONFIG_DISCONTIGMEM
b7dc96d7	218
7d129637	219	#define ARCH_PFN_OFFSET PHYS_PFN_OFFSET
05944d74 RK	220
05944d74 RK	221	#ifndef CONFIG_SPARSEMEM
1da177e4	222	#define pfn_valid(pfn) ((pfn) >= PHYS_PFN_OFFSET && (pfn) < (PHYS_PFN_OFFSET + max_mapnr))
05944d74	223	#endif
1da177e4	224
7d129637	225	#define virt_to_page(kaddr) pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
1da177e4 LT	226	#define virt_addr_valid(kaddr) ((unsigned long)(kaddr) >= PAGE_OFFSET && (unsigned long)(kaddr) < (unsigned long)high_memory)
	227
	228	#define PHYS_TO_NID(addr) (0)
	229
	230	#else /* CONFIG_DISCONTIGMEM */
	231
	232	/*
	233	* This is more complex. We have a set of mem_map arrays spread
	234	* around in memory.
	235	*/
	236	#include <linux/numa.h>
b7dc96d7	237
7d129637	238	#define arch_pfn_to_nid(pfn) PFN_TO_NID(pfn)
0da32350	239	#define arch_local_page_offset(pfn, nid) LOCAL_MAP_NR((pfn) << PAGE_SHIFT)
1b3cb73f RK	240
	241	#define pfn_valid(pfn) \
	242	({ \
	243	unsigned int nid = PFN_TO_NID(pfn); \
	244	int valid = nid < MAX_NUMNODES; \
	245	if (valid) { \
	246	pg_data_t *node = NODE_DATA(nid); \
	247	valid = (pfn - node->node_start_pfn) < \
	248	node->node_spanned_pages; \
	249	} \
	250	valid; \
	251	})
1da177e4 LT	252
	253	#define virt_to_page(kaddr) \
	254	(ADDR_TO_MAPBASE(kaddr) + LOCAL_MAP_NR(kaddr))
1b3cb73f	255
1da177e4 LT	256	#define virt_addr_valid(kaddr) (KVADDR_TO_NID(kaddr) < MAX_NUMNODES)
	257
	258	/*
	259	* Common discontigmem stuff.
	260	* PHYS_TO_NID is used by the ARM kernel/setup.c
	261	*/
	262	#define PHYS_TO_NID(addr) PFN_TO_NID((addr) >> PAGE_SHIFT)
	263
b7dc96d7 RK	264	/*
	265	* Given a kaddr, ADDR_TO_MAPBASE finds the owning node of the memory
	266	* and returns the mem_map of that node.
	267	*/
	268	#define ADDR_TO_MAPBASE(kaddr) NODE_MEM_MAP(KVADDR_TO_NID(kaddr))
	269
	270	/*
	271	* Given a page frame number, find the owning node of the memory
	272	* and returns the mem_map of that node.
	273	*/
	274	#define PFN_TO_MAPBASE(pfn) NODE_MEM_MAP(PFN_TO_NID(pfn))
	275
	276	#ifdef NODE_MEM_SIZE_BITS
	277	#define NODE_MEM_SIZE_MASK ((1 << NODE_MEM_SIZE_BITS) - 1)
	278
	279	/*
	280	* Given a kernel address, find the home node of the underlying memory.
	281	*/
	282	#define KVADDR_TO_NID(addr) \
	283	(((unsigned long)(addr) - PAGE_OFFSET) >> NODE_MEM_SIZE_BITS)
	284
	285	/*
	286	* Given a page frame number, convert it to a node id.
	287	*/
	288	#define PFN_TO_NID(pfn) \
	289	(((pfn) - PHYS_PFN_OFFSET) >> (NODE_MEM_SIZE_BITS - PAGE_SHIFT))
	290
	291	/*
	292	* Given a kaddr, LOCAL_MEM_MAP finds the owning node of the memory
	293	* and returns the index corresponding to the appropriate page in the
	294	* node's mem_map.
	295	*/
	296	#define LOCAL_MAP_NR(addr) \
	297	(((unsigned long)(addr) & NODE_MEM_SIZE_MASK) >> PAGE_SHIFT)
	298
	299	#endif /* NODE_MEM_SIZE_BITS */
	300
1da177e4 LT	301	#endif /* !CONFIG_DISCONTIGMEM */
	302
	303	/*
	304	* For BIO. "will die". Kill me when bio_to_phys() and bvec_to_phys() die.
	305	*/
	306	#define page_to_phys(page) (page_to_pfn(page) << PAGE_SHIFT)
	307
	308	/*
	309	* Optional device DMA address remapping. Do _not_ use directly!
	310	* We should really eliminate virt_to_bus() here - it's deprecated.
	311	*/
	312	#ifndef __arch_page_to_dma
	313	#define page_to_dma(dev, page) ((dma_addr_t)__virt_to_bus((unsigned long)page_address(page)))
	314	#define dma_to_virt(dev, addr) ((void *)__bus_to_virt(addr))
	315	#define virt_to_dma(dev, addr) ((dma_addr_t)__virt_to_bus((unsigned long)(addr)))
	316	#else
	317	#define page_to_dma(dev, page) (__arch_page_to_dma(dev, page))
	318	#define dma_to_virt(dev, addr) (__arch_dma_to_virt(dev, addr))
	319	#define virt_to_dma(dev, addr) (__arch_virt_to_dma(dev, addr))
	320	#endif
	321
23759dc6 LB	322	/*
	323	* Optional coherency support. Currently used only by selected
	324	* Intel XSC3-based systems.
	325	*/
	326	#ifndef arch_is_coherent
	327	#define arch_is_coherent() 0
	328	#endif
	329
1da177e4 LT	330	#endif
1da177e4 LT	331
7eb98a2f KH	332	#include <asm-generic/memory_model.h>
7eb98a2f KH	333
1da177e4	334	#endif