Merge ../linus
[linux-2.6] / arch / x86_64 / mm / ioremap.c
1 /*
2  * arch/x86_64/mm/ioremap.c
3  *
4  * Re-map IO memory to kernel address space so that we can access it.
5  * This is needed for high PCI addresses that aren't mapped in the
6  * 640k-1MB IO memory area on PC's
7  *
8  * (C) Copyright 1995 1996 Linus Torvalds
9  */
10
11 #include <linux/vmalloc.h>
12 #include <linux/init.h>
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/io.h>
16 #include <asm/pgalloc.h>
17 #include <asm/fixmap.h>
18 #include <asm/tlbflush.h>
19 #include <asm/cacheflush.h>
20 #include <asm/proto.h>
21
22 #define ISA_START_ADDRESS      0xa0000
23 #define ISA_END_ADDRESS                0x100000
24
25 /*
26  * Fix up the linear direct mapping of the kernel to avoid cache attribute
27  * conflicts.
28  */
29 static int
30 ioremap_change_attr(unsigned long phys_addr, unsigned long size,
31                                         unsigned long flags)
32 {
33         int err = 0;
34         if (phys_addr + size - 1 < (end_pfn_map << PAGE_SHIFT)) {
35                 unsigned long npages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
36                 unsigned long vaddr = (unsigned long) __va(phys_addr);
37
38                 /*
39                  * Must use a address here and not struct page because the phys addr
40                  * can be a in hole between nodes and not have an memmap entry.
41                  */
42                 err = change_page_attr_addr(vaddr,npages,__pgprot(__PAGE_KERNEL|flags));
43                 if (!err)
44                         global_flush_tlb();
45         }
46         return err;
47 }
48
49 /*
50  * Generic mapping function
51  */
52
53 /*
54  * Remap an arbitrary physical address space into the kernel virtual
55  * address space. Needed when the kernel wants to access high addresses
56  * directly.
57  *
58  * NOTE! We need to allow non-page-aligned mappings too: we will obviously
59  * have to convert them into an offset in a page-aligned mapping, but the
60  * caller shouldn't need to know that small detail.
61  */
62 void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags)
63 {
64         void * addr;
65         struct vm_struct * area;
66         unsigned long offset, last_addr;
67         pgprot_t pgprot;
68
69         /* Don't allow wraparound or zero size */
70         last_addr = phys_addr + size - 1;
71         if (!size || last_addr < phys_addr)
72                 return NULL;
73
74         /*
75          * Don't remap the low PCI/ISA area, it's always mapped..
76          */
77         if (phys_addr >= ISA_START_ADDRESS && last_addr < ISA_END_ADDRESS)
78                 return (__force void __iomem *)phys_to_virt(phys_addr);
79
80 #ifdef CONFIG_FLATMEM
81         /*
82          * Don't allow anybody to remap normal RAM that we're using..
83          */
84         if (last_addr < virt_to_phys(high_memory)) {
85                 char *t_addr, *t_end;
86                 struct page *page;
87
88                 t_addr = __va(phys_addr);
89                 t_end = t_addr + (size - 1);
90            
91                 for(page = virt_to_page(t_addr); page <= virt_to_page(t_end); page++)
92                         if(!PageReserved(page))
93                                 return NULL;
94         }
95 #endif
96
97         pgprot = __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_GLOBAL
98                           | _PAGE_DIRTY | _PAGE_ACCESSED | flags);
99         /*
100          * Mappings have to be page-aligned
101          */
102         offset = phys_addr & ~PAGE_MASK;
103         phys_addr &= PAGE_MASK;
104         size = PAGE_ALIGN(last_addr+1) - phys_addr;
105
106         /*
107          * Ok, go for it..
108          */
109         area = get_vm_area(size, VM_IOREMAP | (flags << 20));
110         if (!area)
111                 return NULL;
112         area->phys_addr = phys_addr;
113         addr = area->addr;
114         if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,
115                                phys_addr, pgprot)) {
116                 remove_vm_area((void *)(PAGE_MASK & (unsigned long) addr));
117                 return NULL;
118         }
119         if (flags && ioremap_change_attr(phys_addr, size, flags) < 0) {
120                 area->flags &= 0xffffff;
121                 vunmap(addr);
122                 return NULL;
123         }
124         return (__force void __iomem *) (offset + (char *)addr);
125 }
126 EXPORT_SYMBOL(__ioremap);
127
128 /**
129  * ioremap_nocache     -   map bus memory into CPU space
130  * @offset:    bus address of the memory
131  * @size:      size of the resource to map
132  *
133  * ioremap_nocache performs a platform specific sequence of operations to
134  * make bus memory CPU accessible via the readb/readw/readl/writeb/
135  * writew/writel functions and the other mmio helpers. The returned
136  * address is not guaranteed to be usable directly as a virtual
137  * address. 
138  *
139  * This version of ioremap ensures that the memory is marked uncachable
140  * on the CPU as well as honouring existing caching rules from things like
141  * the PCI bus. Note that there are other caches and buffers on many 
142  * busses. In particular driver authors should read up on PCI writes
143  *
144  * It's useful if some control registers are in such an area and
145  * write combining or read caching is not desirable:
146  * 
147  * Must be freed with iounmap.
148  */
149
150 void __iomem *ioremap_nocache (unsigned long phys_addr, unsigned long size)
151 {
152         return __ioremap(phys_addr, size, _PAGE_PCD);
153 }
154 EXPORT_SYMBOL(ioremap_nocache);
155
156 /**
157  * iounmap - Free a IO remapping
158  * @addr: virtual address from ioremap_*
159  *
160  * Caller must ensure there is only one unmapping for the same pointer.
161  */
162 void iounmap(volatile void __iomem *addr)
163 {
164         struct vm_struct *p, *o;
165
166         if (addr <= high_memory) 
167                 return; 
168         if (addr >= phys_to_virt(ISA_START_ADDRESS) &&
169                 addr < phys_to_virt(ISA_END_ADDRESS))
170                 return;
171
172         addr = (volatile void __iomem *)(PAGE_MASK & (unsigned long __force)addr);
173         /* Use the vm area unlocked, assuming the caller
174            ensures there isn't another iounmap for the same address
175            in parallel. Reuse of the virtual address is prevented by
176            leaving it in the global lists until we're done with it.
177            cpa takes care of the direct mappings. */
178         read_lock(&vmlist_lock);
179         for (p = vmlist; p; p = p->next) {
180                 if (p->addr == addr)
181                         break;
182         }
183         read_unlock(&vmlist_lock);
184
185         if (!p) {
186                 printk("iounmap: bad address %p\n", addr);
187                 dump_stack();
188                 return;
189         }
190
191         /* Reset the direct mapping. Can block */
192         if (p->flags >> 20)
193                 ioremap_change_attr(p->phys_addr, p->size, 0);
194
195         /* Finally remove it */
196         o = remove_vm_area((void *)addr);
197         BUG_ON(p != o || o == NULL);
198         kfree(p); 
199 }
200 EXPORT_SYMBOL(iounmap);
201