1 /*
2 * efi.c - EFI subsystem
3 *
4 * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
5 * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
6 * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
7 *
8 * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
9 * allowing the efivarfs to be mounted or the efivars module to be loaded.
10 * The existance of /sys/firmware/efi may also be used by userspace to
11 * determine that the system supports EFI.
12 *
13 * This file is released under the GPLv2.
14 */
15
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18 #include <linux/kobject.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/device.h>
22 #include <linux/efi.h>
23 #include <linux/of.h>
24 #include <linux/of_fdt.h>
25 #include <linux/io.h>
26 #include <linux/kexec.h>
27 #include <linux/platform_device.h>
28 #include <linux/random.h>
29 #include <linux/reboot.h>
30 #include <linux/slab.h>
31 #include <linux/acpi.h>
32 #include <linux/ucs2_string.h>
33 #include <linux/memblock.h>
34
35 #include <asm/early_ioremap.h>
36
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 .sal_systab = EFI_INVALID_TABLE_ADDR,
44 .boot_info = EFI_INVALID_TABLE_ADDR,
45 .hcdp = EFI_INVALID_TABLE_ADDR,
46 .uga = EFI_INVALID_TABLE_ADDR,
47 .uv_systab = EFI_INVALID_TABLE_ADDR,
48 .fw_vendor = EFI_INVALID_TABLE_ADDR,
49 .runtime = EFI_INVALID_TABLE_ADDR,
50 .config_table = EFI_INVALID_TABLE_ADDR,
51 .esrt = EFI_INVALID_TABLE_ADDR,
52 .properties_table = EFI_INVALID_TABLE_ADDR,
53 .mem_attr_table = EFI_INVALID_TABLE_ADDR,
54 .rng_seed = EFI_INVALID_TABLE_ADDR,
55 .tpm_log = EFI_INVALID_TABLE_ADDR
56 };
57 EXPORT_SYMBOL(efi);
58
59 static unsigned long *efi_tables[] = {
60 &efi.mps,
61 &efi.acpi,
62 &efi.acpi20,
63 &efi.smbios,
64 &efi.smbios3,
65 &efi.sal_systab,
66 &efi.boot_info,
67 &efi.hcdp,
68 &efi.uga,
69 &efi.uv_systab,
70 &efi.fw_vendor,
71 &efi.runtime,
72 &efi.config_table,
73 &efi.esrt,
74 &efi.properties_table,
75 &efi.mem_attr_table,
76 };
77
78 struct mm_struct efi_mm = {
79 .mm_rb = RB_ROOT,
80 .mm_users = ATOMIC_INIT(2),
81 .mm_count = ATOMIC_INIT(1),
82 .mmap_sem = __RWSEM_INITIALIZER(efi_mm.mmap_sem),
83 .page_table_lock = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
84 .mmlist = LIST_HEAD_INIT(efi_mm.mmlist),
85 .cpu_bitmap = { [BITS_TO_LONGS(NR_CPUS)] = 0},
86 };
87
88 struct workqueue_struct *efi_rts_wq;
89
90 static bool disable_runtime;
setup_noefi(char * arg)91 static int __init setup_noefi(char *arg)
92 {
93 disable_runtime = true;
94 return 0;
95 }
96 early_param("noefi", setup_noefi);
97
efi_runtime_disabled(void)98 bool efi_runtime_disabled(void)
99 {
100 return disable_runtime;
101 }
102
parse_efi_cmdline(char * str)103 static int __init parse_efi_cmdline(char *str)
104 {
105 if (!str) {
106 pr_warn("need at least one option\n");
107 return -EINVAL;
108 }
109
110 if (parse_option_str(str, "debug"))
111 set_bit(EFI_DBG, &efi.flags);
112
113 if (parse_option_str(str, "noruntime"))
114 disable_runtime = true;
115
116 return 0;
117 }
118 early_param("efi", parse_efi_cmdline);
119
120 struct kobject *efi_kobj;
121
122 /*
123 * Let's not leave out systab information that snuck into
124 * the efivars driver
125 * Note, do not add more fields in systab sysfs file as it breaks sysfs
126 * one value per file rule!
127 */
systab_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)128 static ssize_t systab_show(struct kobject *kobj,
129 struct kobj_attribute *attr, char *buf)
130 {
131 char *str = buf;
132
133 if (!kobj || !buf)
134 return -EINVAL;
135
136 if (efi.mps != EFI_INVALID_TABLE_ADDR)
137 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
138 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
139 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
140 if (efi.acpi != EFI_INVALID_TABLE_ADDR)
141 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
142 /*
143 * If both SMBIOS and SMBIOS3 entry points are implemented, the
144 * SMBIOS3 entry point shall be preferred, so we list it first to
145 * let applications stop parsing after the first match.
146 */
147 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
148 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
149 if (efi.smbios != EFI_INVALID_TABLE_ADDR)
150 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
151 if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
152 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
153 if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
154 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
155 if (efi.uga != EFI_INVALID_TABLE_ADDR)
156 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
157
158 return str - buf;
159 }
160
161 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400);
162
163 #define EFI_FIELD(var) efi.var
164
165 #define EFI_ATTR_SHOW(name) \
166 static ssize_t name##_show(struct kobject *kobj, \
167 struct kobj_attribute *attr, char *buf) \
168 { \
169 return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
170 }
171
172 EFI_ATTR_SHOW(fw_vendor);
173 EFI_ATTR_SHOW(runtime);
174 EFI_ATTR_SHOW(config_table);
175
fw_platform_size_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)176 static ssize_t fw_platform_size_show(struct kobject *kobj,
177 struct kobj_attribute *attr, char *buf)
178 {
179 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
180 }
181
182 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
183 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
184 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
185 static struct kobj_attribute efi_attr_fw_platform_size =
186 __ATTR_RO(fw_platform_size);
187
188 static struct attribute *efi_subsys_attrs[] = {
189 &efi_attr_systab.attr,
190 &efi_attr_fw_vendor.attr,
191 &efi_attr_runtime.attr,
192 &efi_attr_config_table.attr,
193 &efi_attr_fw_platform_size.attr,
194 NULL,
195 };
196
efi_attr_is_visible(struct kobject * kobj,struct attribute * attr,int n)197 static umode_t efi_attr_is_visible(struct kobject *kobj,
198 struct attribute *attr, int n)
199 {
200 if (attr == &efi_attr_fw_vendor.attr) {
201 if (efi_enabled(EFI_PARAVIRT) ||
202 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
203 return 0;
204 } else if (attr == &efi_attr_runtime.attr) {
205 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
206 return 0;
207 } else if (attr == &efi_attr_config_table.attr) {
208 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
209 return 0;
210 }
211
212 return attr->mode;
213 }
214
215 static const struct attribute_group efi_subsys_attr_group = {
216 .attrs = efi_subsys_attrs,
217 .is_visible = efi_attr_is_visible,
218 };
219
220 static struct efivars generic_efivars;
221 static struct efivar_operations generic_ops;
222
generic_ops_register(void)223 static int generic_ops_register(void)
224 {
225 generic_ops.get_variable = efi.get_variable;
226 generic_ops.set_variable = efi.set_variable;
227 generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
228 generic_ops.get_next_variable = efi.get_next_variable;
229 generic_ops.query_variable_store = efi_query_variable_store;
230
231 return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
232 }
233
generic_ops_unregister(void)234 static void generic_ops_unregister(void)
235 {
236 efivars_unregister(&generic_efivars);
237 }
238
239 #if IS_ENABLED(CONFIG_ACPI)
240 #define EFIVAR_SSDT_NAME_MAX 16
241 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
efivar_ssdt_setup(char * str)242 static int __init efivar_ssdt_setup(char *str)
243 {
244 if (strlen(str) < sizeof(efivar_ssdt))
245 memcpy(efivar_ssdt, str, strlen(str));
246 else
247 pr_warn("efivar_ssdt: name too long: %s\n", str);
248 return 0;
249 }
250 __setup("efivar_ssdt=", efivar_ssdt_setup);
251
efivar_ssdt_iter(efi_char16_t * name,efi_guid_t vendor,unsigned long name_size,void * data)252 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor,
253 unsigned long name_size, void *data)
254 {
255 struct efivar_entry *entry;
256 struct list_head *list = data;
257 char utf8_name[EFIVAR_SSDT_NAME_MAX];
258 int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size);
259
260 ucs2_as_utf8(utf8_name, name, limit - 1);
261 if (strncmp(utf8_name, efivar_ssdt, limit) != 0)
262 return 0;
263
264 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
265 if (!entry)
266 return 0;
267
268 memcpy(entry->var.VariableName, name, name_size);
269 memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t));
270
271 efivar_entry_add(entry, list);
272
273 return 0;
274 }
275
efivar_ssdt_load(void)276 static __init int efivar_ssdt_load(void)
277 {
278 LIST_HEAD(entries);
279 struct efivar_entry *entry, *aux;
280 unsigned long size;
281 void *data;
282 int ret;
283
284 ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
285
286 list_for_each_entry_safe(entry, aux, &entries, list) {
287 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt,
288 &entry->var.VendorGuid);
289
290 list_del(&entry->list);
291
292 ret = efivar_entry_size(entry, &size);
293 if (ret) {
294 pr_err("failed to get var size\n");
295 goto free_entry;
296 }
297
298 data = kmalloc(size, GFP_KERNEL);
299 if (!data) {
300 ret = -ENOMEM;
301 goto free_entry;
302 }
303
304 ret = efivar_entry_get(entry, NULL, &size, data);
305 if (ret) {
306 pr_err("failed to get var data\n");
307 goto free_data;
308 }
309
310 ret = acpi_load_table(data);
311 if (ret) {
312 pr_err("failed to load table: %d\n", ret);
313 goto free_data;
314 }
315
316 goto free_entry;
317
318 free_data:
319 kfree(data);
320
321 free_entry:
322 kfree(entry);
323 }
324
325 return ret;
326 }
327 #else
efivar_ssdt_load(void)328 static inline int efivar_ssdt_load(void) { return 0; }
329 #endif
330
331 /*
332 * We register the efi subsystem with the firmware subsystem and the
333 * efivars subsystem with the efi subsystem, if the system was booted with
334 * EFI.
335 */
efisubsys_init(void)336 static int __init efisubsys_init(void)
337 {
338 int error;
339
340 if (!efi_enabled(EFI_BOOT))
341 return 0;
342
343 /*
344 * Since we process only one efi_runtime_service() at a time, an
345 * ordered workqueue (which creates only one execution context)
346 * should suffice all our needs.
347 */
348 efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
349 if (!efi_rts_wq) {
350 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
351 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
352 return 0;
353 }
354
355 /* We register the efi directory at /sys/firmware/efi */
356 efi_kobj = kobject_create_and_add("efi", firmware_kobj);
357 if (!efi_kobj) {
358 pr_err("efi: Firmware registration failed.\n");
359 return -ENOMEM;
360 }
361
362 error = generic_ops_register();
363 if (error)
364 goto err_put;
365
366 if (efi_enabled(EFI_RUNTIME_SERVICES))
367 efivar_ssdt_load();
368
369 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
370 if (error) {
371 pr_err("efi: Sysfs attribute export failed with error %d.\n",
372 error);
373 goto err_unregister;
374 }
375
376 error = efi_runtime_map_init(efi_kobj);
377 if (error)
378 goto err_remove_group;
379
380 /* and the standard mountpoint for efivarfs */
381 error = sysfs_create_mount_point(efi_kobj, "efivars");
382 if (error) {
383 pr_err("efivars: Subsystem registration failed.\n");
384 goto err_remove_group;
385 }
386
387 return 0;
388
389 err_remove_group:
390 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
391 err_unregister:
392 generic_ops_unregister();
393 err_put:
394 kobject_put(efi_kobj);
395 return error;
396 }
397
398 subsys_initcall(efisubsys_init);
399
400 /*
401 * Find the efi memory descriptor for a given physical address. Given a
402 * physical address, determine if it exists within an EFI Memory Map entry,
403 * and if so, populate the supplied memory descriptor with the appropriate
404 * data.
405 */
efi_mem_desc_lookup(u64 phys_addr,efi_memory_desc_t * out_md)406 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
407 {
408 efi_memory_desc_t *md;
409
410 if (!efi_enabled(EFI_MEMMAP)) {
411 pr_err_once("EFI_MEMMAP is not enabled.\n");
412 return -EINVAL;
413 }
414
415 if (!out_md) {
416 pr_err_once("out_md is null.\n");
417 return -EINVAL;
418 }
419
420 for_each_efi_memory_desc(md) {
421 u64 size;
422 u64 end;
423
424 size = md->num_pages << EFI_PAGE_SHIFT;
425 end = md->phys_addr + size;
426 if (phys_addr >= md->phys_addr && phys_addr < end) {
427 memcpy(out_md, md, sizeof(*out_md));
428 return 0;
429 }
430 }
431 return -ENOENT;
432 }
433
434 /*
435 * Calculate the highest address of an efi memory descriptor.
436 */
efi_mem_desc_end(efi_memory_desc_t * md)437 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
438 {
439 u64 size = md->num_pages << EFI_PAGE_SHIFT;
440 u64 end = md->phys_addr + size;
441 return end;
442 }
443
efi_arch_mem_reserve(phys_addr_t addr,u64 size)444 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}
445
446 /**
447 * efi_mem_reserve - Reserve an EFI memory region
448 * @addr: Physical address to reserve
449 * @size: Size of reservation
450 *
451 * Mark a region as reserved from general kernel allocation and
452 * prevent it being released by efi_free_boot_services().
453 *
454 * This function should be called drivers once they've parsed EFI
455 * configuration tables to figure out where their data lives, e.g.
456 * efi_esrt_init().
457 */
efi_mem_reserve(phys_addr_t addr,u64 size)458 void __init efi_mem_reserve(phys_addr_t addr, u64 size)
459 {
460 if (!memblock_is_region_reserved(addr, size))
461 memblock_reserve(addr, size);
462
463 /*
464 * Some architectures (x86) reserve all boot services ranges
465 * until efi_free_boot_services() because of buggy firmware
466 * implementations. This means the above memblock_reserve() is
467 * superfluous on x86 and instead what it needs to do is
468 * ensure the @start, @size is not freed.
469 */
470 efi_arch_mem_reserve(addr, size);
471 }
472
473 static __initdata efi_config_table_type_t common_tables[] = {
474 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
475 {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
476 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
477 {MPS_TABLE_GUID, "MPS", &efi.mps},
478 {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
479 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
480 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
481 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
482 {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
483 {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
484 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
485 {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed},
486 {LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log},
487 {NULL_GUID, NULL, NULL},
488 };
489
match_config_table(efi_guid_t * guid,unsigned long table,efi_config_table_type_t * table_types)490 static __init int match_config_table(efi_guid_t *guid,
491 unsigned long table,
492 efi_config_table_type_t *table_types)
493 {
494 int i;
495
496 if (table_types) {
497 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
498 if (!efi_guidcmp(*guid, table_types[i].guid)) {
499 *(table_types[i].ptr) = table;
500 if (table_types[i].name)
501 pr_cont(" %s=0x%lx ",
502 table_types[i].name, table);
503 return 1;
504 }
505 }
506 }
507
508 return 0;
509 }
510
efi_config_parse_tables(void * config_tables,int count,int sz,efi_config_table_type_t * arch_tables)511 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
512 efi_config_table_type_t *arch_tables)
513 {
514 void *tablep;
515 int i;
516
517 tablep = config_tables;
518 pr_info("");
519 for (i = 0; i < count; i++) {
520 efi_guid_t guid;
521 unsigned long table;
522
523 if (efi_enabled(EFI_64BIT)) {
524 u64 table64;
525 guid = ((efi_config_table_64_t *)tablep)->guid;
526 table64 = ((efi_config_table_64_t *)tablep)->table;
527 table = table64;
528 #ifndef CONFIG_64BIT
529 if (table64 >> 32) {
530 pr_cont("\n");
531 pr_err("Table located above 4GB, disabling EFI.\n");
532 return -EINVAL;
533 }
534 #endif
535 } else {
536 guid = ((efi_config_table_32_t *)tablep)->guid;
537 table = ((efi_config_table_32_t *)tablep)->table;
538 }
539
540 if (!match_config_table(&guid, table, common_tables))
541 match_config_table(&guid, table, arch_tables);
542
543 tablep += sz;
544 }
545 pr_cont("\n");
546 set_bit(EFI_CONFIG_TABLES, &efi.flags);
547
548 if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
549 struct linux_efi_random_seed *seed;
550 u32 size = 0;
551
552 seed = early_memremap(efi.rng_seed, sizeof(*seed));
553 if (seed != NULL) {
554 size = seed->size;
555 early_memunmap(seed, sizeof(*seed));
556 } else {
557 pr_err("Could not map UEFI random seed!\n");
558 }
559 if (size > 0) {
560 seed = early_memremap(efi.rng_seed,
561 sizeof(*seed) + size);
562 if (seed != NULL) {
563 pr_notice("seeding entropy pool\n");
564 add_device_randomness(seed->bits, seed->size);
565 early_memunmap(seed, sizeof(*seed) + size);
566 } else {
567 pr_err("Could not map UEFI random seed!\n");
568 }
569 }
570 }
571
572 if (efi_enabled(EFI_MEMMAP))
573 efi_memattr_init();
574
575 efi_tpm_eventlog_init();
576
577 /* Parse the EFI Properties table if it exists */
578 if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
579 efi_properties_table_t *tbl;
580
581 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
582 if (tbl == NULL) {
583 pr_err("Could not map Properties table!\n");
584 return -ENOMEM;
585 }
586
587 if (tbl->memory_protection_attribute &
588 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
589 set_bit(EFI_NX_PE_DATA, &efi.flags);
590
591 early_memunmap(tbl, sizeof(*tbl));
592 }
593
594 return 0;
595 }
596
efi_config_init(efi_config_table_type_t * arch_tables)597 int __init efi_config_init(efi_config_table_type_t *arch_tables)
598 {
599 void *config_tables;
600 int sz, ret;
601
602 if (efi_enabled(EFI_64BIT))
603 sz = sizeof(efi_config_table_64_t);
604 else
605 sz = sizeof(efi_config_table_32_t);
606
607 /*
608 * Let's see what config tables the firmware passed to us.
609 */
610 config_tables = early_memremap(efi.systab->tables,
611 efi.systab->nr_tables * sz);
612 if (config_tables == NULL) {
613 pr_err("Could not map Configuration table!\n");
614 return -ENOMEM;
615 }
616
617 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
618 arch_tables);
619
620 early_memunmap(config_tables, efi.systab->nr_tables * sz);
621 return ret;
622 }
623
624 #ifdef CONFIG_EFI_VARS_MODULE
efi_load_efivars(void)625 static int __init efi_load_efivars(void)
626 {
627 struct platform_device *pdev;
628
629 if (!efi_enabled(EFI_RUNTIME_SERVICES))
630 return 0;
631
632 pdev = platform_device_register_simple("efivars", 0, NULL, 0);
633 return PTR_ERR_OR_ZERO(pdev);
634 }
635 device_initcall(efi_load_efivars);
636 #endif
637
638 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
639
640 #define UEFI_PARAM(name, prop, field) \
641 { \
642 { name }, \
643 { prop }, \
644 offsetof(struct efi_fdt_params, field), \
645 FIELD_SIZEOF(struct efi_fdt_params, field) \
646 }
647
648 struct params {
649 const char name[32];
650 const char propname[32];
651 int offset;
652 int size;
653 };
654
655 static __initdata struct params fdt_params[] = {
656 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
657 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
658 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
659 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
660 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
661 };
662
663 static __initdata struct params xen_fdt_params[] = {
664 UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
665 UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
666 UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
667 UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
668 UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
669 };
670
671 #define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params)
672
673 static __initdata struct {
674 const char *uname;
675 const char *subnode;
676 struct params *params;
677 } dt_params[] = {
678 { "hypervisor", "uefi", xen_fdt_params },
679 { "chosen", NULL, fdt_params },
680 };
681
682 struct param_info {
683 int found;
684 void *params;
685 const char *missing;
686 };
687
__find_uefi_params(unsigned long node,struct param_info * info,struct params * params)688 static int __init __find_uefi_params(unsigned long node,
689 struct param_info *info,
690 struct params *params)
691 {
692 const void *prop;
693 void *dest;
694 u64 val;
695 int i, len;
696
697 for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
698 prop = of_get_flat_dt_prop(node, params[i].propname, &len);
699 if (!prop) {
700 info->missing = params[i].name;
701 return 0;
702 }
703
704 dest = info->params + params[i].offset;
705 info->found++;
706
707 val = of_read_number(prop, len / sizeof(u32));
708
709 if (params[i].size == sizeof(u32))
710 *(u32 *)dest = val;
711 else
712 *(u64 *)dest = val;
713
714 if (efi_enabled(EFI_DBG))
715 pr_info(" %s: 0x%0*llx\n", params[i].name,
716 params[i].size * 2, val);
717 }
718
719 return 1;
720 }
721
fdt_find_uefi_params(unsigned long node,const char * uname,int depth,void * data)722 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
723 int depth, void *data)
724 {
725 struct param_info *info = data;
726 int i;
727
728 for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
729 const char *subnode = dt_params[i].subnode;
730
731 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
732 info->missing = dt_params[i].params[0].name;
733 continue;
734 }
735
736 if (subnode) {
737 int err = of_get_flat_dt_subnode_by_name(node, subnode);
738
739 if (err < 0)
740 return 0;
741
742 node = err;
743 }
744
745 return __find_uefi_params(node, info, dt_params[i].params);
746 }
747
748 return 0;
749 }
750
efi_get_fdt_params(struct efi_fdt_params * params)751 int __init efi_get_fdt_params(struct efi_fdt_params *params)
752 {
753 struct param_info info;
754 int ret;
755
756 pr_info("Getting EFI parameters from FDT:\n");
757
758 info.found = 0;
759 info.params = params;
760
761 ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
762 if (!info.found)
763 pr_info("UEFI not found.\n");
764 else if (!ret)
765 pr_err("Can't find '%s' in device tree!\n",
766 info.missing);
767
768 return ret;
769 }
770 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
771
772 static __initdata char memory_type_name[][20] = {
773 "Reserved",
774 "Loader Code",
775 "Loader Data",
776 "Boot Code",
777 "Boot Data",
778 "Runtime Code",
779 "Runtime Data",
780 "Conventional Memory",
781 "Unusable Memory",
782 "ACPI Reclaim Memory",
783 "ACPI Memory NVS",
784 "Memory Mapped I/O",
785 "MMIO Port Space",
786 "PAL Code",
787 "Persistent Memory",
788 };
789
efi_md_typeattr_format(char * buf,size_t size,const efi_memory_desc_t * md)790 char * __init efi_md_typeattr_format(char *buf, size_t size,
791 const efi_memory_desc_t *md)
792 {
793 char *pos;
794 int type_len;
795 u64 attr;
796
797 pos = buf;
798 if (md->type >= ARRAY_SIZE(memory_type_name))
799 type_len = snprintf(pos, size, "[type=%u", md->type);
800 else
801 type_len = snprintf(pos, size, "[%-*s",
802 (int)(sizeof(memory_type_name[0]) - 1),
803 memory_type_name[md->type]);
804 if (type_len >= size)
805 return buf;
806
807 pos += type_len;
808 size -= type_len;
809
810 attr = md->attribute;
811 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
812 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
813 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
814 EFI_MEMORY_NV |
815 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
816 snprintf(pos, size, "|attr=0x%016llx]",
817 (unsigned long long)attr);
818 else
819 snprintf(pos, size,
820 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
821 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
822 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
823 attr & EFI_MEMORY_NV ? "NV" : "",
824 attr & EFI_MEMORY_XP ? "XP" : "",
825 attr & EFI_MEMORY_RP ? "RP" : "",
826 attr & EFI_MEMORY_WP ? "WP" : "",
827 attr & EFI_MEMORY_RO ? "RO" : "",
828 attr & EFI_MEMORY_UCE ? "UCE" : "",
829 attr & EFI_MEMORY_WB ? "WB" : "",
830 attr & EFI_MEMORY_WT ? "WT" : "",
831 attr & EFI_MEMORY_WC ? "WC" : "",
832 attr & EFI_MEMORY_UC ? "UC" : "");
833 return buf;
834 }
835
836 /*
837 * IA64 has a funky EFI memory map that doesn't work the same way as
838 * other architectures.
839 */
840 #ifndef CONFIG_IA64
841 /*
842 * efi_mem_attributes - lookup memmap attributes for physical address
843 * @phys_addr: the physical address to lookup
844 *
845 * Search in the EFI memory map for the region covering
846 * @phys_addr. Returns the EFI memory attributes if the region
847 * was found in the memory map, 0 otherwise.
848 */
efi_mem_attributes(unsigned long phys_addr)849 u64 efi_mem_attributes(unsigned long phys_addr)
850 {
851 efi_memory_desc_t *md;
852
853 if (!efi_enabled(EFI_MEMMAP))
854 return 0;
855
856 for_each_efi_memory_desc(md) {
857 if ((md->phys_addr <= phys_addr) &&
858 (phys_addr < (md->phys_addr +
859 (md->num_pages << EFI_PAGE_SHIFT))))
860 return md->attribute;
861 }
862 return 0;
863 }
864
865 /*
866 * efi_mem_type - lookup memmap type for physical address
867 * @phys_addr: the physical address to lookup
868 *
869 * Search in the EFI memory map for the region covering @phys_addr.
870 * Returns the EFI memory type if the region was found in the memory
871 * map, EFI_RESERVED_TYPE (zero) otherwise.
872 */
efi_mem_type(unsigned long phys_addr)873 int efi_mem_type(unsigned long phys_addr)
874 {
875 const efi_memory_desc_t *md;
876
877 if (!efi_enabled(EFI_MEMMAP))
878 return -ENOTSUPP;
879
880 for_each_efi_memory_desc(md) {
881 if ((md->phys_addr <= phys_addr) &&
882 (phys_addr < (md->phys_addr +
883 (md->num_pages << EFI_PAGE_SHIFT))))
884 return md->type;
885 }
886 return -EINVAL;
887 }
888 #endif
889
efi_status_to_err(efi_status_t status)890 int efi_status_to_err(efi_status_t status)
891 {
892 int err;
893
894 switch (status) {
895 case EFI_SUCCESS:
896 err = 0;
897 break;
898 case EFI_INVALID_PARAMETER:
899 err = -EINVAL;
900 break;
901 case EFI_OUT_OF_RESOURCES:
902 err = -ENOSPC;
903 break;
904 case EFI_DEVICE_ERROR:
905 err = -EIO;
906 break;
907 case EFI_WRITE_PROTECTED:
908 err = -EROFS;
909 break;
910 case EFI_SECURITY_VIOLATION:
911 err = -EACCES;
912 break;
913 case EFI_NOT_FOUND:
914 err = -ENOENT;
915 break;
916 case EFI_ABORTED:
917 err = -EINTR;
918 break;
919 default:
920 err = -EINVAL;
921 }
922
923 return err;
924 }
925
efi_is_table_address(unsigned long phys_addr)926 bool efi_is_table_address(unsigned long phys_addr)
927 {
928 unsigned int i;
929
930 if (phys_addr == EFI_INVALID_TABLE_ADDR)
931 return false;
932
933 for (i = 0; i < ARRAY_SIZE(efi_tables); i++)
934 if (*(efi_tables[i]) == phys_addr)
935 return true;
936
937 return false;
938 }
939
940 #ifdef CONFIG_KEXEC
update_efi_random_seed(struct notifier_block * nb,unsigned long code,void * unused)941 static int update_efi_random_seed(struct notifier_block *nb,
942 unsigned long code, void *unused)
943 {
944 struct linux_efi_random_seed *seed;
945 u32 size = 0;
946
947 if (!kexec_in_progress)
948 return NOTIFY_DONE;
949
950 seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
951 if (seed != NULL) {
952 size = min(seed->size, EFI_RANDOM_SEED_SIZE);
953 memunmap(seed);
954 } else {
955 pr_err("Could not map UEFI random seed!\n");
956 }
957 if (size > 0) {
958 seed = memremap(efi.rng_seed, sizeof(*seed) + size,
959 MEMREMAP_WB);
960 if (seed != NULL) {
961 seed->size = size;
962 get_random_bytes(seed->bits, seed->size);
963 memunmap(seed);
964 } else {
965 pr_err("Could not map UEFI random seed!\n");
966 }
967 }
968 return NOTIFY_DONE;
969 }
970
971 static struct notifier_block efi_random_seed_nb = {
972 .notifier_call = update_efi_random_seed,
973 };
974
register_update_efi_random_seed(void)975 static int register_update_efi_random_seed(void)
976 {
977 if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
978 return 0;
979 return register_reboot_notifier(&efi_random_seed_nb);
980 }
981 late_initcall(register_update_efi_random_seed);
982 #endif
983
