mmc: core: SDXC speed class support
[linux-2.6.git] / include / linux / highmem.h
1 #ifndef _LINUX_HIGHMEM_H
2 #define _LINUX_HIGHMEM_H
3
4 #include <linux/fs.h>
5 #include <linux/kernel.h>
6 #include <linux/mm.h>
7 #include <linux/uaccess.h>
8 #include <linux/hardirq.h>
9
10 #include <asm/cacheflush.h>
11
12 #ifndef ARCH_HAS_FLUSH_ANON_PAGE
13 static inline void flush_anon_page(struct vm_area_struct *vma, struct page *page, unsigned long vmaddr)
14 {
15 }
16 #endif
17
18 #ifndef ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE
19 static inline void flush_kernel_dcache_page(struct page *page)
20 {
21 }
22 static inline void flush_kernel_vmap_range(void *vaddr, int size)
23 {
24 }
25 static inline void invalidate_kernel_vmap_range(void *vaddr, int size)
26 {
27 }
28 #endif
29
30 #include <asm/kmap_types.h>
31
32 #ifdef CONFIG_HIGHMEM
33 #include <asm/highmem.h>
34
35 /* declarations for linux/mm/highmem.c */
36 unsigned int nr_free_highpages(void);
37 extern unsigned long totalhigh_pages;
38
39 void kmap_flush_unused(void);
40
41 #else /* CONFIG_HIGHMEM */
42
43 static inline unsigned int nr_free_highpages(void) { return 0; }
44
45 #define totalhigh_pages 0UL
46
47 #ifndef ARCH_HAS_KMAP
48 static inline void *kmap(struct page *page)
49 {
50         might_sleep();
51         return page_address(page);
52 }
53
54 static inline void kunmap(struct page *page)
55 {
56 }
57
58 static inline void *__kmap_atomic(struct page *page)
59 {
60         pagefault_disable();
61         return page_address(page);
62 }
63 #define kmap_atomic_prot(page, prot)    __kmap_atomic(page)
64
65 static inline void __kunmap_atomic(void *addr)
66 {
67         pagefault_enable();
68 }
69
70 #define kmap_atomic_pfn(pfn)    kmap_atomic(pfn_to_page(pfn))
71 #define kmap_atomic_to_page(ptr)        virt_to_page(ptr)
72
73 #define kmap_flush_unused()     do {} while(0)
74 #endif
75
76 #endif /* CONFIG_HIGHMEM */
77
78 #if defined(CONFIG_HIGHMEM) || defined(CONFIG_X86_32)
79
80 DECLARE_PER_CPU(int, __kmap_atomic_idx);
81
82 static inline int kmap_atomic_idx_push(void)
83 {
84         int idx = __this_cpu_inc_return(__kmap_atomic_idx) - 1;
85
86 #ifdef CONFIG_DEBUG_HIGHMEM
87         WARN_ON_ONCE(in_irq() && !irqs_disabled());
88         BUG_ON(idx > KM_TYPE_NR);
89 #endif
90         return idx;
91 }
92
93 static inline int kmap_atomic_idx(void)
94 {
95         return __this_cpu_read(__kmap_atomic_idx) - 1;
96 }
97
98 static inline void kmap_atomic_idx_pop(void)
99 {
100 #ifdef CONFIG_DEBUG_HIGHMEM
101         int idx = __this_cpu_dec_return(__kmap_atomic_idx);
102
103         BUG_ON(idx < 0);
104 #else
105         __this_cpu_dec(__kmap_atomic_idx);
106 #endif
107 }
108
109 #endif
110
111 /*
112  * Make both: kmap_atomic(page, idx) and kmap_atomic(page) work.
113  */
114 #define kmap_atomic(page, args...) __kmap_atomic(page)
115
116 /*
117  * Prevent people trying to call kunmap_atomic() as if it were kunmap()
118  * kunmap_atomic() should get the return value of kmap_atomic, not the page.
119  */
120 #define kunmap_atomic(addr, args...)                            \
121 do {                                                            \
122         BUILD_BUG_ON(__same_type((addr), struct page *));       \
123         __kunmap_atomic(addr);                                  \
124 } while (0)
125
126 /* when CONFIG_HIGHMEM is not set these will be plain clear/copy_page */
127 #ifndef clear_user_highpage
128 static inline void clear_user_highpage(struct page *page, unsigned long vaddr)
129 {
130         void *addr = kmap_atomic(page, KM_USER0);
131         clear_user_page(addr, vaddr, page);
132         kunmap_atomic(addr, KM_USER0);
133 }
134 #endif
135
136 #ifndef __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE
137 /**
138  * __alloc_zeroed_user_highpage - Allocate a zeroed HIGHMEM page for a VMA with caller-specified movable GFP flags
139  * @movableflags: The GFP flags related to the pages future ability to move like __GFP_MOVABLE
140  * @vma: The VMA the page is to be allocated for
141  * @vaddr: The virtual address the page will be inserted into
142  *
143  * This function will allocate a page for a VMA but the caller is expected
144  * to specify via movableflags whether the page will be movable in the
145  * future or not
146  *
147  * An architecture may override this function by defining
148  * __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE and providing their own
149  * implementation.
150  */
151 static inline struct page *
152 __alloc_zeroed_user_highpage(gfp_t movableflags,
153                         struct vm_area_struct *vma,
154                         unsigned long vaddr)
155 {
156         struct page *page = alloc_page_vma(GFP_HIGHUSER | movableflags,
157                         vma, vaddr);
158
159         if (page)
160                 clear_user_highpage(page, vaddr);
161
162         return page;
163 }
164 #endif
165
166 /**
167  * alloc_zeroed_user_highpage_movable - Allocate a zeroed HIGHMEM page for a VMA that the caller knows can move
168  * @vma: The VMA the page is to be allocated for
169  * @vaddr: The virtual address the page will be inserted into
170  *
171  * This function will allocate a page for a VMA that the caller knows will
172  * be able to migrate in the future using move_pages() or reclaimed
173  */
174 static inline struct page *
175 alloc_zeroed_user_highpage_movable(struct vm_area_struct *vma,
176                                         unsigned long vaddr)
177 {
178         return __alloc_zeroed_user_highpage(__GFP_MOVABLE, vma, vaddr);
179 }
180
181 static inline void clear_highpage(struct page *page)
182 {
183         void *kaddr = kmap_atomic(page, KM_USER0);
184         clear_page(kaddr);
185         kunmap_atomic(kaddr, KM_USER0);
186 }
187
188 static inline void zero_user_segments(struct page *page,
189         unsigned start1, unsigned end1,
190         unsigned start2, unsigned end2)
191 {
192         void *kaddr = kmap_atomic(page, KM_USER0);
193
194         BUG_ON(end1 > PAGE_SIZE || end2 > PAGE_SIZE);
195
196         if (end1 > start1)
197                 memset(kaddr + start1, 0, end1 - start1);
198
199         if (end2 > start2)
200                 memset(kaddr + start2, 0, end2 - start2);
201
202         kunmap_atomic(kaddr, KM_USER0);
203         flush_dcache_page(page);
204 }
205
206 static inline void zero_user_segment(struct page *page,
207         unsigned start, unsigned end)
208 {
209         zero_user_segments(page, start, end, 0, 0);
210 }
211
212 static inline void zero_user(struct page *page,
213         unsigned start, unsigned size)
214 {
215         zero_user_segments(page, start, start + size, 0, 0);
216 }
217
218 static inline void __deprecated memclear_highpage_flush(struct page *page,
219                         unsigned int offset, unsigned int size)
220 {
221         zero_user(page, offset, size);
222 }
223
224 #ifndef __HAVE_ARCH_COPY_USER_HIGHPAGE
225
226 static inline void copy_user_highpage(struct page *to, struct page *from,
227         unsigned long vaddr, struct vm_area_struct *vma)
228 {
229         char *vfrom, *vto;
230
231         vfrom = kmap_atomic(from, KM_USER0);
232         vto = kmap_atomic(to, KM_USER1);
233         copy_user_page(vto, vfrom, vaddr, to);
234         kunmap_atomic(vto, KM_USER1);
235         kunmap_atomic(vfrom, KM_USER0);
236 }
237
238 #endif
239
240 static inline void copy_highpage(struct page *to, struct page *from)
241 {
242         char *vfrom, *vto;
243
244         vfrom = kmap_atomic(from, KM_USER0);
245         vto = kmap_atomic(to, KM_USER1);
246         copy_page(vto, vfrom);
247         kunmap_atomic(vto, KM_USER1);
248         kunmap_atomic(vfrom, KM_USER0);
249 }
250
251 #endif /* _LINUX_HIGHMEM_H */