1 // SPDX-License-Identifier: GPL-2.0-only
3 * efi.c - EFI subsystem
5 * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
6 * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
7 * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
9 * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
10 * allowing the efivarfs to be mounted or the efivars module to be loaded.
11 * The existance of /sys/firmware/efi may also be used by userspace to
12 * determine that the system supports EFI.
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/kobject.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/device.h>
21 #include <linux/efi.h>
23 #include <linux/of_fdt.h>
25 #include <linux/kexec.h>
26 #include <linux/platform_device.h>
27 #include <linux/random.h>
28 #include <linux/reboot.h>
29 #include <linux/slab.h>
30 #include <linux/acpi.h>
31 #include <linux/ucs2_string.h>
32 #include <linux/memblock.h>
33 #include <linux/security.h>
35 #include <asm/early_ioremap.h>
37 struct efi __read_mostly efi
= {
38 .mps
= EFI_INVALID_TABLE_ADDR
,
39 .acpi
= EFI_INVALID_TABLE_ADDR
,
40 .acpi20
= EFI_INVALID_TABLE_ADDR
,
41 .smbios
= EFI_INVALID_TABLE_ADDR
,
42 .smbios3
= EFI_INVALID_TABLE_ADDR
,
43 .boot_info
= EFI_INVALID_TABLE_ADDR
,
44 .hcdp
= EFI_INVALID_TABLE_ADDR
,
45 .uga
= EFI_INVALID_TABLE_ADDR
,
46 .fw_vendor
= EFI_INVALID_TABLE_ADDR
,
47 .runtime
= EFI_INVALID_TABLE_ADDR
,
48 .config_table
= EFI_INVALID_TABLE_ADDR
,
49 .esrt
= EFI_INVALID_TABLE_ADDR
,
50 .properties_table
= EFI_INVALID_TABLE_ADDR
,
51 .mem_attr_table
= EFI_INVALID_TABLE_ADDR
,
52 .rng_seed
= EFI_INVALID_TABLE_ADDR
,
53 .tpm_log
= EFI_INVALID_TABLE_ADDR
,
54 .tpm_final_log
= EFI_INVALID_TABLE_ADDR
,
55 .mem_reserve
= EFI_INVALID_TABLE_ADDR
,
59 struct mm_struct efi_mm
= {
61 .mm_users
= ATOMIC_INIT(2),
62 .mm_count
= ATOMIC_INIT(1),
63 .mmap_sem
= __RWSEM_INITIALIZER(efi_mm
.mmap_sem
),
64 .page_table_lock
= __SPIN_LOCK_UNLOCKED(efi_mm
.page_table_lock
),
65 .mmlist
= LIST_HEAD_INIT(efi_mm
.mmlist
),
66 .cpu_bitmap
= { [BITS_TO_LONGS(NR_CPUS
)] = 0},
69 struct workqueue_struct
*efi_rts_wq
;
71 static bool disable_runtime
;
72 static int __init
setup_noefi(char *arg
)
74 disable_runtime
= true;
77 early_param("noefi", setup_noefi
);
79 bool efi_runtime_disabled(void)
81 return disable_runtime
;
84 bool __pure
__efi_soft_reserve_enabled(void)
86 return !efi_enabled(EFI_MEM_NO_SOFT_RESERVE
);
89 static int __init
parse_efi_cmdline(char *str
)
92 pr_warn("need at least one option\n");
96 if (parse_option_str(str
, "debug"))
97 set_bit(EFI_DBG
, &efi
.flags
);
99 if (parse_option_str(str
, "noruntime"))
100 disable_runtime
= true;
102 if (parse_option_str(str
, "nosoftreserve"))
103 set_bit(EFI_MEM_NO_SOFT_RESERVE
, &efi
.flags
);
107 early_param("efi", parse_efi_cmdline
);
109 struct kobject
*efi_kobj
;
112 * Let's not leave out systab information that snuck into
114 * Note, do not add more fields in systab sysfs file as it breaks sysfs
115 * one value per file rule!
117 static ssize_t
systab_show(struct kobject
*kobj
,
118 struct kobj_attribute
*attr
, char *buf
)
125 if (efi
.mps
!= EFI_INVALID_TABLE_ADDR
)
126 str
+= sprintf(str
, "MPS=0x%lx\n", efi
.mps
);
127 if (efi
.acpi20
!= EFI_INVALID_TABLE_ADDR
)
128 str
+= sprintf(str
, "ACPI20=0x%lx\n", efi
.acpi20
);
129 if (efi
.acpi
!= EFI_INVALID_TABLE_ADDR
)
130 str
+= sprintf(str
, "ACPI=0x%lx\n", efi
.acpi
);
132 * If both SMBIOS and SMBIOS3 entry points are implemented, the
133 * SMBIOS3 entry point shall be preferred, so we list it first to
134 * let applications stop parsing after the first match.
136 if (efi
.smbios3
!= EFI_INVALID_TABLE_ADDR
)
137 str
+= sprintf(str
, "SMBIOS3=0x%lx\n", efi
.smbios3
);
138 if (efi
.smbios
!= EFI_INVALID_TABLE_ADDR
)
139 str
+= sprintf(str
, "SMBIOS=0x%lx\n", efi
.smbios
);
140 if (efi
.hcdp
!= EFI_INVALID_TABLE_ADDR
)
141 str
+= sprintf(str
, "HCDP=0x%lx\n", efi
.hcdp
);
142 if (efi
.boot_info
!= EFI_INVALID_TABLE_ADDR
)
143 str
+= sprintf(str
, "BOOTINFO=0x%lx\n", efi
.boot_info
);
144 if (efi
.uga
!= EFI_INVALID_TABLE_ADDR
)
145 str
+= sprintf(str
, "UGA=0x%lx\n", efi
.uga
);
150 static struct kobj_attribute efi_attr_systab
= __ATTR_RO_MODE(systab
, 0400);
152 #define EFI_FIELD(var) efi.var
154 #define EFI_ATTR_SHOW(name) \
155 static ssize_t name##_show(struct kobject *kobj, \
156 struct kobj_attribute *attr, char *buf) \
158 return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
161 EFI_ATTR_SHOW(fw_vendor
);
162 EFI_ATTR_SHOW(runtime
);
163 EFI_ATTR_SHOW(config_table
);
165 static ssize_t
fw_platform_size_show(struct kobject
*kobj
,
166 struct kobj_attribute
*attr
, char *buf
)
168 return sprintf(buf
, "%d\n", efi_enabled(EFI_64BIT
) ? 64 : 32);
171 static struct kobj_attribute efi_attr_fw_vendor
= __ATTR_RO(fw_vendor
);
172 static struct kobj_attribute efi_attr_runtime
= __ATTR_RO(runtime
);
173 static struct kobj_attribute efi_attr_config_table
= __ATTR_RO(config_table
);
174 static struct kobj_attribute efi_attr_fw_platform_size
=
175 __ATTR_RO(fw_platform_size
);
177 static struct attribute
*efi_subsys_attrs
[] = {
178 &efi_attr_systab
.attr
,
179 &efi_attr_fw_vendor
.attr
,
180 &efi_attr_runtime
.attr
,
181 &efi_attr_config_table
.attr
,
182 &efi_attr_fw_platform_size
.attr
,
186 static umode_t
efi_attr_is_visible(struct kobject
*kobj
,
187 struct attribute
*attr
, int n
)
189 if (attr
== &efi_attr_fw_vendor
.attr
) {
190 if (efi_enabled(EFI_PARAVIRT
) ||
191 efi
.fw_vendor
== EFI_INVALID_TABLE_ADDR
)
193 } else if (attr
== &efi_attr_runtime
.attr
) {
194 if (efi
.runtime
== EFI_INVALID_TABLE_ADDR
)
196 } else if (attr
== &efi_attr_config_table
.attr
) {
197 if (efi
.config_table
== EFI_INVALID_TABLE_ADDR
)
204 static const struct attribute_group efi_subsys_attr_group
= {
205 .attrs
= efi_subsys_attrs
,
206 .is_visible
= efi_attr_is_visible
,
209 static struct efivars generic_efivars
;
210 static struct efivar_operations generic_ops
;
212 static int generic_ops_register(void)
214 generic_ops
.get_variable
= efi
.get_variable
;
215 generic_ops
.set_variable
= efi
.set_variable
;
216 generic_ops
.set_variable_nonblocking
= efi
.set_variable_nonblocking
;
217 generic_ops
.get_next_variable
= efi
.get_next_variable
;
218 generic_ops
.query_variable_store
= efi_query_variable_store
;
220 return efivars_register(&generic_efivars
, &generic_ops
, efi_kobj
);
223 static void generic_ops_unregister(void)
225 efivars_unregister(&generic_efivars
);
228 #if IS_ENABLED(CONFIG_ACPI)
229 #define EFIVAR_SSDT_NAME_MAX 16
230 static char efivar_ssdt
[EFIVAR_SSDT_NAME_MAX
] __initdata
;
231 static int __init
efivar_ssdt_setup(char *str
)
233 int ret
= security_locked_down(LOCKDOWN_ACPI_TABLES
);
238 if (strlen(str
) < sizeof(efivar_ssdt
))
239 memcpy(efivar_ssdt
, str
, strlen(str
));
241 pr_warn("efivar_ssdt: name too long: %s\n", str
);
244 __setup("efivar_ssdt=", efivar_ssdt_setup
);
246 static __init
int efivar_ssdt_iter(efi_char16_t
*name
, efi_guid_t vendor
,
247 unsigned long name_size
, void *data
)
249 struct efivar_entry
*entry
;
250 struct list_head
*list
= data
;
251 char utf8_name
[EFIVAR_SSDT_NAME_MAX
];
252 int limit
= min_t(unsigned long, EFIVAR_SSDT_NAME_MAX
, name_size
);
254 ucs2_as_utf8(utf8_name
, name
, limit
- 1);
255 if (strncmp(utf8_name
, efivar_ssdt
, limit
) != 0)
258 entry
= kmalloc(sizeof(*entry
), GFP_KERNEL
);
262 memcpy(entry
->var
.VariableName
, name
, name_size
);
263 memcpy(&entry
->var
.VendorGuid
, &vendor
, sizeof(efi_guid_t
));
265 efivar_entry_add(entry
, list
);
270 static __init
int efivar_ssdt_load(void)
273 struct efivar_entry
*entry
, *aux
;
281 ret
= efivar_init(efivar_ssdt_iter
, &entries
, true, &entries
);
283 list_for_each_entry_safe(entry
, aux
, &entries
, list
) {
284 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt
,
285 &entry
->var
.VendorGuid
);
287 list_del(&entry
->list
);
289 ret
= efivar_entry_size(entry
, &size
);
291 pr_err("failed to get var size\n");
295 data
= kmalloc(size
, GFP_KERNEL
);
301 ret
= efivar_entry_get(entry
, NULL
, &size
, data
);
303 pr_err("failed to get var data\n");
307 ret
= acpi_load_table(data
, NULL
);
309 pr_err("failed to load table: %d\n", ret
);
325 static inline int efivar_ssdt_load(void) { return 0; }
329 * We register the efi subsystem with the firmware subsystem and the
330 * efivars subsystem with the efi subsystem, if the system was booted with
333 static int __init
efisubsys_init(void)
337 if (!efi_enabled(EFI_BOOT
))
341 * Since we process only one efi_runtime_service() at a time, an
342 * ordered workqueue (which creates only one execution context)
343 * should suffice all our needs.
345 efi_rts_wq
= alloc_ordered_workqueue("efi_rts_wq", 0);
347 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
348 clear_bit(EFI_RUNTIME_SERVICES
, &efi
.flags
);
352 /* We register the efi directory at /sys/firmware/efi */
353 efi_kobj
= kobject_create_and_add("efi", firmware_kobj
);
355 pr_err("efi: Firmware registration failed.\n");
359 error
= generic_ops_register();
363 if (efi_enabled(EFI_RUNTIME_SERVICES
))
366 error
= sysfs_create_group(efi_kobj
, &efi_subsys_attr_group
);
368 pr_err("efi: Sysfs attribute export failed with error %d.\n",
373 error
= efi_runtime_map_init(efi_kobj
);
375 goto err_remove_group
;
377 /* and the standard mountpoint for efivarfs */
378 error
= sysfs_create_mount_point(efi_kobj
, "efivars");
380 pr_err("efivars: Subsystem registration failed.\n");
381 goto err_remove_group
;
387 sysfs_remove_group(efi_kobj
, &efi_subsys_attr_group
);
389 generic_ops_unregister();
391 kobject_put(efi_kobj
);
395 subsys_initcall(efisubsys_init
);
398 * Find the efi memory descriptor for a given physical address. Given a
399 * physical address, determine if it exists within an EFI Memory Map entry,
400 * and if so, populate the supplied memory descriptor with the appropriate
403 int efi_mem_desc_lookup(u64 phys_addr
, efi_memory_desc_t
*out_md
)
405 efi_memory_desc_t
*md
;
407 if (!efi_enabled(EFI_MEMMAP
)) {
408 pr_err_once("EFI_MEMMAP is not enabled.\n");
413 pr_err_once("out_md is null.\n");
417 for_each_efi_memory_desc(md
) {
421 size
= md
->num_pages
<< EFI_PAGE_SHIFT
;
422 end
= md
->phys_addr
+ size
;
423 if (phys_addr
>= md
->phys_addr
&& phys_addr
< end
) {
424 memcpy(out_md
, md
, sizeof(*out_md
));
432 * Calculate the highest address of an efi memory descriptor.
434 u64 __init
efi_mem_desc_end(efi_memory_desc_t
*md
)
436 u64 size
= md
->num_pages
<< EFI_PAGE_SHIFT
;
437 u64 end
= md
->phys_addr
+ size
;
441 void __init __weak
efi_arch_mem_reserve(phys_addr_t addr
, u64 size
) {}
444 * efi_mem_reserve - Reserve an EFI memory region
445 * @addr: Physical address to reserve
446 * @size: Size of reservation
448 * Mark a region as reserved from general kernel allocation and
449 * prevent it being released by efi_free_boot_services().
451 * This function should be called drivers once they've parsed EFI
452 * configuration tables to figure out where their data lives, e.g.
455 void __init
efi_mem_reserve(phys_addr_t addr
, u64 size
)
457 if (!memblock_is_region_reserved(addr
, size
))
458 memblock_reserve(addr
, size
);
461 * Some architectures (x86) reserve all boot services ranges
462 * until efi_free_boot_services() because of buggy firmware
463 * implementations. This means the above memblock_reserve() is
464 * superfluous on x86 and instead what it needs to do is
465 * ensure the @start, @size is not freed.
467 efi_arch_mem_reserve(addr
, size
);
470 static __initdata efi_config_table_type_t common_tables
[] = {
471 {ACPI_20_TABLE_GUID
, "ACPI 2.0", &efi
.acpi20
},
472 {ACPI_TABLE_GUID
, "ACPI", &efi
.acpi
},
473 {HCDP_TABLE_GUID
, "HCDP", &efi
.hcdp
},
474 {MPS_TABLE_GUID
, "MPS", &efi
.mps
},
475 {SMBIOS_TABLE_GUID
, "SMBIOS", &efi
.smbios
},
476 {SMBIOS3_TABLE_GUID
, "SMBIOS 3.0", &efi
.smbios3
},
477 {UGA_IO_PROTOCOL_GUID
, "UGA", &efi
.uga
},
478 {EFI_SYSTEM_RESOURCE_TABLE_GUID
, "ESRT", &efi
.esrt
},
479 {EFI_PROPERTIES_TABLE_GUID
, "PROP", &efi
.properties_table
},
480 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID
, "MEMATTR", &efi
.mem_attr_table
},
481 {LINUX_EFI_RANDOM_SEED_TABLE_GUID
, "RNG", &efi
.rng_seed
},
482 {LINUX_EFI_TPM_EVENT_LOG_GUID
, "TPMEventLog", &efi
.tpm_log
},
483 {LINUX_EFI_TPM_FINAL_LOG_GUID
, "TPMFinalLog", &efi
.tpm_final_log
},
484 {LINUX_EFI_MEMRESERVE_TABLE_GUID
, "MEMRESERVE", &efi
.mem_reserve
},
485 #ifdef CONFIG_EFI_RCI2_TABLE
486 {DELLEMC_EFI_RCI2_TABLE_GUID
, NULL
, &rci2_table_phys
},
488 {NULL_GUID
, NULL
, NULL
},
491 static __init
int match_config_table(efi_guid_t
*guid
,
493 efi_config_table_type_t
*table_types
)
498 for (i
= 0; efi_guidcmp(table_types
[i
].guid
, NULL_GUID
); i
++) {
499 if (!efi_guidcmp(*guid
, table_types
[i
].guid
)) {
500 *(table_types
[i
].ptr
) = table
;
501 if (table_types
[i
].name
)
502 pr_cont(" %s=0x%lx ",
503 table_types
[i
].name
, table
);
512 int __init
efi_config_parse_tables(void *config_tables
, int count
, int sz
,
513 efi_config_table_type_t
*arch_tables
)
518 tablep
= config_tables
;
520 for (i
= 0; i
< count
; i
++) {
524 if (efi_enabled(EFI_64BIT
)) {
526 guid
= ((efi_config_table_64_t
*)tablep
)->guid
;
527 table64
= ((efi_config_table_64_t
*)tablep
)->table
;
532 pr_err("Table located above 4GB, disabling EFI.\n");
537 guid
= ((efi_config_table_32_t
*)tablep
)->guid
;
538 table
= ((efi_config_table_32_t
*)tablep
)->table
;
541 if (!match_config_table(&guid
, table
, common_tables
))
542 match_config_table(&guid
, table
, arch_tables
);
547 set_bit(EFI_CONFIG_TABLES
, &efi
.flags
);
549 if (efi
.rng_seed
!= EFI_INVALID_TABLE_ADDR
) {
550 struct linux_efi_random_seed
*seed
;
553 seed
= early_memremap(efi
.rng_seed
, sizeof(*seed
));
556 early_memunmap(seed
, sizeof(*seed
));
558 pr_err("Could not map UEFI random seed!\n");
561 seed
= early_memremap(efi
.rng_seed
,
562 sizeof(*seed
) + size
);
564 pr_notice("seeding entropy pool\n");
565 add_bootloader_randomness(seed
->bits
, seed
->size
);
566 early_memunmap(seed
, sizeof(*seed
) + size
);
568 pr_err("Could not map UEFI random seed!\n");
573 if (efi_enabled(EFI_MEMMAP
))
576 efi_tpm_eventlog_init();
578 /* Parse the EFI Properties table if it exists */
579 if (efi
.properties_table
!= EFI_INVALID_TABLE_ADDR
) {
580 efi_properties_table_t
*tbl
;
582 tbl
= early_memremap(efi
.properties_table
, sizeof(*tbl
));
584 pr_err("Could not map Properties table!\n");
588 if (tbl
->memory_protection_attribute
&
589 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA
)
590 set_bit(EFI_NX_PE_DATA
, &efi
.flags
);
592 early_memunmap(tbl
, sizeof(*tbl
));
595 if (efi
.mem_reserve
!= EFI_INVALID_TABLE_ADDR
) {
596 unsigned long prsv
= efi
.mem_reserve
;
599 struct linux_efi_memreserve
*rsv
;
604 * Just map a full page: that is what we will get
605 * anyway, and it permits us to map the entire entry
606 * before knowing its size.
608 p
= early_memremap(ALIGN_DOWN(prsv
, PAGE_SIZE
),
611 pr_err("Could not map UEFI memreserve entry!\n");
615 rsv
= (void *)(p
+ prsv
% PAGE_SIZE
);
617 /* reserve the entry itself */
618 memblock_reserve(prsv
, EFI_MEMRESERVE_SIZE(rsv
->size
));
620 for (i
= 0; i
< atomic_read(&rsv
->count
); i
++) {
621 memblock_reserve(rsv
->entry
[i
].base
,
626 early_memunmap(p
, PAGE_SIZE
);
633 int __init
efi_config_init(efi_config_table_type_t
*arch_tables
)
638 if (efi
.systab
->nr_tables
== 0)
641 if (efi_enabled(EFI_64BIT
))
642 sz
= sizeof(efi_config_table_64_t
);
644 sz
= sizeof(efi_config_table_32_t
);
647 * Let's see what config tables the firmware passed to us.
649 config_tables
= early_memremap(efi
.systab
->tables
,
650 efi
.systab
->nr_tables
* sz
);
651 if (config_tables
== NULL
) {
652 pr_err("Could not map Configuration table!\n");
656 ret
= efi_config_parse_tables(config_tables
, efi
.systab
->nr_tables
, sz
,
659 early_memunmap(config_tables
, efi
.systab
->nr_tables
* sz
);
663 #ifdef CONFIG_EFI_VARS_MODULE
664 static int __init
efi_load_efivars(void)
666 struct platform_device
*pdev
;
668 if (!efi_enabled(EFI_RUNTIME_SERVICES
))
671 pdev
= platform_device_register_simple("efivars", 0, NULL
, 0);
672 return PTR_ERR_OR_ZERO(pdev
);
674 device_initcall(efi_load_efivars
);
677 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
679 #define UEFI_PARAM(name, prop, field) \
683 offsetof(struct efi_fdt_params, field), \
684 sizeof_field(struct efi_fdt_params, field) \
689 const char propname
[32];
694 static __initdata
struct params fdt_params
[] = {
695 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table
),
696 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap
),
697 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size
),
698 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size
),
699 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver
)
702 static __initdata
struct params xen_fdt_params
[] = {
703 UEFI_PARAM("System Table", "xen,uefi-system-table", system_table
),
704 UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap
),
705 UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size
),
706 UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size
),
707 UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver
)
710 #define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params)
712 static __initdata
struct {
715 struct params
*params
;
717 { "hypervisor", "uefi", xen_fdt_params
},
718 { "chosen", NULL
, fdt_params
},
727 static int __init
__find_uefi_params(unsigned long node
,
728 struct param_info
*info
,
729 struct params
*params
)
736 for (i
= 0; i
< EFI_FDT_PARAMS_SIZE
; i
++) {
737 prop
= of_get_flat_dt_prop(node
, params
[i
].propname
, &len
);
739 info
->missing
= params
[i
].name
;
743 dest
= info
->params
+ params
[i
].offset
;
746 val
= of_read_number(prop
, len
/ sizeof(u32
));
748 if (params
[i
].size
== sizeof(u32
))
753 if (efi_enabled(EFI_DBG
))
754 pr_info(" %s: 0x%0*llx\n", params
[i
].name
,
755 params
[i
].size
* 2, val
);
761 static int __init
fdt_find_uefi_params(unsigned long node
, const char *uname
,
762 int depth
, void *data
)
764 struct param_info
*info
= data
;
767 for (i
= 0; i
< ARRAY_SIZE(dt_params
); i
++) {
768 const char *subnode
= dt_params
[i
].subnode
;
770 if (depth
!= 1 || strcmp(uname
, dt_params
[i
].uname
) != 0) {
771 info
->missing
= dt_params
[i
].params
[0].name
;
776 int err
= of_get_flat_dt_subnode_by_name(node
, subnode
);
784 return __find_uefi_params(node
, info
, dt_params
[i
].params
);
790 int __init
efi_get_fdt_params(struct efi_fdt_params
*params
)
792 struct param_info info
;
795 pr_info("Getting EFI parameters from FDT:\n");
798 info
.params
= params
;
800 ret
= of_scan_flat_dt(fdt_find_uefi_params
, &info
);
802 pr_info("UEFI not found.\n");
804 pr_err("Can't find '%s' in device tree!\n",
809 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
811 static __initdata
char memory_type_name
[][20] = {
819 "Conventional Memory",
821 "ACPI Reclaim Memory",
829 char * __init
efi_md_typeattr_format(char *buf
, size_t size
,
830 const efi_memory_desc_t
*md
)
837 if (md
->type
>= ARRAY_SIZE(memory_type_name
))
838 type_len
= snprintf(pos
, size
, "[type=%u", md
->type
);
840 type_len
= snprintf(pos
, size
, "[%-*s",
841 (int)(sizeof(memory_type_name
[0]) - 1),
842 memory_type_name
[md
->type
]);
843 if (type_len
>= size
)
849 attr
= md
->attribute
;
850 if (attr
& ~(EFI_MEMORY_UC
| EFI_MEMORY_WC
| EFI_MEMORY_WT
|
851 EFI_MEMORY_WB
| EFI_MEMORY_UCE
| EFI_MEMORY_RO
|
852 EFI_MEMORY_WP
| EFI_MEMORY_RP
| EFI_MEMORY_XP
|
853 EFI_MEMORY_NV
| EFI_MEMORY_SP
|
854 EFI_MEMORY_RUNTIME
| EFI_MEMORY_MORE_RELIABLE
))
855 snprintf(pos
, size
, "|attr=0x%016llx]",
856 (unsigned long long)attr
);
859 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
860 attr
& EFI_MEMORY_RUNTIME
? "RUN" : "",
861 attr
& EFI_MEMORY_MORE_RELIABLE
? "MR" : "",
862 attr
& EFI_MEMORY_SP
? "SP" : "",
863 attr
& EFI_MEMORY_NV
? "NV" : "",
864 attr
& EFI_MEMORY_XP
? "XP" : "",
865 attr
& EFI_MEMORY_RP
? "RP" : "",
866 attr
& EFI_MEMORY_WP
? "WP" : "",
867 attr
& EFI_MEMORY_RO
? "RO" : "",
868 attr
& EFI_MEMORY_UCE
? "UCE" : "",
869 attr
& EFI_MEMORY_WB
? "WB" : "",
870 attr
& EFI_MEMORY_WT
? "WT" : "",
871 attr
& EFI_MEMORY_WC
? "WC" : "",
872 attr
& EFI_MEMORY_UC
? "UC" : "");
877 * IA64 has a funky EFI memory map that doesn't work the same way as
878 * other architectures.
882 * efi_mem_attributes - lookup memmap attributes for physical address
883 * @phys_addr: the physical address to lookup
885 * Search in the EFI memory map for the region covering
886 * @phys_addr. Returns the EFI memory attributes if the region
887 * was found in the memory map, 0 otherwise.
889 u64
efi_mem_attributes(unsigned long phys_addr
)
891 efi_memory_desc_t
*md
;
893 if (!efi_enabled(EFI_MEMMAP
))
896 for_each_efi_memory_desc(md
) {
897 if ((md
->phys_addr
<= phys_addr
) &&
898 (phys_addr
< (md
->phys_addr
+
899 (md
->num_pages
<< EFI_PAGE_SHIFT
))))
900 return md
->attribute
;
906 * efi_mem_type - lookup memmap type for physical address
907 * @phys_addr: the physical address to lookup
909 * Search in the EFI memory map for the region covering @phys_addr.
910 * Returns the EFI memory type if the region was found in the memory
911 * map, EFI_RESERVED_TYPE (zero) otherwise.
913 int efi_mem_type(unsigned long phys_addr
)
915 const efi_memory_desc_t
*md
;
917 if (!efi_enabled(EFI_MEMMAP
))
920 for_each_efi_memory_desc(md
) {
921 if ((md
->phys_addr
<= phys_addr
) &&
922 (phys_addr
< (md
->phys_addr
+
923 (md
->num_pages
<< EFI_PAGE_SHIFT
))))
930 int efi_status_to_err(efi_status_t status
)
938 case EFI_INVALID_PARAMETER
:
941 case EFI_OUT_OF_RESOURCES
:
944 case EFI_DEVICE_ERROR
:
947 case EFI_WRITE_PROTECTED
:
950 case EFI_SECURITY_VIOLATION
:
966 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock
);
967 static struct linux_efi_memreserve
*efi_memreserve_root __ro_after_init
;
969 static int __init
efi_memreserve_map_root(void)
971 if (efi
.mem_reserve
== EFI_INVALID_TABLE_ADDR
)
974 efi_memreserve_root
= memremap(efi
.mem_reserve
,
975 sizeof(*efi_memreserve_root
),
977 if (WARN_ON_ONCE(!efi_memreserve_root
))
982 static int efi_mem_reserve_iomem(phys_addr_t addr
, u64 size
)
984 struct resource
*res
, *parent
;
986 res
= kzalloc(sizeof(struct resource
), GFP_ATOMIC
);
990 res
->name
= "reserved";
991 res
->flags
= IORESOURCE_MEM
;
993 res
->end
= addr
+ size
- 1;
995 /* we expect a conflict with a 'System RAM' region */
996 parent
= request_resource_conflict(&iomem_resource
, res
);
997 return parent
? request_resource(parent
, res
) : 0;
1000 int __ref
efi_mem_reserve_persistent(phys_addr_t addr
, u64 size
)
1002 struct linux_efi_memreserve
*rsv
;
1006 if (efi_memreserve_root
== (void *)ULONG_MAX
)
1009 if (!efi_memreserve_root
) {
1010 rc
= efi_memreserve_map_root();
1015 /* first try to find a slot in an existing linked list entry */
1016 for (prsv
= efi_memreserve_root
->next
; prsv
; prsv
= rsv
->next
) {
1017 rsv
= memremap(prsv
, sizeof(*rsv
), MEMREMAP_WB
);
1018 index
= atomic_fetch_add_unless(&rsv
->count
, 1, rsv
->size
);
1019 if (index
< rsv
->size
) {
1020 rsv
->entry
[index
].base
= addr
;
1021 rsv
->entry
[index
].size
= size
;
1024 return efi_mem_reserve_iomem(addr
, size
);
1029 /* no slot found - allocate a new linked list entry */
1030 rsv
= (struct linux_efi_memreserve
*)__get_free_page(GFP_ATOMIC
);
1034 rc
= efi_mem_reserve_iomem(__pa(rsv
), SZ_4K
);
1036 free_page((unsigned long)rsv
);
1041 * The memremap() call above assumes that a linux_efi_memreserve entry
1042 * never crosses a page boundary, so let's ensure that this remains true
1043 * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by
1044 * using SZ_4K explicitly in the size calculation below.
1046 rsv
->size
= EFI_MEMRESERVE_COUNT(SZ_4K
);
1047 atomic_set(&rsv
->count
, 1);
1048 rsv
->entry
[0].base
= addr
;
1049 rsv
->entry
[0].size
= size
;
1051 spin_lock(&efi_mem_reserve_persistent_lock
);
1052 rsv
->next
= efi_memreserve_root
->next
;
1053 efi_memreserve_root
->next
= __pa(rsv
);
1054 spin_unlock(&efi_mem_reserve_persistent_lock
);
1056 return efi_mem_reserve_iomem(addr
, size
);
1059 static int __init
efi_memreserve_root_init(void)
1061 if (efi_memreserve_root
)
1063 if (efi_memreserve_map_root())
1064 efi_memreserve_root
= (void *)ULONG_MAX
;
1067 early_initcall(efi_memreserve_root_init
);
1070 static int update_efi_random_seed(struct notifier_block
*nb
,
1071 unsigned long code
, void *unused
)
1073 struct linux_efi_random_seed
*seed
;
1076 if (!kexec_in_progress
)
1079 seed
= memremap(efi
.rng_seed
, sizeof(*seed
), MEMREMAP_WB
);
1081 size
= min(seed
->size
, EFI_RANDOM_SEED_SIZE
);
1084 pr_err("Could not map UEFI random seed!\n");
1087 seed
= memremap(efi
.rng_seed
, sizeof(*seed
) + size
,
1091 get_random_bytes(seed
->bits
, seed
->size
);
1094 pr_err("Could not map UEFI random seed!\n");
1100 static struct notifier_block efi_random_seed_nb
= {
1101 .notifier_call
= update_efi_random_seed
,
1104 static int register_update_efi_random_seed(void)
1106 if (efi
.rng_seed
== EFI_INVALID_TABLE_ADDR
)
1108 return register_reboot_notifier(&efi_random_seed_nb
);
1110 late_initcall(register_update_efi_random_seed
);