]>
Commit | Line | Data |
---|---|---|
f84d0275 MS |
1 | /* |
2 | * Extensible Firmware Interface | |
3 | * | |
4 | * Based on Extensible Firmware Interface Specification version 2.4 | |
5 | * | |
6 | * Copyright (C) 2013, 2014 Linaro Ltd. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
12 | */ | |
13 | ||
d1ae8c00 | 14 | #include <linux/dmi.h> |
f84d0275 | 15 | #include <linux/efi.h> |
e5bc22a4 | 16 | #include <linux/init.h> |
f84d0275 | 17 | |
f84d0275 | 18 | #include <asm/efi.h> |
d1ae8c00 | 19 | |
1fd55a9a AB |
20 | /* |
21 | * Only regions of type EFI_RUNTIME_SERVICES_CODE need to be | |
22 | * executable, everything else can be mapped with the XN bits | |
23 | * set. Also take the new (optional) RO/XP bits into account. | |
24 | */ | |
25 | static __init pteval_t create_mapping_protection(efi_memory_desc_t *md) | |
f7d92489 | 26 | { |
1fd55a9a AB |
27 | u64 attr = md->attribute; |
28 | u32 type = md->type; | |
f7d92489 | 29 | |
1fd55a9a AB |
30 | if (type == EFI_MEMORY_MAPPED_IO) |
31 | return PROT_DEVICE_nGnRE; | |
32 | ||
33 | if (WARN_ONCE(!PAGE_ALIGNED(md->phys_addr), | |
34 | "UEFI Runtime regions are not aligned to 64 KB -- buggy firmware?")) | |
35 | /* | |
36 | * If the region is not aligned to the page size of the OS, we | |
37 | * can not use strict permissions, since that would also affect | |
38 | * the mapping attributes of the adjacent regions. | |
39 | */ | |
40 | return pgprot_val(PAGE_KERNEL_EXEC); | |
41 | ||
42 | /* R-- */ | |
43 | if ((attr & (EFI_MEMORY_XP | EFI_MEMORY_RO)) == | |
44 | (EFI_MEMORY_XP | EFI_MEMORY_RO)) | |
45 | return pgprot_val(PAGE_KERNEL_RO); | |
46 | ||
47 | /* R-X */ | |
48 | if (attr & EFI_MEMORY_RO) | |
49 | return pgprot_val(PAGE_KERNEL_ROX); | |
50 | ||
51 | /* RW- */ | |
52 | if (attr & EFI_MEMORY_XP || type != EFI_RUNTIME_SERVICES_CODE) | |
53 | return pgprot_val(PAGE_KERNEL); | |
54 | ||
55 | /* RWX */ | |
56 | return pgprot_val(PAGE_KERNEL_EXEC); | |
57 | } | |
58 | ||
57fdb89a AB |
59 | /* we will fill this structure from the stub, so don't put it in .bss */ |
60 | struct screen_info screen_info __section(.data); | |
61 | ||
1fd55a9a AB |
62 | int __init efi_create_mapping(struct mm_struct *mm, efi_memory_desc_t *md) |
63 | { | |
64 | pteval_t prot_val = create_mapping_protection(md); | |
f14c66ce AB |
65 | bool page_mappings_only = (md->type == EFI_RUNTIME_SERVICES_CODE || |
66 | md->type == EFI_RUNTIME_SERVICES_DATA); | |
f7d92489 | 67 | |
74c102c9 AB |
68 | if (!PAGE_ALIGNED(md->phys_addr) || |
69 | !PAGE_ALIGNED(md->num_pages << EFI_PAGE_SHIFT)) { | |
70 | /* | |
71 | * If the end address of this region is not aligned to page | |
72 | * size, the mapping is rounded up, and may end up sharing a | |
73 | * page frame with the next UEFI memory region. If we create | |
74 | * a block entry now, we may need to split it again when mapping | |
75 | * the next region, and support for that is going to be removed | |
76 | * from the MMU routines. So avoid block mappings altogether in | |
77 | * that case. | |
78 | */ | |
f14c66ce | 79 | page_mappings_only = true; |
74c102c9 AB |
80 | } |
81 | ||
f7d92489 AB |
82 | create_pgd_mapping(mm, md->phys_addr, md->virt_addr, |
83 | md->num_pages << EFI_PAGE_SHIFT, | |
f14c66ce | 84 | __pgprot(prot_val | PTE_NG), page_mappings_only); |
f7d92489 AB |
85 | return 0; |
86 | } | |
87 | ||
bd264d04 AB |
88 | static int __init set_permissions(pte_t *ptep, pgtable_t token, |
89 | unsigned long addr, void *data) | |
90 | { | |
91 | efi_memory_desc_t *md = data; | |
92 | pte_t pte = *ptep; | |
93 | ||
94 | if (md->attribute & EFI_MEMORY_RO) | |
95 | pte = set_pte_bit(pte, __pgprot(PTE_RDONLY)); | |
96 | if (md->attribute & EFI_MEMORY_XP) | |
97 | pte = set_pte_bit(pte, __pgprot(PTE_PXN)); | |
98 | set_pte(ptep, pte); | |
99 | return 0; | |
100 | } | |
101 | ||
102 | int __init efi_set_mapping_permissions(struct mm_struct *mm, | |
103 | efi_memory_desc_t *md) | |
104 | { | |
105 | BUG_ON(md->type != EFI_RUNTIME_SERVICES_CODE && | |
106 | md->type != EFI_RUNTIME_SERVICES_DATA); | |
107 | ||
108 | /* | |
109 | * Calling apply_to_page_range() is only safe on regions that are | |
110 | * guaranteed to be mapped down to pages. Since we are only called | |
111 | * for regions that have been mapped using efi_create_mapping() above | |
112 | * (and this is checked by the generic Memory Attributes table parsing | |
113 | * routines), there is no need to check that again here. | |
114 | */ | |
115 | return apply_to_page_range(mm, md->virt_addr, | |
116 | md->num_pages << EFI_PAGE_SHIFT, | |
117 | set_permissions, md); | |
118 | } | |
119 | ||
d1ae8c00 YL |
120 | static int __init arm64_dmi_init(void) |
121 | { | |
122 | /* | |
123 | * On arm64, DMI depends on UEFI, and dmi_scan_machine() needs to | |
124 | * be called early because dmi_id_init(), which is an arch_initcall | |
125 | * itself, depends on dmi_scan_machine() having been called already. | |
126 | */ | |
127 | dmi_scan_machine(); | |
b07bfaa3 AB |
128 | if (dmi_available) |
129 | dmi_set_dump_stack_arch_desc(); | |
d1ae8c00 YL |
130 | return 0; |
131 | } | |
132 | core_initcall(arm64_dmi_init); | |
f3cdfd23 | 133 | |
60c0d45a AB |
134 | /* |
135 | * UpdateCapsule() depends on the system being shutdown via | |
136 | * ResetSystem(). | |
137 | */ | |
138 | bool efi_poweroff_required(void) | |
139 | { | |
140 | return efi_enabled(EFI_RUNTIME_SERVICES); | |
141 | } |