arch/arm/kernel/efi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2015 Linaro Ltd <ard.biesheuvel@linaro.org>
   4  */
   5
   6 #include <linux/efi.h>
   7 #include <linux/memblock.h>
   8 #include <asm/efi.h>
   9 #include <asm/mach/map.h>
  10 #include <asm/mmu_context.h>
  11
  12 static int __init set_permissions(pte_t *ptep, unsigned long addr, void *data)
  13 {
  14         efi_memory_desc_t *md = data;
  15         pte_t pte = *ptep;
  16
  17         if (md->attribute & EFI_MEMORY_RO)
  18                 pte = set_pte_bit(pte, __pgprot(L_PTE_RDONLY));
  19         if (md->attribute & EFI_MEMORY_XP)
  20                 pte = set_pte_bit(pte, __pgprot(L_PTE_XN));
  21         set_pte_ext(ptep, pte, PTE_EXT_NG);
  22         return 0;
  23 }
  24
  25 int __init efi_set_mapping_permissions(struct mm_struct *mm,
  26                                        efi_memory_desc_t *md)
  27 {
  28         unsigned long base, size;
  29
  30         base = md->virt_addr;
  31         size = md->num_pages << EFI_PAGE_SHIFT;
  32
  33         /*
  34          * We can only use apply_to_page_range() if we can guarantee that the
  35          * entire region was mapped using pages. This should be the case if the
  36          * region does not cover any naturally aligned SECTION_SIZE sized
  37          * blocks.
  38          */
  39         if (round_down(base + size, SECTION_SIZE) <
  40             round_up(base, SECTION_SIZE) + SECTION_SIZE)
  41                 return apply_to_page_range(mm, base, size, set_permissions, md);
  42
  43         return 0;
  44 }
  45
  46 int __init efi_create_mapping(struct mm_struct *mm, efi_memory_desc_t *md)
  47 {
  48         struct map_desc desc = {
  49                 .virtual        = md->virt_addr,
  50                 .pfn            = __phys_to_pfn(md->phys_addr),
  51                 .length         = md->num_pages * EFI_PAGE_SIZE,
  52         };
  53
  54         /*
  55          * Order is important here: memory regions may have all of the
  56          * bits below set (and usually do), so we check them in order of
  57          * preference.
  58          */
  59         if (md->attribute & EFI_MEMORY_WB)
  60                 desc.type = MT_MEMORY_RWX;
  61         else if (md->attribute & EFI_MEMORY_WT)
  62                 desc.type = MT_MEMORY_RWX_NONCACHED;
  63         else if (md->attribute & EFI_MEMORY_WC)
  64                 desc.type = MT_DEVICE_WC;
  65         else
  66                 desc.type = MT_DEVICE;
  67
  68         create_mapping_late(mm, &desc, true);
  69
  70         /*
  71          * If stricter permissions were specified, apply them now.
  72          */
  73         if (md->attribute & (EFI_MEMORY_RO | EFI_MEMORY_XP))
  74                 return efi_set_mapping_permissions(mm, md);
  75         return 0;
  76 }
  77
  78 static unsigned long __initdata screen_info_table = EFI_INVALID_TABLE_ADDR;
  79 static unsigned long __initdata cpu_state_table = EFI_INVALID_TABLE_ADDR;
  80
  81 const efi_config_table_type_t efi_arch_tables[] __initconst = {
  82         {LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID, &screen_info_table},
  83         {LINUX_EFI_ARM_CPU_STATE_TABLE_GUID, &cpu_state_table},
  84         {}
  85 };
  86
  87 static void __init load_screen_info_table(void)
  88 {
  89         struct screen_info *si;
  90
  91         if (screen_info_table != EFI_INVALID_TABLE_ADDR) {
  92                 si = early_memremap_ro(screen_info_table, sizeof(*si));
  93                 if (!si) {
  94                         pr_err("Could not map screen_info config table\n");
  95                         return;
  96                 }
  97                 screen_info = *si;
  98                 early_memunmap(si, sizeof(*si));
  99
 100                 /* dummycon on ARM needs non-zero values for columns/lines */
 101                 screen_info.orig_video_cols = 80;
 102                 screen_info.orig_video_lines = 25;
 103
 104                 if (memblock_is_map_memory(screen_info.lfb_base))
 105                         memblock_mark_nomap(screen_info.lfb_base,
 106                                             screen_info.lfb_size);
 107         }
 108 }
 109
 110 static void __init load_cpu_state_table(void)
 111 {
 112         if (cpu_state_table != EFI_INVALID_TABLE_ADDR) {
 113                 struct efi_arm_entry_state *state;
 114                 bool dump_state = true;
 115
 116                 state = early_memremap_ro(cpu_state_table,
 117                                           sizeof(struct efi_arm_entry_state));
 118                 if (state == NULL) {
 119                         pr_warn("Unable to map CPU entry state table.\n");
 120                         return;
 121                 }
 122
 123                 if ((state->sctlr_before_ebs & 1) == 0)
 124                         pr_warn(FW_BUG "EFI stub was entered with MMU and Dcache disabled, please fix your firmware!\n");
 125                 else if ((state->sctlr_after_ebs & 1) == 0)
 126                         pr_warn(FW_BUG "ExitBootServices() returned with MMU and Dcache disabled, please fix your firmware!\n");
 127                 else
 128                         dump_state = false;
 129
 130                 if (dump_state || efi_enabled(EFI_DBG)) {
 131                         pr_info("CPSR at EFI stub entry        : 0x%08x\n",
 132                                 state->cpsr_before_ebs);
 133                         pr_info("SCTLR at EFI stub entry       : 0x%08x\n",
 134                                 state->sctlr_before_ebs);
 135                         pr_info("CPSR after ExitBootServices() : 0x%08x\n",
 136                                 state->cpsr_after_ebs);
 137                         pr_info("SCTLR after ExitBootServices(): 0x%08x\n",
 138                                 state->sctlr_after_ebs);
 139                 }
 140                 early_memunmap(state, sizeof(struct efi_arm_entry_state));
 141         }
 142 }
 143
 144 void __init arm_efi_init(void)
 145 {
 146         efi_init();
 147
 148         load_screen_info_table();
 149
 150         /* ARM does not permit early mappings to persist across paging_init() */
 151         efi_memmap_unmap();
 152
 153         load_cpu_state_table();
 154 }