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