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