1 // SPDX-License-Identifier: GPL-2.0-only
3 * Re-map IO memory to kernel address space so that we can access it.
4 * This is needed for high PCI addresses that aren't mapped in the
5 * 640k-1MB IO memory area on PC's
7 * (C) Copyright 1995 1996 Linus Torvalds
10 #include <linux/memblock.h>
11 #include <linux/init.h>
13 #include <linux/ioport.h>
14 #include <linux/slab.h>
15 #include <linux/vmalloc.h>
16 #include <linux/mmiotrace.h>
17 #include <linux/mem_encrypt.h>
18 #include <linux/efi.h>
19 #include <linux/pgtable.h>
21 #include <asm/set_memory.h>
22 #include <asm/e820/api.h>
24 #include <asm/fixmap.h>
25 #include <asm/tlbflush.h>
26 #include <asm/pgalloc.h>
27 #include <asm/memtype.h>
28 #include <asm/setup.h>
33 * Descriptor controlling ioremap() behavior.
40 * Fix up the linear direct mapping of the kernel to avoid cache attribute
43 int ioremap_change_attr(unsigned long vaddr, unsigned long size,
44 enum page_cache_mode pcm)
46 unsigned long nrpages = size >> PAGE_SHIFT;
50 case _PAGE_CACHE_MODE_UC:
52 err = _set_memory_uc(vaddr, nrpages);
54 case _PAGE_CACHE_MODE_WC:
55 err = _set_memory_wc(vaddr, nrpages);
57 case _PAGE_CACHE_MODE_WT:
58 err = _set_memory_wt(vaddr, nrpages);
60 case _PAGE_CACHE_MODE_WB:
61 err = _set_memory_wb(vaddr, nrpages);
68 /* Does the range (or a subset of) contain normal RAM? */
69 static unsigned int __ioremap_check_ram(struct resource *res)
71 unsigned long start_pfn, stop_pfn;
74 if ((res->flags & IORESOURCE_SYSTEM_RAM) != IORESOURCE_SYSTEM_RAM)
77 start_pfn = (res->start + PAGE_SIZE - 1) >> PAGE_SHIFT;
78 stop_pfn = (res->end + 1) >> PAGE_SHIFT;
79 if (stop_pfn > start_pfn) {
80 for (i = 0; i < (stop_pfn - start_pfn); ++i)
81 if (pfn_valid(start_pfn + i) &&
82 !PageReserved(pfn_to_page(start_pfn + i)))
83 return IORES_MAP_SYSTEM_RAM;
90 * In a SEV guest, NONE and RESERVED should not be mapped encrypted because
91 * there the whole memory is already encrypted.
93 static unsigned int __ioremap_check_encrypted(struct resource *res)
100 case IORES_DESC_RESERVED:
103 return IORES_MAP_ENCRYPTED;
110 * The EFI runtime services data area is not covered by walk_mem_res(), but must
111 * be mapped encrypted when SEV is active.
113 static void __ioremap_check_other(resource_size_t addr, struct ioremap_desc *desc)
118 if (!IS_ENABLED(CONFIG_EFI))
121 if (efi_mem_type(addr) == EFI_RUNTIME_SERVICES_DATA ||
122 (efi_mem_type(addr) == EFI_BOOT_SERVICES_DATA &&
123 efi_mem_attributes(addr) & EFI_MEMORY_RUNTIME))
124 desc->flags |= IORES_MAP_ENCRYPTED;
127 static int __ioremap_collect_map_flags(struct resource *res, void *arg)
129 struct ioremap_desc *desc = arg;
131 if (!(desc->flags & IORES_MAP_SYSTEM_RAM))
132 desc->flags |= __ioremap_check_ram(res);
134 if (!(desc->flags & IORES_MAP_ENCRYPTED))
135 desc->flags |= __ioremap_check_encrypted(res);
137 return ((desc->flags & (IORES_MAP_SYSTEM_RAM | IORES_MAP_ENCRYPTED)) ==
138 (IORES_MAP_SYSTEM_RAM | IORES_MAP_ENCRYPTED));
142 * To avoid multiple resource walks, this function walks resources marked as
143 * IORESOURCE_MEM and IORESOURCE_BUSY and looking for system RAM and/or a
144 * resource described not as IORES_DESC_NONE (e.g. IORES_DESC_ACPI_TABLES).
146 * After that, deal with misc other ranges in __ioremap_check_other() which do
147 * not fall into the above category.
149 static void __ioremap_check_mem(resource_size_t addr, unsigned long size,
150 struct ioremap_desc *desc)
155 end = start + size - 1;
156 memset(desc, 0, sizeof(struct ioremap_desc));
158 walk_mem_res(start, end, desc, __ioremap_collect_map_flags);
160 __ioremap_check_other(addr, desc);
164 * Remap an arbitrary physical address space into the kernel virtual
165 * address space. It transparently creates kernel huge I/O mapping when
166 * the physical address is aligned by a huge page size (1GB or 2MB) and
167 * the requested size is at least the huge page size.
169 * NOTE: MTRRs can override PAT memory types with a 4KB granularity.
170 * Therefore, the mapping code falls back to use a smaller page toward 4KB
171 * when a mapping range is covered by non-WB type of MTRRs.
173 * NOTE! We need to allow non-page-aligned mappings too: we will obviously
174 * have to convert them into an offset in a page-aligned mapping, but the
175 * caller shouldn't need to know that small detail.
177 static void __iomem *
178 __ioremap_caller(resource_size_t phys_addr, unsigned long size,
179 enum page_cache_mode pcm, void *caller, bool encrypted)
181 unsigned long offset, vaddr;
182 resource_size_t last_addr;
183 const resource_size_t unaligned_phys_addr = phys_addr;
184 const unsigned long unaligned_size = size;
185 struct ioremap_desc io_desc;
186 struct vm_struct *area;
187 enum page_cache_mode new_pcm;
190 void __iomem *ret_addr;
192 /* Don't allow wraparound or zero size */
193 last_addr = phys_addr + size - 1;
194 if (!size || last_addr < phys_addr)
197 if (!phys_addr_valid(phys_addr)) {
198 printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
199 (unsigned long long)phys_addr);
204 __ioremap_check_mem(phys_addr, size, &io_desc);
207 * Don't allow anybody to remap normal RAM that we're using..
209 if (io_desc.flags & IORES_MAP_SYSTEM_RAM) {
210 WARN_ONCE(1, "ioremap on RAM at %pa - %pa\n",
211 &phys_addr, &last_addr);
216 * Mappings have to be page-aligned
218 offset = phys_addr & ~PAGE_MASK;
219 phys_addr &= PHYSICAL_PAGE_MASK;
220 size = PAGE_ALIGN(last_addr+1) - phys_addr;
222 retval = memtype_reserve(phys_addr, (u64)phys_addr + size,
225 printk(KERN_ERR "ioremap memtype_reserve failed %d\n", retval);
229 if (pcm != new_pcm) {
230 if (!is_new_memtype_allowed(phys_addr, size, pcm, new_pcm)) {
232 "ioremap error for 0x%llx-0x%llx, requested 0x%x, got 0x%x\n",
233 (unsigned long long)phys_addr,
234 (unsigned long long)(phys_addr + size),
236 goto err_free_memtype;
242 * If the page being mapped is in memory and SEV is active then
243 * make sure the memory encryption attribute is enabled in the
246 prot = PAGE_KERNEL_IO;
247 if ((io_desc.flags & IORES_MAP_ENCRYPTED) || encrypted)
248 prot = pgprot_encrypted(prot);
251 case _PAGE_CACHE_MODE_UC:
253 prot = __pgprot(pgprot_val(prot) |
254 cachemode2protval(_PAGE_CACHE_MODE_UC));
256 case _PAGE_CACHE_MODE_UC_MINUS:
257 prot = __pgprot(pgprot_val(prot) |
258 cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS));
260 case _PAGE_CACHE_MODE_WC:
261 prot = __pgprot(pgprot_val(prot) |
262 cachemode2protval(_PAGE_CACHE_MODE_WC));
264 case _PAGE_CACHE_MODE_WT:
265 prot = __pgprot(pgprot_val(prot) |
266 cachemode2protval(_PAGE_CACHE_MODE_WT));
268 case _PAGE_CACHE_MODE_WB:
275 area = get_vm_area_caller(size, VM_IOREMAP, caller);
277 goto err_free_memtype;
278 area->phys_addr = phys_addr;
279 vaddr = (unsigned long) area->addr;
281 if (memtype_kernel_map_sync(phys_addr, size, pcm))
284 if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot))
287 ret_addr = (void __iomem *) (vaddr + offset);
288 mmiotrace_ioremap(unaligned_phys_addr, unaligned_size, ret_addr);
291 * Check if the request spans more than any BAR in the iomem resource
294 if (iomem_map_sanity_check(unaligned_phys_addr, unaligned_size))
295 pr_warn("caller %pS mapping multiple BARs\n", caller);
301 memtype_free(phys_addr, phys_addr + size);
306 * ioremap - map bus memory into CPU space
307 * @phys_addr: bus address of the memory
308 * @size: size of the resource to map
310 * ioremap performs a platform specific sequence of operations to
311 * make bus memory CPU accessible via the readb/readw/readl/writeb/
312 * writew/writel functions and the other mmio helpers. The returned
313 * address is not guaranteed to be usable directly as a virtual
316 * This version of ioremap ensures that the memory is marked uncachable
317 * on the CPU as well as honouring existing caching rules from things like
318 * the PCI bus. Note that there are other caches and buffers on many
319 * busses. In particular driver authors should read up on PCI writes
321 * It's useful if some control registers are in such an area and
322 * write combining or read caching is not desirable:
324 * Must be freed with iounmap.
326 void __iomem *ioremap(resource_size_t phys_addr, unsigned long size)
329 * Ideally, this should be:
330 * pat_enabled() ? _PAGE_CACHE_MODE_UC : _PAGE_CACHE_MODE_UC_MINUS;
332 * Till we fix all X drivers to use ioremap_wc(), we will use
333 * UC MINUS. Drivers that are certain they need or can already
334 * be converted over to strong UC can use ioremap_uc().
336 enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC_MINUS;
338 return __ioremap_caller(phys_addr, size, pcm,
339 __builtin_return_address(0), false);
341 EXPORT_SYMBOL(ioremap);
344 * ioremap_uc - map bus memory into CPU space as strongly uncachable
345 * @phys_addr: bus address of the memory
346 * @size: size of the resource to map
348 * ioremap_uc performs a platform specific sequence of operations to
349 * make bus memory CPU accessible via the readb/readw/readl/writeb/
350 * writew/writel functions and the other mmio helpers. The returned
351 * address is not guaranteed to be usable directly as a virtual
354 * This version of ioremap ensures that the memory is marked with a strong
355 * preference as completely uncachable on the CPU when possible. For non-PAT
356 * systems this ends up setting page-attribute flags PCD=1, PWT=1. For PAT
357 * systems this will set the PAT entry for the pages as strong UC. This call
358 * will honor existing caching rules from things like the PCI bus. Note that
359 * there are other caches and buffers on many busses. In particular driver
360 * authors should read up on PCI writes.
362 * It's useful if some control registers are in such an area and
363 * write combining or read caching is not desirable:
365 * Must be freed with iounmap.
367 void __iomem *ioremap_uc(resource_size_t phys_addr, unsigned long size)
369 enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC;
371 return __ioremap_caller(phys_addr, size, pcm,
372 __builtin_return_address(0), false);
374 EXPORT_SYMBOL_GPL(ioremap_uc);
377 * ioremap_wc - map memory into CPU space write combined
378 * @phys_addr: bus address of the memory
379 * @size: size of the resource to map
381 * This version of ioremap ensures that the memory is marked write combining.
382 * Write combining allows faster writes to some hardware devices.
384 * Must be freed with iounmap.
386 void __iomem *ioremap_wc(resource_size_t phys_addr, unsigned long size)
388 return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WC,
389 __builtin_return_address(0), false);
391 EXPORT_SYMBOL(ioremap_wc);
394 * ioremap_wt - map memory into CPU space write through
395 * @phys_addr: bus address of the memory
396 * @size: size of the resource to map
398 * This version of ioremap ensures that the memory is marked write through.
399 * Write through stores data into memory while keeping the cache up-to-date.
401 * Must be freed with iounmap.
403 void __iomem *ioremap_wt(resource_size_t phys_addr, unsigned long size)
405 return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WT,
406 __builtin_return_address(0), false);
408 EXPORT_SYMBOL(ioremap_wt);
410 void __iomem *ioremap_encrypted(resource_size_t phys_addr, unsigned long size)
412 return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
413 __builtin_return_address(0), true);
415 EXPORT_SYMBOL(ioremap_encrypted);
417 void __iomem *ioremap_cache(resource_size_t phys_addr, unsigned long size)
419 return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
420 __builtin_return_address(0), false);
422 EXPORT_SYMBOL(ioremap_cache);
424 void __iomem *ioremap_prot(resource_size_t phys_addr, unsigned long size,
425 unsigned long prot_val)
427 return __ioremap_caller(phys_addr, size,
428 pgprot2cachemode(__pgprot(prot_val)),
429 __builtin_return_address(0), false);
431 EXPORT_SYMBOL(ioremap_prot);
434 * iounmap - Free a IO remapping
435 * @addr: virtual address from ioremap_*
437 * Caller must ensure there is only one unmapping for the same pointer.
439 void iounmap(volatile void __iomem *addr)
441 struct vm_struct *p, *o;
443 if ((void __force *)addr <= high_memory)
447 * The PCI/ISA range special-casing was removed from __ioremap()
448 * so this check, in theory, can be removed. However, there are
449 * cases where iounmap() is called for addresses not obtained via
450 * ioremap() (vga16fb for example). Add a warning so that these
451 * cases can be caught and fixed.
453 if ((void __force *)addr >= phys_to_virt(ISA_START_ADDRESS) &&
454 (void __force *)addr < phys_to_virt(ISA_END_ADDRESS)) {
455 WARN(1, "iounmap() called for ISA range not obtained using ioremap()\n");
459 mmiotrace_iounmap(addr);
461 addr = (volatile void __iomem *)
462 (PAGE_MASK & (unsigned long __force)addr);
464 /* Use the vm area unlocked, assuming the caller
465 ensures there isn't another iounmap for the same address
466 in parallel. Reuse of the virtual address is prevented by
467 leaving it in the global lists until we're done with it.
468 cpa takes care of the direct mappings. */
469 p = find_vm_area((void __force *)addr);
472 printk(KERN_ERR "iounmap: bad address %p\n", addr);
477 memtype_free(p->phys_addr, p->phys_addr + get_vm_area_size(p));
479 /* Finally remove it */
480 o = remove_vm_area((void __force *)addr);
481 BUG_ON(p != o || o == NULL);
484 EXPORT_SYMBOL(iounmap);
487 * Convert a physical pointer to a virtual kernel pointer for /dev/mem
490 void *xlate_dev_mem_ptr(phys_addr_t phys)
492 unsigned long start = phys & PAGE_MASK;
493 unsigned long offset = phys & ~PAGE_MASK;
496 /* memremap() maps if RAM, otherwise falls back to ioremap() */
497 vaddr = memremap(start, PAGE_SIZE, MEMREMAP_WB);
499 /* Only add the offset on success and return NULL if memremap() failed */
506 void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
508 memunmap((void *)((unsigned long)addr & PAGE_MASK));
512 * Examine the physical address to determine if it is an area of memory
513 * that should be mapped decrypted. If the memory is not part of the
514 * kernel usable area it was accessed and created decrypted, so these
515 * areas should be mapped decrypted. And since the encryption key can
516 * change across reboots, persistent memory should also be mapped
519 * If SEV is active, that implies that BIOS/UEFI also ran encrypted so
520 * only persistent memory should be mapped decrypted.
522 static bool memremap_should_map_decrypted(resource_size_t phys_addr,
528 * Check if the address is part of a persistent memory region.
529 * This check covers areas added by E820, EFI and ACPI.
531 is_pmem = region_intersects(phys_addr, size, IORESOURCE_MEM,
532 IORES_DESC_PERSISTENT_MEMORY);
533 if (is_pmem != REGION_DISJOINT)
537 * Check if the non-volatile attribute is set for an EFI
540 if (efi_enabled(EFI_BOOT)) {
541 switch (efi_mem_type(phys_addr)) {
542 case EFI_RESERVED_TYPE:
543 if (efi_mem_attributes(phys_addr) & EFI_MEMORY_NV)
551 /* Check if the address is outside kernel usable area */
552 switch (e820__get_entry_type(phys_addr, phys_addr + size - 1)) {
553 case E820_TYPE_RESERVED:
556 case E820_TYPE_UNUSABLE:
557 /* For SEV, these areas are encrypted */
572 * Examine the physical address to determine if it is EFI data. Check
573 * it against the boot params structure and EFI tables and memory types.
575 static bool memremap_is_efi_data(resource_size_t phys_addr,
580 /* Check if the address is part of EFI boot/runtime data */
581 if (!efi_enabled(EFI_BOOT))
584 paddr = boot_params.efi_info.efi_memmap_hi;
586 paddr |= boot_params.efi_info.efi_memmap;
587 if (phys_addr == paddr)
590 paddr = boot_params.efi_info.efi_systab_hi;
592 paddr |= boot_params.efi_info.efi_systab;
593 if (phys_addr == paddr)
596 if (efi_is_table_address(phys_addr))
599 switch (efi_mem_type(phys_addr)) {
600 case EFI_BOOT_SERVICES_DATA:
601 case EFI_RUNTIME_SERVICES_DATA:
611 * Examine the physical address to determine if it is boot data by checking
612 * it against the boot params setup_data chain.
614 static bool memremap_is_setup_data(resource_size_t phys_addr,
617 struct setup_indirect *indirect;
618 struct setup_data *data;
619 u64 paddr, paddr_next;
621 paddr = boot_params.hdr.setup_data;
625 if (phys_addr == paddr)
628 data = memremap(paddr, sizeof(*data),
629 MEMREMAP_WB | MEMREMAP_DEC);
631 pr_warn("failed to memremap setup_data entry\n");
635 paddr_next = data->next;
638 if ((phys_addr > paddr) && (phys_addr < (paddr + len))) {
643 if (data->type == SETUP_INDIRECT) {
645 data = memremap(paddr, sizeof(*data) + len,
646 MEMREMAP_WB | MEMREMAP_DEC);
648 pr_warn("failed to memremap indirect setup_data\n");
652 indirect = (struct setup_indirect *)data->data;
654 if (indirect->type != SETUP_INDIRECT) {
655 paddr = indirect->addr;
662 if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
672 * Examine the physical address to determine if it is boot data by checking
673 * it against the boot params setup_data chain (early boot version).
675 static bool __init early_memremap_is_setup_data(resource_size_t phys_addr,
678 struct setup_indirect *indirect;
679 struct setup_data *data;
680 u64 paddr, paddr_next;
682 paddr = boot_params.hdr.setup_data;
684 unsigned int len, size;
686 if (phys_addr == paddr)
689 data = early_memremap_decrypted(paddr, sizeof(*data));
691 pr_warn("failed to early memremap setup_data entry\n");
695 size = sizeof(*data);
697 paddr_next = data->next;
700 if ((phys_addr > paddr) && (phys_addr < (paddr + len))) {
701 early_memunmap(data, sizeof(*data));
705 if (data->type == SETUP_INDIRECT) {
707 early_memunmap(data, sizeof(*data));
708 data = early_memremap_decrypted(paddr, size);
710 pr_warn("failed to early memremap indirect setup_data\n");
714 indirect = (struct setup_indirect *)data->data;
716 if (indirect->type != SETUP_INDIRECT) {
717 paddr = indirect->addr;
722 early_memunmap(data, size);
724 if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
734 * Architecture function to determine if RAM remap is allowed. By default, a
735 * RAM remap will map the data as encrypted. Determine if a RAM remap should
736 * not be done so that the data will be mapped decrypted.
738 bool arch_memremap_can_ram_remap(resource_size_t phys_addr, unsigned long size,
741 if (!mem_encrypt_active())
744 if (flags & MEMREMAP_ENC)
747 if (flags & MEMREMAP_DEC)
751 if (memremap_is_setup_data(phys_addr, size) ||
752 memremap_is_efi_data(phys_addr, size))
756 return !memremap_should_map_decrypted(phys_addr, size);
760 * Architecture override of __weak function to adjust the protection attributes
761 * used when remapping memory. By default, early_memremap() will map the data
762 * as encrypted. Determine if an encrypted mapping should not be done and set
763 * the appropriate protection attributes.
765 pgprot_t __init early_memremap_pgprot_adjust(resource_size_t phys_addr,
771 if (!mem_encrypt_active())
774 encrypted_prot = true;
777 if (early_memremap_is_setup_data(phys_addr, size) ||
778 memremap_is_efi_data(phys_addr, size))
779 encrypted_prot = false;
782 if (encrypted_prot && memremap_should_map_decrypted(phys_addr, size))
783 encrypted_prot = false;
785 return encrypted_prot ? pgprot_encrypted(prot)
786 : pgprot_decrypted(prot);
789 bool phys_mem_access_encrypted(unsigned long phys_addr, unsigned long size)
791 return arch_memremap_can_ram_remap(phys_addr, size, 0);
794 #ifdef CONFIG_AMD_MEM_ENCRYPT
795 /* Remap memory with encryption */
796 void __init *early_memremap_encrypted(resource_size_t phys_addr,
799 return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC);
803 * Remap memory with encryption and write-protected - cannot be called
804 * before pat_init() is called
806 void __init *early_memremap_encrypted_wp(resource_size_t phys_addr,
809 if (!x86_has_pat_wp())
811 return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC_WP);
814 /* Remap memory without encryption */
815 void __init *early_memremap_decrypted(resource_size_t phys_addr,
818 return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC);
822 * Remap memory without encryption and write-protected - cannot be called
823 * before pat_init() is called
825 void __init *early_memremap_decrypted_wp(resource_size_t phys_addr,
828 if (!x86_has_pat_wp())
830 return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC_WP);
832 #endif /* CONFIG_AMD_MEM_ENCRYPT */
834 static pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)] __page_aligned_bss;
836 static inline pmd_t * __init early_ioremap_pmd(unsigned long addr)
838 /* Don't assume we're using swapper_pg_dir at this point */
839 pgd_t *base = __va(read_cr3_pa());
840 pgd_t *pgd = &base[pgd_index(addr)];
841 p4d_t *p4d = p4d_offset(pgd, addr);
842 pud_t *pud = pud_offset(p4d, addr);
843 pmd_t *pmd = pmd_offset(pud, addr);
848 static inline pte_t * __init early_ioremap_pte(unsigned long addr)
850 return &bm_pte[pte_index(addr)];
853 bool __init is_early_ioremap_ptep(pte_t *ptep)
855 return ptep >= &bm_pte[0] && ptep < &bm_pte[PAGE_SIZE/sizeof(pte_t)];
858 void __init early_ioremap_init(void)
863 BUILD_BUG_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
865 WARN_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
868 early_ioremap_setup();
870 pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
871 memset(bm_pte, 0, sizeof(bm_pte));
872 pmd_populate_kernel(&init_mm, pmd, bm_pte);
875 * The boot-ioremap range spans multiple pmds, for which
876 * we are not prepared:
878 #define __FIXADDR_TOP (-PAGE_SIZE)
879 BUILD_BUG_ON((__fix_to_virt(FIX_BTMAP_BEGIN) >> PMD_SHIFT)
880 != (__fix_to_virt(FIX_BTMAP_END) >> PMD_SHIFT));
882 if (pmd != early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END))) {
884 printk(KERN_WARNING "pmd %p != %p\n",
885 pmd, early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END)));
886 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
887 fix_to_virt(FIX_BTMAP_BEGIN));
888 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END): %08lx\n",
889 fix_to_virt(FIX_BTMAP_END));
891 printk(KERN_WARNING "FIX_BTMAP_END: %d\n", FIX_BTMAP_END);
892 printk(KERN_WARNING "FIX_BTMAP_BEGIN: %d\n",
897 void __init __early_set_fixmap(enum fixed_addresses idx,
898 phys_addr_t phys, pgprot_t flags)
900 unsigned long addr = __fix_to_virt(idx);
903 if (idx >= __end_of_fixed_addresses) {
907 pte = early_ioremap_pte(addr);
909 /* Sanitize 'prot' against any unsupported bits: */
910 pgprot_val(flags) &= __supported_pte_mask;
912 if (pgprot_val(flags))
913 set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
915 pte_clear(&init_mm, addr, pte);
916 flush_tlb_one_kernel(addr);