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