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