drivers/firmware/efi/efi.c

   1 /*
   2  * efi.c - EFI subsystem
   3  *
   4  * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
   5  * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
   6  * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
   7  *
   8  * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
   9  * allowing the efivarfs to be mounted or the efivars module to be loaded.
  10  * The existance of /sys/firmware/efi may also be used by userspace to
  11  * determine that the system supports EFI.
  12  *
  13  * This file is released under the GPLv2.
  14  */
  15
  16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  17
  18 #include <linux/kobject.h>
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/device.h>
  22 #include <linux/efi.h>
  23 #include <linux/of.h>
  24 #include <linux/of_fdt.h>
  25 #include <linux/io.h>
  26 #include <linux/platform_device.h>
  27
  28 struct 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         .esrt       = EFI_INVALID_TABLE_ADDR,
  43 };
  44 EXPORT_SYMBOL(efi);
  45
  46 static bool disable_runtime;
  47 static int __init setup_noefi(char *arg)
  48 {
  49         disable_runtime = true;
  50         return 0;
  51 }
  52 early_param("noefi", setup_noefi);
  53
  54 bool efi_runtime_disabled(void)
  55 {
  56         return disable_runtime;
  57 }
  58
  59 static int __init parse_efi_cmdline(char *str)
  60 {
  61         if (!str) {
  62                 pr_warn("need at least one option\n");
  63                 return -EINVAL;
  64         }
  65
  66         if (parse_option_str(str, "noruntime"))
  67                 disable_runtime = true;
  68
  69         return 0;
  70 }
  71 early_param("efi", parse_efi_cmdline);
  72
  73 struct kobject *efi_kobj;
  74
  75 /*
  76  * Let's not leave out systab information that snuck into
  77  * the efivars driver
  78  */
  79 static ssize_t systab_show(struct kobject *kobj,
  80                            struct kobj_attribute *attr, char *buf)
  81 {
  82         char *str = buf;
  83
  84         if (!kobj || !buf)
  85                 return -EINVAL;
  86
  87         if (efi.mps != EFI_INVALID_TABLE_ADDR)
  88                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
  89         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
  90                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
  91         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
  92                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
  93         /*
  94          * If both SMBIOS and SMBIOS3 entry points are implemented, the
  95          * SMBIOS3 entry point shall be preferred, so we list it first to
  96          * let applications stop parsing after the first match.
  97          */
  98         if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
  99                 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
 100         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
 101                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
 102         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
 103                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
 104         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
 105                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
 106         if (efi.uga != EFI_INVALID_TABLE_ADDR)
 107                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
 108
 109         return str - buf;
 110 }
 111
 112 static struct kobj_attribute efi_attr_systab =
 113                         __ATTR(systab, 0400, systab_show, NULL);
 114
 115 #define EFI_FIELD(var) efi.var
 116
 117 #define EFI_ATTR_SHOW(name) \
 118 static ssize_t name##_show(struct kobject *kobj, \
 119                                 struct kobj_attribute *attr, char *buf) \
 120 { \
 121         return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
 122 }
 123
 124 EFI_ATTR_SHOW(fw_vendor);
 125 EFI_ATTR_SHOW(runtime);
 126 EFI_ATTR_SHOW(config_table);
 127
 128 static ssize_t fw_platform_size_show(struct kobject *kobj,
 129                                      struct kobj_attribute *attr, char *buf)
 130 {
 131         return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
 132 }
 133
 134 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
 135 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
 136 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
 137 static struct kobj_attribute efi_attr_fw_platform_size =
 138         __ATTR_RO(fw_platform_size);
 139
 140 static struct attribute *efi_subsys_attrs[] = {
 141         &efi_attr_systab.attr,
 142         &efi_attr_fw_vendor.attr,
 143         &efi_attr_runtime.attr,
 144         &efi_attr_config_table.attr,
 145         &efi_attr_fw_platform_size.attr,
 146         NULL,
 147 };
 148
 149 static umode_t efi_attr_is_visible(struct kobject *kobj,
 150                                    struct attribute *attr, int n)
 151 {
 152         if (attr == &efi_attr_fw_vendor.attr) {
 153                 if (efi_enabled(EFI_PARAVIRT) ||
 154                                 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
 155                         return 0;
 156         } else if (attr == &efi_attr_runtime.attr) {
 157                 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
 158                         return 0;
 159         } else if (attr == &efi_attr_config_table.attr) {
 160                 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
 161                         return 0;
 162         }
 163
 164         return attr->mode;
 165 }
 166
 167 static struct attribute_group efi_subsys_attr_group = {
 168         .attrs = efi_subsys_attrs,
 169         .is_visible = efi_attr_is_visible,
 170 };
 171
 172 static struct efivars generic_efivars;
 173 static struct efivar_operations generic_ops;
 174
 175 static int generic_ops_register(void)
 176 {
 177         generic_ops.get_variable = efi.get_variable;
 178         generic_ops.set_variable = efi.set_variable;
 179         generic_ops.get_next_variable = efi.get_next_variable;
 180         generic_ops.query_variable_store = efi_query_variable_store;
 181
 182         return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
 183 }
 184
 185 static void generic_ops_unregister(void)
 186 {
 187         efivars_unregister(&generic_efivars);
 188 }
 189
 190 /*
 191  * We register the efi subsystem with the firmware subsystem and the
 192  * efivars subsystem with the efi subsystem, if the system was booted with
 193  * EFI.
 194  */
 195 static int __init efisubsys_init(void)
 196 {
 197         int error;
 198
 199         if (!efi_enabled(EFI_BOOT))
 200                 return 0;
 201
 202         /* We register the efi directory at /sys/firmware/efi */
 203         efi_kobj = kobject_create_and_add("efi", firmware_kobj);
 204         if (!efi_kobj) {
 205                 pr_err("efi: Firmware registration failed.\n");
 206                 return -ENOMEM;
 207         }
 208
 209         error = generic_ops_register();
 210         if (error)
 211                 goto err_put;
 212
 213         error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
 214         if (error) {
 215                 pr_err("efi: Sysfs attribute export failed with error %d.\n",
 216                        error);
 217                 goto err_unregister;
 218         }
 219
 220         error = efi_runtime_map_init(efi_kobj);
 221         if (error)
 222                 goto err_remove_group;
 223
 224         /* and the standard mountpoint for efivarfs */
 225         error = sysfs_create_mount_point(efi_kobj, "efivars");
 226         if (error) {
 227                 pr_err("efivars: Subsystem registration failed.\n");
 228                 goto err_remove_group;
 229         }
 230
 231         return 0;
 232
 233 err_remove_group:
 234         sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
 235 err_unregister:
 236         generic_ops_unregister();
 237 err_put:
 238         kobject_put(efi_kobj);
 239         return error;
 240 }
 241
 242 subsys_initcall(efisubsys_init);
 243
 244 /*
 245  * Find the efi memory descriptor for a given physical address.  Given a
 246  * physicall address, determine if it exists within an EFI Memory Map entry,
 247  * and if so, populate the supplied memory descriptor with the appropriate
 248  * data.
 249  */
 250 int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
 251 {
 252         struct efi_memory_map *map = efi.memmap;
 253         void *p, *e;
 254
 255         if (!efi_enabled(EFI_MEMMAP)) {
 256                 pr_err_once("EFI_MEMMAP is not enabled.\n");
 257                 return -EINVAL;
 258         }
 259
 260         if (!map) {
 261                 pr_err_once("efi.memmap is not set.\n");
 262                 return -EINVAL;
 263         }
 264         if (!out_md) {
 265                 pr_err_once("out_md is null.\n");
 266                 return -EINVAL;
 267         }
 268         if (WARN_ON_ONCE(!map->phys_map))
 269                 return -EINVAL;
 270         if (WARN_ON_ONCE(map->nr_map == 0) || WARN_ON_ONCE(map->desc_size == 0))
 271                 return -EINVAL;
 272
 273         e = map->phys_map + map->nr_map * map->desc_size;
 274         for (p = map->phys_map; p < e; p += map->desc_size) {
 275                 efi_memory_desc_t *md;
 276                 u64 size;
 277                 u64 end;
 278
 279                 /*
 280                  * If a driver calls this after efi_free_boot_services,
 281                  * ->map will be NULL, and the target may also not be mapped.
 282                  * So just always get our own virtual map on the CPU.
 283                  *
 284                  */
 285                 md = early_memremap((phys_addr_t)p, sizeof (*md));
 286                 if (!md) {
 287                         pr_err_once("early_memremap(%p, %zu) failed.\n",
 288                                     p, sizeof (*md));
 289                         return -ENOMEM;
 290                 }
 291
 292                 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
 293                     md->type != EFI_BOOT_SERVICES_DATA &&
 294                     md->type != EFI_RUNTIME_SERVICES_DATA) {
 295                         early_memunmap(md, sizeof (*md));
 296                         continue;
 297                 }
 298
 299                 size = md->num_pages << EFI_PAGE_SHIFT;
 300                 end = md->phys_addr + size;
 301                 if (phys_addr >= md->phys_addr && phys_addr < end) {
 302                         memcpy(out_md, md, sizeof(*out_md));
 303                         early_memunmap(md, sizeof (*md));
 304                         return 0;
 305                 }
 306
 307                 early_memunmap(md, sizeof (*md));
 308         }
 309         pr_err_once("requested map not found.\n");
 310         return -ENOENT;
 311 }
 312
 313 /*
 314  * Calculate the highest address of an efi memory descriptor.
 315  */
 316 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
 317 {
 318         u64 size = md->num_pages << EFI_PAGE_SHIFT;
 319         u64 end = md->phys_addr + size;
 320         return end;
 321 }
 322
 323 /*
 324  * We can't ioremap data in EFI boot services RAM, because we've already mapped
 325  * it as RAM.  So, look it up in the existing EFI memory map instead.  Only
 326  * callable after efi_enter_virtual_mode and before efi_free_boot_services.
 327  */
 328 void __iomem *efi_lookup_mapped_addr(u64 phys_addr)
 329 {
 330         struct efi_memory_map *map;
 331         void *p;
 332         map = efi.memmap;
 333         if (!map)
 334                 return NULL;
 335         if (WARN_ON(!map->map))
 336                 return NULL;
 337         for (p = map->map; p < map->map_end; p += map->desc_size) {
 338                 efi_memory_desc_t *md = p;
 339                 u64 size = md->num_pages << EFI_PAGE_SHIFT;
 340                 u64 end = md->phys_addr + size;
 341                 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
 342                     md->type != EFI_BOOT_SERVICES_CODE &&
 343                     md->type != EFI_BOOT_SERVICES_DATA)
 344                         continue;
 345                 if (!md->virt_addr)
 346                         continue;
 347                 if (phys_addr >= md->phys_addr && phys_addr < end) {
 348                         phys_addr += md->virt_addr - md->phys_addr;
 349                         return (__force void __iomem *)(unsigned long)phys_addr;
 350                 }
 351         }
 352         return NULL;
 353 }
 354
 355 static __initdata efi_config_table_type_t common_tables[] = {
 356         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
 357         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
 358         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
 359         {MPS_TABLE_GUID, "MPS", &efi.mps},
 360         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
 361         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
 362         {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
 363         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
 364         {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
 365         {NULL_GUID, NULL, NULL},
 366 };
 367
 368 static __init int match_config_table(efi_guid_t *guid,
 369                                      unsigned long table,
 370                                      efi_config_table_type_t *table_types)
 371 {
 372         int i;
 373
 374         if (table_types) {
 375                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
 376                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
 377                                 *(table_types[i].ptr) = table;
 378                                 pr_cont(" %s=0x%lx ",
 379                                         table_types[i].name, table);
 380                                 return 1;
 381                         }
 382                 }
 383         }
 384
 385         return 0;
 386 }
 387
 388 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
 389                                    efi_config_table_type_t *arch_tables)
 390 {
 391         void *tablep;
 392         int i;
 393
 394         tablep = config_tables;
 395         pr_info("");
 396         for (i = 0; i < count; i++) {
 397                 efi_guid_t guid;
 398                 unsigned long table;
 399
 400                 if (efi_enabled(EFI_64BIT)) {
 401                         u64 table64;
 402                         guid = ((efi_config_table_64_t *)tablep)->guid;
 403                         table64 = ((efi_config_table_64_t *)tablep)->table;
 404                         table = table64;
 405 #ifndef CONFIG_64BIT
 406                         if (table64 >> 32) {
 407                                 pr_cont("\n");
 408                                 pr_err("Table located above 4GB, disabling EFI.\n");
 409                                 return -EINVAL;
 410                         }
 411 #endif
 412                 } else {
 413                         guid = ((efi_config_table_32_t *)tablep)->guid;
 414                         table = ((efi_config_table_32_t *)tablep)->table;
 415                 }
 416
 417                 if (!match_config_table(&guid, table, common_tables))
 418                         match_config_table(&guid, table, arch_tables);
 419
 420                 tablep += sz;
 421         }
 422         pr_cont("\n");
 423         set_bit(EFI_CONFIG_TABLES, &efi.flags);
 424         return 0;
 425 }
 426
 427 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 428 {
 429         void *config_tables;
 430         int sz, ret;
 431
 432         if (efi_enabled(EFI_64BIT))
 433                 sz = sizeof(efi_config_table_64_t);
 434         else
 435                 sz = sizeof(efi_config_table_32_t);
 436
 437         /*
 438          * Let's see what config tables the firmware passed to us.
 439          */
 440         config_tables = early_memremap(efi.systab->tables,
 441                                        efi.systab->nr_tables * sz);
 442         if (config_tables == NULL) {
 443                 pr_err("Could not map Configuration table!\n");
 444                 return -ENOMEM;
 445         }
 446
 447         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
 448                                       arch_tables);
 449
 450         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 451         return ret;
 452 }
 453
 454 #ifdef CONFIG_EFI_VARS_MODULE
 455 static int __init efi_load_efivars(void)
 456 {
 457         struct platform_device *pdev;
 458
 459         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 460                 return 0;
 461
 462         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 463         return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
 464 }
 465 device_initcall(efi_load_efivars);
 466 #endif
 467
 468 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 469
 470 #define UEFI_PARAM(name, prop, field)                      \
 471         {                                                  \
 472                 { name },                                  \
 473                 { prop },                                  \
 474                 offsetof(struct efi_fdt_params, field),    \
 475                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 476         }
 477
 478 static __initdata struct {
 479         const char name[32];
 480         const char propname[32];
 481         int offset;
 482         int size;
 483 } dt_params[] = {
 484         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 485         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 486         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 487         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 488         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 489 };
 490
 491 struct param_info {
 492         int verbose;
 493         int found;
 494         void *params;
 495 };
 496
 497 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 498                                        int depth, void *data)
 499 {
 500         struct param_info *info = data;
 501         const void *prop;
 502         void *dest;
 503         u64 val;
 504         int i, len;
 505
 506         if (depth != 1 || strcmp(uname, "chosen") != 0)
 507                 return 0;
 508
 509         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 510                 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
 511                 if (!prop)
 512                         return 0;
 513                 dest = info->params + dt_params[i].offset;
 514                 info->found++;
 515
 516                 val = of_read_number(prop, len / sizeof(u32));
 517
 518                 if (dt_params[i].size == sizeof(u32))
 519                         *(u32 *)dest = val;
 520                 else
 521                         *(u64 *)dest = val;
 522
 523                 if (info->verbose)
 524                         pr_info("  %s: 0x%0*llx\n", dt_params[i].name,
 525                                 dt_params[i].size * 2, val);
 526         }
 527         return 1;
 528 }
 529
 530 int __init efi_get_fdt_params(struct efi_fdt_params *params, int verbose)
 531 {
 532         struct param_info info;
 533         int ret;
 534
 535         pr_info("Getting EFI parameters from FDT:\n");
 536
 537         info.verbose = verbose;
 538         info.found = 0;
 539         info.params = params;
 540
 541         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 542         if (!info.found)
 543                 pr_info("UEFI not found.\n");
 544         else if (!ret)
 545                 pr_err("Can't find '%s' in device tree!\n",
 546                        dt_params[info.found].name);
 547
 548         return ret;
 549 }
 550 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 551
 552 static __initdata char memory_type_name[][20] = {
 553         "Reserved",
 554         "Loader Code",
 555         "Loader Data",
 556         "Boot Code",
 557         "Boot Data",
 558         "Runtime Code",
 559         "Runtime Data",
 560         "Conventional Memory",
 561         "Unusable Memory",
 562         "ACPI Reclaim Memory",
 563         "ACPI Memory NVS",
 564         "Memory Mapped I/O",
 565         "MMIO Port Space",
 566         "PAL Code"
 567 };
 568
 569 char * __init efi_md_typeattr_format(char *buf, size_t size,
 570                                      const efi_memory_desc_t *md)
 571 {
 572         char *pos;
 573         int type_len;
 574         u64 attr;
 575
 576         pos = buf;
 577         if (md->type >= ARRAY_SIZE(memory_type_name))
 578                 type_len = snprintf(pos, size, "[type=%u", md->type);
 579         else
 580                 type_len = snprintf(pos, size, "[%-*s",
 581                                     (int)(sizeof(memory_type_name[0]) - 1),
 582                                     memory_type_name[md->type]);
 583         if (type_len >= size)
 584                 return buf;
 585
 586         pos += type_len;
 587         size -= type_len;
 588
 589         attr = md->attribute;
 590         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 591                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_WP |
 592                      EFI_MEMORY_RP | EFI_MEMORY_XP | EFI_MEMORY_RUNTIME))
 593                 snprintf(pos, size, "|attr=0x%016llx]",
 594                          (unsigned long long)attr);
 595         else
 596                 snprintf(pos, size, "|%3s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 597                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 598                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 599                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 600                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 601                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 602                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 603                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 604                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 605                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 606         return buf;
 607 }