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