[PATCH] avr32 architecture
[linux-2.6.git] / include / asm-avr32 / cacheflush.h
1 /*
2  * Copyright (C) 2004-2006 Atmel Corporation
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  */
8 #ifndef __ASM_AVR32_CACHEFLUSH_H
9 #define __ASM_AVR32_CACHEFLUSH_H
10
11 /* Keep includes the same across arches.  */
12 #include <linux/mm.h>
13
14 #define CACHE_OP_ICACHE_INVALIDATE      0x01
15 #define CACHE_OP_DCACHE_INVALIDATE      0x0b
16 #define CACHE_OP_DCACHE_CLEAN           0x0c
17 #define CACHE_OP_DCACHE_CLEAN_INVAL     0x0d
18
19 /*
20  * Invalidate any cacheline containing virtual address vaddr without
21  * writing anything back to memory.
22  *
23  * Note that this function may corrupt unrelated data structures when
24  * applied on buffers that are not cacheline aligned in both ends.
25  */
26 static inline void invalidate_dcache_line(void *vaddr)
27 {
28         asm volatile("cache %0[0], %1"
29                      :
30                      : "r"(vaddr), "n"(CACHE_OP_DCACHE_INVALIDATE)
31                      : "memory");
32 }
33
34 /*
35  * Make sure any cacheline containing virtual address vaddr is written
36  * to memory.
37  */
38 static inline void clean_dcache_line(void *vaddr)
39 {
40         asm volatile("cache %0[0], %1"
41                      :
42                      : "r"(vaddr), "n"(CACHE_OP_DCACHE_CLEAN)
43                      : "memory");
44 }
45
46 /*
47  * Make sure any cacheline containing virtual address vaddr is written
48  * to memory and then invalidate it.
49  */
50 static inline void flush_dcache_line(void *vaddr)
51 {
52         asm volatile("cache %0[0], %1"
53                      :
54                      : "r"(vaddr), "n"(CACHE_OP_DCACHE_CLEAN_INVAL)
55                      : "memory");
56 }
57
58 /*
59  * Invalidate any instruction cacheline containing virtual address
60  * vaddr.
61  */
62 static inline void invalidate_icache_line(void *vaddr)
63 {
64         asm volatile("cache %0[0], %1"
65                      :
66                      : "r"(vaddr), "n"(CACHE_OP_ICACHE_INVALIDATE)
67                      : "memory");
68 }
69
70 /*
71  * Applies the above functions on all lines that are touched by the
72  * specified virtual address range.
73  */
74 void invalidate_dcache_region(void *start, size_t len);
75 void clean_dcache_region(void *start, size_t len);
76 void flush_dcache_region(void *start, size_t len);
77 void invalidate_icache_region(void *start, size_t len);
78
79 /*
80  * Make sure any pending writes are completed before continuing.
81  */
82 #define flush_write_buffer() asm volatile("sync 0" : : : "memory")
83
84 /*
85  * The following functions are called when a virtual mapping changes.
86  * We do not need to flush anything in this case.
87  */
88 #define flush_cache_all()                       do { } while (0)
89 #define flush_cache_mm(mm)                      do { } while (0)
90 #define flush_cache_range(vma, start, end)      do { } while (0)
91 #define flush_cache_page(vma, vmaddr, pfn)      do { } while (0)
92 #define flush_cache_vmap(start, end)            do { } while (0)
93 #define flush_cache_vunmap(start, end)          do { } while (0)
94
95 /*
96  * I think we need to implement this one to be able to reliably
97  * execute pages from RAMDISK. However, if we implement the
98  * flush_dcache_*() functions, it might not be needed anymore.
99  *
100  * #define flush_icache_page(vma, page)         do { } while (0)
101  */
102 extern void flush_icache_page(struct vm_area_struct *vma, struct page *page);
103
104 /*
105  * These are (I think) related to D-cache aliasing.  We might need to
106  * do something here, but only for certain configurations.  No such
107  * configurations exist at this time.
108  */
109 #define flush_dcache_page(page)                 do { } while (0)
110 #define flush_dcache_mmap_lock(page)            do { } while (0)
111 #define flush_dcache_mmap_unlock(page)          do { } while (0)
112
113 /*
114  * These are for I/D cache coherency. In this case, we do need to
115  * flush with all configurations.
116  */
117 extern void flush_icache_range(unsigned long start, unsigned long end);
118 extern void flush_icache_user_range(struct vm_area_struct *vma,
119                                     struct page *page,
120                                     unsigned long addr, int len);
121
122 #define copy_to_user_page(vma, page, vaddr, dst, src, len) do { \
123         memcpy(dst, src, len);                                  \
124         flush_icache_user_range(vma, page, vaddr, len);         \
125 } while(0)
126 #define copy_from_user_page(vma, page, vaddr, dst, src, len)    \
127         memcpy(dst, src, len)
128
129 #endif /* __ASM_AVR32_CACHEFLUSH_H */