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