[AVR32] Don't use kmap() in flush_icache_page()
[linux-2.6.git] / arch / avr32 / mm / cache.c
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
9 #include <linux/highmem.h>
10 #include <linux/unistd.h>
11
12 #include <asm/cacheflush.h>
13 #include <asm/cachectl.h>
14 #include <asm/processor.h>
15 #include <asm/uaccess.h>
16
17 /*
18  * If you attempt to flush anything more than this, you need superuser
19  * privileges.  The value is completely arbitrary.
20  */
21 #define CACHEFLUSH_MAX_LEN      1024
22
23 void invalidate_dcache_region(void *start, size_t size)
24 {
25         unsigned long v, begin, end, linesz, mask;
26         int flush = 0;
27
28         linesz = boot_cpu_data.dcache.linesz;
29         mask = linesz - 1;
30
31         /* when first and/or last cachelines are shared, flush them
32          * instead of invalidating ... never discard valid data!
33          */
34         begin = (unsigned long)start;
35         end = begin + size - 1;
36
37         if (begin & mask) {
38                 flush_dcache_line(start);
39                 begin += linesz;
40                 flush = 1;
41         }
42         if ((end & mask) != mask) {
43                 flush_dcache_line((void *)end);
44                 end -= linesz;
45                 flush = 1;
46         }
47
48         /* remaining cachelines only need invalidation */
49         for (v = begin; v <= end; v += linesz)
50                 invalidate_dcache_line((void *)v);
51         if (flush)
52                 flush_write_buffer();
53 }
54
55 void clean_dcache_region(void *start, size_t size)
56 {
57         unsigned long v, begin, end, linesz;
58
59         linesz = boot_cpu_data.dcache.linesz;
60         begin = (unsigned long)start & ~(linesz - 1);
61         end = ((unsigned long)start + size + linesz - 1) & ~(linesz - 1);
62
63         for (v = begin; v < end; v += linesz)
64                 clean_dcache_line((void *)v);
65         flush_write_buffer();
66 }
67
68 void flush_dcache_region(void *start, size_t size)
69 {
70         unsigned long v, begin, end, linesz;
71
72         linesz = boot_cpu_data.dcache.linesz;
73         begin = (unsigned long)start & ~(linesz - 1);
74         end = ((unsigned long)start + size + linesz - 1) & ~(linesz - 1);
75
76         for (v = begin; v < end; v += linesz)
77                 flush_dcache_line((void *)v);
78         flush_write_buffer();
79 }
80
81 void invalidate_icache_region(void *start, size_t size)
82 {
83         unsigned long v, begin, end, linesz;
84
85         linesz = boot_cpu_data.icache.linesz;
86         begin = (unsigned long)start & ~(linesz - 1);
87         end = ((unsigned long)start + size + linesz - 1) & ~(linesz - 1);
88
89         for (v = begin; v < end; v += linesz)
90                 invalidate_icache_line((void *)v);
91 }
92
93 static inline void __flush_icache_range(unsigned long start, unsigned long end)
94 {
95         unsigned long v, linesz;
96
97         linesz = boot_cpu_data.dcache.linesz;
98         for (v = start; v < end; v += linesz) {
99                 clean_dcache_line((void *)v);
100                 invalidate_icache_line((void *)v);
101         }
102
103         flush_write_buffer();
104 }
105
106 /*
107  * This one is called after a module has been loaded.
108  */
109 void flush_icache_range(unsigned long start, unsigned long end)
110 {
111         unsigned long linesz;
112
113         linesz = boot_cpu_data.dcache.linesz;
114         __flush_icache_range(start & ~(linesz - 1),
115                              (end + linesz - 1) & ~(linesz - 1));
116 }
117
118 /*
119  * This one is called from do_no_page(), do_swap_page() and install_page().
120  */
121 void flush_icache_page(struct vm_area_struct *vma, struct page *page)
122 {
123         if (vma->vm_flags & VM_EXEC) {
124                 void *v = page_address(page);
125                 __flush_icache_range((unsigned long)v, (unsigned long)v + PAGE_SIZE);
126         }
127 }
128
129 /*
130  * This one is used by copy_to_user_page()
131  */
132 void flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
133                              unsigned long addr, int len)
134 {
135         if (vma->vm_flags & VM_EXEC)
136                 flush_icache_range(addr, addr + len);
137 }
138
139 asmlinkage int sys_cacheflush(int operation, void __user *addr, size_t len)
140 {
141         int ret;
142
143         if (len > CACHEFLUSH_MAX_LEN) {
144                 ret = -EPERM;
145                 if (!capable(CAP_SYS_ADMIN))
146                         goto out;
147         }
148
149         ret = -EFAULT;
150         if (!access_ok(VERIFY_WRITE, addr, len))
151                 goto out;
152
153         switch (operation) {
154         case CACHE_IFLUSH:
155                 flush_icache_range((unsigned long)addr,
156                                    (unsigned long)addr + len);
157                 ret = 0;
158                 break;
159         default:
160                 ret = -EINVAL;
161         }
162
163 out:
164         return ret;
165 }