?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / firmware / efi / efi.c
blobde1bc38ab39fbf02f2277943b89a7ace319f0462
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;
91 static int __init setup_noefi(char *arg)
92 {
93 disable_runtime = true;
94 return 0;
95 }
96 early_param("noefi", setup_noefi);
97
98 bool efi_runtime_disabled(void)
99 {
100 return disable_runtime;
101 }
102
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 */
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
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
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
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
234 static void generic_ops_unregister(void)
235 {
236 efivars_unregister(&generic_efivars);
237 }
238
239 #ifdef CONFIG_EFI_CUSTOM_SSDT_OVERLAYS
240 #define EFIVAR_SSDT_NAME_MAX 16
241 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
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
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
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 if (!efivar_ssdt[0])
285 return 0;
286
287 ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
288
289 list_for_each_entry_safe(entry, aux, &entries, list) {
290 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt,
291 &entry->var.VendorGuid);
292
293 list_del(&entry->list);
294
295 ret = efivar_entry_size(entry, &size);
296 if (ret) {
297 pr_err("failed to get var size\n");
298 goto free_entry;
299 }
300
301 data = kmalloc(size, GFP_KERNEL);
302 if (!data) {
303 ret = -ENOMEM;
304 goto free_entry;
305 }
306
307 ret = efivar_entry_get(entry, NULL, &size, data);
308 if (ret) {
309 pr_err("failed to get var data\n");
310 goto free_data;
311 }
312
313 ret = acpi_load_table(data);
314 if (ret) {
315 pr_err("failed to load table: %d\n", ret);
316 goto free_data;
317 }
318
319 goto free_entry;
320
321 free_data:
322 kfree(data);
323
324 free_entry:
325 kfree(entry);
326 }
327
328 return ret;
329 }
330 #else
331 static inline int efivar_ssdt_load(void) { return 0; }
332 #endif
333
334 /*
335 * We register the efi subsystem with the firmware subsystem and the
336 * efivars subsystem with the efi subsystem, if the system was booted with
337 * EFI.
338 */
339 static int __init efisubsys_init(void)
340 {
341 int error;
342
343 if (!efi_enabled(EFI_BOOT))
344 return 0;
345
346 /*
347 * Since we process only one efi_runtime_service() at a time, an
348 * ordered workqueue (which creates only one execution context)
349 * should suffice all our needs.
350 */
351 efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
352 if (!efi_rts_wq) {
353 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
354 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
355 return 0;
356 }
357
358 /* We register the efi directory at /sys/firmware/efi */
359 efi_kobj = kobject_create_and_add("efi", firmware_kobj);
360 if (!efi_kobj) {
361 pr_err("efi: Firmware registration failed.\n");
362 return -ENOMEM;
363 }
364
365 error = generic_ops_register();
366 if (error)
367 goto err_put;
368
369 if (efi_enabled(EFI_RUNTIME_SERVICES))
370 efivar_ssdt_load();
371
372 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
373 if (error) {
374 pr_err("efi: Sysfs attribute export failed with error %d.\n",
375 error);
376 goto err_unregister;
377 }
378
379 error = efi_runtime_map_init(efi_kobj);
380 if (error)
381 goto err_remove_group;
382
383 /* and the standard mountpoint for efivarfs */
384 error = sysfs_create_mount_point(efi_kobj, "efivars");
385 if (error) {
386 pr_err("efivars: Subsystem registration failed.\n");
387 goto err_remove_group;
388 }
389
390 return 0;
391
392 err_remove_group:
393 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
394 err_unregister:
395 generic_ops_unregister();
396 err_put:
397 kobject_put(efi_kobj);
398 return error;
399 }
400
401 subsys_initcall(efisubsys_init);
402
403 /*
404 * Find the efi memory descriptor for a given physical address. Given a
405 * physical address, determine if it exists within an EFI Memory Map entry,
406 * and if so, populate the supplied memory descriptor with the appropriate
407 * data.
408 */
409 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
410 {
411 efi_memory_desc_t *md;
412
413 if (!efi_enabled(EFI_MEMMAP)) {
414 pr_err_once("EFI_MEMMAP is not enabled.\n");
415 return -EINVAL;
416 }
417
418 if (!out_md) {
419 pr_err_once("out_md is null.\n");
420 return -EINVAL;
421 }
422
423 for_each_efi_memory_desc(md) {
424 u64 size;
425 u64 end;
426
427 size = md->num_pages << EFI_PAGE_SHIFT;
428 end = md->phys_addr + size;
429 if (phys_addr >= md->phys_addr && phys_addr < end) {
430 memcpy(out_md, md, sizeof(*out_md));
431 return 0;
432 }
433 }
434 return -ENOENT;
435 }
436
437 /*
438 * Calculate the highest address of an efi memory descriptor.
439 */
440 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
441 {
442 u64 size = md->num_pages << EFI_PAGE_SHIFT;
443 u64 end = md->phys_addr + size;
444 return end;
445 }
446
447 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}
448
449 /**
450 * efi_mem_reserve - Reserve an EFI memory region
451 * @addr: Physical address to reserve
452 * @size: Size of reservation
453 *
454 * Mark a region as reserved from general kernel allocation and
455 * prevent it being released by efi_free_boot_services().
456 *
457 * This function should be called drivers once they've parsed EFI
458 * configuration tables to figure out where their data lives, e.g.
459 * efi_esrt_init().
460 */
461 void __init efi_mem_reserve(phys_addr_t addr, u64 size)
462 {
463 if (!memblock_is_region_reserved(addr, size))
464 memblock_reserve(addr, size);
465
466 /*
467 * Some architectures (x86) reserve all boot services ranges
468 * until efi_free_boot_services() because of buggy firmware
469 * implementations. This means the above memblock_reserve() is
470 * superfluous on x86 and instead what it needs to do is
471 * ensure the @start, @size is not freed.
472 */
473 efi_arch_mem_reserve(addr, size);
474 }
475
476 static __initdata efi_config_table_type_t common_tables[] = {
477 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
478 {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
479 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
480 {MPS_TABLE_GUID, "MPS", &efi.mps},
481 {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
482 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
483 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
484 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
485 {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
486 {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
487 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
488 {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed},
489 {LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log},
490 {NULL_GUID, NULL, NULL},
491 };
492
493 static __init int match_config_table(efi_guid_t *guid,
494 unsigned long table,
495 efi_config_table_type_t *table_types)
496 {
497 int i;
498
499 if (table_types) {
500 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
501 if (!efi_guidcmp(*guid, table_types[i].guid)) {
502 *(table_types[i].ptr) = table;
503 if (table_types[i].name)
504 pr_cont(" %s=0x%lx ",
505 table_types[i].name, table);
506 return 1;
507 }
508 }
509 }
510
511 return 0;
512 }
513
514 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
515 efi_config_table_type_t *arch_tables)
516 {
517 void *tablep;
518 int i;
519
520 tablep = config_tables;
521 pr_info("");
522 for (i = 0; i < count; i++) {
523 efi_guid_t guid;
524 unsigned long table;
525
526 if (efi_enabled(EFI_64BIT)) {
527 u64 table64;
528 guid = ((efi_config_table_64_t *)tablep)->guid;
529 table64 = ((efi_config_table_64_t *)tablep)->table;
530 table = table64;
531 #ifndef CONFIG_64BIT
532 if (table64 >> 32) {
533 pr_cont("\n");
534 pr_err("Table located above 4GB, disabling EFI.\n");
535 return -EINVAL;
536 }
537 #endif
538 } else {
539 guid = ((efi_config_table_32_t *)tablep)->guid;
540 table = ((efi_config_table_32_t *)tablep)->table;
541 }
542
543 if (!match_config_table(&guid, table, common_tables))
544 match_config_table(&guid, table, arch_tables);
545
546 tablep += sz;
547 }
548 pr_cont("\n");
549 set_bit(EFI_CONFIG_TABLES, &efi.flags);
550
551 if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
552 struct linux_efi_random_seed *seed;
553 u32 size = 0;
554
555 seed = early_memremap(efi.rng_seed, sizeof(*seed));
556 if (seed != NULL) {
557 size = seed->size;
558 early_memunmap(seed, sizeof(*seed));
559 } else {
560 pr_err("Could not map UEFI random seed!\n");
561 }
562 if (size > 0) {
563 seed = early_memremap(efi.rng_seed,
564 sizeof(*seed) + size);
565 if (seed != NULL) {
566 pr_notice("seeding entropy pool\n");
567 add_device_randomness(seed->bits, seed->size);
568 early_memunmap(seed, sizeof(*seed) + size);
569 } else {
570 pr_err("Could not map UEFI random seed!\n");
571 }
572 }
573 }
574
575 if (!IS_ENABLED(CONFIG_X86_32) && efi_enabled(EFI_MEMMAP))
576 efi_memattr_init();
577
578 efi_tpm_eventlog_init();
579
580 /* Parse the EFI Properties table if it exists */
581 if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
582 efi_properties_table_t *tbl;
583
584 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
585 if (tbl == NULL) {
586 pr_err("Could not map Properties table!\n");
587 return -ENOMEM;
588 }
589
590 if (tbl->memory_protection_attribute &
591 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
592 set_bit(EFI_NX_PE_DATA, &efi.flags);
593
594 early_memunmap(tbl, sizeof(*tbl));
595 }
596
597 return 0;
598 }
599
600 int __init efi_config_init(efi_config_table_type_t *arch_tables)
601 {
602 void *config_tables;
603 int sz, ret;
604
605 if (efi_enabled(EFI_64BIT))
606 sz = sizeof(efi_config_table_64_t);
607 else
608 sz = sizeof(efi_config_table_32_t);
609
610 /*
611 * Let's see what config tables the firmware passed to us.
612 */
613 config_tables = early_memremap(efi.systab->tables,
614 efi.systab->nr_tables * sz);
615 if (config_tables == NULL) {
616 pr_err("Could not map Configuration table!\n");
617 return -ENOMEM;
618 }
619
620 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
621 arch_tables);
622
623 early_memunmap(config_tables, efi.systab->nr_tables * sz);
624 return ret;
625 }
626
627 #ifdef CONFIG_EFI_VARS_MODULE
628 static int __init efi_load_efivars(void)
629 {
630 struct platform_device *pdev;
631
632 if (!efi_enabled(EFI_RUNTIME_SERVICES))
633 return 0;
634
635 pdev = platform_device_register_simple("efivars", 0, NULL, 0);
636 return PTR_ERR_OR_ZERO(pdev);
637 }
638 device_initcall(efi_load_efivars);
639 #endif
640
641 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
642
643 #define UEFI_PARAM(name, prop, field) \
644 { \
645 { name }, \
646 { prop }, \
647 offsetof(struct efi_fdt_params, field), \
648 FIELD_SIZEOF(struct efi_fdt_params, field) \
649 }
650
651 struct params {
652 const char name[32];
653 const char propname[32];
654 int offset;
655 int size;
656 };
657
658 static __initdata struct params fdt_params[] = {
659 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
660 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
661 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
662 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
663 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
664 };
665
666 static __initdata struct params xen_fdt_params[] = {
667 UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
668 UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
669 UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
670 UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
671 UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
672 };
673
674 #define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params)
675
676 static __initdata struct {
677 const char *uname;
678 const char *subnode;
679 struct params *params;
680 } dt_params[] = {
681 { "hypervisor", "uefi", xen_fdt_params },
682 { "chosen", NULL, fdt_params },
683 };
684
685 struct param_info {
686 int found;
687 void *params;
688 const char *missing;
689 };
690
691 static int __init __find_uefi_params(unsigned long node,
692 struct param_info *info,
693 struct params *params)
694 {
695 const void *prop;
696 void *dest;
697 u64 val;
698 int i, len;
699
700 for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
701 prop = of_get_flat_dt_prop(node, params[i].propname, &len);
702 if (!prop) {
703 info->missing = params[i].name;
704 return 0;
705 }
706
707 dest = info->params + params[i].offset;
708 info->found++;
709
710 val = of_read_number(prop, len / sizeof(u32));
711
712 if (params[i].size == sizeof(u32))
713 *(u32 *)dest = val;
714 else
715 *(u64 *)dest = val;
716
717 if (efi_enabled(EFI_DBG))
718 pr_info(" %s: 0x%0*llx\n", params[i].name,
719 params[i].size * 2, val);
720 }
721
722 return 1;
723 }
724
725 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
726 int depth, void *data)
727 {
728 struct param_info *info = data;
729 int i;
730
731 for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
732 const char *subnode = dt_params[i].subnode;
733
734 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
735 info->missing = dt_params[i].params[0].name;
736 continue;
737 }
738
739 if (subnode) {
740 int err = of_get_flat_dt_subnode_by_name(node, subnode);
741
742 if (err < 0)
743 return 0;
744
745 node = err;
746 }
747
748 return __find_uefi_params(node, info, dt_params[i].params);
749 }
750
751 return 0;
752 }
753
754 int __init efi_get_fdt_params(struct efi_fdt_params *params)
755 {
756 struct param_info info;
757 int ret;
758
759 pr_info("Getting EFI parameters from FDT:\n");
760
761 info.found = 0;
762 info.params = params;
763
764 ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
765 if (!info.found)
766 pr_info("UEFI not found.\n");
767 else if (!ret)
768 pr_err("Can't find '%s' in device tree!\n",
769 info.missing);
770
771 return ret;
772 }
773 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
774
775 static __initdata char memory_type_name[][20] = {
776 "Reserved",
777 "Loader Code",
778 "Loader Data",
779 "Boot Code",
780 "Boot Data",
781 "Runtime Code",
782 "Runtime Data",
783 "Conventional Memory",
784 "Unusable Memory",
785 "ACPI Reclaim Memory",
786 "ACPI Memory NVS",
787 "Memory Mapped I/O",
788 "MMIO Port Space",
789 "PAL Code",
790 "Persistent Memory",
791 };
792
793 char * __init efi_md_typeattr_format(char *buf, size_t size,
794 const efi_memory_desc_t *md)
795 {
796 char *pos;
797 int type_len;
798 u64 attr;
799
800 pos = buf;
801 if (md->type >= ARRAY_SIZE(memory_type_name))
802 type_len = snprintf(pos, size, "[type=%u", md->type);
803 else
804 type_len = snprintf(pos, size, "[%-*s",
805 (int)(sizeof(memory_type_name[0]) - 1),
806 memory_type_name[md->type]);
807 if (type_len >= size)
808 return buf;
809
810 pos += type_len;
811 size -= type_len;
812
813 attr = md->attribute;
814 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
815 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
816 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
817 EFI_MEMORY_NV |
818 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
819 snprintf(pos, size, "|attr=0x%016llx]",
820 (unsigned long long)attr);
821 else
822 snprintf(pos, size,
823 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
824 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
825 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
826 attr & EFI_MEMORY_NV ? "NV" : "",
827 attr & EFI_MEMORY_XP ? "XP" : "",
828 attr & EFI_MEMORY_RP ? "RP" : "",
829 attr & EFI_MEMORY_WP ? "WP" : "",
830 attr & EFI_MEMORY_RO ? "RO" : "",
831 attr & EFI_MEMORY_UCE ? "UCE" : "",
832 attr & EFI_MEMORY_WB ? "WB" : "",
833 attr & EFI_MEMORY_WT ? "WT" : "",
834 attr & EFI_MEMORY_WC ? "WC" : "",
835 attr & EFI_MEMORY_UC ? "UC" : "");
836 return buf;
837 }
838
839 /*
840 * IA64 has a funky EFI memory map that doesn't work the same way as
841 * other architectures.
842 */
843 #ifndef CONFIG_IA64
844 /*
845 * efi_mem_attributes - lookup memmap attributes for physical address
846 * @phys_addr: the physical address to lookup
847 *
848 * Search in the EFI memory map for the region covering
849 * @phys_addr. Returns the EFI memory attributes if the region
850 * was found in the memory map, 0 otherwise.
851 */
852 u64 efi_mem_attributes(unsigned long phys_addr)
853 {
854 efi_memory_desc_t *md;
855
856 if (!efi_enabled(EFI_MEMMAP))
857 return 0;
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->attribute;
864 }
865 return 0;
866 }
867
868 /*
869 * efi_mem_type - lookup memmap type for physical address
870 * @phys_addr: the physical address to lookup
871 *
872 * Search in the EFI memory map for the region covering @phys_addr.
873 * Returns the EFI memory type if the region was found in the memory
874 * map, EFI_RESERVED_TYPE (zero) otherwise.
875 */
876 int efi_mem_type(unsigned long phys_addr)
877 {
878 const efi_memory_desc_t *md;
879
880 if (!efi_enabled(EFI_MEMMAP))
881 return -ENOTSUPP;
882
883 for_each_efi_memory_desc(md) {
884 if ((md->phys_addr <= phys_addr) &&
885 (phys_addr < (md->phys_addr +
886 (md->num_pages << EFI_PAGE_SHIFT))))
887 return md->type;
888 }
889 return -EINVAL;
890 }
891 #endif
892
893 int efi_status_to_err(efi_status_t status)
894 {
895 int err;
896
897 switch (status) {
898 case EFI_SUCCESS:
899 err = 0;
900 break;
901 case EFI_INVALID_PARAMETER:
902 err = -EINVAL;
903 break;
904 case EFI_OUT_OF_RESOURCES:
905 err = -ENOSPC;
906 break;
907 case EFI_DEVICE_ERROR:
908 err = -EIO;
909 break;
910 case EFI_WRITE_PROTECTED:
911 err = -EROFS;
912 break;
913 case EFI_SECURITY_VIOLATION:
914 err = -EACCES;
915 break;
916 case EFI_NOT_FOUND:
917 err = -ENOENT;
918 break;
919 case EFI_ABORTED:
920 err = -EINTR;
921 break;
922 default:
923 err = -EINVAL;
924 }
925
926 return err;
927 }
928
929 bool efi_is_table_address(unsigned long phys_addr)
930 {
931 unsigned int i;
932
933 if (phys_addr == EFI_INVALID_TABLE_ADDR)
934 return false;
935
936 for (i = 0; i < ARRAY_SIZE(efi_tables); i++)
937 if (*(efi_tables[i]) == phys_addr)
938 return true;
939
940 return false;
941 }
942
943 #ifdef CONFIG_KEXEC
944 static int update_efi_random_seed(struct notifier_block *nb,
945 unsigned long code, void *unused)
946 {
947 struct linux_efi_random_seed *seed;
948 u32 size = 0;
949
950 if (!kexec_in_progress)
951 return NOTIFY_DONE;
952
953 seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
954 if (seed != NULL) {
955 size = min(seed->size, EFI_RANDOM_SEED_SIZE);
956 memunmap(seed);
957 } else {
958 pr_err("Could not map UEFI random seed!\n");
959 }
960 if (size > 0) {
961 seed = memremap(efi.rng_seed, sizeof(*seed) + size,
962 MEMREMAP_WB);
963 if (seed != NULL) {
964 seed->size = size;
965 get_random_bytes(seed->bits, seed->size);
966 memunmap(seed);
967 } else {
968 pr_err("Could not map UEFI random seed!\n");
969 }
970 }
971 return NOTIFY_DONE;
972 }
973
974 static struct notifier_block efi_random_seed_nb = {
975 .notifier_call = update_efi_random_seed,
976 };
977
978 static int register_update_efi_random_seed(void)
979 {
980 if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
981 return 0;
982 return register_reboot_notifier(&efi_random_seed_nb);
983 }
984 late_initcall(register_update_efi_random_seed);
985 #endif
Linux with added FPC-III support