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 static __initdata struct {
 572         const char name[32];
 573         const char propname[32];
 574         int offset;
 575         int size;
 576 } dt_params[] = {
 577         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 578         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 579         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 580         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 581         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 582 };
 583
 584 struct param_info {
 585         int found;
 586         void *params;
 587 };
 588
 589 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 590                                        int depth, void *data)
 591 {
 592         struct param_info *info = data;
 593         const void *prop;
 594         void *dest;
 595         u64 val;
 596         int i, len;
 597
 598         if (depth != 1 || strcmp(uname, "chosen") != 0)
 599                 return 0;
 600
 601         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 602                 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
 603                 if (!prop)
 604                         return 0;
 605                 dest = info->params + dt_params[i].offset;
 606                 info->found++;
 607
 608                 val = of_read_number(prop, len / sizeof(u32));
 609
 610                 if (dt_params[i].size == sizeof(u32))
 611                         *(u32 *)dest = val;
 612                 else
 613                         *(u64 *)dest = val;
 614
 615                 if (efi_enabled(EFI_DBG))
 616                         pr_info("  %s: 0x%0*llx\n", dt_params[i].name,
 617                                 dt_params[i].size * 2, val);
 618         }
 619         return 1;
 620 }
 621
 622 int __init efi_get_fdt_params(struct efi_fdt_params *params)
 623 {
 624         struct param_info info;
 625         int ret;
 626
 627         pr_info("Getting EFI parameters from FDT:\n");
 628
 629         info.found = 0;
 630         info.params = params;
 631
 632         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 633         if (!info.found)
 634                 pr_info("UEFI not found.\n");
 635         else if (!ret)
 636                 pr_err("Can't find '%s' in device tree!\n",
 637                        dt_params[info.found].name);
 638
 639         return ret;
 640 }
 641 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 642
 643 static __initdata char memory_type_name[][20] = {
 644         "Reserved",
 645         "Loader Code",
 646         "Loader Data",
 647         "Boot Code",
 648         "Boot Data",
 649         "Runtime Code",
 650         "Runtime Data",
 651         "Conventional Memory",
 652         "Unusable Memory",
 653         "ACPI Reclaim Memory",
 654         "ACPI Memory NVS",
 655         "Memory Mapped I/O",
 656         "MMIO Port Space",
 657         "PAL Code",
 658         "Persistent Memory",
 659 };
 660
 661 char * __init efi_md_typeattr_format(char *buf, size_t size,
 662                                      const efi_memory_desc_t *md)
 663 {
 664         char *pos;
 665         int type_len;
 666         u64 attr;
 667
 668         pos = buf;
 669         if (md->type >= ARRAY_SIZE(memory_type_name))
 670                 type_len = snprintf(pos, size, "[type=%u", md->type);
 671         else
 672                 type_len = snprintf(pos, size, "[%-*s",
 673                                     (int)(sizeof(memory_type_name[0]) - 1),
 674                                     memory_type_name[md->type]);
 675         if (type_len >= size)
 676                 return buf;
 677
 678         pos += type_len;
 679         size -= type_len;
 680
 681         attr = md->attribute;
 682         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 683                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
 684                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
 685                      EFI_MEMORY_NV |
 686                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
 687                 snprintf(pos, size, "|attr=0x%016llx]",
 688                          (unsigned long long)attr);
 689         else
 690                 snprintf(pos, size,
 691                          "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 692                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 693                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
 694                          attr & EFI_MEMORY_NV      ? "NV"  : "",
 695                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 696                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 697                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 698                          attr & EFI_MEMORY_RO      ? "RO"  : "",
 699                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 700                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 701                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 702                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 703                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 704         return buf;
 705 }
 706
 707 /*
 708  * efi_mem_attributes - lookup memmap attributes for physical address
 709  * @phys_addr: the physical address to lookup
 710  *
 711  * Search in the EFI memory map for the region covering
 712  * @phys_addr. Returns the EFI memory attributes if the region
 713  * was found in the memory map, 0 otherwise.
 714  *
 715  * Despite being marked __weak, most architectures should *not*
 716  * override this function. It is __weak solely for the benefit
 717  * of ia64 which has a funky EFI memory map that doesn't work
 718  * the same way as other architectures.
 719  */
 720 u64 __weak efi_mem_attributes(unsigned long phys_addr)
 721 {
 722         efi_memory_desc_t *md;
 723
 724         if (!efi_enabled(EFI_MEMMAP))
 725                 return 0;
 726
 727         for_each_efi_memory_desc(md) {
 728                 if ((md->phys_addr <= phys_addr) &&
 729                     (phys_addr < (md->phys_addr +
 730                     (md->num_pages << EFI_PAGE_SHIFT))))
 731                         return md->attribute;
 732         }
 733         return 0;
 734 }
 735
 736 int efi_status_to_err(efi_status_t status)
 737 {
 738         int err;
 739
 740         switch (status) {
 741         case EFI_SUCCESS:
 742                 err = 0;
 743                 break;
 744         case EFI_INVALID_PARAMETER:
 745                 err = -EINVAL;
 746                 break;
 747         case EFI_OUT_OF_RESOURCES:
 748                 err = -ENOSPC;
 749                 break;
 750         case EFI_DEVICE_ERROR:
 751                 err = -EIO;
 752                 break;
 753         case EFI_WRITE_PROTECTED:
 754                 err = -EROFS;
 755                 break;
 756         case EFI_SECURITY_VIOLATION:
 757                 err = -EACCES;
 758                 break;
 759         case EFI_NOT_FOUND:
 760                 err = -ENOENT;
 761                 break;
 762         default:
 763                 err = -EINVAL;
 764         }
 765
 766         return err;
 767 }