[IPV4]: [2/4] signed vs unsigned cleanup in net/ipv4/raw.c
[linux-2.6.git] / arch / sh64 / mm / ioremap.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * arch/sh64/mm/ioremap.c
7  *
8  * Copyright (C) 2000, 2001  Paolo Alberelli
9  * Copyright (C) 2003, 2004  Paul Mundt
10  *
11  * Mostly derived from arch/sh/mm/ioremap.c which, in turn is mostly
12  * derived from arch/i386/mm/ioremap.c .
13  *
14  *   (C) Copyright 1995 1996 Linus Torvalds
15  */
16 #include <linux/kernel.h>
17 #include <linux/slab.h>
18 #include <linux/vmalloc.h>
19 #include <linux/sched.h>
20 #include <linux/string.h>
21 #include <asm/io.h>
22 #include <asm/pgalloc.h>
23 #include <asm/tlbflush.h>
24 #include <linux/ioport.h>
25 #include <linux/bootmem.h>
26 #include <linux/proc_fs.h>
27
28 static void shmedia_mapioaddr(unsigned long, unsigned long);
29 static unsigned long shmedia_ioremap(struct resource *, u32, int);
30
31 static inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
32         unsigned long phys_addr, unsigned long flags)
33 {
34         unsigned long end;
35         unsigned long pfn;
36         pgprot_t pgprot = __pgprot(_PAGE_PRESENT  | _PAGE_READ   |
37                                    _PAGE_WRITE    | _PAGE_DIRTY  |
38                                    _PAGE_ACCESSED | _PAGE_SHARED | flags);
39
40         address &= ~PMD_MASK;
41         end = address + size;
42         if (end > PMD_SIZE)
43                 end = PMD_SIZE;
44         if (address >= end)
45                 BUG();
46
47         pfn = phys_addr >> PAGE_SHIFT;
48
49         pr_debug("    %s: pte %p address %lx size %lx phys_addr %lx\n",
50                  __FUNCTION__,pte,address,size,phys_addr);
51
52         do {
53                 if (!pte_none(*pte)) {
54                         printk("remap_area_pte: page already exists\n");
55                         BUG();
56                 }
57
58                 set_pte(pte, pfn_pte(pfn, pgprot));
59                 address += PAGE_SIZE;
60                 pfn++;
61                 pte++;
62         } while (address && (address < end));
63 }
64
65 static inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
66         unsigned long phys_addr, unsigned long flags)
67 {
68         unsigned long end;
69
70         address &= ~PGDIR_MASK;
71         end = address + size;
72
73         if (end > PGDIR_SIZE)
74                 end = PGDIR_SIZE;
75
76         phys_addr -= address;
77
78         if (address >= end)
79                 BUG();
80
81         do {
82                 pte_t * pte = pte_alloc_kernel(&init_mm, pmd, address);
83                 if (!pte)
84                         return -ENOMEM;
85                 remap_area_pte(pte, address, end - address, address + phys_addr, flags);
86                 address = (address + PMD_SIZE) & PMD_MASK;
87                 pmd++;
88         } while (address && (address < end));
89         return 0;
90 }
91
92 static int remap_area_pages(unsigned long address, unsigned long phys_addr,
93                                  unsigned long size, unsigned long flags)
94 {
95         int error;
96         pgd_t * dir;
97         unsigned long end = address + size;
98
99         phys_addr -= address;
100         dir = pgd_offset_k(address);
101         flush_cache_all();
102         if (address >= end)
103                 BUG();
104         spin_lock(&init_mm.page_table_lock);
105         do {
106                 pmd_t *pmd = pmd_alloc(&init_mm, dir, address);
107                 error = -ENOMEM;
108                 if (!pmd)
109                         break;
110                 if (remap_area_pmd(pmd, address, end - address,
111                                    phys_addr + address, flags)) {
112                          break;
113                 }
114                 error = 0;
115                 address = (address + PGDIR_SIZE) & PGDIR_MASK;
116                 dir++;
117         } while (address && (address < end));
118         spin_unlock(&init_mm.page_table_lock);
119         flush_tlb_all();
120         return 0;
121 }
122
123 /*
124  * Generic mapping function (not visible outside):
125  */
126
127 /*
128  * Remap an arbitrary physical address space into the kernel virtual
129  * address space. Needed when the kernel wants to access high addresses
130  * directly.
131  *
132  * NOTE! We need to allow non-page-aligned mappings too: we will obviously
133  * have to convert them into an offset in a page-aligned mapping, but the
134  * caller shouldn't need to know that small detail.
135  */
136 void * __ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags)
137 {
138         void * addr;
139         struct vm_struct * area;
140         unsigned long offset, last_addr;
141
142         /* Don't allow wraparound or zero size */
143         last_addr = phys_addr + size - 1;
144         if (!size || last_addr < phys_addr)
145                 return NULL;
146
147         /*
148          * Mappings have to be page-aligned
149          */
150         offset = phys_addr & ~PAGE_MASK;
151         phys_addr &= PAGE_MASK;
152         size = PAGE_ALIGN(last_addr + 1) - phys_addr;
153
154         /*
155          * Ok, go for it..
156          */
157         area = get_vm_area(size, VM_IOREMAP);
158         pr_debug("Get vm_area returns %p addr %p\n",area,area->addr);
159         if (!area)
160                 return NULL;
161         area->phys_addr = phys_addr;
162         addr = area->addr;
163         if (remap_area_pages((unsigned long)addr, phys_addr, size, flags)) {
164                 vunmap(addr);
165                 return NULL;
166         }
167         return (void *) (offset + (char *)addr);
168 }
169
170 void iounmap(void *addr)
171 {
172         struct vm_struct *area;
173
174         vfree((void *) (PAGE_MASK & (unsigned long) addr));
175         area = remove_vm_area((void *) (PAGE_MASK & (unsigned long) addr));
176         if (!area) {
177                 printk(KERN_ERR "iounmap: bad address %p\n", addr);
178                 return;
179         }
180
181         kfree(area);
182 }
183
184 static struct resource shmedia_iomap = {
185         .name   = "shmedia_iomap",
186         .start  = IOBASE_VADDR + PAGE_SIZE,
187         .end    = IOBASE_END - 1,
188 };
189
190 static void shmedia_mapioaddr(unsigned long pa, unsigned long va);
191 static void shmedia_unmapioaddr(unsigned long vaddr);
192 static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz);
193
194 /*
195  * We have the same problem as the SPARC, so lets have the same comment:
196  * Our mini-allocator...
197  * Boy this is gross! We need it because we must map I/O for
198  * timers and interrupt controller before the kmalloc is available.
199  */
200
201 #define XNMLN  15
202 #define XNRES  10
203
204 struct xresource {
205         struct resource xres;   /* Must be first */
206         int xflag;              /* 1 == used */
207         char xname[XNMLN+1];
208 };
209
210 static struct xresource xresv[XNRES];
211
212 static struct xresource *xres_alloc(void)
213 {
214         struct xresource *xrp;
215         int n;
216
217         xrp = xresv;
218         for (n = 0; n < XNRES; n++) {
219                 if (xrp->xflag == 0) {
220                         xrp->xflag = 1;
221                         return xrp;
222                 }
223                 xrp++;
224         }
225         return NULL;
226 }
227
228 static void xres_free(struct xresource *xrp)
229 {
230         xrp->xflag = 0;
231 }
232
233 static struct resource *shmedia_find_resource(struct resource *root,
234                                               unsigned long vaddr)
235 {
236         struct resource *res;
237
238         for (res = root->child; res; res = res->sibling)
239                 if (res->start <= vaddr && res->end >= vaddr)
240                         return res;
241
242         return NULL;
243 }
244
245 static unsigned long shmedia_alloc_io(unsigned long phys, unsigned long size,
246                                       const char *name)
247 {
248         static int printed_full = 0;
249         struct xresource *xres;
250         struct resource *res;
251         char *tack;
252         int tlen;
253
254         if (name == NULL) name = "???";
255
256         if ((xres = xres_alloc()) != 0) {
257                 tack = xres->xname;
258                 res = &xres->xres;
259         } else {
260                 if (!printed_full) {
261                         printk("%s: done with statics, switching to kmalloc\n",
262                                __FUNCTION__);
263                         printed_full = 1;
264                 }
265                 tlen = strlen(name);
266                 tack = kmalloc(sizeof (struct resource) + tlen + 1, GFP_KERNEL);
267                 if (!tack)
268                         return -ENOMEM;
269                 memset(tack, 0, sizeof(struct resource));
270                 res = (struct resource *) tack;
271                 tack += sizeof (struct resource);
272         }
273
274         strncpy(tack, name, XNMLN);
275         tack[XNMLN] = 0;
276         res->name = tack;
277
278         return shmedia_ioremap(res, phys, size);
279 }
280
281 static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz)
282 {
283         unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
284         unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
285         unsigned long va;
286         unsigned int psz;
287
288         if (allocate_resource(&shmedia_iomap, res, round_sz,
289                               shmedia_iomap.start, shmedia_iomap.end,
290                               PAGE_SIZE, NULL, NULL) != 0) {
291                 panic("alloc_io_res(%s): cannot occupy\n",
292                     (res->name != NULL)? res->name: "???");
293         }
294
295         va = res->start;
296         pa &= PAGE_MASK;
297
298         psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
299
300         /* log at boot time ... */
301         printk("mapioaddr: %6s  [%2d page%s]  va 0x%08lx   pa 0x%08x\n",
302                ((res->name != NULL) ? res->name : "???"),
303                psz, psz == 1 ? " " : "s", va, pa);
304
305         for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
306                 shmedia_mapioaddr(pa, va);
307                 va += PAGE_SIZE;
308                 pa += PAGE_SIZE;
309         }
310
311         res->start += offset;
312         res->end = res->start + sz - 1;         /* not strictly necessary.. */
313
314         return res->start;
315 }
316
317 static void shmedia_free_io(struct resource *res)
318 {
319         unsigned long len = res->end - res->start + 1;
320
321         BUG_ON((len & (PAGE_SIZE - 1)) != 0);
322
323         while (len) {
324                 len -= PAGE_SIZE;
325                 shmedia_unmapioaddr(res->start + len);
326         }
327
328         release_resource(res);
329 }
330
331 static void *sh64_get_page(void)
332 {
333         extern int after_bootmem;
334         void *page;
335
336         if (after_bootmem) {
337                 page = (void *)get_zeroed_page(GFP_ATOMIC);
338         } else {
339                 page = alloc_bootmem_pages(PAGE_SIZE);
340         }
341
342         if (!page || ((unsigned long)page & ~PAGE_MASK))
343                 panic("sh64_get_page: Out of memory already?\n");
344
345         return page;
346 }
347
348 static void shmedia_mapioaddr(unsigned long pa, unsigned long va)
349 {
350         pgd_t *pgdp;
351         pmd_t *pmdp;
352         pte_t *ptep, pte;
353         pgprot_t prot;
354         unsigned long flags = 1; /* 1 = CB0-1 device */
355
356         pr_debug("shmedia_mapiopage pa %08lx va %08lx\n",  pa, va);
357
358         pgdp = pgd_offset_k(va);
359         if (pgd_none(*pgdp) || !pgd_present(*pgdp)) {
360                 pmdp = (pmd_t *)sh64_get_page();
361                 set_pgd(pgdp, __pgd((unsigned long)pmdp | _KERNPG_TABLE));
362         }
363
364         pmdp = pmd_offset(pgdp, va);
365         if (pmd_none(*pmdp) || !pmd_present(*pmdp) ) {
366                 ptep = (pte_t *)sh64_get_page();
367                 set_pmd(pmdp, __pmd((unsigned long)ptep + _PAGE_TABLE));
368         }
369
370         prot = __pgprot(_PAGE_PRESENT | _PAGE_READ     | _PAGE_WRITE  |
371                         _PAGE_DIRTY   | _PAGE_ACCESSED | _PAGE_SHARED | flags);
372
373         pte = pfn_pte(pa >> PAGE_SHIFT, prot);
374         ptep = pte_offset_kernel(pmdp, va);
375
376         if (!pte_none(*ptep) &&
377             pte_val(*ptep) != pte_val(pte))
378                 pte_ERROR(*ptep);
379
380         set_pte(ptep, pte);
381
382         flush_tlb_kernel_range(va, PAGE_SIZE);
383 }
384
385 static void shmedia_unmapioaddr(unsigned long vaddr)
386 {
387         pgd_t *pgdp;
388         pmd_t *pmdp;
389         pte_t *ptep;
390
391         pgdp = pgd_offset_k(vaddr);
392         pmdp = pmd_offset(pgdp, vaddr);
393
394         if (pmd_none(*pmdp) || pmd_bad(*pmdp))
395                 return;
396
397         ptep = pte_offset_kernel(pmdp, vaddr);
398
399         if (pte_none(*ptep) || !pte_present(*ptep))
400                 return;
401
402         clear_page((void *)ptep);
403         pte_clear(&init_mm, vaddr, ptep);
404 }
405
406 unsigned long onchip_remap(unsigned long phys, unsigned long size, const char *name)
407 {
408         if (size < PAGE_SIZE)
409                 size = PAGE_SIZE;
410
411         return shmedia_alloc_io(phys, size, name);
412 }
413
414 void onchip_unmap(unsigned long vaddr)
415 {
416         struct resource *res;
417         unsigned int psz;
418
419         res = shmedia_find_resource(&shmedia_iomap, vaddr);
420         if (!res) {
421                 printk(KERN_ERR "%s: Failed to free 0x%08lx\n",
422                        __FUNCTION__, vaddr);
423                 return;
424         }
425
426         psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
427
428         printk(KERN_DEBUG "unmapioaddr: %6s  [%2d page%s] freed\n",
429                res->name, psz, psz == 1 ? " " : "s");
430
431         shmedia_free_io(res);
432
433         if ((char *)res >= (char *)xresv &&
434             (char *)res <  (char *)&xresv[XNRES]) {
435                 xres_free((struct xresource *)res);
436         } else {
437                 kfree(res);
438         }
439 }
440
441 #ifdef CONFIG_PROC_FS
442 static int
443 ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
444                   void *data)
445 {
446         char *p = buf, *e = buf + length;
447         struct resource *r;
448         const char *nm;
449
450         for (r = ((struct resource *)data)->child; r != NULL; r = r->sibling) {
451                 if (p + 32 >= e)        /* Better than nothing */
452                         break;
453                 if ((nm = r->name) == 0) nm = "???";
454                 p += sprintf(p, "%08lx-%08lx: %s\n", r->start, r->end, nm);
455         }
456
457         return p-buf;
458 }
459 #endif /* CONFIG_PROC_FS */
460
461 static int __init register_proc_onchip(void)
462 {
463 #ifdef CONFIG_PROC_FS
464         create_proc_read_entry("io_map",0,0, ioremap_proc_info, &shmedia_iomap);
465 #endif
466         return 0;
467 }
468
469 __initcall(register_proc_onchip);