x86-32: Pass the full resource data to ioremap()
[linux-3.10.git] / arch / x86 / mm / ioremap.c
1 /*
2  * Re-map IO memory to kernel address space so that we can access it.
3  * This is needed for high PCI addresses that aren't mapped in the
4  * 640k-1MB IO memory area on PC's
5  *
6  * (C) Copyright 1995 1996 Linus Torvalds
7  */
8
9 #include <linux/bootmem.h>
10 #include <linux/init.h>
11 #include <linux/io.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/vmalloc.h>
15
16 #include <asm/cacheflush.h>
17 #include <asm/e820.h>
18 #include <asm/fixmap.h>
19 #include <asm/pgtable.h>
20 #include <asm/tlbflush.h>
21 #include <asm/pgalloc.h>
22
23 enum ioremap_mode {
24         IOR_MODE_UNCACHED,
25         IOR_MODE_CACHED,
26 };
27
28 #ifdef CONFIG_X86_64
29
30 unsigned long __phys_addr(unsigned long x)
31 {
32         if (x >= __START_KERNEL_map)
33                 return x - __START_KERNEL_map + phys_base;
34         return x - PAGE_OFFSET;
35 }
36 EXPORT_SYMBOL(__phys_addr);
37
38 #endif
39
40 int page_is_ram(unsigned long pagenr)
41 {
42         unsigned long addr, end;
43         int i;
44
45         /*
46          * A special case is the first 4Kb of memory;
47          * This is a BIOS owned area, not kernel ram, but generally
48          * not listed as such in the E820 table.
49          */
50         if (pagenr == 0)
51                 return 0;
52
53         /*
54          * Second special case: Some BIOSen report the PC BIOS
55          * area (640->1Mb) as ram even though it is not.
56          */
57         if (pagenr >= (BIOS_BEGIN >> PAGE_SHIFT) &&
58                     pagenr < (BIOS_END >> PAGE_SHIFT))
59                 return 0;
60
61         for (i = 0; i < e820.nr_map; i++) {
62                 /*
63                  * Not usable memory:
64                  */
65                 if (e820.map[i].type != E820_RAM)
66                         continue;
67                 addr = (e820.map[i].addr + PAGE_SIZE-1) >> PAGE_SHIFT;
68                 end = (e820.map[i].addr + e820.map[i].size) >> PAGE_SHIFT;
69
70
71                 if ((pagenr >= addr) && (pagenr < end))
72                         return 1;
73         }
74         return 0;
75 }
76
77 /*
78  * Fix up the linear direct mapping of the kernel to avoid cache attribute
79  * conflicts.
80  */
81 static int ioremap_change_attr(unsigned long vaddr, unsigned long size,
82                                enum ioremap_mode mode)
83 {
84         unsigned long nrpages = size >> PAGE_SHIFT;
85         int err;
86
87         switch (mode) {
88         case IOR_MODE_UNCACHED:
89         default:
90                 err = set_memory_uc(vaddr, nrpages);
91                 break;
92         case IOR_MODE_CACHED:
93                 err = set_memory_wb(vaddr, nrpages);
94                 break;
95         }
96
97         return err;
98 }
99
100 /*
101  * Remap an arbitrary physical address space into the kernel virtual
102  * address space. Needed when the kernel wants to access high addresses
103  * directly.
104  *
105  * NOTE! We need to allow non-page-aligned mappings too: we will obviously
106  * have to convert them into an offset in a page-aligned mapping, but the
107  * caller shouldn't need to know that small detail.
108  */
109 static void __iomem *__ioremap(resource_size_t phys_addr, unsigned long size,
110                                enum ioremap_mode mode)
111 {
112         unsigned long pfn, offset, last_addr, vaddr;
113         struct vm_struct *area;
114         pgprot_t prot;
115
116         /* Don't allow wraparound or zero size */
117         last_addr = phys_addr + size - 1;
118         if (!size || last_addr < phys_addr)
119                 return NULL;
120
121         /*
122          * Don't remap the low PCI/ISA area, it's always mapped..
123          */
124         if (phys_addr >= ISA_START_ADDRESS && last_addr < ISA_END_ADDRESS)
125                 return (__force void __iomem *)phys_to_virt(phys_addr);
126
127         /*
128          * Don't allow anybody to remap normal RAM that we're using..
129          */
130         for (pfn = phys_addr >> PAGE_SHIFT; pfn < max_pfn_mapped &&
131              (pfn << PAGE_SHIFT) < last_addr; pfn++) {
132                 if (page_is_ram(pfn) && pfn_valid(pfn) &&
133                     !PageReserved(pfn_to_page(pfn)))
134                         return NULL;
135         }
136
137         switch (mode) {
138         case IOR_MODE_UNCACHED:
139         default:
140                 prot = PAGE_KERNEL_NOCACHE;
141                 break;
142         case IOR_MODE_CACHED:
143                 prot = PAGE_KERNEL;
144                 break;
145         }
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         if (!area)
159                 return NULL;
160         area->phys_addr = phys_addr;
161         vaddr = (unsigned long) area->addr;
162         if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot)) {
163                 free_vm_area(area);
164                 return NULL;
165         }
166
167         if (ioremap_change_attr(vaddr, size, mode) < 0) {
168                 vunmap(area->addr);
169                 return NULL;
170         }
171
172         return (void __iomem *) (vaddr + offset);
173 }
174
175 /**
176  * ioremap_nocache     -   map bus memory into CPU space
177  * @offset:    bus address of the memory
178  * @size:      size of the resource to map
179  *
180  * ioremap_nocache performs a platform specific sequence of operations to
181  * make bus memory CPU accessible via the readb/readw/readl/writeb/
182  * writew/writel functions and the other mmio helpers. The returned
183  * address is not guaranteed to be usable directly as a virtual
184  * address.
185  *
186  * This version of ioremap ensures that the memory is marked uncachable
187  * on the CPU as well as honouring existing caching rules from things like
188  * the PCI bus. Note that there are other caches and buffers on many
189  * busses. In particular driver authors should read up on PCI writes
190  *
191  * It's useful if some control registers are in such an area and
192  * write combining or read caching is not desirable:
193  *
194  * Must be freed with iounmap.
195  */
196 void __iomem *ioremap_nocache(resource_size_t phys_addr, unsigned long size)
197 {
198         return __ioremap(phys_addr, size, IOR_MODE_UNCACHED);
199 }
200 EXPORT_SYMBOL(ioremap_nocache);
201
202 void __iomem *ioremap_cache(resource_size_t phys_addr, unsigned long size)
203 {
204         return __ioremap(phys_addr, size, IOR_MODE_CACHED);
205 }
206 EXPORT_SYMBOL(ioremap_cache);
207
208 /**
209  * iounmap - Free a IO remapping
210  * @addr: virtual address from ioremap_*
211  *
212  * Caller must ensure there is only one unmapping for the same pointer.
213  */
214 void iounmap(volatile void __iomem *addr)
215 {
216         struct vm_struct *p, *o;
217
218         if ((void __force *)addr <= high_memory)
219                 return;
220
221         /*
222          * __ioremap special-cases the PCI/ISA range by not instantiating a
223          * vm_area and by simply returning an address into the kernel mapping
224          * of ISA space.   So handle that here.
225          */
226         if (addr >= phys_to_virt(ISA_START_ADDRESS) &&
227             addr < phys_to_virt(ISA_END_ADDRESS))
228                 return;
229
230         addr = (volatile void __iomem *)
231                 (PAGE_MASK & (unsigned long __force)addr);
232
233         /* Use the vm area unlocked, assuming the caller
234            ensures there isn't another iounmap for the same address
235            in parallel. Reuse of the virtual address is prevented by
236            leaving it in the global lists until we're done with it.
237            cpa takes care of the direct mappings. */
238         read_lock(&vmlist_lock);
239         for (p = vmlist; p; p = p->next) {
240                 if (p->addr == addr)
241                         break;
242         }
243         read_unlock(&vmlist_lock);
244
245         if (!p) {
246                 printk(KERN_ERR "iounmap: bad address %p\n", addr);
247                 dump_stack();
248                 return;
249         }
250
251         /* Finally remove it */
252         o = remove_vm_area((void *)addr);
253         BUG_ON(p != o || o == NULL);
254         kfree(p);
255 }
256 EXPORT_SYMBOL(iounmap);
257
258 #ifdef CONFIG_X86_32
259
260 int __initdata early_ioremap_debug;
261
262 static int __init early_ioremap_debug_setup(char *str)
263 {
264         early_ioremap_debug = 1;
265
266         return 0;
267 }
268 early_param("early_ioremap_debug", early_ioremap_debug_setup);
269
270 static __initdata int after_paging_init;
271 static __initdata pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)]
272                                 __attribute__((aligned(PAGE_SIZE)));
273
274 static inline pmd_t * __init early_ioremap_pmd(unsigned long addr)
275 {
276         /* Don't assume we're using swapper_pg_dir at this point */
277         pgd_t *base = __va(read_cr3());
278         pgd_t *pgd = &base[pgd_index(addr)];
279         pud_t *pud = pud_offset(pgd, addr);
280         pmd_t *pmd = pmd_offset(pud, addr);
281
282         return pmd;
283 }
284
285 static inline pte_t * __init early_ioremap_pte(unsigned long addr)
286 {
287         return &bm_pte[pte_index(addr)];
288 }
289
290 void __init early_ioremap_init(void)
291 {
292         pmd_t *pmd;
293
294         if (early_ioremap_debug)
295                 printk(KERN_INFO "early_ioremap_init()\n");
296
297         pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
298         memset(bm_pte, 0, sizeof(bm_pte));
299         pmd_populate_kernel(&init_mm, pmd, bm_pte);
300
301         /*
302          * The boot-ioremap range spans multiple pmds, for which
303          * we are not prepared:
304          */
305         if (pmd != early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END))) {
306                 WARN_ON(1);
307                 printk(KERN_WARNING "pmd %p != %p\n",
308                        pmd, early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END)));
309                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
310                         fix_to_virt(FIX_BTMAP_BEGIN));
311                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END):   %08lx\n",
312                         fix_to_virt(FIX_BTMAP_END));
313
314                 printk(KERN_WARNING "FIX_BTMAP_END:       %d\n", FIX_BTMAP_END);
315                 printk(KERN_WARNING "FIX_BTMAP_BEGIN:     %d\n",
316                        FIX_BTMAP_BEGIN);
317         }
318 }
319
320 void __init early_ioremap_clear(void)
321 {
322         pmd_t *pmd;
323
324         if (early_ioremap_debug)
325                 printk(KERN_INFO "early_ioremap_clear()\n");
326
327         pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
328         pmd_clear(pmd);
329         paravirt_release_pt(__pa(bm_pte) >> PAGE_SHIFT);
330         __flush_tlb_all();
331 }
332
333 void __init early_ioremap_reset(void)
334 {
335         enum fixed_addresses idx;
336         unsigned long addr, phys;
337         pte_t *pte;
338
339         after_paging_init = 1;
340         for (idx = FIX_BTMAP_BEGIN; idx >= FIX_BTMAP_END; idx--) {
341                 addr = fix_to_virt(idx);
342                 pte = early_ioremap_pte(addr);
343                 if (pte_present(*pte)) {
344                         phys = pte_val(*pte) & PAGE_MASK;
345                         set_fixmap(idx, phys);
346                 }
347         }
348 }
349
350 static void __init __early_set_fixmap(enum fixed_addresses idx,
351                                    unsigned long phys, pgprot_t flags)
352 {
353         unsigned long addr = __fix_to_virt(idx);
354         pte_t *pte;
355
356         if (idx >= __end_of_fixed_addresses) {
357                 BUG();
358                 return;
359         }
360         pte = early_ioremap_pte(addr);
361         if (pgprot_val(flags))
362                 set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
363         else
364                 pte_clear(NULL, addr, pte);
365         __flush_tlb_one(addr);
366 }
367
368 static inline void __init early_set_fixmap(enum fixed_addresses idx,
369                                         unsigned long phys)
370 {
371         if (after_paging_init)
372                 set_fixmap(idx, phys);
373         else
374                 __early_set_fixmap(idx, phys, PAGE_KERNEL);
375 }
376
377 static inline void __init early_clear_fixmap(enum fixed_addresses idx)
378 {
379         if (after_paging_init)
380                 clear_fixmap(idx);
381         else
382                 __early_set_fixmap(idx, 0, __pgprot(0));
383 }
384
385
386 int __initdata early_ioremap_nested;
387
388 static int __init check_early_ioremap_leak(void)
389 {
390         if (!early_ioremap_nested)
391                 return 0;
392
393         printk(KERN_WARNING
394                "Debug warning: early ioremap leak of %d areas detected.\n",
395                early_ioremap_nested);
396         printk(KERN_WARNING
397                "please boot with early_ioremap_debug and report the dmesg.\n");
398         WARN_ON(1);
399
400         return 1;
401 }
402 late_initcall(check_early_ioremap_leak);
403
404 void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
405 {
406         unsigned long offset, last_addr;
407         unsigned int nrpages, nesting;
408         enum fixed_addresses idx0, idx;
409
410         WARN_ON(system_state != SYSTEM_BOOTING);
411
412         nesting = early_ioremap_nested;
413         if (early_ioremap_debug) {
414                 printk(KERN_INFO "early_ioremap(%08lx, %08lx) [%d] => ",
415                        phys_addr, size, nesting);
416                 dump_stack();
417         }
418
419         /* Don't allow wraparound or zero size */
420         last_addr = phys_addr + size - 1;
421         if (!size || last_addr < phys_addr) {
422                 WARN_ON(1);
423                 return NULL;
424         }
425
426         if (nesting >= FIX_BTMAPS_NESTING) {
427                 WARN_ON(1);
428                 return NULL;
429         }
430         early_ioremap_nested++;
431         /*
432          * Mappings have to be page-aligned
433          */
434         offset = phys_addr & ~PAGE_MASK;
435         phys_addr &= PAGE_MASK;
436         size = PAGE_ALIGN(last_addr) - phys_addr;
437
438         /*
439          * Mappings have to fit in the FIX_BTMAP area.
440          */
441         nrpages = size >> PAGE_SHIFT;
442         if (nrpages > NR_FIX_BTMAPS) {
443                 WARN_ON(1);
444                 return NULL;
445         }
446
447         /*
448          * Ok, go for it..
449          */
450         idx0 = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
451         idx = idx0;
452         while (nrpages > 0) {
453                 early_set_fixmap(idx, phys_addr);
454                 phys_addr += PAGE_SIZE;
455                 --idx;
456                 --nrpages;
457         }
458         if (early_ioremap_debug)
459                 printk(KERN_CONT "%08lx + %08lx\n", offset, fix_to_virt(idx0));
460
461         return (void *) (offset + fix_to_virt(idx0));
462 }
463
464 void __init early_iounmap(void *addr, unsigned long size)
465 {
466         unsigned long virt_addr;
467         unsigned long offset;
468         unsigned int nrpages;
469         enum fixed_addresses idx;
470         unsigned int nesting;
471
472         nesting = --early_ioremap_nested;
473         WARN_ON(nesting < 0);
474
475         if (early_ioremap_debug) {
476                 printk(KERN_INFO "early_iounmap(%p, %08lx) [%d]\n", addr,
477                        size, nesting);
478                 dump_stack();
479         }
480
481         virt_addr = (unsigned long)addr;
482         if (virt_addr < fix_to_virt(FIX_BTMAP_BEGIN)) {
483                 WARN_ON(1);
484                 return;
485         }
486         offset = virt_addr & ~PAGE_MASK;
487         nrpages = PAGE_ALIGN(offset + size - 1) >> PAGE_SHIFT;
488
489         idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
490         while (nrpages > 0) {
491                 early_clear_fixmap(idx);
492                 --idx;
493                 --nrpages;
494         }
495 }
496
497 void __this_fixmap_does_not_exist(void)
498 {
499         WARN_ON(1);
500 }
501
502 #endif /* CONFIG_X86_32 */