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