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