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