1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _M68K_CACHEFLUSH_H
3 #define _M68K_CACHEFLUSH_H
4
5 #include <linux/mm.h>
6 #ifdef CONFIG_COLDFIRE
7 #include <asm/mcfsim.h>
8 #endif
9
10 /* cache code */
11 #define FLUSH_I_AND_D (0x00000808)
12 #define FLUSH_I (0x00000008)
13
14 #ifndef ICACHE_MAX_ADDR
15 #define ICACHE_MAX_ADDR 0
16 #define ICACHE_SET_MASK 0
17 #define DCACHE_MAX_ADDR 0
18 #define DCACHE_SETMASK 0
19 #endif
20 #ifndef CACHE_MODE
21 #define CACHE_MODE 0
22 #define CACR_ICINVA 0
23 #define CACR_DCINVA 0
24 #define CACR_BCINVA 0
25 #endif
26
27 /*
28 * ColdFire architecture has no way to clear individual cache lines, so we
29 * are stuck invalidating all the cache entries when we want a clear operation.
30 */
31 static inline void clear_cf_icache(unsigned long start, unsigned long end)
32 {
33 __asm__ __volatile__ (
34 "movec %0,%%cacr\n\t"
35 "nop"
36 :
37 : "r" (CACHE_MODE | CACR_ICINVA | CACR_BCINVA));
38 }
39
40 static inline void clear_cf_dcache(unsigned long start, unsigned long end)
41 {
42 __asm__ __volatile__ (
43 "movec %0,%%cacr\n\t"
44 "nop"
45 :
46 : "r" (CACHE_MODE | CACR_DCINVA));
47 }
48
49 static inline void clear_cf_bcache(unsigned long start, unsigned long end)
50 {
51 __asm__ __volatile__ (
52 "movec %0,%%cacr\n\t"
53 "nop"
54 :
55 : "r" (CACHE_MODE | CACR_ICINVA | CACR_BCINVA | CACR_DCINVA));
56 }
57
58 /*
59 * Use the ColdFire cpushl instruction to push (and invalidate) cache lines.
60 * The start and end addresses are cache line numbers not memory addresses.
61 */
62 static inline void flush_cf_icache(unsigned long start, unsigned long end)
63 {
64 unsigned long set;
65
66 for (set = start; set <= end; set += (0x10 - 3)) {
67 __asm__ __volatile__ (
68 "cpushl %%ic,(%0)\n\t"
69 "addq%.l #1,%0\n\t"
70 "cpushl %%ic,(%0)\n\t"
71 "addq%.l #1,%0\n\t"
72 "cpushl %%ic,(%0)\n\t"
73 "addq%.l #1,%0\n\t"
74 "cpushl %%ic,(%0)"
75 : "=a" (set)
76 : "a" (set));
77 }
78 }
79
80 static inline void flush_cf_dcache(unsigned long start, unsigned long end)
81 {
82 unsigned long set;
83
84 for (set = start; set <= end; set += (0x10 - 3)) {
85 __asm__ __volatile__ (
86 "cpushl %%dc,(%0)\n\t"
87 "addq%.l #1,%0\n\t"
88 "cpushl %%dc,(%0)\n\t"
89 "addq%.l #1,%0\n\t"
90 "cpushl %%dc,(%0)\n\t"
91 "addq%.l #1,%0\n\t"
92 "cpushl %%dc,(%0)"
93 : "=a" (set)
94 : "a" (set));
95 }
96 }
97
98 static inline void flush_cf_bcache(unsigned long start, unsigned long end)
99 {
100 unsigned long set;
101
102 for (set = start; set <= end; set += (0x10 - 3)) {
103 __asm__ __volatile__ (
104 "cpushl %%bc,(%0)\n\t"
105 "addq%.l #1,%0\n\t"
106 "cpushl %%bc,(%0)\n\t"
107 "addq%.l #1,%0\n\t"
108 "cpushl %%bc,(%0)\n\t"
109 "addq%.l #1,%0\n\t"
110 "cpushl %%bc,(%0)"
111 : "=a" (set)
112 : "a" (set));
113 }
114 }
115
116 /*
117 * Cache handling functions
118 */
119
120 static inline void flush_icache(void)
121 {
122 if (CPU_IS_COLDFIRE) {
123 flush_cf_icache(0, ICACHE_MAX_ADDR);
124 } else if (CPU_IS_040_OR_060) {
125 asm volatile ( "nop\n"
126 " .chip 68040\n"
127 " cpusha %bc\n"
128 " .chip 68k");
129 } else {
130 unsigned long tmp;
131 asm volatile ( "movec %%cacr,%0\n"
132 " or.w %1,%0\n"
133 " movec %0,%%cacr"
134 : "=&d" (tmp)
135 : "id" (FLUSH_I));
136 }
137 }
138
139 /*
140 * invalidate the cache for the specified memory range.
141 * It starts at the physical address specified for
142 * the given number of bytes.
143 */
144 extern void cache_clear(unsigned long paddr, int len);
145 /*
146 * push any dirty cache in the specified memory range.
147 * It starts at the physical address specified for
148 * the given number of bytes.
149 */
150 extern void cache_push(unsigned long paddr, int len);
151
152 /*
153 * push and invalidate pages in the specified user virtual
154 * memory range.
155 */
156 extern void cache_push_v(unsigned long vaddr, int len);
157
158 /* This is needed whenever the virtual mapping of the current
159 process changes. */
160 #define __flush_cache_all() \
161 ({ \
162 if (CPU_IS_COLDFIRE) { \
163 flush_cf_dcache(0, DCACHE_MAX_ADDR); \
164 } else if (CPU_IS_040_OR_060) { \
165 __asm__ __volatile__("nop\n\t" \
166 ".chip 68040\n\t" \
167 "cpusha %dc\n\t" \
168 ".chip 68k"); \
169 } else { \
170 unsigned long _tmp; \
171 __asm__ __volatile__("movec %%cacr,%0\n\t" \
172 "orw %1,%0\n\t" \
173 "movec %0,%%cacr" \
174 : "=&d" (_tmp) \
175 : "di" (FLUSH_I_AND_D)); \
176 } \
177 })
178
179 #define __flush_cache_030() \
180 ({ \
181 if (CPU_IS_020_OR_030) { \
182 unsigned long _tmp; \
183 __asm__ __volatile__("movec %%cacr,%0\n\t" \
184 "orw %1,%0\n\t" \
185 "movec %0,%%cacr" \
186 : "=&d" (_tmp) \
187 : "di" (FLUSH_I_AND_D)); \
188 } \
189 })
190
191 #define flush_cache_all() __flush_cache_all()
192
193 #define flush_cache_vmap(start, end) flush_cache_all()
194 #define flush_cache_vmap_early(start, end) do { } while (0)
195 #define flush_cache_vunmap(start, end) flush_cache_all()
196
197 static inline void flush_cache_mm(struct mm_struct *mm)
198 {
199 if (mm == current->mm)
200 __flush_cache_030();
201 }
202
203 #define flush_cache_dup_mm(mm) flush_cache_mm(mm)
204
205 /* flush_cache_range/flush_cache_page must be macros to avoid
206 a dependency on linux/mm.h, which includes this file... */
207 static inline void flush_cache_range(struct vm_area_struct *vma,
208 unsigned long start,
209 unsigned long end)
210 {
211 if (vma->vm_mm == current->mm)
212 __flush_cache_030();
213 }
214
215 static inline void flush_cache_page(struct vm_area_struct *vma, unsigned long vmaddr, unsigned long pfn)
216 {
217 if (vma->vm_mm == current->mm)
218 __flush_cache_030();
219 }
220
221
222 /* Push the page at kernel virtual address and clear the icache */
223 /* RZ: use cpush %bc instead of cpush %dc, cinv %ic */
224 static inline void __flush_pages_to_ram(void *vaddr, unsigned int nr)
225 {
226 if (CPU_IS_COLDFIRE) {
227 unsigned long addr, start, end;
228 addr = ((unsigned long) vaddr) & ~(PAGE_SIZE - 1);
229 start = addr & ICACHE_SET_MASK;
230 end = (addr + nr * PAGE_SIZE - 1) & ICACHE_SET_MASK;
231 if (start > end) {
232 flush_cf_bcache(0, end);
233 end = ICACHE_MAX_ADDR;
234 }
235 flush_cf_bcache(start, end);
236 } else if (CPU_IS_040_OR_060) {
237 unsigned long paddr = __pa(vaddr);
238
239 do {
240 __asm__ __volatile__("nop\n\t"
241 ".chip 68040\n\t"
242 "cpushp %%bc,(%0)\n\t"
243 ".chip 68k"
244 : : "a" (paddr));
245 paddr += PAGE_SIZE;
246 } while (--nr);
247 } else {
248 unsigned long _tmp;
249 __asm__ __volatile__("movec %%cacr,%0\n\t"
250 "orw %1,%0\n\t"
251 "movec %0,%%cacr"
252 : "=&d" (_tmp)
253 : "di" (FLUSH_I));
254 }
255 }
256
257 #define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 1
258 #define flush_dcache_page(page) __flush_pages_to_ram(page_address(page), 1)
259 #define flush_dcache_folio(folio) \
260 __flush_pages_to_ram(folio_address(folio), folio_nr_pages(folio))
261 #define flush_dcache_mmap_lock(mapping) do { } while (0)
262 #define flush_dcache_mmap_unlock(mapping) do { } while (0)
263 #define flush_icache_pages(vma, page, nr) \
264 __flush_pages_to_ram(page_address(page), nr)
265
266 extern void flush_icache_user_page(struct vm_area_struct *vma, struct page *page,
267 unsigned long addr, int len);
268 extern void flush_icache_range(unsigned long address, unsigned long endaddr);
269 extern void flush_icache_user_range(unsigned long address,
270 unsigned long endaddr);
271
272 static inline void copy_to_user_page(struct vm_area_struct *vma,
273 struct page *page, unsigned long vaddr,
274 void *dst, void *src, int len)
275 {
276 flush_cache_page(vma, vaddr, page_to_pfn(page));
277 memcpy(dst, src, len);
278 flush_icache_user_page(vma, page, vaddr, len);
279 }
280 static inline void copy_from_user_page(struct vm_area_struct *vma,
281 struct page *page, unsigned long vaddr,
282 void *dst, void *src, int len)
283 {
284 flush_cache_page(vma, vaddr, page_to_pfn(page));
285 memcpy(dst, src, len);
286 }
287
288 #endif /* _M68K_CACHEFLUSH_H */
289
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.