drivers/firmware/efi/efi.c

   1 /*
   2  * efi.c - EFI subsystem
   3  *
   4  * Copyright (C) 2001,2003,2004 Dell <[email protected]>
   5  * Copyright (C) 2004 Intel Corporation <[email protected]>
   6  * Copyright (C) 2013 Tom Gundersen <[email protected]>
   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 };
  43 EXPORT_SYMBOL(efi);
  44
  45 static bool disable_runtime;
  46 static int __init setup_noefi(char *arg)
  47 {
  48         disable_runtime = true;
  49         return 0;
  50 }
  51 early_param("noefi", setup_noefi);
  52
  53 bool efi_runtime_disabled(void)
  54 {
  55         return disable_runtime;
  56 }
  57
  58 static int __init parse_efi_cmdline(char *str)
  59 {
  60         if (parse_option_str(str, "noruntime"))
  61                 disable_runtime = true;
  62
  63         return 0;
  64 }
  65 early_param("efi", parse_efi_cmdline);
  66
  67 static struct kobject *efi_kobj;
  68 static struct kobject *efivars_kobj;
  69
  70 /*
  71  * Let's not leave out systab information that snuck into
  72  * the efivars driver
  73  */
  74 static 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
 102 static 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) \
 108 static 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
 114 EFI_ATTR_SHOW(fw_vendor);
 115 EFI_ATTR_SHOW(runtime);
 116 EFI_ATTR_SHOW(config_table);
 117
 118 static 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
 124 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
 125 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
 126 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
 127 static struct kobj_attribute efi_attr_fw_platform_size =
 128         __ATTR_RO(fw_platform_size);
 129
 130 static 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
 139 static 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
 157 static struct attribute_group efi_subsys_attr_group = {
 158         .attrs = efi_subsys_attrs,
 159         .is_visible = efi_attr_is_visible,
 160 };
 161
 162 static struct efivars generic_efivars;
 163 static struct efivar_operations generic_ops;
 164
 165 static 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
 175 static 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  */
 185 static 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
 224 err_remove_group:
 225         sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
 226 err_unregister:
 227         generic_ops_unregister();
 228 err_put:
 229         kobject_put(efi_kobj);
 230         return error;
 231 }
 232
 233 subsys_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  */
 241 void __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
 268 static __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
 280 static __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
 300 int __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
 339 int __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
 367 static 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 }
 377 device_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
 390 static __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
 403 struct param_info {
 404         int verbose;
 405         int found;
 406         void *params;
 407 };
 408
 409 static 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
 442 int __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
 464 static __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
 481 char * __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 }