1========================
 2The io_mapping functions
 3========================
 4
 5API
 6===
 7
 8The io_mapping functions in linux/io-mapping.h provide an abstraction for
 9efficiently mapping small regions of an I/O device to the CPU. The initial
10usage is to support the large graphics aperture on 32-bit processors where
11ioremap_wc cannot be used to statically map the entire aperture to the CPU
12as it would consume too much of the kernel address space.
13
14A mapping object is created during driver initialization using::
15
16	struct io_mapping *io_mapping_create_wc(unsigned long base,
17						unsigned long size)
18
19'base' is the bus address of the region to be made
20mappable, while 'size' indicates how large a mapping region to
21enable. Both are in bytes.
22
23This _wc variant provides a mapping which may only be used with
24io_mapping_map_atomic_wc(), io_mapping_map_local_wc() or
25io_mapping_map_wc().
26
27With this mapping object, individual pages can be mapped either temporarily
28or long term, depending on the requirements. Of course, temporary maps are
29more efficient. They come in two flavours::
30
31	void *io_mapping_map_local_wc(struct io_mapping *mapping,
32				      unsigned long offset)
 
33
34	void *io_mapping_map_atomic_wc(struct io_mapping *mapping,
35				       unsigned long offset)
36
37'offset' is the offset within the defined mapping region.  Accessing
38addresses beyond the region specified in the creation function yields
39undefined results. Using an offset which is not page aligned yields an
40undefined result. The return value points to a single page in CPU address
41space.
 
 
 
 
42
43This _wc variant returns a write-combining map to the page and may only be
44used with mappings created by io_mapping_create_wc()
45
46Temporary mappings are only valid in the context of the caller. The mapping
47is not guaranteed to be globaly visible.
48
49io_mapping_map_local_wc() has a side effect on X86 32bit as it disables
50migration to make the mapping code work. No caller can rely on this side
51effect.
52
53io_mapping_map_atomic_wc() has the side effect of disabling preemption and
54pagefaults. Don't use in new code. Use io_mapping_map_local_wc() instead.
55
56Nested mappings need to be undone in reverse order because the mapping
57code uses a stack for keeping track of them::
58
59 addr1 = io_mapping_map_local_wc(map1, offset1);
60 addr2 = io_mapping_map_local_wc(map2, offset2);
61 ...
62 io_mapping_unmap_local(addr2);
63 io_mapping_unmap_local(addr1);
64
65The mappings are released with::
66
67	void io_mapping_unmap_local(void *vaddr)
68	void io_mapping_unmap_atomic(void *vaddr)
69
70'vaddr' must be the value returned by the last io_mapping_map_local_wc() or
71io_mapping_map_atomic_wc() call. This unmaps the specified mapping and
72undoes the side effects of the mapping functions.
73
74If you need to sleep while holding a mapping, you can use the regular
75variant, although this may be significantly slower::
 
 
76
77	void *io_mapping_map_wc(struct io_mapping *mapping,
78				unsigned long offset)
79
80This works like io_mapping_map_atomic/local_wc() except it has no side
81effects and the pointer is globaly visible.
 
82
83The mappings are released with::
84
85	void io_mapping_unmap(void *vaddr)
86
87Use for pages mapped with io_mapping_map_wc().
 
88
89At driver close time, the io_mapping object must be freed::
90
91	void io_mapping_free(struct io_mapping *mapping)

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