Remove obsolete #include <linux/config.h>
[linux-3.10.git] / arch / m68k / mm / kmap.c
1 /*
2  *  linux/arch/m68k/mm/kmap.c
3  *
4  *  Copyright (C) 1997 Roman Hodek
5  *
6  *  10/01/99 cleaned up the code and changing to the same interface
7  *           used by other architectures                /Roman Zippel
8  */
9
10 #include <linux/mm.h>
11 #include <linux/kernel.h>
12 #include <linux/string.h>
13 #include <linux/types.h>
14 #include <linux/slab.h>
15 #include <linux/vmalloc.h>
16
17 #include <asm/setup.h>
18 #include <asm/segment.h>
19 #include <asm/page.h>
20 #include <asm/pgalloc.h>
21 #include <asm/io.h>
22 #include <asm/system.h>
23
24 #undef DEBUG
25
26 #define PTRTREESIZE     (256*1024)
27
28 /*
29  * For 040/060 we can use the virtual memory area like other architectures,
30  * but for 020/030 we want to use early termination page descriptor and we
31  * can't mix this with normal page descriptors, so we have to copy that code
32  * (mm/vmalloc.c) and return appriorate aligned addresses.
33  */
34
35 #ifdef CPU_M68040_OR_M68060_ONLY
36
37 #define IO_SIZE         PAGE_SIZE
38
39 static inline struct vm_struct *get_io_area(unsigned long size)
40 {
41         return get_vm_area(size, VM_IOREMAP);
42 }
43
44
45 static inline void free_io_area(void *addr)
46 {
47         vfree((void *)(PAGE_MASK & (unsigned long)addr));
48 }
49
50 #else
51
52 #define IO_SIZE         (256*1024)
53
54 static struct vm_struct *iolist;
55
56 static struct vm_struct *get_io_area(unsigned long size)
57 {
58         unsigned long addr;
59         struct vm_struct **p, *tmp, *area;
60
61         area = (struct vm_struct *)kmalloc(sizeof(*area), GFP_KERNEL);
62         if (!area)
63                 return NULL;
64         addr = KMAP_START;
65         for (p = &iolist; (tmp = *p) ; p = &tmp->next) {
66                 if (size + addr < (unsigned long)tmp->addr)
67                         break;
68                 if (addr > KMAP_END-size)
69                         return NULL;
70                 addr = tmp->size + (unsigned long)tmp->addr;
71         }
72         area->addr = (void *)addr;
73         area->size = size + IO_SIZE;
74         area->next = *p;
75         *p = area;
76         return area;
77 }
78
79 static inline void free_io_area(void *addr)
80 {
81         struct vm_struct **p, *tmp;
82
83         if (!addr)
84                 return;
85         addr = (void *)((unsigned long)addr & -IO_SIZE);
86         for (p = &iolist ; (tmp = *p) ; p = &tmp->next) {
87                 if (tmp->addr == addr) {
88                         *p = tmp->next;
89                         __iounmap(tmp->addr, tmp->size);
90                         kfree(tmp);
91                         return;
92                 }
93         }
94 }
95
96 #endif
97
98 /*
99  * Map some physical address range into the kernel address space. The
100  * code is copied and adapted from map_chunk().
101  */
102 /* Rewritten by Andreas Schwab to remove all races. */
103
104 void __iomem *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag)
105 {
106         struct vm_struct *area;
107         unsigned long virtaddr, retaddr;
108         long offset;
109         pgd_t *pgd_dir;
110         pmd_t *pmd_dir;
111         pte_t *pte_dir;
112
113         /*
114          * Don't allow mappings that wrap..
115          */
116         if (!size || size > physaddr + size)
117                 return NULL;
118
119 #ifdef CONFIG_AMIGA
120         if (MACH_IS_AMIGA) {
121                 if ((physaddr >= 0x40000000) && (physaddr + size < 0x60000000)
122                     && (cacheflag == IOMAP_NOCACHE_SER))
123                         return (void __iomem *)physaddr;
124         }
125 #endif
126
127 #ifdef DEBUG
128         printk("ioremap: 0x%lx,0x%lx(%d) - ", physaddr, size, cacheflag);
129 #endif
130         /*
131          * Mappings have to be aligned
132          */
133         offset = physaddr & (IO_SIZE - 1);
134         physaddr &= -IO_SIZE;
135         size = (size + offset + IO_SIZE - 1) & -IO_SIZE;
136
137         /*
138          * Ok, go for it..
139          */
140         area = get_io_area(size);
141         if (!area)
142                 return NULL;
143
144         virtaddr = (unsigned long)area->addr;
145         retaddr = virtaddr + offset;
146 #ifdef DEBUG
147         printk("0x%lx,0x%lx,0x%lx", physaddr, virtaddr, retaddr);
148 #endif
149
150         /*
151          * add cache and table flags to physical address
152          */
153         if (CPU_IS_040_OR_060) {
154                 physaddr |= (_PAGE_PRESENT | _PAGE_GLOBAL040 |
155                              _PAGE_ACCESSED | _PAGE_DIRTY);
156                 switch (cacheflag) {
157                 case IOMAP_FULL_CACHING:
158                         physaddr |= _PAGE_CACHE040;
159                         break;
160                 case IOMAP_NOCACHE_SER:
161                 default:
162                         physaddr |= _PAGE_NOCACHE_S;
163                         break;
164                 case IOMAP_NOCACHE_NONSER:
165                         physaddr |= _PAGE_NOCACHE;
166                         break;
167                 case IOMAP_WRITETHROUGH:
168                         physaddr |= _PAGE_CACHE040W;
169                         break;
170                 }
171         } else {
172                 physaddr |= (_PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_DIRTY);
173                 switch (cacheflag) {
174                 case IOMAP_NOCACHE_SER:
175                 case IOMAP_NOCACHE_NONSER:
176                 default:
177                         physaddr |= _PAGE_NOCACHE030;
178                         break;
179                 case IOMAP_FULL_CACHING:
180                 case IOMAP_WRITETHROUGH:
181                         break;
182                 }
183         }
184
185         while ((long)size > 0) {
186 #ifdef DEBUG
187                 if (!(virtaddr & (PTRTREESIZE-1)))
188                         printk ("\npa=%#lx va=%#lx ", physaddr, virtaddr);
189 #endif
190                 pgd_dir = pgd_offset_k(virtaddr);
191                 pmd_dir = pmd_alloc(&init_mm, pgd_dir, virtaddr);
192                 if (!pmd_dir) {
193                         printk("ioremap: no mem for pmd_dir\n");
194                         return NULL;
195                 }
196
197                 if (CPU_IS_020_OR_030) {
198                         pmd_dir->pmd[(virtaddr/PTRTREESIZE) & 15] = physaddr;
199                         physaddr += PTRTREESIZE;
200                         virtaddr += PTRTREESIZE;
201                         size -= PTRTREESIZE;
202                 } else {
203                         pte_dir = pte_alloc_kernel(pmd_dir, virtaddr);
204                         if (!pte_dir) {
205                                 printk("ioremap: no mem for pte_dir\n");
206                                 return NULL;
207                         }
208
209                         pte_val(*pte_dir) = physaddr;
210                         virtaddr += PAGE_SIZE;
211                         physaddr += PAGE_SIZE;
212                         size -= PAGE_SIZE;
213                 }
214         }
215 #ifdef DEBUG
216         printk("\n");
217 #endif
218         flush_tlb_all();
219
220         return (void __iomem *)retaddr;
221 }
222
223 /*
224  * Unmap a ioremap()ed region again
225  */
226 void iounmap(void __iomem *addr)
227 {
228 #ifdef CONFIG_AMIGA
229         if ((!MACH_IS_AMIGA) ||
230             (((unsigned long)addr < 0x40000000) ||
231              ((unsigned long)addr > 0x60000000)))
232                         free_io_area((__force void *)addr);
233 #else
234         free_io_area((__force void *)addr);
235 #endif
236 }
237
238 /*
239  * __iounmap unmaps nearly everything, so be careful
240  * it doesn't free currently pointer/page tables anymore but it
241  * wans't used anyway and might be added later.
242  */
243 void __iounmap(void *addr, unsigned long size)
244 {
245         unsigned long virtaddr = (unsigned long)addr;
246         pgd_t *pgd_dir;
247         pmd_t *pmd_dir;
248         pte_t *pte_dir;
249
250         while ((long)size > 0) {
251                 pgd_dir = pgd_offset_k(virtaddr);
252                 if (pgd_bad(*pgd_dir)) {
253                         printk("iounmap: bad pgd(%08lx)\n", pgd_val(*pgd_dir));
254                         pgd_clear(pgd_dir);
255                         return;
256                 }
257                 pmd_dir = pmd_offset(pgd_dir, virtaddr);
258
259                 if (CPU_IS_020_OR_030) {
260                         int pmd_off = (virtaddr/PTRTREESIZE) & 15;
261                         int pmd_type = pmd_dir->pmd[pmd_off] & _DESCTYPE_MASK;
262
263                         if (pmd_type == _PAGE_PRESENT) {
264                                 pmd_dir->pmd[pmd_off] = 0;
265                                 virtaddr += PTRTREESIZE;
266                                 size -= PTRTREESIZE;
267                                 continue;
268                         } else if (pmd_type == 0)
269                                 continue;
270                 }
271
272                 if (pmd_bad(*pmd_dir)) {
273                         printk("iounmap: bad pmd (%08lx)\n", pmd_val(*pmd_dir));
274                         pmd_clear(pmd_dir);
275                         return;
276                 }
277                 pte_dir = pte_offset_kernel(pmd_dir, virtaddr);
278
279                 pte_val(*pte_dir) = 0;
280                 virtaddr += PAGE_SIZE;
281                 size -= PAGE_SIZE;
282         }
283
284         flush_tlb_all();
285 }
286
287 /*
288  * Set new cache mode for some kernel address space.
289  * The caller must push data for that range itself, if such data may already
290  * be in the cache.
291  */
292 void kernel_set_cachemode(void *addr, unsigned long size, int cmode)
293 {
294         unsigned long virtaddr = (unsigned long)addr;
295         pgd_t *pgd_dir;
296         pmd_t *pmd_dir;
297         pte_t *pte_dir;
298
299         if (CPU_IS_040_OR_060) {
300                 switch (cmode) {
301                 case IOMAP_FULL_CACHING:
302                         cmode = _PAGE_CACHE040;
303                         break;
304                 case IOMAP_NOCACHE_SER:
305                 default:
306                         cmode = _PAGE_NOCACHE_S;
307                         break;
308                 case IOMAP_NOCACHE_NONSER:
309                         cmode = _PAGE_NOCACHE;
310                         break;
311                 case IOMAP_WRITETHROUGH:
312                         cmode = _PAGE_CACHE040W;
313                         break;
314                 }
315         } else {
316                 switch (cmode) {
317                 case IOMAP_NOCACHE_SER:
318                 case IOMAP_NOCACHE_NONSER:
319                 default:
320                         cmode = _PAGE_NOCACHE030;
321                         break;
322                 case IOMAP_FULL_CACHING:
323                 case IOMAP_WRITETHROUGH:
324                         cmode = 0;
325                 }
326         }
327
328         while ((long)size > 0) {
329                 pgd_dir = pgd_offset_k(virtaddr);
330                 if (pgd_bad(*pgd_dir)) {
331                         printk("iocachemode: bad pgd(%08lx)\n", pgd_val(*pgd_dir));
332                         pgd_clear(pgd_dir);
333                         return;
334                 }
335                 pmd_dir = pmd_offset(pgd_dir, virtaddr);
336
337                 if (CPU_IS_020_OR_030) {
338                         int pmd_off = (virtaddr/PTRTREESIZE) & 15;
339
340                         if ((pmd_dir->pmd[pmd_off] & _DESCTYPE_MASK) == _PAGE_PRESENT) {
341                                 pmd_dir->pmd[pmd_off] = (pmd_dir->pmd[pmd_off] &
342                                                          _CACHEMASK040) | cmode;
343                                 virtaddr += PTRTREESIZE;
344                                 size -= PTRTREESIZE;
345                                 continue;
346                         }
347                 }
348
349                 if (pmd_bad(*pmd_dir)) {
350                         printk("iocachemode: bad pmd (%08lx)\n", pmd_val(*pmd_dir));
351                         pmd_clear(pmd_dir);
352                         return;
353                 }
354                 pte_dir = pte_offset_kernel(pmd_dir, virtaddr);
355
356                 pte_val(*pte_dir) = (pte_val(*pte_dir) & _CACHEMASK040) | cmode;
357                 virtaddr += PAGE_SIZE;
358                 size -= PAGE_SIZE;
359         }
360
361         flush_tlb_all();
362 }