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 struct kobject *efi_kobj;
  45 static struct kobject *efivars_kobj;
  46
  47 /*
  48  * Let's not leave out systab information that snuck into
  49  * the efivars driver
  50  */
  51 static ssize_t systab_show(struct kobject *kobj,
  52                            struct kobj_attribute *attr, char *buf)
  53 {
  54         char *str = buf;
  55
  56         if (!kobj || !buf)
  57                 return -EINVAL;
  58
  59         if (efi.mps != EFI_INVALID_TABLE_ADDR)
  60                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
  61         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
  62                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
  63         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
  64                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
  65         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
  66                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
  67         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
  68                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
  69         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
  70                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
  71         if (efi.uga != EFI_INVALID_TABLE_ADDR)
  72                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
  73
  74         return str - buf;
  75 }
  76
  77 static struct kobj_attribute efi_attr_systab =
  78                         __ATTR(systab, 0400, systab_show, NULL);
  79
  80 #define EFI_FIELD(var) efi.var
  81
  82 #define EFI_ATTR_SHOW(name) \
  83 static ssize_t name##_show(struct kobject *kobj, \
  84                                 struct kobj_attribute *attr, char *buf) \
  85 { \
  86         return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
  87 }
  88
  89 EFI_ATTR_SHOW(fw_vendor);
  90 EFI_ATTR_SHOW(runtime);
  91 EFI_ATTR_SHOW(config_table);
  92
  93 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
  94 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
  95 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
  96
  97 static struct attribute *efi_subsys_attrs[] = {
  98         &efi_attr_systab.attr,
  99         &efi_attr_fw_vendor.attr,
 100         &efi_attr_runtime.attr,
 101         &efi_attr_config_table.attr,
 102         NULL,
 103 };
 104
 105 static umode_t efi_attr_is_visible(struct kobject *kobj,
 106                                    struct attribute *attr, int n)
 107 {
 108         if (attr == &efi_attr_fw_vendor.attr) {
 109                 if (efi_enabled(EFI_PARAVIRT) ||
 110                                 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
 111                         return 0;
 112         } else if (attr == &efi_attr_runtime.attr) {
 113                 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
 114                         return 0;
 115         } else if (attr == &efi_attr_config_table.attr) {
 116                 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
 117                         return 0;
 118         }
 119
 120         return attr->mode;
 121 }
 122
 123 static struct attribute_group efi_subsys_attr_group = {
 124         .attrs = efi_subsys_attrs,
 125         .is_visible = efi_attr_is_visible,
 126 };
 127
 128 static struct efivars generic_efivars;
 129 static struct efivar_operations generic_ops;
 130
 131 static int generic_ops_register(void)
 132 {
 133         generic_ops.get_variable = efi.get_variable;
 134         generic_ops.set_variable = efi.set_variable;
 135         generic_ops.get_next_variable = efi.get_next_variable;
 136         generic_ops.query_variable_store = efi_query_variable_store;
 137
 138         return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
 139 }
 140
 141 static void generic_ops_unregister(void)
 142 {
 143         efivars_unregister(&generic_efivars);
 144 }
 145
 146 /*
 147  * We register the efi subsystem with the firmware subsystem and the
 148  * efivars subsystem with the efi subsystem, if the system was booted with
 149  * EFI.
 150  */
 151 static int __init efisubsys_init(void)
 152 {
 153         int error;
 154
 155         if (!efi_enabled(EFI_BOOT))
 156                 return 0;
 157
 158         /* We register the efi directory at /sys/firmware/efi */
 159         efi_kobj = kobject_create_and_add("efi", firmware_kobj);
 160         if (!efi_kobj) {
 161                 pr_err("efi: Firmware registration failed.\n");
 162                 return -ENOMEM;
 163         }
 164
 165         error = generic_ops_register();
 166         if (error)
 167                 goto err_put;
 168
 169         error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
 170         if (error) {
 171                 pr_err("efi: Sysfs attribute export failed with error %d.\n",
 172                        error);
 173                 goto err_unregister;
 174         }
 175
 176         error = efi_runtime_map_init(efi_kobj);
 177         if (error)
 178                 goto err_remove_group;
 179
 180         /* and the standard mountpoint for efivarfs */
 181         efivars_kobj = kobject_create_and_add("efivars", efi_kobj);
 182         if (!efivars_kobj) {
 183                 pr_err("efivars: Subsystem registration failed.\n");
 184                 error = -ENOMEM;
 185                 goto err_remove_group;
 186         }
 187
 188         return 0;
 189
 190 err_remove_group:
 191         sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
 192 err_unregister:
 193         generic_ops_unregister();
 194 err_put:
 195         kobject_put(efi_kobj);
 196         return error;
 197 }
 198
 199 subsys_initcall(efisubsys_init);
 200
 201
 202 /*
 203  * We can't ioremap data in EFI boot services RAM, because we've already mapped
 204  * it as RAM.  So, look it up in the existing EFI memory map instead.  Only
 205  * callable after efi_enter_virtual_mode and before efi_free_boot_services.
 206  */
 207 void __iomem *efi_lookup_mapped_addr(u64 phys_addr)
 208 {
 209         struct efi_memory_map *map;
 210         void *p;
 211         map = efi.memmap;
 212         if (!map)
 213                 return NULL;
 214         if (WARN_ON(!map->map))
 215                 return NULL;
 216         for (p = map->map; p < map->map_end; p += map->desc_size) {
 217                 efi_memory_desc_t *md = p;
 218                 u64 size = md->num_pages << EFI_PAGE_SHIFT;
 219                 u64 end = md->phys_addr + size;
 220                 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
 221                     md->type != EFI_BOOT_SERVICES_CODE &&
 222                     md->type != EFI_BOOT_SERVICES_DATA)
 223                         continue;
 224                 if (!md->virt_addr)
 225                         continue;
 226                 if (phys_addr >= md->phys_addr && phys_addr < end) {
 227                         phys_addr += md->virt_addr - md->phys_addr;
 228                         return (__force void __iomem *)(unsigned long)phys_addr;
 229                 }
 230         }
 231         return NULL;
 232 }
 233
 234 static __initdata efi_config_table_type_t common_tables[] = {
 235         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
 236         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
 237         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
 238         {MPS_TABLE_GUID, "MPS", &efi.mps},
 239         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
 240         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
 241         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
 242         {NULL_GUID, NULL, NULL},
 243 };
 244
 245 static __init int match_config_table(efi_guid_t *guid,
 246                                      unsigned long table,
 247                                      efi_config_table_type_t *table_types)
 248 {
 249         u8 str[EFI_VARIABLE_GUID_LEN + 1];
 250         int i;
 251
 252         if (table_types) {
 253                 efi_guid_unparse(guid, str);
 254
 255                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
 256                         efi_guid_unparse(&table_types[i].guid, str);
 257
 258                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
 259                                 *(table_types[i].ptr) = table;
 260                                 pr_cont(" %s=0x%lx ",
 261                                         table_types[i].name, table);
 262                                 return 1;
 263                         }
 264                 }
 265         }
 266
 267         return 0;
 268 }
 269
 270 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 271 {
 272         void *config_tables, *tablep;
 273         int i, sz;
 274
 275         if (efi_enabled(EFI_64BIT))
 276                 sz = sizeof(efi_config_table_64_t);
 277         else
 278                 sz = sizeof(efi_config_table_32_t);
 279
 280         /*
 281          * Let's see what config tables the firmware passed to us.
 282          */
 283         config_tables = early_memremap(efi.systab->tables,
 284                                        efi.systab->nr_tables * sz);
 285         if (config_tables == NULL) {
 286                 pr_err("Could not map Configuration table!\n");
 287                 return -ENOMEM;
 288         }
 289
 290         tablep = config_tables;
 291         pr_info("");
 292         for (i = 0; i < efi.systab->nr_tables; i++) {
 293                 efi_guid_t guid;
 294                 unsigned long table;
 295
 296                 if (efi_enabled(EFI_64BIT)) {
 297                         u64 table64;
 298                         guid = ((efi_config_table_64_t *)tablep)->guid;
 299                         table64 = ((efi_config_table_64_t *)tablep)->table;
 300                         table = table64;
 301 #ifndef CONFIG_64BIT
 302                         if (table64 >> 32) {
 303                                 pr_cont("\n");
 304                                 pr_err("Table located above 4GB, disabling EFI.\n");
 305                                 early_memunmap(config_tables,
 306                                                efi.systab->nr_tables * sz);
 307                                 return -EINVAL;
 308                         }
 309 #endif
 310                 } else {
 311                         guid = ((efi_config_table_32_t *)tablep)->guid;
 312                         table = ((efi_config_table_32_t *)tablep)->table;
 313                 }
 314
 315                 if (!match_config_table(&guid, table, common_tables))
 316                         match_config_table(&guid, table, arch_tables);
 317
 318                 tablep += sz;
 319         }
 320         pr_cont("\n");
 321         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 322
 323         set_bit(EFI_CONFIG_TABLES, &efi.flags);
 324
 325         return 0;
 326 }
 327
 328 #ifdef CONFIG_EFI_VARS_MODULE
 329 static int __init efi_load_efivars(void)
 330 {
 331         struct platform_device *pdev;
 332
 333         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 334                 return 0;
 335
 336         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 337         return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
 338 }
 339 device_initcall(efi_load_efivars);
 340 #endif
 341
 342 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 343
 344 #define UEFI_PARAM(name, prop, field)                      \
 345         {                                                  \
 346                 { name },                                  \
 347                 { prop },                                  \
 348                 offsetof(struct efi_fdt_params, field),    \
 349                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 350         }
 351
 352 static __initdata struct {
 353         const char name[32];
 354         const char propname[32];
 355         int offset;
 356         int size;
 357 } dt_params[] = {
 358         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 359         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 360         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 361         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 362         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 363 };
 364
 365 struct param_info {
 366         int verbose;
 367         int found;
 368         void *params;
 369 };
 370
 371 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 372                                        int depth, void *data)
 373 {
 374         struct param_info *info = data;
 375         const void *prop;
 376         void *dest;
 377         u64 val;
 378         int i, len;
 379
 380         if (depth != 1 ||
 381             (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
 382                 return 0;
 383
 384         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 385                 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
 386                 if (!prop)
 387                         return 0;
 388                 dest = info->params + dt_params[i].offset;
 389                 info->found++;
 390
 391                 val = of_read_number(prop, len / sizeof(u32));
 392
 393                 if (dt_params[i].size == sizeof(u32))
 394                         *(u32 *)dest = val;
 395                 else
 396                         *(u64 *)dest = val;
 397
 398                 if (info->verbose)
 399                         pr_info("  %s: 0x%0*llx\n", dt_params[i].name,
 400                                 dt_params[i].size * 2, val);
 401         }
 402         return 1;
 403 }
 404
 405 int __init efi_get_fdt_params(struct efi_fdt_params *params, int verbose)
 406 {
 407         struct param_info info;
 408         int ret;
 409
 410         pr_info("Getting EFI parameters from FDT:\n");
 411
 412         info.verbose = verbose;
 413         info.found = 0;
 414         info.params = params;
 415
 416         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 417         if (!info.found)
 418                 pr_info("UEFI not found.\n");
 419         else if (!ret)
 420                 pr_err("Can't find '%s' in device tree!\n",
 421                        dt_params[info.found].name);
 422
 423         return ret;
 424 }
 425 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */