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