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