tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
28struct efi __read_mostly efi = {
29 .mps = EFI_INVALID_TABLE_ADDR,
30 .acpi = EFI_INVALID_TABLE_ADDR,
31 .acpi20 = EFI_INVALID_TABLE_ADDR,
32 .smbios = EFI_INVALID_TABLE_ADDR,
33 .smbios3 = EFI_INVALID_TABLE_ADDR,
34 .sal_systab = EFI_INVALID_TABLE_ADDR,
35 .boot_info = EFI_INVALID_TABLE_ADDR,
36 .hcdp = EFI_INVALID_TABLE_ADDR,
37 .uga = EFI_INVALID_TABLE_ADDR,
38 .uv_systab = EFI_INVALID_TABLE_ADDR,
39 .fw_vendor = EFI_INVALID_TABLE_ADDR,
40 .runtime = EFI_INVALID_TABLE_ADDR,
41 .config_table = EFI_INVALID_TABLE_ADDR,
42};
43EXPORT_SYMBOL(efi);
44
45static bool disable_runtime;
46static int __init setup_noefi(char *arg)
47{
48 disable_runtime = true;
49 return 0;
50}
51early_param("noefi", setup_noefi);
52
53bool efi_runtime_disabled(void)
54{
55 return disable_runtime;
56}
57
58static int __init parse_efi_cmdline(char *str)
59{
60 if (parse_option_str(str, "noruntime"))
61 disable_runtime = true;
62
63 return 0;
64}
65early_param("efi", parse_efi_cmdline);
66
67static struct kobject *efi_kobj;
68static struct kobject *efivars_kobj;
69
70/*
71 * Let's not leave out systab information that snuck into
72 * the efivars driver
73 */
74static ssize_t systab_show(struct kobject *kobj,
75 struct kobj_attribute *attr, char *buf)
76{
77 char *str = buf;
78
79 if (!kobj || !buf)
80 return -EINVAL;
81
82 if (efi.mps != EFI_INVALID_TABLE_ADDR)
83 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
84 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
85 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
86 if (efi.acpi != EFI_INVALID_TABLE_ADDR)
87 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
88 if (efi.smbios != EFI_INVALID_TABLE_ADDR)
89 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
90 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
91 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
92 if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
93 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
94 if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
95 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
96 if (efi.uga != EFI_INVALID_TABLE_ADDR)
97 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
98
99 return str - buf;
100}
101
102static struct kobj_attribute efi_attr_systab =
103 __ATTR(systab, 0400, systab_show, NULL);
104
105#define EFI_FIELD(var) efi.var
106
107#define EFI_ATTR_SHOW(name) \
108static ssize_t name##_show(struct kobject *kobj, \
109 struct kobj_attribute *attr, char *buf) \
110{ \
111 return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
112}
113
114EFI_ATTR_SHOW(fw_vendor);
115EFI_ATTR_SHOW(runtime);
116EFI_ATTR_SHOW(config_table);
117
118static ssize_t fw_platform_size_show(struct kobject *kobj,
119 struct kobj_attribute *attr, char *buf)
120{
121 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
122}
123
124static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
125static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
126static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
127static struct kobj_attribute efi_attr_fw_platform_size =
128 __ATTR_RO(fw_platform_size);
129
130static struct attribute *efi_subsys_attrs[] = {
131 &efi_attr_systab.attr,
132 &efi_attr_fw_vendor.attr,
133 &efi_attr_runtime.attr,
134 &efi_attr_config_table.attr,
135 &efi_attr_fw_platform_size.attr,
136 NULL,
137};
138
139static umode_t efi_attr_is_visible(struct kobject *kobj,
140 struct attribute *attr, int n)
141{
142 if (attr == &efi_attr_fw_vendor.attr) {
143 if (efi_enabled(EFI_PARAVIRT) ||
144 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
145 return 0;
146 } else if (attr == &efi_attr_runtime.attr) {
147 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
148 return 0;
149 } else if (attr == &efi_attr_config_table.attr) {
150 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
151 return 0;
152 }
153
154 return attr->mode;
155}
156
157static struct attribute_group efi_subsys_attr_group = {
158 .attrs = efi_subsys_attrs,
159 .is_visible = efi_attr_is_visible,
160};
161
162static struct efivars generic_efivars;
163static struct efivar_operations generic_ops;
164
165static int generic_ops_register(void)
166{
167 generic_ops.get_variable = efi.get_variable;
168 generic_ops.set_variable = efi.set_variable;
169 generic_ops.get_next_variable = efi.get_next_variable;
170 generic_ops.query_variable_store = efi_query_variable_store;
171
172 return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
173}
174
175static void generic_ops_unregister(void)
176{
177 efivars_unregister(&generic_efivars);
178}
179
180/*
181 * We register the efi subsystem with the firmware subsystem and the
182 * efivars subsystem with the efi subsystem, if the system was booted with
183 * EFI.
184 */
185static int __init efisubsys_init(void)
186{
187 int error;
188
189 if (!efi_enabled(EFI_BOOT))
190 return 0;
191
192 /* We register the efi directory at /sys/firmware/efi */
193 efi_kobj = kobject_create_and_add("efi", firmware_kobj);
194 if (!efi_kobj) {
195 pr_err("efi: Firmware registration failed.\n");
196 return -ENOMEM;
197 }
198
199 error = generic_ops_register();
200 if (error)
201 goto err_put;
202
203 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
204 if (error) {
205 pr_err("efi: Sysfs attribute export failed with error %d.\n",
206 error);
207 goto err_unregister;
208 }
209
210 error = efi_runtime_map_init(efi_kobj);
211 if (error)
212 goto err_remove_group;
213
214 /* and the standard mountpoint for efivarfs */
215 efivars_kobj = kobject_create_and_add("efivars", efi_kobj);
216 if (!efivars_kobj) {
217 pr_err("efivars: Subsystem registration failed.\n");
218 error = -ENOMEM;
219 goto err_remove_group;
220 }
221
222 return 0;
223
224err_remove_group:
225 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
226err_unregister:
227 generic_ops_unregister();
228err_put:
229 kobject_put(efi_kobj);
230 return error;
231}
232
233subsys_initcall(efisubsys_init);
234
235
236/*
237 * We can't ioremap data in EFI boot services RAM, because we've already mapped
238 * it as RAM. So, look it up in the existing EFI memory map instead. Only
239 * callable after efi_enter_virtual_mode and before efi_free_boot_services.
240 */
241void __iomem *efi_lookup_mapped_addr(u64 phys_addr)
242{
243 struct efi_memory_map *map;
244 void *p;
245 map = efi.memmap;
246 if (!map)
247 return NULL;
248 if (WARN_ON(!map->map))
249 return NULL;
250 for (p = map->map; p < map->map_end; p += map->desc_size) {
251 efi_memory_desc_t *md = p;
252 u64 size = md->num_pages << EFI_PAGE_SHIFT;
253 u64 end = md->phys_addr + size;
254 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
255 md->type != EFI_BOOT_SERVICES_CODE &&
256 md->type != EFI_BOOT_SERVICES_DATA)
257 continue;
258 if (!md->virt_addr)
259 continue;
260 if (phys_addr >= md->phys_addr && phys_addr < end) {
261 phys_addr += md->virt_addr - md->phys_addr;
262 return (__force void __iomem *)(unsigned long)phys_addr;
263 }
264 }
265 return NULL;
266}
267
268static __initdata efi_config_table_type_t common_tables[] = {
269 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
270 {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
271 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
272 {MPS_TABLE_GUID, "MPS", &efi.mps},
273 {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
274 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
275 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
276 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
277 {NULL_GUID, NULL, NULL},
278};
279
280static __init int match_config_table(efi_guid_t *guid,
281 unsigned long table,
282 efi_config_table_type_t *table_types)
283{
284 int i;
285
286 if (table_types) {
287 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
288 if (!efi_guidcmp(*guid, table_types[i].guid)) {
289 *(table_types[i].ptr) = table;
290 pr_cont(" %s=0x%lx ",
291 table_types[i].name, table);
292 return 1;
293 }
294 }
295 }
296
297 return 0;
298}
299
300int __init efi_config_parse_tables(void *config_tables, int count, int sz,
301 efi_config_table_type_t *arch_tables)
302{
303 void *tablep;
304 int i;
305
306 tablep = config_tables;
307 pr_info("");
308 for (i = 0; i < count; i++) {
309 efi_guid_t guid;
310 unsigned long table;
311
312 if (efi_enabled(EFI_64BIT)) {
313 u64 table64;
314 guid = ((efi_config_table_64_t *)tablep)->guid;
315 table64 = ((efi_config_table_64_t *)tablep)->table;
316 table = table64;
317#ifndef CONFIG_64BIT
318 if (table64 >> 32) {
319 pr_cont("\n");
320 pr_err("Table located above 4GB, disabling EFI.\n");
321 return -EINVAL;
322 }
323#endif
324 } else {
325 guid = ((efi_config_table_32_t *)tablep)->guid;
326 table = ((efi_config_table_32_t *)tablep)->table;
327 }
328
329 if (!match_config_table(&guid, table, common_tables))
330 match_config_table(&guid, table, arch_tables);
331
332 tablep += sz;
333 }
334 pr_cont("\n");
335 set_bit(EFI_CONFIG_TABLES, &efi.flags);
336 return 0;
337}
338
339int __init efi_config_init(efi_config_table_type_t *arch_tables)
340{
341 void *config_tables;
342 int sz, ret;
343
344 if (efi_enabled(EFI_64BIT))
345 sz = sizeof(efi_config_table_64_t);
346 else
347 sz = sizeof(efi_config_table_32_t);
348
349 /*
350 * Let's see what config tables the firmware passed to us.
351 */
352 config_tables = early_memremap(efi.systab->tables,
353 efi.systab->nr_tables * sz);
354 if (config_tables == NULL) {
355 pr_err("Could not map Configuration table!\n");
356 return -ENOMEM;
357 }
358
359 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
360 arch_tables);
361
362 early_memunmap(config_tables, efi.systab->nr_tables * sz);
363 return ret;
364}
365
366#ifdef CONFIG_EFI_VARS_MODULE
367static int __init efi_load_efivars(void)
368{
369 struct platform_device *pdev;
370
371 if (!efi_enabled(EFI_RUNTIME_SERVICES))
372 return 0;
373
374 pdev = platform_device_register_simple("efivars", 0, NULL, 0);
375 return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
376}
377device_initcall(efi_load_efivars);
378#endif
379
380#ifdef CONFIG_EFI_PARAMS_FROM_FDT
381
382#define UEFI_PARAM(name, prop, field) \
383 { \
384 { name }, \
385 { prop }, \
386 offsetof(struct efi_fdt_params, field), \
387 FIELD_SIZEOF(struct efi_fdt_params, field) \
388 }
389
390static __initdata struct {
391 const char name[32];
392 const char propname[32];
393 int offset;
394 int size;
395} dt_params[] = {
396 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
397 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
398 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
399 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
400 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
401};
402
403struct param_info {
404 int verbose;
405 int found;
406 void *params;
407};
408
409static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
410 int depth, void *data)
411{
412 struct param_info *info = data;
413 const void *prop;
414 void *dest;
415 u64 val;
416 int i, len;
417
418 if (depth != 1 || strcmp(uname, "chosen") != 0)
419 return 0;
420
421 for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
422 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
423 if (!prop)
424 return 0;
425 dest = info->params + dt_params[i].offset;
426 info->found++;
427
428 val = of_read_number(prop, len / sizeof(u32));
429
430 if (dt_params[i].size == sizeof(u32))
431 *(u32 *)dest = val;
432 else
433 *(u64 *)dest = val;
434
435 if (info->verbose)
436 pr_info(" %s: 0x%0*llx\n", dt_params[i].name,
437 dt_params[i].size * 2, val);
438 }
439 return 1;
440}
441
442int __init efi_get_fdt_params(struct efi_fdt_params *params, int verbose)
443{
444 struct param_info info;
445 int ret;
446
447 pr_info("Getting EFI parameters from FDT:\n");
448
449 info.verbose = verbose;
450 info.found = 0;
451 info.params = params;
452
453 ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
454 if (!info.found)
455 pr_info("UEFI not found.\n");
456 else if (!ret)
457 pr_err("Can't find '%s' in device tree!\n",
458 dt_params[info.found].name);
459
460 return ret;
461}
462#endif /* CONFIG_EFI_PARAMS_FROM_FDT */
463
464static __initdata char memory_type_name[][20] = {
465 "Reserved",
466 "Loader Code",
467 "Loader Data",
468 "Boot Code",
469 "Boot Data",
470 "Runtime Code",
471 "Runtime Data",
472 "Conventional Memory",
473 "Unusable Memory",
474 "ACPI Reclaim Memory",
475 "ACPI Memory NVS",
476 "Memory Mapped I/O",
477 "MMIO Port Space",
478 "PAL Code"
479};
480
481char * __init efi_md_typeattr_format(char *buf, size_t size,
482 const efi_memory_desc_t *md)
483{
484 char *pos;
485 int type_len;
486 u64 attr;
487
488 pos = buf;
489 if (md->type >= ARRAY_SIZE(memory_type_name))
490 type_len = snprintf(pos, size, "[type=%u", md->type);
491 else
492 type_len = snprintf(pos, size, "[%-*s",
493 (int)(sizeof(memory_type_name[0]) - 1),
494 memory_type_name[md->type]);
495 if (type_len >= size)
496 return buf;
497
498 pos += type_len;
499 size -= type_len;
500
501 attr = md->attribute;
502 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
503 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_WP |
504 EFI_MEMORY_RP | EFI_MEMORY_XP | EFI_MEMORY_RUNTIME))
505 snprintf(pos, size, "|attr=0x%016llx]",
506 (unsigned long long)attr);
507 else
508 snprintf(pos, size, "|%3s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
509 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
510 attr & EFI_MEMORY_XP ? "XP" : "",
511 attr & EFI_MEMORY_RP ? "RP" : "",
512 attr & EFI_MEMORY_WP ? "WP" : "",
513 attr & EFI_MEMORY_UCE ? "UCE" : "",
514 attr & EFI_MEMORY_WB ? "WB" : "",
515 attr & EFI_MEMORY_WT ? "WT" : "",
516 attr & EFI_MEMORY_WC ? "WC" : "",
517 attr & EFI_MEMORY_UC ? "UC" : "");
518 return buf;
519}