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/ioport.h>
  13 #include <linux/slab.h>
  14 #include <linux/vmalloc.h>
  15 #include <linux/mmiotrace.h>
  16 #include <linux/mem_encrypt.h>
  17 #include <linux/efi.h>
  18
  19 #include <asm/set_memory.h>
  20 #include <asm/e820/api.h>
  21 #include <asm/fixmap.h>
  22 #include <asm/pgtable.h>
  23 #include <asm/tlbflush.h>
  24 #include <asm/pgalloc.h>
  25 #include <asm/pat.h>
  26 #include <asm/setup.h>
  27
  28 #include "physaddr.h"
  29
  30 struct ioremap_mem_flags {
  31         bool system_ram;
  32         bool desc_other;
  33 };
  34
  35 /*
  36  * Fix up the linear direct mapping of the kernel to avoid cache attribute
  37  * conflicts.
  38  */
  39 int ioremap_change_attr(unsigned long vaddr, unsigned long size,
  40                         enum page_cache_mode pcm)
  41 {
  42         unsigned long nrpages = size >> PAGE_SHIFT;
  43         int err;
  44
  45         switch (pcm) {
  46         case _PAGE_CACHE_MODE_UC:
  47         default:
  48                 err = _set_memory_uc(vaddr, nrpages);
  49                 break;
  50         case _PAGE_CACHE_MODE_WC:
  51                 err = _set_memory_wc(vaddr, nrpages);
  52                 break;
  53         case _PAGE_CACHE_MODE_WT:
  54                 err = _set_memory_wt(vaddr, nrpages);
  55                 break;
  56         case _PAGE_CACHE_MODE_WB:
  57                 err = _set_memory_wb(vaddr, nrpages);
  58                 break;
  59         }
  60
  61         return err;
  62 }
  63
  64 static bool __ioremap_check_ram(struct resource *res)
  65 {
  66         unsigned long start_pfn, stop_pfn;
  67         unsigned long i;
  68
  69         if ((res->flags & IORESOURCE_SYSTEM_RAM) != IORESOURCE_SYSTEM_RAM)
  70                 return false;
  71
  72         start_pfn = (res->start + PAGE_SIZE - 1) >> PAGE_SHIFT;
  73         stop_pfn = (res->end + 1) >> PAGE_SHIFT;
  74         if (stop_pfn > start_pfn) {
  75                 for (i = 0; i < (stop_pfn - start_pfn); ++i)
  76                         if (pfn_valid(start_pfn + i) &&
  77                             !PageReserved(pfn_to_page(start_pfn + i)))
  78                                 return true;
  79         }
  80
  81         return false;
  82 }
  83
  84 static int __ioremap_check_desc_other(struct resource *res)
  85 {
  86         return (res->desc != IORES_DESC_NONE);
  87 }
  88
  89 static int __ioremap_res_check(struct resource *res, void *arg)
  90 {
  91         struct ioremap_mem_flags *flags = arg;
  92
  93         if (!flags->system_ram)
  94                 flags->system_ram = __ioremap_check_ram(res);
  95
  96         if (!flags->desc_other)
  97                 flags->desc_other = __ioremap_check_desc_other(res);
  98
  99         return flags->system_ram && flags->desc_other;
 100 }
 101
 102 /*
 103  * To avoid multiple resource walks, this function walks resources marked as
 104  * IORESOURCE_MEM and IORESOURCE_BUSY and looking for system RAM and/or a
 105  * resource described not as IORES_DESC_NONE (e.g. IORES_DESC_ACPI_TABLES).
 106  */
 107 static void __ioremap_check_mem(resource_size_t addr, unsigned long size,
 108                                 struct ioremap_mem_flags *flags)
 109 {
 110         u64 start, end;
 111
 112         start = (u64)addr;
 113         end = start + size - 1;
 114         memset(flags, 0, sizeof(*flags));
 115
 116         walk_mem_res(start, end, flags, __ioremap_res_check);
 117 }
 118
 119 /*
 120  * Remap an arbitrary physical address space into the kernel virtual
 121  * address space. It transparently creates kernel huge I/O mapping when
 122  * the physical address is aligned by a huge page size (1GB or 2MB) and
 123  * the requested size is at least the huge page size.
 124  *
 125  * NOTE: MTRRs can override PAT memory types with a 4KB granularity.
 126  * Therefore, the mapping code falls back to use a smaller page toward 4KB
 127  * when a mapping range is covered by non-WB type of MTRRs.
 128  *
 129  * NOTE! We need to allow non-page-aligned mappings too: we will obviously
 130  * have to convert them into an offset in a page-aligned mapping, but the
 131  * caller shouldn't need to know that small detail.
 132  */
 133 static void __iomem *__ioremap_caller(resource_size_t phys_addr,
 134                 unsigned long size, enum page_cache_mode pcm, void *caller)
 135 {
 136         unsigned long offset, vaddr;
 137         resource_size_t last_addr;
 138         const resource_size_t unaligned_phys_addr = phys_addr;
 139         const unsigned long unaligned_size = size;
 140         struct ioremap_mem_flags mem_flags;
 141         struct vm_struct *area;
 142         enum page_cache_mode new_pcm;
 143         pgprot_t prot;
 144         int retval;
 145         void __iomem *ret_addr;
 146
 147         /* Don't allow wraparound or zero size */
 148         last_addr = phys_addr + size - 1;
 149         if (!size || last_addr < phys_addr)
 150                 return NULL;
 151
 152         if (!phys_addr_valid(phys_addr)) {
 153                 printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
 154                        (unsigned long long)phys_addr);
 155                 WARN_ON_ONCE(1);
 156                 return NULL;
 157         }
 158
 159         __ioremap_check_mem(phys_addr, size, &mem_flags);
 160
 161         /*
 162          * Don't allow anybody to remap normal RAM that we're using..
 163          */
 164         if (mem_flags.system_ram) {
 165                 WARN_ONCE(1, "ioremap on RAM at %pa - %pa\n",
 166                           &phys_addr, &last_addr);
 167                 return NULL;
 168         }
 169
 170         /*
 171          * Mappings have to be page-aligned
 172          */
 173         offset = phys_addr & ~PAGE_MASK;
 174         phys_addr &= PAGE_MASK;
 175         size = PAGE_ALIGN(last_addr+1) - phys_addr;
 176
 177         /*
 178          * Mask out any bits not part of the actual physical
 179          * address, like memory encryption bits.
 180          */
 181         phys_addr &= PHYSICAL_PAGE_MASK;
 182
 183         retval = reserve_memtype(phys_addr, (u64)phys_addr + size,
 184                                                 pcm, &new_pcm);
 185         if (retval) {
 186                 printk(KERN_ERR "ioremap reserve_memtype failed %d\n", retval);
 187                 return NULL;
 188         }
 189
 190         if (pcm != new_pcm) {
 191                 if (!is_new_memtype_allowed(phys_addr, size, pcm, new_pcm)) {
 192                         printk(KERN_ERR
 193                 "ioremap error for 0x%llx-0x%llx, requested 0x%x, got 0x%x\n",
 194                                 (unsigned long long)phys_addr,
 195                                 (unsigned long long)(phys_addr + size),
 196                                 pcm, new_pcm);
 197                         goto err_free_memtype;
 198                 }
 199                 pcm = new_pcm;
 200         }
 201
 202         /*
 203          * If the page being mapped is in memory and SEV is active then
 204          * make sure the memory encryption attribute is enabled in the
 205          * resulting mapping.
 206          */
 207         prot = PAGE_KERNEL_IO;
 208         if (sev_active() && mem_flags.desc_other)
 209                 prot = pgprot_encrypted(prot);
 210
 211         switch (pcm) {
 212         case _PAGE_CACHE_MODE_UC:
 213         default:
 214                 prot = __pgprot(pgprot_val(prot) |
 215                                 cachemode2protval(_PAGE_CACHE_MODE_UC));
 216                 break;
 217         case _PAGE_CACHE_MODE_UC_MINUS:
 218                 prot = __pgprot(pgprot_val(prot) |
 219                                 cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS));
 220                 break;
 221         case _PAGE_CACHE_MODE_WC:
 222                 prot = __pgprot(pgprot_val(prot) |
 223                                 cachemode2protval(_PAGE_CACHE_MODE_WC));
 224                 break;
 225         case _PAGE_CACHE_MODE_WT:
 226                 prot = __pgprot(pgprot_val(prot) |
 227                                 cachemode2protval(_PAGE_CACHE_MODE_WT));
 228                 break;
 229         case _PAGE_CACHE_MODE_WB:
 230                 break;
 231         }
 232
 233         /*
 234          * Ok, go for it..
 235          */
 236         area = get_vm_area_caller(size, VM_IOREMAP, caller);
 237         if (!area)
 238                 goto err_free_memtype;
 239         area->phys_addr = phys_addr;
 240         vaddr = (unsigned long) area->addr;
 241
 242         if (kernel_map_sync_memtype(phys_addr, size, pcm))
 243                 goto err_free_area;
 244
 245         if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot))
 246                 goto err_free_area;
 247
 248         ret_addr = (void __iomem *) (vaddr + offset);
 249         mmiotrace_ioremap(unaligned_phys_addr, unaligned_size, ret_addr);
 250
 251         /*
 252          * Check if the request spans more than any BAR in the iomem resource
 253          * tree.
 254          */
 255         if (iomem_map_sanity_check(unaligned_phys_addr, unaligned_size))
 256                 pr_warn("caller %pS mapping multiple BARs\n", caller);
 257
 258         return ret_addr;
 259 err_free_area:
 260         free_vm_area(area);
 261 err_free_memtype:
 262         free_memtype(phys_addr, phys_addr + size);
 263         return NULL;
 264 }
 265
 266 /**
 267  * ioremap_nocache     -   map bus memory into CPU space
 268  * @phys_addr:    bus address of the memory
 269  * @size:      size of the resource to map
 270  *
 271  * ioremap_nocache performs a platform specific sequence of operations to
 272  * make bus memory CPU accessible via the readb/readw/readl/writeb/
 273  * writew/writel functions and the other mmio helpers. The returned
 274  * address is not guaranteed to be usable directly as a virtual
 275  * address.
 276  *
 277  * This version of ioremap ensures that the memory is marked uncachable
 278  * on the CPU as well as honouring existing caching rules from things like
 279  * the PCI bus. Note that there are other caches and buffers on many
 280  * busses. In particular driver authors should read up on PCI writes
 281  *
 282  * It's useful if some control registers are in such an area and
 283  * write combining or read caching is not desirable:
 284  *
 285  * Must be freed with iounmap.
 286  */
 287 void __iomem *ioremap_nocache(resource_size_t phys_addr, unsigned long size)
 288 {
 289         /*
 290          * Ideally, this should be:
 291          *      pat_enabled() ? _PAGE_CACHE_MODE_UC : _PAGE_CACHE_MODE_UC_MINUS;
 292          *
 293          * Till we fix all X drivers to use ioremap_wc(), we will use
 294          * UC MINUS. Drivers that are certain they need or can already
 295          * be converted over to strong UC can use ioremap_uc().
 296          */
 297         enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC_MINUS;
 298
 299         return __ioremap_caller(phys_addr, size, pcm,
 300                                 __builtin_return_address(0));
 301 }
 302 EXPORT_SYMBOL(ioremap_nocache);
 303
 304 /**
 305  * ioremap_uc     -   map bus memory into CPU space as strongly uncachable
 306  * @phys_addr:    bus address of the memory
 307  * @size:      size of the resource to map
 308  *
 309  * ioremap_uc performs a platform specific sequence of operations to
 310  * make bus memory CPU accessible via the readb/readw/readl/writeb/
 311  * writew/writel functions and the other mmio helpers. The returned
 312  * address is not guaranteed to be usable directly as a virtual
 313  * address.
 314  *
 315  * This version of ioremap ensures that the memory is marked with a strong
 316  * preference as completely uncachable on the CPU when possible. For non-PAT
 317  * systems this ends up setting page-attribute flags PCD=1, PWT=1. For PAT
 318  * systems this will set the PAT entry for the pages as strong UC.  This call
 319  * will honor existing caching rules from things like the PCI bus. Note that
 320  * there are other caches and buffers on many busses. In particular driver
 321  * authors should read up on PCI writes.
 322  *
 323  * It's useful if some control registers are in such an area and
 324  * write combining or read caching is not desirable:
 325  *
 326  * Must be freed with iounmap.
 327  */
 328 void __iomem *ioremap_uc(resource_size_t phys_addr, unsigned long size)
 329 {
 330         enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC;
 331
 332         return __ioremap_caller(phys_addr, size, pcm,
 333                                 __builtin_return_address(0));
 334 }
 335 EXPORT_SYMBOL_GPL(ioremap_uc);
 336
 337 /**
 338  * ioremap_wc   -       map memory into CPU space write combined
 339  * @phys_addr:  bus address of the memory
 340  * @size:       size of the resource to map
 341  *
 342  * This version of ioremap ensures that the memory is marked write combining.
 343  * Write combining allows faster writes to some hardware devices.
 344  *
 345  * Must be freed with iounmap.
 346  */
 347 void __iomem *ioremap_wc(resource_size_t phys_addr, unsigned long size)
 348 {
 349         return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WC,
 350                                         __builtin_return_address(0));
 351 }
 352 EXPORT_SYMBOL(ioremap_wc);
 353
 354 /**
 355  * ioremap_wt   -       map memory into CPU space write through
 356  * @phys_addr:  bus address of the memory
 357  * @size:       size of the resource to map
 358  *
 359  * This version of ioremap ensures that the memory is marked write through.
 360  * Write through stores data into memory while keeping the cache up-to-date.
 361  *
 362  * Must be freed with iounmap.
 363  */
 364 void __iomem *ioremap_wt(resource_size_t phys_addr, unsigned long size)
 365 {
 366         return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WT,
 367                                         __builtin_return_address(0));
 368 }
 369 EXPORT_SYMBOL(ioremap_wt);
 370
 371 void __iomem *ioremap_cache(resource_size_t phys_addr, unsigned long size)
 372 {
 373         return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
 374                                 __builtin_return_address(0));
 375 }
 376 EXPORT_SYMBOL(ioremap_cache);
 377
 378 void __iomem *ioremap_prot(resource_size_t phys_addr, unsigned long size,
 379                                 unsigned long prot_val)
 380 {
 381         return __ioremap_caller(phys_addr, size,
 382                                 pgprot2cachemode(__pgprot(prot_val)),
 383                                 __builtin_return_address(0));
 384 }
 385 EXPORT_SYMBOL(ioremap_prot);
 386
 387 /**
 388  * iounmap - Free a IO remapping
 389  * @addr: virtual address from ioremap_*
 390  *
 391  * Caller must ensure there is only one unmapping for the same pointer.
 392  */
 393 void iounmap(volatile void __iomem *addr)
 394 {
 395         struct vm_struct *p, *o;
 396
 397         if ((void __force *)addr <= high_memory)
 398                 return;
 399
 400         /*
 401          * The PCI/ISA range special-casing was removed from __ioremap()
 402          * so this check, in theory, can be removed. However, there are
 403          * cases where iounmap() is called for addresses not obtained via
 404          * ioremap() (vga16fb for example). Add a warning so that these
 405          * cases can be caught and fixed.
 406          */
 407         if ((void __force *)addr >= phys_to_virt(ISA_START_ADDRESS) &&
 408             (void __force *)addr < phys_to_virt(ISA_END_ADDRESS)) {
 409                 WARN(1, "iounmap() called for ISA range not obtained using ioremap()\n");
 410                 return;
 411         }
 412
 413         mmiotrace_iounmap(addr);
 414
 415         addr = (volatile void __iomem *)
 416                 (PAGE_MASK & (unsigned long __force)addr);
 417
 418         /* Use the vm area unlocked, assuming the caller
 419            ensures there isn't another iounmap for the same address
 420            in parallel. Reuse of the virtual address is prevented by
 421            leaving it in the global lists until we're done with it.
 422            cpa takes care of the direct mappings. */
 423         p = find_vm_area((void __force *)addr);
 424
 425         if (!p) {
 426                 printk(KERN_ERR "iounmap: bad address %p\n", addr);
 427                 dump_stack();
 428                 return;
 429         }
 430
 431         free_memtype(p->phys_addr, p->phys_addr + get_vm_area_size(p));
 432
 433         /* Finally remove it */
 434         o = remove_vm_area((void __force *)addr);
 435         BUG_ON(p != o || o == NULL);
 436         kfree(p);
 437 }
 438 EXPORT_SYMBOL(iounmap);
 439
 440 int __init arch_ioremap_pud_supported(void)
 441 {
 442 #ifdef CONFIG_X86_64
 443         return boot_cpu_has(X86_FEATURE_GBPAGES);
 444 #else
 445         return 0;
 446 #endif
 447 }
 448
 449 int __init arch_ioremap_pmd_supported(void)
 450 {
 451         return boot_cpu_has(X86_FEATURE_PSE);
 452 }
 453
 454 /*
 455  * Convert a physical pointer to a virtual kernel pointer for /dev/mem
 456  * access
 457  */
 458 void *xlate_dev_mem_ptr(phys_addr_t phys)
 459 {
 460         unsigned long start  = phys &  PAGE_MASK;
 461         unsigned long offset = phys & ~PAGE_MASK;
 462         void *vaddr;
 463
 464         /* memremap() maps if RAM, otherwise falls back to ioremap() */
 465         vaddr = memremap(start, PAGE_SIZE, MEMREMAP_WB);
 466
 467         /* Only add the offset on success and return NULL if memremap() failed */
 468         if (vaddr)
 469                 vaddr += offset;
 470
 471         return vaddr;
 472 }
 473
 474 void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
 475 {
 476         memunmap((void *)((unsigned long)addr & PAGE_MASK));
 477 }
 478
 479 /*
 480  * Examine the physical address to determine if it is an area of memory
 481  * that should be mapped decrypted.  If the memory is not part of the
 482  * kernel usable area it was accessed and created decrypted, so these
 483  * areas should be mapped decrypted. And since the encryption key can
 484  * change across reboots, persistent memory should also be mapped
 485  * decrypted.
 486  *
 487  * If SEV is active, that implies that BIOS/UEFI also ran encrypted so
 488  * only persistent memory should be mapped decrypted.
 489  */
 490 static bool memremap_should_map_decrypted(resource_size_t phys_addr,
 491                                           unsigned long size)
 492 {
 493         int is_pmem;
 494
 495         /*
 496          * Check if the address is part of a persistent memory region.
 497          * This check covers areas added by E820, EFI and ACPI.
 498          */
 499         is_pmem = region_intersects(phys_addr, size, IORESOURCE_MEM,
 500                                     IORES_DESC_PERSISTENT_MEMORY);
 501         if (is_pmem != REGION_DISJOINT)
 502                 return true;
 503
 504         /*
 505          * Check if the non-volatile attribute is set for an EFI
 506          * reserved area.
 507          */
 508         if (efi_enabled(EFI_BOOT)) {
 509                 switch (efi_mem_type(phys_addr)) {
 510                 case EFI_RESERVED_TYPE:
 511                         if (efi_mem_attributes(phys_addr) & EFI_MEMORY_NV)
 512                                 return true;
 513                         break;
 514                 default:
 515                         break;
 516                 }
 517         }
 518
 519         /* Check if the address is outside kernel usable area */
 520         switch (e820__get_entry_type(phys_addr, phys_addr + size - 1)) {
 521         case E820_TYPE_RESERVED:
 522         case E820_TYPE_ACPI:
 523         case E820_TYPE_NVS:
 524         case E820_TYPE_UNUSABLE:
 525                 /* For SEV, these areas are encrypted */
 526                 if (sev_active())
 527                         break;
 528                 /* Fallthrough */
 529
 530         case E820_TYPE_PRAM:
 531                 return true;
 532         default:
 533                 break;
 534         }
 535
 536         return false;
 537 }
 538
 539 /*
 540  * Examine the physical address to determine if it is EFI data. Check
 541  * it against the boot params structure and EFI tables and memory types.
 542  */
 543 static bool memremap_is_efi_data(resource_size_t phys_addr,
 544                                  unsigned long size)
 545 {
 546         u64 paddr;
 547
 548         /* Check if the address is part of EFI boot/runtime data */
 549         if (!efi_enabled(EFI_BOOT))
 550                 return false;
 551
 552         paddr = boot_params.efi_info.efi_memmap_hi;
 553         paddr <<= 32;
 554         paddr |= boot_params.efi_info.efi_memmap;
 555         if (phys_addr == paddr)
 556                 return true;
 557
 558         paddr = boot_params.efi_info.efi_systab_hi;
 559         paddr <<= 32;
 560         paddr |= boot_params.efi_info.efi_systab;
 561         if (phys_addr == paddr)
 562                 return true;
 563
 564         if (efi_is_table_address(phys_addr))
 565                 return true;
 566
 567         switch (efi_mem_type(phys_addr)) {
 568         case EFI_BOOT_SERVICES_DATA:
 569         case EFI_RUNTIME_SERVICES_DATA:
 570                 return true;
 571         default:
 572                 break;
 573         }
 574
 575         return false;
 576 }
 577
 578 /*
 579  * Examine the physical address to determine if it is boot data by checking
 580  * it against the boot params setup_data chain.
 581  */
 582 static bool memremap_is_setup_data(resource_size_t phys_addr,
 583                                    unsigned long size)
 584 {
 585         struct setup_data *data;
 586         u64 paddr, paddr_next;
 587
 588         paddr = boot_params.hdr.setup_data;
 589         while (paddr) {
 590                 unsigned int len;
 591
 592                 if (phys_addr == paddr)
 593                         return true;
 594
 595                 data = memremap(paddr, sizeof(*data),
 596                                 MEMREMAP_WB | MEMREMAP_DEC);
 597
 598                 paddr_next = data->next;
 599                 len = data->len;
 600
 601                 memunmap(data);
 602
 603                 if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
 604                         return true;
 605
 606                 paddr = paddr_next;
 607         }
 608
 609         return false;
 610 }
 611
 612 /*
 613  * Examine the physical address to determine if it is boot data by checking
 614  * it against the boot params setup_data chain (early boot version).
 615  */
 616 static bool __init early_memremap_is_setup_data(resource_size_t phys_addr,
 617                                                 unsigned long size)
 618 {
 619         struct setup_data *data;
 620         u64 paddr, paddr_next;
 621
 622         paddr = boot_params.hdr.setup_data;
 623         while (paddr) {
 624                 unsigned int len;
 625
 626                 if (phys_addr == paddr)
 627                         return true;
 628
 629                 data = early_memremap_decrypted(paddr, sizeof(*data));
 630
 631                 paddr_next = data->next;
 632                 len = data->len;
 633
 634                 early_memunmap(data, sizeof(*data));
 635
 636                 if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
 637                         return true;
 638
 639                 paddr = paddr_next;
 640         }
 641
 642         return false;
 643 }
 644
 645 /*
 646  * Architecture function to determine if RAM remap is allowed. By default, a
 647  * RAM remap will map the data as encrypted. Determine if a RAM remap should
 648  * not be done so that the data will be mapped decrypted.
 649  */
 650 bool arch_memremap_can_ram_remap(resource_size_t phys_addr, unsigned long size,
 651                                  unsigned long flags)
 652 {
 653         if (!mem_encrypt_active())
 654                 return true;
 655
 656         if (flags & MEMREMAP_ENC)
 657                 return true;
 658
 659         if (flags & MEMREMAP_DEC)
 660                 return false;
 661
 662         if (sme_active()) {
 663                 if (memremap_is_setup_data(phys_addr, size) ||
 664                     memremap_is_efi_data(phys_addr, size))
 665                         return false;
 666         }
 667
 668         return !memremap_should_map_decrypted(phys_addr, size);
 669 }
 670
 671 /*
 672  * Architecture override of __weak function to adjust the protection attributes
 673  * used when remapping memory. By default, early_memremap() will map the data
 674  * as encrypted. Determine if an encrypted mapping should not be done and set
 675  * the appropriate protection attributes.
 676  */
 677 pgprot_t __init early_memremap_pgprot_adjust(resource_size_t phys_addr,
 678                                              unsigned long size,
 679                                              pgprot_t prot)
 680 {
 681         bool encrypted_prot;
 682
 683         if (!mem_encrypt_active())
 684                 return prot;
 685
 686         encrypted_prot = true;
 687
 688         if (sme_active()) {
 689                 if (early_memremap_is_setup_data(phys_addr, size) ||
 690                     memremap_is_efi_data(phys_addr, size))
 691                         encrypted_prot = false;
 692         }
 693
 694         if (encrypted_prot && memremap_should_map_decrypted(phys_addr, size))
 695                 encrypted_prot = false;
 696
 697         return encrypted_prot ? pgprot_encrypted(prot)
 698                               : pgprot_decrypted(prot);
 699 }
 700
 701 bool phys_mem_access_encrypted(unsigned long phys_addr, unsigned long size)
 702 {
 703         return arch_memremap_can_ram_remap(phys_addr, size, 0);
 704 }
 705
 706 #ifdef CONFIG_AMD_MEM_ENCRYPT
 707 /* Remap memory with encryption */
 708 void __init *early_memremap_encrypted(resource_size_t phys_addr,
 709                                       unsigned long size)
 710 {
 711         return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC);
 712 }
 713
 714 /*
 715  * Remap memory with encryption and write-protected - cannot be called
 716  * before pat_init() is called
 717  */
 718 void __init *early_memremap_encrypted_wp(resource_size_t phys_addr,
 719                                          unsigned long size)
 720 {
 721         /* Be sure the write-protect PAT entry is set for write-protect */
 722         if (__pte2cachemode_tbl[_PAGE_CACHE_MODE_WP] != _PAGE_CACHE_MODE_WP)
 723                 return NULL;
 724
 725         return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC_WP);
 726 }
 727
 728 /* Remap memory without encryption */
 729 void __init *early_memremap_decrypted(resource_size_t phys_addr,
 730                                       unsigned long size)
 731 {
 732         return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC);
 733 }
 734
 735 /*
 736  * Remap memory without encryption and write-protected - cannot be called
 737  * before pat_init() is called
 738  */
 739 void __init *early_memremap_decrypted_wp(resource_size_t phys_addr,
 740                                          unsigned long size)
 741 {
 742         /* Be sure the write-protect PAT entry is set for write-protect */
 743         if (__pte2cachemode_tbl[_PAGE_CACHE_MODE_WP] != _PAGE_CACHE_MODE_WP)
 744                 return NULL;
 745
 746         return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC_WP);
 747 }
 748 #endif  /* CONFIG_AMD_MEM_ENCRYPT */
 749
 750 static pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)] __page_aligned_bss;
 751
 752 static inline pmd_t * __init early_ioremap_pmd(unsigned long addr)
 753 {
 754         /* Don't assume we're using swapper_pg_dir at this point */
 755         pgd_t *base = __va(read_cr3_pa());
 756         pgd_t *pgd = &base[pgd_index(addr)];
 757         p4d_t *p4d = p4d_offset(pgd, addr);
 758         pud_t *pud = pud_offset(p4d, addr);
 759         pmd_t *pmd = pmd_offset(pud, addr);
 760
 761         return pmd;
 762 }
 763
 764 static inline pte_t * __init early_ioremap_pte(unsigned long addr)
 765 {
 766         return &bm_pte[pte_index(addr)];
 767 }
 768
 769 bool __init is_early_ioremap_ptep(pte_t *ptep)
 770 {
 771         return ptep >= &bm_pte[0] && ptep < &bm_pte[PAGE_SIZE/sizeof(pte_t)];
 772 }
 773
 774 void __init early_ioremap_init(void)
 775 {
 776         pmd_t *pmd;
 777
 778 #ifdef CONFIG_X86_64
 779         BUILD_BUG_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
 780 #else
 781         WARN_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
 782 #endif
 783
 784         early_ioremap_setup();
 785
 786         pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
 787         memset(bm_pte, 0, sizeof(bm_pte));
 788         pmd_populate_kernel(&init_mm, pmd, bm_pte);
 789
 790         /*
 791          * The boot-ioremap range spans multiple pmds, for which
 792          * we are not prepared:
 793          */
 794 #define __FIXADDR_TOP (-PAGE_SIZE)
 795         BUILD_BUG_ON((__fix_to_virt(FIX_BTMAP_BEGIN) >> PMD_SHIFT)
 796                      != (__fix_to_virt(FIX_BTMAP_END) >> PMD_SHIFT));
 797 #undef __FIXADDR_TOP
 798         if (pmd != early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END))) {
 799                 WARN_ON(1);
 800                 printk(KERN_WARNING "pmd %p != %p\n",
 801                        pmd, early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END)));
 802                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
 803                         fix_to_virt(FIX_BTMAP_BEGIN));
 804                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END):   %08lx\n",
 805                         fix_to_virt(FIX_BTMAP_END));
 806
 807                 printk(KERN_WARNING "FIX_BTMAP_END:       %d\n", FIX_BTMAP_END);
 808                 printk(KERN_WARNING "FIX_BTMAP_BEGIN:     %d\n",
 809                        FIX_BTMAP_BEGIN);
 810         }
 811 }
 812
 813 void __init __early_set_fixmap(enum fixed_addresses idx,
 814                                phys_addr_t phys, pgprot_t flags)
 815 {
 816         unsigned long addr = __fix_to_virt(idx);
 817         pte_t *pte;
 818
 819         if (idx >= __end_of_fixed_addresses) {
 820                 BUG();
 821                 return;
 822         }
 823         pte = early_ioremap_pte(addr);
 824
 825         /* Sanitize 'prot' against any unsupported bits: */
 826         pgprot_val(flags) &= __default_kernel_pte_mask;
 827
 828         if (pgprot_val(flags))
 829                 set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
 830         else
 831                 pte_clear(&init_mm, addr, pte);
 832         __flush_tlb_one_kernel(addr);
 833 }