block: add helpers to run flush_dcache_page() against a bio and a request's pages
[linux-2.6.git] / arch / m68k / include / asm / cacheflush_mm.h
1 #ifndef _M68K_CACHEFLUSH_H
2 #define _M68K_CACHEFLUSH_H
3
4 #include <linux/mm.h>
5
6 /* cache code */
7 #define FLUSH_I_AND_D   (0x00000808)
8 #define FLUSH_I         (0x00000008)
9
10 /*
11  * Cache handling functions
12  */
13
14 static inline void flush_icache(void)
15 {
16         if (CPU_IS_040_OR_060)
17                 asm volatile (  "nop\n"
18                         "       .chip   68040\n"
19                         "       cpusha  %bc\n"
20                         "       .chip   68k");
21         else {
22                 unsigned long tmp;
23                 asm volatile (  "movec  %%cacr,%0\n"
24                         "       or.w    %1,%0\n"
25                         "       movec   %0,%%cacr"
26                         : "=&d" (tmp)
27                         : "id" (FLUSH_I));
28         }
29 }
30
31 /*
32  * invalidate the cache for the specified memory range.
33  * It starts at the physical address specified for
34  * the given number of bytes.
35  */
36 extern void cache_clear(unsigned long paddr, int len);
37 /*
38  * push any dirty cache in the specified memory range.
39  * It starts at the physical address specified for
40  * the given number of bytes.
41  */
42 extern void cache_push(unsigned long paddr, int len);
43
44 /*
45  * push and invalidate pages in the specified user virtual
46  * memory range.
47  */
48 extern void cache_push_v(unsigned long vaddr, int len);
49
50 /* This is needed whenever the virtual mapping of the current
51    process changes.  */
52 #define __flush_cache_all()                                     \
53 ({                                                              \
54         if (CPU_IS_040_OR_060)                                  \
55                 __asm__ __volatile__("nop\n\t"                  \
56                                      ".chip 68040\n\t"          \
57                                      "cpusha %dc\n\t"           \
58                                      ".chip 68k");              \
59         else {                                                  \
60                 unsigned long _tmp;                             \
61                 __asm__ __volatile__("movec %%cacr,%0\n\t"      \
62                                      "orw %1,%0\n\t"            \
63                                      "movec %0,%%cacr"          \
64                                      : "=&d" (_tmp)             \
65                                      : "di" (FLUSH_I_AND_D));   \
66         }                                                       \
67 })
68
69 #define __flush_cache_030()                                     \
70 ({                                                              \
71         if (CPU_IS_020_OR_030) {                                \
72                 unsigned long _tmp;                             \
73                 __asm__ __volatile__("movec %%cacr,%0\n\t"      \
74                                      "orw %1,%0\n\t"            \
75                                      "movec %0,%%cacr"          \
76                                      : "=&d" (_tmp)             \
77                                      : "di" (FLUSH_I_AND_D));   \
78         }                                                       \
79 })
80
81 #define flush_cache_all() __flush_cache_all()
82
83 #define flush_cache_vmap(start, end)            flush_cache_all()
84 #define flush_cache_vunmap(start, end)          flush_cache_all()
85
86 static inline void flush_cache_mm(struct mm_struct *mm)
87 {
88         if (mm == current->mm)
89                 __flush_cache_030();
90 }
91
92 #define flush_cache_dup_mm(mm)                  flush_cache_mm(mm)
93
94 /* flush_cache_range/flush_cache_page must be macros to avoid
95    a dependency on linux/mm.h, which includes this file... */
96 static inline void flush_cache_range(struct vm_area_struct *vma,
97                                      unsigned long start,
98                                      unsigned long end)
99 {
100         if (vma->vm_mm == current->mm)
101                 __flush_cache_030();
102 }
103
104 static inline void flush_cache_page(struct vm_area_struct *vma, unsigned long vmaddr, unsigned long pfn)
105 {
106         if (vma->vm_mm == current->mm)
107                 __flush_cache_030();
108 }
109
110
111 /* Push the page at kernel virtual address and clear the icache */
112 /* RZ: use cpush %bc instead of cpush %dc, cinv %ic */
113 static inline void __flush_page_to_ram(void *vaddr)
114 {
115         if (CPU_IS_040_OR_060) {
116                 __asm__ __volatile__("nop\n\t"
117                                      ".chip 68040\n\t"
118                                      "cpushp %%bc,(%0)\n\t"
119                                      ".chip 68k"
120                                      : : "a" (__pa(vaddr)));
121         } else {
122                 unsigned long _tmp;
123                 __asm__ __volatile__("movec %%cacr,%0\n\t"
124                                      "orw %1,%0\n\t"
125                                      "movec %0,%%cacr"
126                                      : "=&d" (_tmp)
127                                      : "di" (FLUSH_I));
128         }
129 }
130
131 #define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 1
132 #define flush_dcache_page(page)         __flush_page_to_ram(page_address(page))
133 #define flush_dcache_mmap_lock(mapping)         do { } while (0)
134 #define flush_dcache_mmap_unlock(mapping)       do { } while (0)
135 #define flush_icache_page(vma, page)    __flush_page_to_ram(page_address(page))
136
137 extern void flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
138                                     unsigned long addr, int len);
139 extern void flush_icache_range(unsigned long address, unsigned long endaddr);
140
141 static inline void copy_to_user_page(struct vm_area_struct *vma,
142                                      struct page *page, unsigned long vaddr,
143                                      void *dst, void *src, int len)
144 {
145         flush_cache_page(vma, vaddr, page_to_pfn(page));
146         memcpy(dst, src, len);
147         flush_icache_user_range(vma, page, vaddr, len);
148 }
149 static inline void copy_from_user_page(struct vm_area_struct *vma,
150                                        struct page *page, unsigned long vaddr,
151                                        void *dst, void *src, int len)
152 {
153         flush_cache_page(vma, vaddr, page_to_pfn(page));
154         memcpy(dst, src, len);
155 }
156
157 #endif /* _M68K_CACHEFLUSH_H */