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 #include <linux/slab.h>
  28 #include <linux/acpi.h>
  29 #include <linux/ucs2_string.h>
  30
  31 #include <asm/early_ioremap.h>
  32
  33 struct efi __read_mostly efi = {
  34         .mps                    = EFI_INVALID_TABLE_ADDR,
  35         .acpi                   = EFI_INVALID_TABLE_ADDR,
  36         .acpi20                 = EFI_INVALID_TABLE_ADDR,
  37         .smbios                 = EFI_INVALID_TABLE_ADDR,
  38         .smbios3                = EFI_INVALID_TABLE_ADDR,
  39         .sal_systab             = EFI_INVALID_TABLE_ADDR,
  40         .boot_info              = EFI_INVALID_TABLE_ADDR,
  41         .hcdp                   = EFI_INVALID_TABLE_ADDR,
  42         .uga                    = EFI_INVALID_TABLE_ADDR,
  43         .uv_systab              = EFI_INVALID_TABLE_ADDR,
  44         .fw_vendor              = EFI_INVALID_TABLE_ADDR,
  45         .runtime                = EFI_INVALID_TABLE_ADDR,
  46         .config_table           = EFI_INVALID_TABLE_ADDR,
  47         .esrt                   = EFI_INVALID_TABLE_ADDR,
  48         .properties_table       = EFI_INVALID_TABLE_ADDR,
  49         .mem_attr_table         = EFI_INVALID_TABLE_ADDR,
  50 };
  51 EXPORT_SYMBOL(efi);
  52
  53 static bool disable_runtime;
  54 static int __init setup_noefi(char *arg)
  55 {
  56         disable_runtime = true;
  57         return 0;
  58 }
  59 early_param("noefi", setup_noefi);
  60
  61 bool efi_runtime_disabled(void)
  62 {
  63         return disable_runtime;
  64 }
  65
  66 static int __init parse_efi_cmdline(char *str)
  67 {
  68         if (!str) {
  69                 pr_warn("need at least one option\n");
  70                 return -EINVAL;
  71         }
  72
  73         if (parse_option_str(str, "debug"))
  74                 set_bit(EFI_DBG, &efi.flags);
  75
  76         if (parse_option_str(str, "noruntime"))
  77                 disable_runtime = true;
  78
  79         return 0;
  80 }
  81 early_param("efi", parse_efi_cmdline);
  82
  83 struct kobject *efi_kobj;
  84
  85 /*
  86  * Let's not leave out systab information that snuck into
  87  * the efivars driver
  88  */
  89 static ssize_t systab_show(struct kobject *kobj,
  90                            struct kobj_attribute *attr, char *buf)
  91 {
  92         char *str = buf;
  93
  94         if (!kobj || !buf)
  95                 return -EINVAL;
  96
  97         if (efi.mps != EFI_INVALID_TABLE_ADDR)
  98                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
  99         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
 100                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
 101         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
 102                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
 103         /*
 104          * If both SMBIOS and SMBIOS3 entry points are implemented, the
 105          * SMBIOS3 entry point shall be preferred, so we list it first to
 106          * let applications stop parsing after the first match.
 107          */
 108         if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
 109                 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
 110         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
 111                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
 112         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
 113                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
 114         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
 115                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
 116         if (efi.uga != EFI_INVALID_TABLE_ADDR)
 117                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
 118
 119         return str - buf;
 120 }
 121
 122 static struct kobj_attribute efi_attr_systab =
 123                         __ATTR(systab, 0400, systab_show, NULL);
 124
 125 #define EFI_FIELD(var) efi.var
 126
 127 #define EFI_ATTR_SHOW(name) \
 128 static ssize_t name##_show(struct kobject *kobj, \
 129                                 struct kobj_attribute *attr, char *buf) \
 130 { \
 131         return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
 132 }
 133
 134 EFI_ATTR_SHOW(fw_vendor);
 135 EFI_ATTR_SHOW(runtime);
 136 EFI_ATTR_SHOW(config_table);
 137
 138 static ssize_t fw_platform_size_show(struct kobject *kobj,
 139                                      struct kobj_attribute *attr, char *buf)
 140 {
 141         return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
 142 }
 143
 144 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
 145 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
 146 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
 147 static struct kobj_attribute efi_attr_fw_platform_size =
 148         __ATTR_RO(fw_platform_size);
 149
 150 static struct attribute *efi_subsys_attrs[] = {
 151         &efi_attr_systab.attr,
 152         &efi_attr_fw_vendor.attr,
 153         &efi_attr_runtime.attr,
 154         &efi_attr_config_table.attr,
 155         &efi_attr_fw_platform_size.attr,
 156         NULL,
 157 };
 158
 159 static umode_t efi_attr_is_visible(struct kobject *kobj,
 160                                    struct attribute *attr, int n)
 161 {
 162         if (attr == &efi_attr_fw_vendor.attr) {
 163                 if (efi_enabled(EFI_PARAVIRT) ||
 164                                 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
 165                         return 0;
 166         } else if (attr == &efi_attr_runtime.attr) {
 167                 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
 168                         return 0;
 169         } else if (attr == &efi_attr_config_table.attr) {
 170                 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
 171                         return 0;
 172         }
 173
 174         return attr->mode;
 175 }
 176
 177 static struct attribute_group efi_subsys_attr_group = {
 178         .attrs = efi_subsys_attrs,
 179         .is_visible = efi_attr_is_visible,
 180 };
 181
 182 static struct efivars generic_efivars;
 183 static struct efivar_operations generic_ops;
 184
 185 static int generic_ops_register(void)
 186 {
 187         generic_ops.get_variable = efi.get_variable;
 188         generic_ops.set_variable = efi.set_variable;
 189         generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
 190         generic_ops.get_next_variable = efi.get_next_variable;
 191         generic_ops.query_variable_store = efi_query_variable_store;
 192
 193         return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
 194 }
 195
 196 static void generic_ops_unregister(void)
 197 {
 198         efivars_unregister(&generic_efivars);
 199 }
 200
 201 #if IS_ENABLED(CONFIG_ACPI)
 202 #define EFIVAR_SSDT_NAME_MAX    16
 203 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
 204 static int __init efivar_ssdt_setup(char *str)
 205 {
 206         if (strlen(str) < sizeof(efivar_ssdt))
 207                 memcpy(efivar_ssdt, str, strlen(str));
 208         else
 209                 pr_warn("efivar_ssdt: name too long: %s\n", str);
 210         return 0;
 211 }
 212 __setup("efivar_ssdt=", efivar_ssdt_setup);
 213
 214 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor,
 215                                    unsigned long name_size, void *data)
 216 {
 217         struct efivar_entry *entry;
 218         struct list_head *list = data;
 219         char utf8_name[EFIVAR_SSDT_NAME_MAX];
 220         int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size);
 221
 222         ucs2_as_utf8(utf8_name, name, limit - 1);
 223         if (strncmp(utf8_name, efivar_ssdt, limit) != 0)
 224                 return 0;
 225
 226         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
 227         if (!entry)
 228                 return 0;
 229
 230         memcpy(entry->var.VariableName, name, name_size);
 231         memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t));
 232
 233         efivar_entry_add(entry, list);
 234
 235         return 0;
 236 }
 237
 238 static __init int efivar_ssdt_load(void)
 239 {
 240         LIST_HEAD(entries);
 241         struct efivar_entry *entry, *aux;
 242         unsigned long size;
 243         void *data;
 244         int ret;
 245
 246         ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
 247
 248         list_for_each_entry_safe(entry, aux, &entries, list) {
 249                 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt,
 250                         &entry->var.VendorGuid);
 251
 252                 list_del(&entry->list);
 253
 254                 ret = efivar_entry_size(entry, &size);
 255                 if (ret) {
 256                         pr_err("failed to get var size\n");
 257                         goto free_entry;
 258                 }
 259
 260                 data = kmalloc(size, GFP_KERNEL);
 261                 if (!data)
 262                         goto free_entry;
 263
 264                 ret = efivar_entry_get(entry, NULL, &size, data);
 265                 if (ret) {
 266                         pr_err("failed to get var data\n");
 267                         goto free_data;
 268                 }
 269
 270                 ret = acpi_load_table(data);
 271                 if (ret) {
 272                         pr_err("failed to load table: %d\n", ret);
 273                         goto free_data;
 274                 }
 275
 276                 goto free_entry;
 277
 278 free_data:
 279                 kfree(data);
 280
 281 free_entry:
 282                 kfree(entry);
 283         }
 284
 285         return ret;
 286 }
 287 #else
 288 static inline int efivar_ssdt_load(void) { return 0; }
 289 #endif
 290
 291 /*
 292  * We register the efi subsystem with the firmware subsystem and the
 293  * efivars subsystem with the efi subsystem, if the system was booted with
 294  * EFI.
 295  */
 296 static int __init efisubsys_init(void)
 297 {
 298         int error;
 299
 300         if (!efi_enabled(EFI_BOOT))
 301                 return 0;
 302
 303         /* We register the efi directory at /sys/firmware/efi */
 304         efi_kobj = kobject_create_and_add("efi", firmware_kobj);
 305         if (!efi_kobj) {
 306                 pr_err("efi: Firmware registration failed.\n");
 307                 return -ENOMEM;
 308         }
 309
 310         error = generic_ops_register();
 311         if (error)
 312                 goto err_put;
 313
 314         if (efi_enabled(EFI_RUNTIME_SERVICES))
 315                 efivar_ssdt_load();
 316
 317         error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
 318         if (error) {
 319                 pr_err("efi: Sysfs attribute export failed with error %d.\n",
 320                        error);
 321                 goto err_unregister;
 322         }
 323
 324         error = efi_runtime_map_init(efi_kobj);
 325         if (error)
 326                 goto err_remove_group;
 327
 328         /* and the standard mountpoint for efivarfs */
 329         error = sysfs_create_mount_point(efi_kobj, "efivars");
 330         if (error) {
 331                 pr_err("efivars: Subsystem registration failed.\n");
 332                 goto err_remove_group;
 333         }
 334
 335         return 0;
 336
 337 err_remove_group:
 338         sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
 339 err_unregister:
 340         generic_ops_unregister();
 341 err_put:
 342         kobject_put(efi_kobj);
 343         return error;
 344 }
 345
 346 subsys_initcall(efisubsys_init);
 347
 348 /*
 349  * Find the efi memory descriptor for a given physical address.  Given a
 350  * physicall address, determine if it exists within an EFI Memory Map entry,
 351  * and if so, populate the supplied memory descriptor with the appropriate
 352  * data.
 353  */
 354 int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
 355 {
 356         struct efi_memory_map *map = &efi.memmap;
 357         phys_addr_t p, e;
 358
 359         if (!efi_enabled(EFI_MEMMAP)) {
 360                 pr_err_once("EFI_MEMMAP is not enabled.\n");
 361                 return -EINVAL;
 362         }
 363
 364         if (!map) {
 365                 pr_err_once("efi.memmap is not set.\n");
 366                 return -EINVAL;
 367         }
 368         if (!out_md) {
 369                 pr_err_once("out_md is null.\n");
 370                 return -EINVAL;
 371         }
 372         if (WARN_ON_ONCE(!map->phys_map))
 373                 return -EINVAL;
 374         if (WARN_ON_ONCE(map->nr_map == 0) || WARN_ON_ONCE(map->desc_size == 0))
 375                 return -EINVAL;
 376
 377         e = map->phys_map + map->nr_map * map->desc_size;
 378         for (p = map->phys_map; p < e; p += map->desc_size) {
 379                 efi_memory_desc_t *md;
 380                 u64 size;
 381                 u64 end;
 382
 383                 /*
 384                  * If a driver calls this after efi_free_boot_services,
 385                  * ->map will be NULL, and the target may also not be mapped.
 386                  * So just always get our own virtual map on the CPU.
 387                  *
 388                  */
 389                 md = early_memremap(p, sizeof (*md));
 390                 if (!md) {
 391                         pr_err_once("early_memremap(%pa, %zu) failed.\n",
 392                                     &p, sizeof (*md));
 393                         return -ENOMEM;
 394                 }
 395
 396                 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
 397                     md->type != EFI_BOOT_SERVICES_DATA &&
 398                     md->type != EFI_RUNTIME_SERVICES_DATA) {
 399                         early_memunmap(md, sizeof (*md));
 400                         continue;
 401                 }
 402
 403                 size = md->num_pages << EFI_PAGE_SHIFT;
 404                 end = md->phys_addr + size;
 405                 if (phys_addr >= md->phys_addr && phys_addr < end) {
 406                         memcpy(out_md, md, sizeof(*out_md));
 407                         early_memunmap(md, sizeof (*md));
 408                         return 0;
 409                 }
 410
 411                 early_memunmap(md, sizeof (*md));
 412         }
 413         pr_err_once("requested map not found.\n");
 414         return -ENOENT;
 415 }
 416
 417 /*
 418  * Calculate the highest address of an efi memory descriptor.
 419  */
 420 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
 421 {
 422         u64 size = md->num_pages << EFI_PAGE_SHIFT;
 423         u64 end = md->phys_addr + size;
 424         return end;
 425 }
 426
 427 static __initdata efi_config_table_type_t common_tables[] = {
 428         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
 429         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
 430         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
 431         {MPS_TABLE_GUID, "MPS", &efi.mps},
 432         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
 433         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
 434         {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
 435         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
 436         {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
 437         {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
 438         {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
 439         {NULL_GUID, NULL, NULL},
 440 };
 441
 442 static __init int match_config_table(efi_guid_t *guid,
 443                                      unsigned long table,
 444                                      efi_config_table_type_t *table_types)
 445 {
 446         int i;
 447
 448         if (table_types) {
 449                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
 450                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
 451                                 *(table_types[i].ptr) = table;
 452                                 if (table_types[i].name)
 453                                         pr_cont(" %s=0x%lx ",
 454                                                 table_types[i].name, table);
 455                                 return 1;
 456                         }
 457                 }
 458         }
 459
 460         return 0;
 461 }
 462
 463 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
 464                                    efi_config_table_type_t *arch_tables)
 465 {
 466         void *tablep;
 467         int i;
 468
 469         tablep = config_tables;
 470         pr_info("");
 471         for (i = 0; i < count; i++) {
 472                 efi_guid_t guid;
 473                 unsigned long table;
 474
 475                 if (efi_enabled(EFI_64BIT)) {
 476                         u64 table64;
 477                         guid = ((efi_config_table_64_t *)tablep)->guid;
 478                         table64 = ((efi_config_table_64_t *)tablep)->table;
 479                         table = table64;
 480 #ifndef CONFIG_64BIT
 481                         if (table64 >> 32) {
 482                                 pr_cont("\n");
 483                                 pr_err("Table located above 4GB, disabling EFI.\n");
 484                                 return -EINVAL;
 485                         }
 486 #endif
 487                 } else {
 488                         guid = ((efi_config_table_32_t *)tablep)->guid;
 489                         table = ((efi_config_table_32_t *)tablep)->table;
 490                 }
 491
 492                 if (!match_config_table(&guid, table, common_tables))
 493                         match_config_table(&guid, table, arch_tables);
 494
 495                 tablep += sz;
 496         }
 497         pr_cont("\n");
 498         set_bit(EFI_CONFIG_TABLES, &efi.flags);
 499
 500         /* Parse the EFI Properties table if it exists */
 501         if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
 502                 efi_properties_table_t *tbl;
 503
 504                 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
 505                 if (tbl == NULL) {
 506                         pr_err("Could not map Properties table!\n");
 507                         return -ENOMEM;
 508                 }
 509
 510                 if (tbl->memory_protection_attribute &
 511                     EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
 512                         set_bit(EFI_NX_PE_DATA, &efi.flags);
 513
 514                 early_memunmap(tbl, sizeof(*tbl));
 515         }
 516
 517         return 0;
 518 }
 519
 520 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 521 {
 522         void *config_tables;
 523         int sz, ret;
 524
 525         if (efi_enabled(EFI_64BIT))
 526                 sz = sizeof(efi_config_table_64_t);
 527         else
 528                 sz = sizeof(efi_config_table_32_t);
 529
 530         /*
 531          * Let's see what config tables the firmware passed to us.
 532          */
 533         config_tables = early_memremap(efi.systab->tables,
 534                                        efi.systab->nr_tables * sz);
 535         if (config_tables == NULL) {
 536                 pr_err("Could not map Configuration table!\n");
 537                 return -ENOMEM;
 538         }
 539
 540         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
 541                                       arch_tables);
 542
 543         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 544         return ret;
 545 }
 546
 547 #ifdef CONFIG_EFI_VARS_MODULE
 548 static int __init efi_load_efivars(void)
 549 {
 550         struct platform_device *pdev;
 551
 552         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 553                 return 0;
 554
 555         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 556         return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
 557 }
 558 device_initcall(efi_load_efivars);
 559 #endif
 560
 561 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 562
 563 #define UEFI_PARAM(name, prop, field)                      \
 564         {                                                  \
 565                 { name },                                  \
 566                 { prop },                                  \
 567                 offsetof(struct efi_fdt_params, field),    \
 568                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 569         }
 570
 571 struct params {
 572         const char name[32];
 573         const char propname[32];
 574         int offset;
 575         int size;
 576 };
 577
 578 static __initdata struct params fdt_params[] = {
 579         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 580         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 581         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 582         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 583         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 584 };
 585
 586 static __initdata struct params xen_fdt_params[] = {
 587         UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
 588         UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
 589         UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
 590         UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
 591         UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
 592 };
 593
 594 #define EFI_FDT_PARAMS_SIZE     ARRAY_SIZE(fdt_params)
 595
 596 static __initdata struct {
 597         const char *uname;
 598         const char *subnode;
 599         struct params *params;
 600 } dt_params[] = {
 601         { "hypervisor", "uefi", xen_fdt_params },
 602         { "chosen", NULL, fdt_params },
 603 };
 604
 605 struct param_info {
 606         int found;
 607         void *params;
 608         const char *missing;
 609 };
 610
 611 static int __init __find_uefi_params(unsigned long node,
 612                                      struct param_info *info,
 613                                      struct params *params)
 614 {
 615         const void *prop;
 616         void *dest;
 617         u64 val;
 618         int i, len;
 619
 620         for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
 621                 prop = of_get_flat_dt_prop(node, params[i].propname, &len);
 622                 if (!prop) {
 623                         info->missing = params[i].name;
 624                         return 0;
 625                 }
 626
 627                 dest = info->params + params[i].offset;
 628                 info->found++;
 629
 630                 val = of_read_number(prop, len / sizeof(u32));
 631
 632                 if (params[i].size == sizeof(u32))
 633                         *(u32 *)dest = val;
 634                 else
 635                         *(u64 *)dest = val;
 636
 637                 if (efi_enabled(EFI_DBG))
 638                         pr_info("  %s: 0x%0*llx\n", params[i].name,
 639                                 params[i].size * 2, val);
 640         }
 641
 642         return 1;
 643 }
 644
 645 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 646                                        int depth, void *data)
 647 {
 648         struct param_info *info = data;
 649         int i;
 650
 651         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 652                 const char *subnode = dt_params[i].subnode;
 653
 654                 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
 655                         info->missing = dt_params[i].params[0].name;
 656                         continue;
 657                 }
 658
 659                 if (subnode) {
 660                         node = of_get_flat_dt_subnode_by_name(node, subnode);
 661                         if (node < 0)
 662                                 return 0;
 663                 }
 664
 665                 return __find_uefi_params(node, info, dt_params[i].params);
 666         }
 667
 668         return 0;
 669 }
 670
 671 int __init efi_get_fdt_params(struct efi_fdt_params *params)
 672 {
 673         struct param_info info;
 674         int ret;
 675
 676         pr_info("Getting EFI parameters from FDT:\n");
 677
 678         info.found = 0;
 679         info.params = params;
 680
 681         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 682         if (!info.found)
 683                 pr_info("UEFI not found.\n");
 684         else if (!ret)
 685                 pr_err("Can't find '%s' in device tree!\n",
 686                        info.missing);
 687
 688         return ret;
 689 }
 690 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 691
 692 static __initdata char memory_type_name[][20] = {
 693         "Reserved",
 694         "Loader Code",
 695         "Loader Data",
 696         "Boot Code",
 697         "Boot Data",
 698         "Runtime Code",
 699         "Runtime Data",
 700         "Conventional Memory",
 701         "Unusable Memory",
 702         "ACPI Reclaim Memory",
 703         "ACPI Memory NVS",
 704         "Memory Mapped I/O",
 705         "MMIO Port Space",
 706         "PAL Code",
 707         "Persistent Memory",
 708 };
 709
 710 char * __init efi_md_typeattr_format(char *buf, size_t size,
 711                                      const efi_memory_desc_t *md)
 712 {
 713         char *pos;
 714         int type_len;
 715         u64 attr;
 716
 717         pos = buf;
 718         if (md->type >= ARRAY_SIZE(memory_type_name))
 719                 type_len = snprintf(pos, size, "[type=%u", md->type);
 720         else
 721                 type_len = snprintf(pos, size, "[%-*s",
 722                                     (int)(sizeof(memory_type_name[0]) - 1),
 723                                     memory_type_name[md->type]);
 724         if (type_len >= size)
 725                 return buf;
 726
 727         pos += type_len;
 728         size -= type_len;
 729
 730         attr = md->attribute;
 731         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 732                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
 733                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
 734                      EFI_MEMORY_NV |
 735                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
 736                 snprintf(pos, size, "|attr=0x%016llx]",
 737                          (unsigned long long)attr);
 738         else
 739                 snprintf(pos, size,
 740                          "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 741                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 742                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
 743                          attr & EFI_MEMORY_NV      ? "NV"  : "",
 744                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 745                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 746                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 747                          attr & EFI_MEMORY_RO      ? "RO"  : "",
 748                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 749                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 750                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 751                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 752                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 753         return buf;
 754 }
 755
 756 /*
 757  * efi_mem_attributes - lookup memmap attributes for physical address
 758  * @phys_addr: the physical address to lookup
 759  *
 760  * Search in the EFI memory map for the region covering
 761  * @phys_addr. Returns the EFI memory attributes if the region
 762  * was found in the memory map, 0 otherwise.
 763  *
 764  * Despite being marked __weak, most architectures should *not*
 765  * override this function. It is __weak solely for the benefit
 766  * of ia64 which has a funky EFI memory map that doesn't work
 767  * the same way as other architectures.
 768  */
 769 u64 __weak efi_mem_attributes(unsigned long phys_addr)
 770 {
 771         efi_memory_desc_t *md;
 772
 773         if (!efi_enabled(EFI_MEMMAP))
 774                 return 0;
 775
 776         for_each_efi_memory_desc(md) {
 777                 if ((md->phys_addr <= phys_addr) &&
 778                     (phys_addr < (md->phys_addr +
 779                     (md->num_pages << EFI_PAGE_SHIFT))))
 780                         return md->attribute;
 781         }
 782         return 0;
 783 }
 784
 785 int efi_status_to_err(efi_status_t status)
 786 {
 787         int err;
 788
 789         switch (status) {
 790         case EFI_SUCCESS:
 791                 err = 0;
 792                 break;
 793         case EFI_INVALID_PARAMETER:
 794                 err = -EINVAL;
 795                 break;
 796         case EFI_OUT_OF_RESOURCES:
 797                 err = -ENOSPC;
 798                 break;
 799         case EFI_DEVICE_ERROR:
 800                 err = -EIO;
 801                 break;
 802         case EFI_WRITE_PROTECTED:
 803                 err = -EROFS;
 804                 break;
 805         case EFI_SECURITY_VIOLATION:
 806                 err = -EACCES;
 807                 break;
 808         case EFI_NOT_FOUND:
 809                 err = -ENOENT;
 810                 break;
 811         default:
 812                 err = -EINVAL;
 813         }
 814
 815         return err;
 816 }