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