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