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 #include <linux/mmiotrace.h>
  16
  17 #include <asm/cacheflush.h>
  18 #include <asm/e820.h>
  19 #include <asm/fixmap.h>
  20 #include <asm/pgtable.h>
  21 #include <asm/tlbflush.h>
  22 #include <asm/pgalloc.h>
  23 #include <asm/pat.h>
  24
  25 #include "physaddr.h"
  26
  27 /*
  28  * Fix up the linear direct mapping of the kernel to avoid cache attribute
  29  * conflicts.
  30  */
  31 int ioremap_change_attr(unsigned long vaddr, unsigned long size,
  32                         enum page_cache_mode pcm)
  33 {
  34         unsigned long nrpages = size >> PAGE_SHIFT;
  35         int err;
  36
  37         switch (pcm) {
  38         case _PAGE_CACHE_MODE_UC:
  39         default:
  40                 err = _set_memory_uc(vaddr, nrpages);
  41                 break;
  42         case _PAGE_CACHE_MODE_WC:
  43                 err = _set_memory_wc(vaddr, nrpages);
  44                 break;
  45         case _PAGE_CACHE_MODE_WT:
  46                 err = _set_memory_wt(vaddr, nrpages);
  47                 break;
  48         case _PAGE_CACHE_MODE_WB:
  49                 err = _set_memory_wb(vaddr, nrpages);
  50                 break;
  51         }
  52
  53         return err;
  54 }
  55
  56 static int __ioremap_check_ram(unsigned long start_pfn, unsigned long nr_pages,
  57                                void *arg)
  58 {
  59         unsigned long i;
  60
  61         for (i = 0; i < nr_pages; ++i)
  62                 if (pfn_valid(start_pfn + i) &&
  63                     !PageReserved(pfn_to_page(start_pfn + i)))
  64                         return 1;
  65
  66         return 0;
  67 }
  68
  69 /*
  70  * Remap an arbitrary physical address space into the kernel virtual
  71  * address space. It transparently creates kernel huge I/O mapping when
  72  * the physical address is aligned by a huge page size (1GB or 2MB) and
  73  * the requested size is at least the huge page size.
  74  *
  75  * NOTE: MTRRs can override PAT memory types with a 4KB granularity.
  76  * Therefore, the mapping code falls back to use a smaller page toward 4KB
  77  * when a mapping range is covered by non-WB type of MTRRs.
  78  *
  79  * NOTE! We need to allow non-page-aligned mappings too: we will obviously
  80  * have to convert them into an offset in a page-aligned mapping, but the
  81  * caller shouldn't need to know that small detail.
  82  */
  83 static void __iomem *__ioremap_caller(resource_size_t phys_addr,
  84                 unsigned long size, enum page_cache_mode pcm, void *caller)
  85 {
  86         unsigned long offset, vaddr;
  87         resource_size_t pfn, last_pfn, last_addr;
  88         const resource_size_t unaligned_phys_addr = phys_addr;
  89         const unsigned long unaligned_size = size;
  90         struct vm_struct *area;
  91         enum page_cache_mode new_pcm;
  92         pgprot_t prot;
  93         int retval;
  94         void __iomem *ret_addr;
  95         int ram_region;
  96
  97         /* Don't allow wraparound or zero size */
  98         last_addr = phys_addr + size - 1;
  99         if (!size || last_addr < phys_addr)
 100                 return NULL;
 101
 102         if (!phys_addr_valid(phys_addr)) {
 103                 printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
 104                        (unsigned long long)phys_addr);
 105                 WARN_ON_ONCE(1);
 106                 return NULL;
 107         }
 108
 109         /*
 110          * Don't remap the low PCI/ISA area, it's always mapped..
 111          */
 112         if (is_ISA_range(phys_addr, last_addr))
 113                 return (__force void __iomem *)phys_to_virt(phys_addr);
 114
 115         /*
 116          * Don't allow anybody to remap normal RAM that we're using..
 117          */
 118         /* First check if whole region can be identified as RAM or not */
 119         ram_region = region_is_ram(phys_addr, size);
 120         if (ram_region > 0) {
 121                 WARN_ONCE(1, "ioremap on RAM at 0x%lx - 0x%lx\n",
 122                                 (unsigned long int)phys_addr,
 123                                 (unsigned long int)last_addr);
 124                 return NULL;
 125         }
 126
 127         /* If could not be identified(-1), check page by page */
 128         if (ram_region < 0) {
 129                 pfn      = phys_addr >> PAGE_SHIFT;
 130                 last_pfn = last_addr >> PAGE_SHIFT;
 131                 if (walk_system_ram_range(pfn, last_pfn - pfn + 1, NULL,
 132                                           __ioremap_check_ram) == 1) {
 133                         WARN_ONCE(1, "ioremap on RAM at 0x%llx - 0x%llx\n",
 134                                         phys_addr, last_addr);
 135                         return NULL;
 136                 }
 137         }
 138         /*
 139          * Mappings have to be page-aligned
 140          */
 141         offset = phys_addr & ~PAGE_MASK;
 142         phys_addr &= PHYSICAL_PAGE_MASK;
 143         size = PAGE_ALIGN(last_addr+1) - phys_addr;
 144
 145         retval = reserve_memtype(phys_addr, (u64)phys_addr + size,
 146                                                 pcm, &new_pcm);
 147         if (retval) {
 148                 printk(KERN_ERR "ioremap reserve_memtype failed %d\n", retval);
 149                 return NULL;
 150         }
 151
 152         if (pcm != new_pcm) {
 153                 if (!is_new_memtype_allowed(phys_addr, size, pcm, new_pcm)) {
 154                         printk(KERN_ERR
 155                 "ioremap error for 0x%llx-0x%llx, requested 0x%x, got 0x%x\n",
 156                                 (unsigned long long)phys_addr,
 157                                 (unsigned long long)(phys_addr + size),
 158                                 pcm, new_pcm);
 159                         goto err_free_memtype;
 160                 }
 161                 pcm = new_pcm;
 162         }
 163
 164         prot = PAGE_KERNEL_IO;
 165         switch (pcm) {
 166         case _PAGE_CACHE_MODE_UC:
 167         default:
 168                 prot = __pgprot(pgprot_val(prot) |
 169                                 cachemode2protval(_PAGE_CACHE_MODE_UC));
 170                 break;
 171         case _PAGE_CACHE_MODE_UC_MINUS:
 172                 prot = __pgprot(pgprot_val(prot) |
 173                                 cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS));
 174                 break;
 175         case _PAGE_CACHE_MODE_WC:
 176                 prot = __pgprot(pgprot_val(prot) |
 177                                 cachemode2protval(_PAGE_CACHE_MODE_WC));
 178                 break;
 179         case _PAGE_CACHE_MODE_WT:
 180                 prot = __pgprot(pgprot_val(prot) |
 181                                 cachemode2protval(_PAGE_CACHE_MODE_WT));
 182                 break;
 183         case _PAGE_CACHE_MODE_WB:
 184                 break;
 185         }
 186
 187         /*
 188          * Ok, go for it..
 189          */
 190         area = get_vm_area_caller(size, VM_IOREMAP, caller);
 191         if (!area)
 192                 goto err_free_memtype;
 193         area->phys_addr = phys_addr;
 194         vaddr = (unsigned long) area->addr;
 195
 196         if (kernel_map_sync_memtype(phys_addr, size, pcm))
 197                 goto err_free_area;
 198
 199         if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot))
 200                 goto err_free_area;
 201
 202         ret_addr = (void __iomem *) (vaddr + offset);
 203         mmiotrace_ioremap(unaligned_phys_addr, unaligned_size, ret_addr);
 204
 205         /*
 206          * Check if the request spans more than any BAR in the iomem resource
 207          * tree.
 208          */
 209         WARN_ONCE(iomem_map_sanity_check(unaligned_phys_addr, unaligned_size),
 210                   KERN_INFO "Info: mapping multiple BARs. Your kernel is fine.");
 211
 212         return ret_addr;
 213 err_free_area:
 214         free_vm_area(area);
 215 err_free_memtype:
 216         free_memtype(phys_addr, phys_addr + size);
 217         return NULL;
 218 }
 219
 220 /**
 221  * ioremap_nocache     -   map bus memory into CPU space
 222  * @phys_addr:    bus address of the memory
 223  * @size:      size of the resource to map
 224  *
 225  * ioremap_nocache performs a platform specific sequence of operations to
 226  * make bus memory CPU accessible via the readb/readw/readl/writeb/
 227  * writew/writel functions and the other mmio helpers. The returned
 228  * address is not guaranteed to be usable directly as a virtual
 229  * address.
 230  *
 231  * This version of ioremap ensures that the memory is marked uncachable
 232  * on the CPU as well as honouring existing caching rules from things like
 233  * the PCI bus. Note that there are other caches and buffers on many
 234  * busses. In particular driver authors should read up on PCI writes
 235  *
 236  * It's useful if some control registers are in such an area and
 237  * write combining or read caching is not desirable:
 238  *
 239  * Must be freed with iounmap.
 240  */
 241 void __iomem *ioremap_nocache(resource_size_t phys_addr, unsigned long size)
 242 {
 243         /*
 244          * Ideally, this should be:
 245          *      pat_enabled() ? _PAGE_CACHE_MODE_UC : _PAGE_CACHE_MODE_UC_MINUS;
 246          *
 247          * Till we fix all X drivers to use ioremap_wc(), we will use
 248          * UC MINUS. Drivers that are certain they need or can already
 249          * be converted over to strong UC can use ioremap_uc().
 250          */
 251         enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC_MINUS;
 252
 253         return __ioremap_caller(phys_addr, size, pcm,
 254                                 __builtin_return_address(0));
 255 }
 256 EXPORT_SYMBOL(ioremap_nocache);
 257
 258 /**
 259  * ioremap_uc     -   map bus memory into CPU space as strongly uncachable
 260  * @phys_addr:    bus address of the memory
 261  * @size:      size of the resource to map
 262  *
 263  * ioremap_uc performs a platform specific sequence of operations to
 264  * make bus memory CPU accessible via the readb/readw/readl/writeb/
 265  * writew/writel functions and the other mmio helpers. The returned
 266  * address is not guaranteed to be usable directly as a virtual
 267  * address.
 268  *
 269  * This version of ioremap ensures that the memory is marked with a strong
 270  * preference as completely uncachable on the CPU when possible. For non-PAT
 271  * systems this ends up setting page-attribute flags PCD=1, PWT=1. For PAT
 272  * systems this will set the PAT entry for the pages as strong UC.  This call
 273  * will honor existing caching rules from things like the PCI bus. Note that
 274  * there are other caches and buffers on many busses. In particular driver
 275  * authors should read up on PCI writes.
 276  *
 277  * It's useful if some control registers are in such an area and
 278  * write combining or read caching is not desirable:
 279  *
 280  * Must be freed with iounmap.
 281  */
 282 void __iomem *ioremap_uc(resource_size_t phys_addr, unsigned long size)
 283 {
 284         enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC;
 285
 286         return __ioremap_caller(phys_addr, size, pcm,
 287                                 __builtin_return_address(0));
 288 }
 289 EXPORT_SYMBOL_GPL(ioremap_uc);
 290
 291 /**
 292  * ioremap_wc   -       map memory into CPU space write combined
 293  * @phys_addr:  bus address of the memory
 294  * @size:       size of the resource to map
 295  *
 296  * This version of ioremap ensures that the memory is marked write combining.
 297  * Write combining allows faster writes to some hardware devices.
 298  *
 299  * Must be freed with iounmap.
 300  */
 301 void __iomem *ioremap_wc(resource_size_t phys_addr, unsigned long size)
 302 {
 303         return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WC,
 304                                         __builtin_return_address(0));
 305 }
 306 EXPORT_SYMBOL(ioremap_wc);
 307
 308 /**
 309  * ioremap_wt   -       map memory into CPU space write through
 310  * @phys_addr:  bus address of the memory
 311  * @size:       size of the resource to map
 312  *
 313  * This version of ioremap ensures that the memory is marked write through.
 314  * Write through stores data into memory while keeping the cache up-to-date.
 315  *
 316  * Must be freed with iounmap.
 317  */
 318 void __iomem *ioremap_wt(resource_size_t phys_addr, unsigned long size)
 319 {
 320         return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WT,
 321                                         __builtin_return_address(0));
 322 }
 323 EXPORT_SYMBOL(ioremap_wt);
 324
 325 void __iomem *ioremap_cache(resource_size_t phys_addr, unsigned long size)
 326 {
 327         return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
 328                                 __builtin_return_address(0));
 329 }
 330 EXPORT_SYMBOL(ioremap_cache);
 331
 332 void __iomem *ioremap_prot(resource_size_t phys_addr, unsigned long size,
 333                                 unsigned long prot_val)
 334 {
 335         return __ioremap_caller(phys_addr, size,
 336                                 pgprot2cachemode(__pgprot(prot_val)),
 337                                 __builtin_return_address(0));
 338 }
 339 EXPORT_SYMBOL(ioremap_prot);
 340
 341 /**
 342  * iounmap - Free a IO remapping
 343  * @addr: virtual address from ioremap_*
 344  *
 345  * Caller must ensure there is only one unmapping for the same pointer.
 346  */
 347 void iounmap(volatile void __iomem *addr)
 348 {
 349         struct vm_struct *p, *o;
 350
 351         if ((void __force *)addr <= high_memory)
 352                 return;
 353
 354         /*
 355          * __ioremap special-cases the PCI/ISA range by not instantiating a
 356          * vm_area and by simply returning an address into the kernel mapping
 357          * of ISA space.   So handle that here.
 358          */
 359         if ((void __force *)addr >= phys_to_virt(ISA_START_ADDRESS) &&
 360             (void __force *)addr < phys_to_virt(ISA_END_ADDRESS))
 361                 return;
 362
 363         addr = (volatile void __iomem *)
 364                 (PAGE_MASK & (unsigned long __force)addr);
 365
 366         mmiotrace_iounmap(addr);
 367
 368         /* Use the vm area unlocked, assuming the caller
 369            ensures there isn't another iounmap for the same address
 370            in parallel. Reuse of the virtual address is prevented by
 371            leaving it in the global lists until we're done with it.
 372            cpa takes care of the direct mappings. */
 373         p = find_vm_area((void __force *)addr);
 374
 375         if (!p) {
 376                 printk(KERN_ERR "iounmap: bad address %p\n", addr);
 377                 dump_stack();
 378                 return;
 379         }
 380
 381         free_memtype(p->phys_addr, p->phys_addr + get_vm_area_size(p));
 382
 383         /* Finally remove it */
 384         o = remove_vm_area((void __force *)addr);
 385         BUG_ON(p != o || o == NULL);
 386         kfree(p);
 387 }
 388 EXPORT_SYMBOL(iounmap);
 389
 390 int __init arch_ioremap_pud_supported(void)
 391 {
 392 #ifdef CONFIG_X86_64
 393         return cpu_has_gbpages;
 394 #else
 395         return 0;
 396 #endif
 397 }
 398
 399 int __init arch_ioremap_pmd_supported(void)
 400 {
 401         return cpu_has_pse;
 402 }
 403
 404 /*
 405  * Convert a physical pointer to a virtual kernel pointer for /dev/mem
 406  * access
 407  */
 408 void *xlate_dev_mem_ptr(phys_addr_t phys)
 409 {
 410         unsigned long start  = phys &  PAGE_MASK;
 411         unsigned long offset = phys & ~PAGE_MASK;
 412         void *vaddr;
 413
 414         /* If page is RAM, we can use __va. Otherwise ioremap and unmap. */
 415         if (page_is_ram(start >> PAGE_SHIFT))
 416                 return __va(phys);
 417
 418         vaddr = ioremap_cache(start, PAGE_SIZE);
 419         /* Only add the offset on success and return NULL if the ioremap() failed: */
 420         if (vaddr)
 421                 vaddr += offset;
 422
 423         return vaddr;
 424 }
 425
 426 void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
 427 {
 428         if (page_is_ram(phys >> PAGE_SHIFT))
 429                 return;
 430
 431         iounmap((void __iomem *)((unsigned long)addr & PAGE_MASK));
 432 }
 433
 434 static pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)] __page_aligned_bss;
 435
 436 static inline pmd_t * __init early_ioremap_pmd(unsigned long addr)
 437 {
 438         /* Don't assume we're using swapper_pg_dir at this point */
 439         pgd_t *base = __va(read_cr3());
 440         pgd_t *pgd = &base[pgd_index(addr)];
 441         pud_t *pud = pud_offset(pgd, addr);
 442         pmd_t *pmd = pmd_offset(pud, addr);
 443
 444         return pmd;
 445 }
 446
 447 static inline pte_t * __init early_ioremap_pte(unsigned long addr)
 448 {
 449         return &bm_pte[pte_index(addr)];
 450 }
 451
 452 bool __init is_early_ioremap_ptep(pte_t *ptep)
 453 {
 454         return ptep >= &bm_pte[0] && ptep < &bm_pte[PAGE_SIZE/sizeof(pte_t)];
 455 }
 456
 457 void __init early_ioremap_init(void)
 458 {
 459         pmd_t *pmd;
 460
 461 #ifdef CONFIG_X86_64
 462         BUILD_BUG_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
 463 #else
 464         WARN_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
 465 #endif
 466
 467         early_ioremap_setup();
 468
 469         pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
 470         memset(bm_pte, 0, sizeof(bm_pte));
 471         pmd_populate_kernel(&init_mm, pmd, bm_pte);
 472
 473         /*
 474          * The boot-ioremap range spans multiple pmds, for which
 475          * we are not prepared:
 476          */
 477 #define __FIXADDR_TOP (-PAGE_SIZE)
 478         BUILD_BUG_ON((__fix_to_virt(FIX_BTMAP_BEGIN) >> PMD_SHIFT)
 479                      != (__fix_to_virt(FIX_BTMAP_END) >> PMD_SHIFT));
 480 #undef __FIXADDR_TOP
 481         if (pmd != early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END))) {
 482                 WARN_ON(1);
 483                 printk(KERN_WARNING "pmd %p != %p\n",
 484                        pmd, early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END)));
 485                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
 486                         fix_to_virt(FIX_BTMAP_BEGIN));
 487                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END):   %08lx\n",
 488                         fix_to_virt(FIX_BTMAP_END));
 489
 490                 printk(KERN_WARNING "FIX_BTMAP_END:       %d\n", FIX_BTMAP_END);
 491                 printk(KERN_WARNING "FIX_BTMAP_BEGIN:     %d\n",
 492                        FIX_BTMAP_BEGIN);
 493         }
 494 }
 495
 496 void __init __early_set_fixmap(enum fixed_addresses idx,
 497                                phys_addr_t phys, pgprot_t flags)
 498 {
 499         unsigned long addr = __fix_to_virt(idx);
 500         pte_t *pte;
 501
 502         if (idx >= __end_of_fixed_addresses) {
 503                 BUG();
 504                 return;
 505         }
 506         pte = early_ioremap_pte(addr);
 507
 508         if (pgprot_val(flags))
 509                 set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
 510         else
 511                 pte_clear(&init_mm, addr, pte);
 512         __flush_tlb_one(addr);
 513 }