[linux.git] / Documentation / io-mapping.txt

========================
The io_mapping functions
========================

API
===

The io_mapping functions in linux/io-mapping.h provide an abstraction for
efficiently mapping small regions of an I/O device to the CPU. The initial
usage is to support the large graphics aperture on 32-bit processors where
ioremap_wc cannot be used to statically map the entire aperture to the CPU
as it would consume too much of the kernel address space.

A mapping object is created during driver initialization using::

	struct io_mapping *io_mapping_create_wc(unsigned long base,
						unsigned long size)

'base' is the bus address of the region to be made
mappable, while 'size' indicates how large a mapping region to
enable. Both are in bytes.

This _wc variant provides a mapping which may only be used
with the io_mapping_map_atomic_wc or io_mapping_map_wc.

With this mapping object, individual pages can be mapped either atomically
or not, depending on the necessary scheduling environment. Of course, atomic
maps are more efficient::

	void *io_mapping_map_atomic_wc(struct io_mapping *mapping,
				       unsigned long offset)

'offset' is the offset within the defined mapping region.
Accessing addresses beyond the region specified in the
creation function yields undefined results. Using an offset
which is not page aligned yields an undefined result. The
return value points to a single page in CPU address space.

This _wc variant returns a write-combining map to the
page and may only be used with mappings created by
io_mapping_create_wc

Note that the task may not sleep while holding this page
mapped.

::

	void io_mapping_unmap_atomic(void *vaddr)

'vaddr' must be the value returned by the last
io_mapping_map_atomic_wc call. This unmaps the specified
page and allows the task to sleep once again.

If you need to sleep while holding the lock, you can use the non-atomic
variant, although they may be significantly slower.

::

	void *io_mapping_map_wc(struct io_mapping *mapping,
				unsigned long offset)

This works like io_mapping_map_atomic_wc except it allows
the task to sleep while holding the page mapped.


::

	void io_mapping_unmap(void *vaddr)

This works like io_mapping_unmap_atomic, except it is used
for pages mapped with io_mapping_map_wc.

At driver close time, the io_mapping object must be freed::

	void io_mapping_free(struct io_mapping *mapping)

Current Implementation
======================

The initial implementation of these functions uses existing mapping
mechanisms and so provides only an abstraction layer and no new
functionality.

On 64-bit processors, io_mapping_create_wc calls ioremap_wc for the whole
range, creating a permanent kernel-visible mapping to the resource. The
map_atomic and map functions add the requested offset to the base of the
virtual address returned by ioremap_wc.

On 32-bit processors with HIGHMEM defined, io_mapping_map_atomic_wc uses
kmap_atomic_pfn to map the specified page in an atomic fashion;
kmap_atomic_pfn isn't really supposed to be used with device pages, but it
provides an efficient mapping for this usage.

On 32-bit processors without HIGHMEM defined, io_mapping_map_atomic_wc and
io_mapping_map_wc both use ioremap_wc, a terribly inefficient function which
performs an IPI to inform all processors about the new mapping. This results
in a significant performance penalty.
Commit	Line	Data
9cf5116d MCC	1	========================
	2	The io_mapping functions
	3	========================
	4
	5	API
	6	===
	7
9663f2e6 KP	8	The io_mapping functions in linux/io-mapping.h provide an abstraction for
	9	efficiently mapping small regions of an I/O device to the CPU. The initial
	10	usage is to support the large graphics aperture on 32-bit processors where
	11	ioremap_wc cannot be used to statically map the entire aperture to the CPU
	12	as it would consume too much of the kernel address space.
	13
9cf5116d	14	A mapping object is created during driver initialization using::
9663f2e6 KP	15
	16	struct io_mapping *io_mapping_create_wc(unsigned long base,
	17	unsigned long size)
	18
9cf5116d MCC	19	'base' is the bus address of the region to be made
	20	mappable, while 'size' indicates how large a mapping region to
	21	enable. Both are in bytes.
9663f2e6	22
9cf5116d MCC	23	This _wc variant provides a mapping which may only be used
9cf5116d MCC	24	with the io_mapping_map_atomic_wc or io_mapping_map_wc.
9663f2e6 KP	25
	26	With this mapping object, individual pages can be mapped either atomically
	27	or not, depending on the necessary scheduling environment. Of course, atomic
9cf5116d	28	maps are more efficient::
9663f2e6 KP	29
	30	void io_mapping_map_atomic_wc(struct io_mapping mapping,
	31	unsigned long offset)
	32
9cf5116d MCC	33	'offset' is the offset within the defined mapping region.
	34	Accessing addresses beyond the region specified in the
	35	creation function yields undefined results. Using an offset
	36	which is not page aligned yields an undefined result. The
	37	return value points to a single page in CPU address space.
	38
	39	This _wc variant returns a write-combining map to the
	40	page and may only be used with mappings created by
	41	io_mapping_create_wc
9663f2e6	42
9cf5116d MCC	43	Note that the task may not sleep while holding this page
9cf5116d MCC	44	mapped.
9663f2e6	45
9cf5116d	46	::
9663f2e6 KP	47
	48	void io_mapping_unmap_atomic(void *vaddr)
	49
9cf5116d MCC	50	'vaddr' must be the value returned by the last
	51	io_mapping_map_atomic_wc call. This unmaps the specified
	52	page and allows the task to sleep once again.
9663f2e6 KP	53
	54	If you need to sleep while holding the lock, you can use the non-atomic
	55	variant, although they may be significantly slower.
	56
9cf5116d MCC	57	::
9cf5116d MCC	58
9663f2e6 KP	59	void io_mapping_map_wc(struct io_mapping mapping,
	60	unsigned long offset)
	61
9cf5116d MCC	62	This works like io_mapping_map_atomic_wc except it allows
	63	the task to sleep while holding the page mapped.
	64
	65
	66	::
9663f2e6 KP	67
	68	void io_mapping_unmap(void *vaddr)
	69
9cf5116d MCC	70	This works like io_mapping_unmap_atomic, except it is used
9cf5116d MCC	71	for pages mapped with io_mapping_map_wc.
9663f2e6	72
9cf5116d	73	At driver close time, the io_mapping object must be freed::
9663f2e6 KP	74
	75	void io_mapping_free(struct io_mapping *mapping)
	76
9cf5116d MCC	77	Current Implementation
9cf5116d MCC	78	======================
9663f2e6 KP	79
	80	The initial implementation of these functions uses existing mapping
	81	mechanisms and so provides only an abstraction layer and no new
	82	functionality.
	83
	84	On 64-bit processors, io_mapping_create_wc calls ioremap_wc for the whole
	85	range, creating a permanent kernel-visible mapping to the resource. The
	86	map_atomic and map functions add the requested offset to the base of the
	87	virtual address returned by ioremap_wc.
	88
8d5c6603 KP	89	On 32-bit processors with HIGHMEM defined, io_mapping_map_atomic_wc uses
	90	kmap_atomic_pfn to map the specified page in an atomic fashion;
	91	kmap_atomic_pfn isn't really supposed to be used with device pages, but it
	92	provides an efficient mapping for this usage.
	93
	94	On 32-bit processors without HIGHMEM defined, io_mapping_map_atomic_wc and
	95	io_mapping_map_wc both use ioremap_wc, a terribly inefficient function which
	96	performs an IPI to inform all processors about the new mapping. This results
	97	in a significant performance penalty.