Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/arch/arm/mm/ioremap.c |
| 3 | * |
| 4 | * Re-map IO memory to kernel address space so that we can access it. |
| 5 | * |
| 6 | * (C) Copyright 1995 1996 Linus Torvalds |
| 7 | * |
| 8 | * Hacked for ARM by Phil Blundell <philb@gnu.org> |
| 9 | * Hacked to allow all architectures to build, and various cleanups |
| 10 | * by Russell King |
| 11 | * |
| 12 | * This allows a driver to remap an arbitrary region of bus memory into |
| 13 | * virtual space. One should *only* use readl, writel, memcpy_toio and |
| 14 | * so on with such remapped areas. |
| 15 | * |
| 16 | * Because the ARM only has a 32-bit address space we can't address the |
| 17 | * whole of the (physical) PCI space at once. PCI huge-mode addressing |
| 18 | * allows us to circumvent this restriction by splitting PCI space into |
| 19 | * two 2GB chunks and mapping only one at a time into processor memory. |
| 20 | * We use MMU protection domains to trap any attempt to access the bank |
| 21 | * that is not currently mapped. (This isn't fully implemented yet.) |
| 22 | */ |
| 23 | #include <linux/module.h> |
| 24 | #include <linux/errno.h> |
| 25 | #include <linux/mm.h> |
| 26 | #include <linux/vmalloc.h> |
| 27 | |
| 28 | #include <asm/cacheflush.h> |
| 29 | #include <asm/io.h> |
| 30 | #include <asm/tlbflush.h> |
| 31 | |
| 32 | static inline void |
| 33 | remap_area_pte(pte_t * pte, unsigned long address, unsigned long size, |
| 34 | unsigned long phys_addr, pgprot_t pgprot) |
| 35 | { |
| 36 | unsigned long end; |
| 37 | |
| 38 | address &= ~PMD_MASK; |
| 39 | end = address + size; |
| 40 | if (end > PMD_SIZE) |
| 41 | end = PMD_SIZE; |
| 42 | BUG_ON(address >= end); |
| 43 | do { |
| 44 | if (!pte_none(*pte)) |
| 45 | goto bad; |
| 46 | |
| 47 | set_pte(pte, pfn_pte(phys_addr >> PAGE_SHIFT, pgprot)); |
| 48 | address += PAGE_SIZE; |
| 49 | phys_addr += PAGE_SIZE; |
| 50 | pte++; |
| 51 | } while (address && (address < end)); |
| 52 | return; |
| 53 | |
| 54 | bad: |
| 55 | printk("remap_area_pte: page already exists\n"); |
| 56 | BUG(); |
| 57 | } |
| 58 | |
| 59 | static inline int |
| 60 | remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size, |
| 61 | unsigned long phys_addr, unsigned long flags) |
| 62 | { |
| 63 | unsigned long end; |
| 64 | pgprot_t pgprot; |
| 65 | |
| 66 | address &= ~PGDIR_MASK; |
| 67 | end = address + size; |
| 68 | |
| 69 | if (end > PGDIR_SIZE) |
| 70 | end = PGDIR_SIZE; |
| 71 | |
| 72 | phys_addr -= address; |
| 73 | BUG_ON(address >= end); |
| 74 | |
| 75 | pgprot = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY | L_PTE_WRITE | flags); |
| 76 | do { |
Hugh Dickins | 872fec1 | 2005-10-29 18:16:21 -0700 | [diff] [blame] | 77 | pte_t * pte = pte_alloc_kernel(pmd, address); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | if (!pte) |
| 79 | return -ENOMEM; |
| 80 | remap_area_pte(pte, address, end - address, address + phys_addr, pgprot); |
| 81 | address = (address + PMD_SIZE) & PMD_MASK; |
| 82 | pmd++; |
| 83 | } while (address && (address < end)); |
| 84 | return 0; |
| 85 | } |
| 86 | |
| 87 | static int |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 88 | remap_area_pages(unsigned long start, unsigned long pfn, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | unsigned long size, unsigned long flags) |
| 90 | { |
| 91 | unsigned long address = start; |
| 92 | unsigned long end = start + size; |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 93 | unsigned long phys_addr = __pfn_to_phys(pfn); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | int err = 0; |
| 95 | pgd_t * dir; |
| 96 | |
| 97 | phys_addr -= address; |
| 98 | dir = pgd_offset(&init_mm, address); |
| 99 | BUG_ON(address >= end); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | do { |
| 101 | pmd_t *pmd = pmd_alloc(&init_mm, dir, address); |
| 102 | if (!pmd) { |
| 103 | err = -ENOMEM; |
| 104 | break; |
| 105 | } |
| 106 | if (remap_area_pmd(pmd, address, end - address, |
| 107 | phys_addr + address, flags)) { |
| 108 | err = -ENOMEM; |
| 109 | break; |
| 110 | } |
| 111 | |
| 112 | address = (address + PGDIR_SIZE) & PGDIR_MASK; |
| 113 | dir++; |
| 114 | } while (address && (address < end)); |
| 115 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | flush_cache_vmap(start, end); |
| 117 | return err; |
| 118 | } |
| 119 | |
| 120 | /* |
| 121 | * Remap an arbitrary physical address space into the kernel virtual |
| 122 | * address space. Needed when the kernel wants to access high addresses |
| 123 | * directly. |
| 124 | * |
| 125 | * NOTE! We need to allow non-page-aligned mappings too: we will obviously |
| 126 | * have to convert them into an offset in a page-aligned mapping, but the |
| 127 | * caller shouldn't need to know that small detail. |
| 128 | * |
| 129 | * 'flags' are the extra L_PTE_ flags that you want to specify for this |
| 130 | * mapping. See include/asm-arm/proc-armv/pgtable.h for more information. |
| 131 | */ |
| 132 | void __iomem * |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 133 | __ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size, |
| 134 | unsigned long flags) |
| 135 | { |
| 136 | unsigned long addr; |
| 137 | struct vm_struct * area; |
| 138 | |
| 139 | area = get_vm_area(size, VM_IOREMAP); |
| 140 | if (!area) |
| 141 | return NULL; |
| 142 | addr = (unsigned long)area->addr; |
| 143 | if (remap_area_pages(addr, pfn, size, flags)) { |
Catalin Marinas | 478922c | 2006-05-16 11:30:26 +0100 | [diff] [blame] | 144 | vunmap((void *)addr); |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 145 | return NULL; |
| 146 | } |
| 147 | return (void __iomem *) (offset + (char *)addr); |
| 148 | } |
| 149 | EXPORT_SYMBOL(__ioremap_pfn); |
| 150 | |
| 151 | void __iomem * |
Russell King | 67a1901 | 2005-11-17 16:48:00 +0000 | [diff] [blame] | 152 | __ioremap(unsigned long phys_addr, size_t size, unsigned long flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | { |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 154 | unsigned long last_addr; |
| 155 | unsigned long offset = phys_addr & ~PAGE_MASK; |
| 156 | unsigned long pfn = __phys_to_pfn(phys_addr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 158 | /* |
| 159 | * Don't allow wraparound or zero size |
| 160 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | last_addr = phys_addr + size - 1; |
| 162 | if (!size || last_addr < phys_addr) |
| 163 | return NULL; |
| 164 | |
| 165 | /* |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 166 | * Page align the mapping size |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | size = PAGE_ALIGN(last_addr + 1) - phys_addr; |
| 169 | |
Deepak Saxena | 9d4ae72 | 2006-01-09 19:23:11 +0000 | [diff] [blame] | 170 | return __ioremap_pfn(pfn, offset, size, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | } |
| 172 | EXPORT_SYMBOL(__ioremap); |
| 173 | |
| 174 | void __iounmap(void __iomem *addr) |
| 175 | { |
Catalin Marinas | 478922c | 2006-05-16 11:30:26 +0100 | [diff] [blame] | 176 | vunmap((void *)(PAGE_MASK & (unsigned long)addr)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | } |
| 178 | EXPORT_SYMBOL(__iounmap); |
Russell King | 09f0551 | 2005-06-20 18:44:37 +0100 | [diff] [blame] | 179 | |
| 180 | #ifdef __io |
| 181 | void __iomem *ioport_map(unsigned long port, unsigned int nr) |
| 182 | { |
| 183 | return __io(port); |
| 184 | } |
| 185 | EXPORT_SYMBOL(ioport_map); |
| 186 | |
| 187 | void ioport_unmap(void __iomem *addr) |
| 188 | { |
| 189 | } |
| 190 | EXPORT_SYMBOL(ioport_unmap); |
| 191 | #endif |
| 192 | |
| 193 | #ifdef CONFIG_PCI |
| 194 | #include <linux/pci.h> |
| 195 | #include <linux/ioport.h> |
| 196 | |
| 197 | void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) |
| 198 | { |
| 199 | unsigned long start = pci_resource_start(dev, bar); |
| 200 | unsigned long len = pci_resource_len(dev, bar); |
| 201 | unsigned long flags = pci_resource_flags(dev, bar); |
| 202 | |
| 203 | if (!len || !start) |
| 204 | return NULL; |
| 205 | if (maxlen && len > maxlen) |
| 206 | len = maxlen; |
| 207 | if (flags & IORESOURCE_IO) |
| 208 | return ioport_map(start, len); |
| 209 | if (flags & IORESOURCE_MEM) { |
| 210 | if (flags & IORESOURCE_CACHEABLE) |
| 211 | return ioremap(start, len); |
| 212 | return ioremap_nocache(start, len); |
| 213 | } |
| 214 | return NULL; |
| 215 | } |
| 216 | EXPORT_SYMBOL(pci_iomap); |
| 217 | |
| 218 | void pci_iounmap(struct pci_dev *dev, void __iomem *addr) |
| 219 | { |
| 220 | if ((unsigned long)addr >= VMALLOC_START && |
| 221 | (unsigned long)addr < VMALLOC_END) |
| 222 | iounmap(addr); |
| 223 | } |
| 224 | EXPORT_SYMBOL(pci_iounmap); |
| 225 | #endif |