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