Merge tag 'for-linus-4.8-rc0-tag' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / drivers / firmware / efi / efi.c
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
31 #include <asm/early_ioremap.h>
32
33 struct efi __read_mostly efi = {
34         .mps                    = EFI_INVALID_TABLE_ADDR,
35         .acpi                   = EFI_INVALID_TABLE_ADDR,
36         .acpi20                 = EFI_INVALID_TABLE_ADDR,
37         .smbios                 = EFI_INVALID_TABLE_ADDR,
38         .smbios3                = EFI_INVALID_TABLE_ADDR,
39         .sal_systab             = EFI_INVALID_TABLE_ADDR,
40         .boot_info              = EFI_INVALID_TABLE_ADDR,
41         .hcdp                   = EFI_INVALID_TABLE_ADDR,
42         .uga                    = EFI_INVALID_TABLE_ADDR,
43         .uv_systab              = EFI_INVALID_TABLE_ADDR,
44         .fw_vendor              = EFI_INVALID_TABLE_ADDR,
45         .runtime                = EFI_INVALID_TABLE_ADDR,
46         .config_table           = EFI_INVALID_TABLE_ADDR,
47         .esrt                   = EFI_INVALID_TABLE_ADDR,
48         .properties_table       = EFI_INVALID_TABLE_ADDR,
49         .mem_attr_table         = EFI_INVALID_TABLE_ADDR,
50 };
51 EXPORT_SYMBOL(efi);
52
53 static bool disable_runtime;
54 static int __init setup_noefi(char *arg)
55 {
56         disable_runtime = true;
57         return 0;
58 }
59 early_param("noefi", setup_noefi);
60
61 bool efi_runtime_disabled(void)
62 {
63         return disable_runtime;
64 }
65
66 static int __init parse_efi_cmdline(char *str)
67 {
68         if (!str) {
69                 pr_warn("need at least one option\n");
70                 return -EINVAL;
71         }
72
73         if (parse_option_str(str, "debug"))
74                 set_bit(EFI_DBG, &efi.flags);
75
76         if (parse_option_str(str, "noruntime"))
77                 disable_runtime = true;
78
79         return 0;
80 }
81 early_param("efi", parse_efi_cmdline);
82
83 struct kobject *efi_kobj;
84
85 /*
86  * Let's not leave out systab information that snuck into
87  * the efivars driver
88  */
89 static ssize_t systab_show(struct kobject *kobj,
90                            struct kobj_attribute *attr, char *buf)
91 {
92         char *str = buf;
93
94         if (!kobj || !buf)
95                 return -EINVAL;
96
97         if (efi.mps != EFI_INVALID_TABLE_ADDR)
98                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
99         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
100                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
101         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
102                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
103         /*
104          * If both SMBIOS and SMBIOS3 entry points are implemented, the
105          * SMBIOS3 entry point shall be preferred, so we list it first to
106          * let applications stop parsing after the first match.
107          */
108         if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
109                 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
110         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
111                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
112         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
113                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
114         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
115                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
116         if (efi.uga != EFI_INVALID_TABLE_ADDR)
117                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
118
119         return str - buf;
120 }
121
122 static struct kobj_attribute efi_attr_systab =
123                         __ATTR(systab, 0400, systab_show, NULL);
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
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
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
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
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;
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
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
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                         goto free_entry;
263
264                 ret = efivar_entry_get(entry, NULL, &size, data);
265                 if (ret) {
266                         pr_err("failed to get var data\n");
267                         goto free_data;
268                 }
269
270                 ret = acpi_load_table(data);
271                 if (ret) {
272                         pr_err("failed to load table: %d\n", ret);
273                         goto free_data;
274                 }
275
276                 goto free_entry;
277
278 free_data:
279                 kfree(data);
280
281 free_entry:
282                 kfree(entry);
283         }
284
285         return ret;
286 }
287 #else
288 static inline int efivar_ssdt_load(void) { return 0; }
289 #endif
290
291 /*
292  * We register the efi subsystem with the firmware subsystem and the
293  * efivars subsystem with the efi subsystem, if the system was booted with
294  * EFI.
295  */
296 static int __init efisubsys_init(void)
297 {
298         int error;
299
300         if (!efi_enabled(EFI_BOOT))
301                 return 0;
302
303         /* We register the efi directory at /sys/firmware/efi */
304         efi_kobj = kobject_create_and_add("efi", firmware_kobj);
305         if (!efi_kobj) {
306                 pr_err("efi: Firmware registration failed.\n");
307                 return -ENOMEM;
308         }
309
310         error = generic_ops_register();
311         if (error)
312                 goto err_put;
313
314         if (efi_enabled(EFI_RUNTIME_SERVICES))
315                 efivar_ssdt_load();
316
317         error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
318         if (error) {
319                 pr_err("efi: Sysfs attribute export failed with error %d.\n",
320                        error);
321                 goto err_unregister;
322         }
323
324         error = efi_runtime_map_init(efi_kobj);
325         if (error)
326                 goto err_remove_group;
327
328         /* and the standard mountpoint for efivarfs */
329         error = sysfs_create_mount_point(efi_kobj, "efivars");
330         if (error) {
331                 pr_err("efivars: Subsystem registration failed.\n");
332                 goto err_remove_group;
333         }
334
335         return 0;
336
337 err_remove_group:
338         sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
339 err_unregister:
340         generic_ops_unregister();
341 err_put:
342         kobject_put(efi_kobj);
343         return error;
344 }
345
346 subsys_initcall(efisubsys_init);
347
348 /*
349  * Find the efi memory descriptor for a given physical address.  Given a
350  * physicall address, determine if it exists within an EFI Memory Map entry,
351  * and if so, populate the supplied memory descriptor with the appropriate
352  * data.
353  */
354 int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
355 {
356         struct efi_memory_map *map = &efi.memmap;
357         phys_addr_t p, e;
358
359         if (!efi_enabled(EFI_MEMMAP)) {
360                 pr_err_once("EFI_MEMMAP is not enabled.\n");
361                 return -EINVAL;
362         }
363
364         if (!map) {
365                 pr_err_once("efi.memmap is not set.\n");
366                 return -EINVAL;
367         }
368         if (!out_md) {
369                 pr_err_once("out_md is null.\n");
370                 return -EINVAL;
371         }
372         if (WARN_ON_ONCE(!map->phys_map))
373                 return -EINVAL;
374         if (WARN_ON_ONCE(map->nr_map == 0) || WARN_ON_ONCE(map->desc_size == 0))
375                 return -EINVAL;
376
377         e = map->phys_map + map->nr_map * map->desc_size;
378         for (p = map->phys_map; p < e; p += map->desc_size) {
379                 efi_memory_desc_t *md;
380                 u64 size;
381                 u64 end;
382
383                 /*
384                  * If a driver calls this after efi_free_boot_services,
385                  * ->map will be NULL, and the target may also not be mapped.
386                  * So just always get our own virtual map on the CPU.
387                  *
388                  */
389                 md = early_memremap(p, sizeof (*md));
390                 if (!md) {
391                         pr_err_once("early_memremap(%pa, %zu) failed.\n",
392                                     &p, sizeof (*md));
393                         return -ENOMEM;
394                 }
395
396                 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
397                     md->type != EFI_BOOT_SERVICES_DATA &&
398                     md->type != EFI_RUNTIME_SERVICES_DATA) {
399                         early_memunmap(md, sizeof (*md));
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                         early_memunmap(md, sizeof (*md));
408                         return 0;
409                 }
410
411                 early_memunmap(md, sizeof (*md));
412         }
413         pr_err_once("requested map not found.\n");
414         return -ENOENT;
415 }
416
417 /*
418  * Calculate the highest address of an efi memory descriptor.
419  */
420 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
421 {
422         u64 size = md->num_pages << EFI_PAGE_SHIFT;
423         u64 end = md->phys_addr + size;
424         return end;
425 }
426
427 static __initdata efi_config_table_type_t common_tables[] = {
428         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
429         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
430         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
431         {MPS_TABLE_GUID, "MPS", &efi.mps},
432         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
433         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
434         {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
435         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
436         {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
437         {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
438         {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
439         {NULL_GUID, NULL, NULL},
440 };
441
442 static __init int match_config_table(efi_guid_t *guid,
443                                      unsigned long table,
444                                      efi_config_table_type_t *table_types)
445 {
446         int i;
447
448         if (table_types) {
449                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
450                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
451                                 *(table_types[i].ptr) = table;
452                                 if (table_types[i].name)
453                                         pr_cont(" %s=0x%lx ",
454                                                 table_types[i].name, table);
455                                 return 1;
456                         }
457                 }
458         }
459
460         return 0;
461 }
462
463 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
464                                    efi_config_table_type_t *arch_tables)
465 {
466         void *tablep;
467         int i;
468
469         tablep = config_tables;
470         pr_info("");
471         for (i = 0; i < count; i++) {
472                 efi_guid_t guid;
473                 unsigned long table;
474
475                 if (efi_enabled(EFI_64BIT)) {
476                         u64 table64;
477                         guid = ((efi_config_table_64_t *)tablep)->guid;
478                         table64 = ((efi_config_table_64_t *)tablep)->table;
479                         table = table64;
480 #ifndef CONFIG_64BIT
481                         if (table64 >> 32) {
482                                 pr_cont("\n");
483                                 pr_err("Table located above 4GB, disabling EFI.\n");
484                                 return -EINVAL;
485                         }
486 #endif
487                 } else {
488                         guid = ((efi_config_table_32_t *)tablep)->guid;
489                         table = ((efi_config_table_32_t *)tablep)->table;
490                 }
491
492                 if (!match_config_table(&guid, table, common_tables))
493                         match_config_table(&guid, table, arch_tables);
494
495                 tablep += sz;
496         }
497         pr_cont("\n");
498         set_bit(EFI_CONFIG_TABLES, &efi.flags);
499
500         /* Parse the EFI Properties table if it exists */
501         if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
502                 efi_properties_table_t *tbl;
503
504                 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
505                 if (tbl == NULL) {
506                         pr_err("Could not map Properties table!\n");
507                         return -ENOMEM;
508                 }
509
510                 if (tbl->memory_protection_attribute &
511                     EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
512                         set_bit(EFI_NX_PE_DATA, &efi.flags);
513
514                 early_memunmap(tbl, sizeof(*tbl));
515         }
516
517         return 0;
518 }
519
520 int __init efi_config_init(efi_config_table_type_t *arch_tables)
521 {
522         void *config_tables;
523         int sz, ret;
524
525         if (efi_enabled(EFI_64BIT))
526                 sz = sizeof(efi_config_table_64_t);
527         else
528                 sz = sizeof(efi_config_table_32_t);
529
530         /*
531          * Let's see what config tables the firmware passed to us.
532          */
533         config_tables = early_memremap(efi.systab->tables,
534                                        efi.systab->nr_tables * sz);
535         if (config_tables == NULL) {
536                 pr_err("Could not map Configuration table!\n");
537                 return -ENOMEM;
538         }
539
540         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
541                                       arch_tables);
542
543         early_memunmap(config_tables, efi.systab->nr_tables * sz);
544         return ret;
545 }
546
547 #ifdef CONFIG_EFI_VARS_MODULE
548 static int __init efi_load_efivars(void)
549 {
550         struct platform_device *pdev;
551
552         if (!efi_enabled(EFI_RUNTIME_SERVICES))
553                 return 0;
554
555         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
556         return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
557 }
558 device_initcall(efi_load_efivars);
559 #endif
560
561 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
562
563 #define UEFI_PARAM(name, prop, field)                      \
564         {                                                  \
565                 { name },                                  \
566                 { prop },                                  \
567                 offsetof(struct efi_fdt_params, field),    \
568                 FIELD_SIZEOF(struct efi_fdt_params, field) \
569         }
570
571 struct params {
572         const char name[32];
573         const char propname[32];
574         int offset;
575         int size;
576 };
577
578 static __initdata struct params fdt_params[] = {
579         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
580         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
581         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
582         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
583         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
584 };
585
586 static __initdata struct params xen_fdt_params[] = {
587         UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
588         UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
589         UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
590         UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
591         UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
592 };
593
594 #define EFI_FDT_PARAMS_SIZE     ARRAY_SIZE(fdt_params)
595
596 static __initdata struct {
597         const char *uname;
598         const char *subnode;
599         struct params *params;
600 } dt_params[] = {
601         { "hypervisor", "uefi", xen_fdt_params },
602         { "chosen", NULL, fdt_params },
603 };
604
605 struct param_info {
606         int found;
607         void *params;
608         const char *missing;
609 };
610
611 static int __init __find_uefi_params(unsigned long node,
612                                      struct param_info *info,
613                                      struct params *params)
614 {
615         const void *prop;
616         void *dest;
617         u64 val;
618         int i, len;
619
620         for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
621                 prop = of_get_flat_dt_prop(node, params[i].propname, &len);
622                 if (!prop) {
623                         info->missing = params[i].name;
624                         return 0;
625                 }
626
627                 dest = info->params + params[i].offset;
628                 info->found++;
629
630                 val = of_read_number(prop, len / sizeof(u32));
631
632                 if (params[i].size == sizeof(u32))
633                         *(u32 *)dest = val;
634                 else
635                         *(u64 *)dest = val;
636
637                 if (efi_enabled(EFI_DBG))
638                         pr_info("  %s: 0x%0*llx\n", params[i].name,
639                                 params[i].size * 2, val);
640         }
641
642         return 1;
643 }
644
645 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
646                                        int depth, void *data)
647 {
648         struct param_info *info = data;
649         int i;
650
651         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
652                 const char *subnode = dt_params[i].subnode;
653
654                 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
655                         info->missing = dt_params[i].params[0].name;
656                         continue;
657                 }
658
659                 if (subnode) {
660                         node = of_get_flat_dt_subnode_by_name(node, subnode);
661                         if (node < 0)
662                                 return 0;
663                 }
664
665                 return __find_uefi_params(node, info, dt_params[i].params);
666         }
667
668         return 0;
669 }
670
671 int __init efi_get_fdt_params(struct efi_fdt_params *params)
672 {
673         struct param_info info;
674         int ret;
675
676         pr_info("Getting EFI parameters from FDT:\n");
677
678         info.found = 0;
679         info.params = params;
680
681         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
682         if (!info.found)
683                 pr_info("UEFI not found.\n");
684         else if (!ret)
685                 pr_err("Can't find '%s' in device tree!\n",
686                        info.missing);
687
688         return ret;
689 }
690 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
691
692 static __initdata char memory_type_name[][20] = {
693         "Reserved",
694         "Loader Code",
695         "Loader Data",
696         "Boot Code",
697         "Boot Data",
698         "Runtime Code",
699         "Runtime Data",
700         "Conventional Memory",
701         "Unusable Memory",
702         "ACPI Reclaim Memory",
703         "ACPI Memory NVS",
704         "Memory Mapped I/O",
705         "MMIO Port Space",
706         "PAL Code",
707         "Persistent Memory",
708 };
709
710 char * __init efi_md_typeattr_format(char *buf, size_t size,
711                                      const efi_memory_desc_t *md)
712 {
713         char *pos;
714         int type_len;
715         u64 attr;
716
717         pos = buf;
718         if (md->type >= ARRAY_SIZE(memory_type_name))
719                 type_len = snprintf(pos, size, "[type=%u", md->type);
720         else
721                 type_len = snprintf(pos, size, "[%-*s",
722                                     (int)(sizeof(memory_type_name[0]) - 1),
723                                     memory_type_name[md->type]);
724         if (type_len >= size)
725                 return buf;
726
727         pos += type_len;
728         size -= type_len;
729
730         attr = md->attribute;
731         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
732                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
733                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
734                      EFI_MEMORY_NV |
735                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
736                 snprintf(pos, size, "|attr=0x%016llx]",
737                          (unsigned long long)attr);
738         else
739                 snprintf(pos, size,
740                          "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
741                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
742                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
743                          attr & EFI_MEMORY_NV      ? "NV"  : "",
744                          attr & EFI_MEMORY_XP      ? "XP"  : "",
745                          attr & EFI_MEMORY_RP      ? "RP"  : "",
746                          attr & EFI_MEMORY_WP      ? "WP"  : "",
747                          attr & EFI_MEMORY_RO      ? "RO"  : "",
748                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
749                          attr & EFI_MEMORY_WB      ? "WB"  : "",
750                          attr & EFI_MEMORY_WT      ? "WT"  : "",
751                          attr & EFI_MEMORY_WC      ? "WC"  : "",
752                          attr & EFI_MEMORY_UC      ? "UC"  : "");
753         return buf;
754 }
755
756 /*
757  * efi_mem_attributes - lookup memmap attributes for physical address
758  * @phys_addr: the physical address to lookup
759  *
760  * Search in the EFI memory map for the region covering
761  * @phys_addr. Returns the EFI memory attributes if the region
762  * was found in the memory map, 0 otherwise.
763  *
764  * Despite being marked __weak, most architectures should *not*
765  * override this function. It is __weak solely for the benefit
766  * of ia64 which has a funky EFI memory map that doesn't work
767  * the same way as other architectures.
768  */
769 u64 __weak efi_mem_attributes(unsigned long phys_addr)
770 {
771         efi_memory_desc_t *md;
772
773         if (!efi_enabled(EFI_MEMMAP))
774                 return 0;
775
776         for_each_efi_memory_desc(md) {
777                 if ((md->phys_addr <= phys_addr) &&
778                     (phys_addr < (md->phys_addr +
779                     (md->num_pages << EFI_PAGE_SHIFT))))
780                         return md->attribute;
781         }
782         return 0;
783 }
784
785 int efi_status_to_err(efi_status_t status)
786 {
787         int err;
788
789         switch (status) {
790         case EFI_SUCCESS:
791                 err = 0;
792                 break;
793         case EFI_INVALID_PARAMETER:
794                 err = -EINVAL;
795                 break;
796         case EFI_OUT_OF_RESOURCES:
797                 err = -ENOSPC;
798                 break;
799         case EFI_DEVICE_ERROR:
800                 err = -EIO;
801                 break;
802         case EFI_WRITE_PROTECTED:
803                 err = -EROFS;
804                 break;
805         case EFI_SECURITY_VIOLATION:
806                 err = -EACCES;
807                 break;
808         case EFI_NOT_FOUND:
809                 err = -ENOENT;
810                 break;
811         default:
812                 err = -EINVAL;
813         }
814
815         return err;
816 }