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 = __ATTR_RO_MODE(systab, 0400);
 117
 118 #define EFI_FIELD(var) efi.var
 119
 120 #define EFI_ATTR_SHOW(name) \
 121 static ssize_t name##_show(struct kobject *kobj, \
 122                                 struct kobj_attribute *attr, char *buf) \
 123 { \
 124         return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
 125 }
 126
 127 EFI_ATTR_SHOW(fw_vendor);
 128 EFI_ATTR_SHOW(runtime);
 129 EFI_ATTR_SHOW(config_table);
 130
 131 static ssize_t fw_platform_size_show(struct kobject *kobj,
 132                                      struct kobj_attribute *attr, char *buf)
 133 {
 134         return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
 135 }
 136
 137 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
 138 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
 139 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
 140 static struct kobj_attribute efi_attr_fw_platform_size =
 141         __ATTR_RO(fw_platform_size);
 142
 143 static struct attribute *efi_subsys_attrs[] = {
 144         &efi_attr_systab.attr,
 145         &efi_attr_fw_vendor.attr,
 146         &efi_attr_runtime.attr,
 147         &efi_attr_config_table.attr,
 148         &efi_attr_fw_platform_size.attr,
 149         NULL,
 150 };
 151
 152 static umode_t efi_attr_is_visible(struct kobject *kobj,
 153                                    struct attribute *attr, int n)
 154 {
 155         if (attr == &efi_attr_fw_vendor.attr) {
 156                 if (efi_enabled(EFI_PARAVIRT) ||
 157                                 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
 158                         return 0;
 159         } else if (attr == &efi_attr_runtime.attr) {
 160                 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
 161                         return 0;
 162         } else if (attr == &efi_attr_config_table.attr) {
 163                 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
 164                         return 0;
 165         }
 166
 167         return attr->mode;
 168 }
 169
 170 static struct attribute_group efi_subsys_attr_group = {
 171         .attrs = efi_subsys_attrs,
 172         .is_visible = efi_attr_is_visible,
 173 };
 174
 175 static struct efivars generic_efivars;
 176 static struct efivar_operations generic_ops;
 177
 178 static int generic_ops_register(void)
 179 {
 180         generic_ops.get_variable = efi.get_variable;
 181         generic_ops.set_variable = efi.set_variable;
 182         generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
 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         return -ENOENT;
 314 }
 315
 316 /*
 317  * Calculate the highest address of an efi memory descriptor.
 318  */
 319 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
 320 {
 321         u64 size = md->num_pages << EFI_PAGE_SHIFT;
 322         u64 end = md->phys_addr + size;
 323         return end;
 324 }
 325
 326 static __initdata efi_config_table_type_t common_tables[] = {
 327         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
 328         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
 329         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
 330         {MPS_TABLE_GUID, "MPS", &efi.mps},
 331         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
 332         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
 333         {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
 334         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
 335         {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
 336         {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
 337         {NULL_GUID, NULL, NULL},
 338 };
 339
 340 static __init int match_config_table(efi_guid_t *guid,
 341                                      unsigned long table,
 342                                      efi_config_table_type_t *table_types)
 343 {
 344         int i;
 345
 346         if (table_types) {
 347                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
 348                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
 349                                 *(table_types[i].ptr) = table;
 350                                 pr_cont(" %s=0x%lx ",
 351                                         table_types[i].name, table);
 352                                 return 1;
 353                         }
 354                 }
 355         }
 356
 357         return 0;
 358 }
 359
 360 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
 361                                    efi_config_table_type_t *arch_tables)
 362 {
 363         void *tablep;
 364         int i;
 365
 366         tablep = config_tables;
 367         pr_info("");
 368         for (i = 0; i < count; i++) {
 369                 efi_guid_t guid;
 370                 unsigned long table;
 371
 372                 if (efi_enabled(EFI_64BIT)) {
 373                         u64 table64;
 374                         guid = ((efi_config_table_64_t *)tablep)->guid;
 375                         table64 = ((efi_config_table_64_t *)tablep)->table;
 376                         table = table64;
 377 #ifndef CONFIG_64BIT
 378                         if (table64 >> 32) {
 379                                 pr_cont("\n");
 380                                 pr_err("Table located above 4GB, disabling EFI.\n");
 381                                 return -EINVAL;
 382                         }
 383 #endif
 384                 } else {
 385                         guid = ((efi_config_table_32_t *)tablep)->guid;
 386                         table = ((efi_config_table_32_t *)tablep)->table;
 387                 }
 388
 389                 if (!match_config_table(&guid, table, common_tables))
 390                         match_config_table(&guid, table, arch_tables);
 391
 392                 tablep += sz;
 393         }
 394         pr_cont("\n");
 395         set_bit(EFI_CONFIG_TABLES, &efi.flags);
 396
 397         /* Parse the EFI Properties table if it exists */
 398         if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
 399                 efi_properties_table_t *tbl;
 400
 401                 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
 402                 if (tbl == NULL) {
 403                         pr_err("Could not map Properties table!\n");
 404                         return -ENOMEM;
 405                 }
 406
 407                 if (tbl->memory_protection_attribute &
 408                     EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
 409                         set_bit(EFI_NX_PE_DATA, &efi.flags);
 410
 411                 early_memunmap(tbl, sizeof(*tbl));
 412         }
 413
 414         return 0;
 415 }
 416
 417 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 418 {
 419         void *config_tables;
 420         int sz, ret;
 421
 422         if (efi_enabled(EFI_64BIT))
 423                 sz = sizeof(efi_config_table_64_t);
 424         else
 425                 sz = sizeof(efi_config_table_32_t);
 426
 427         /*
 428          * Let's see what config tables the firmware passed to us.
 429          */
 430         config_tables = early_memremap(efi.systab->tables,
 431                                        efi.systab->nr_tables * sz);
 432         if (config_tables == NULL) {
 433                 pr_err("Could not map Configuration table!\n");
 434                 return -ENOMEM;
 435         }
 436
 437         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
 438                                       arch_tables);
 439
 440         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 441         return ret;
 442 }
 443
 444 #ifdef CONFIG_EFI_VARS_MODULE
 445 static int __init efi_load_efivars(void)
 446 {
 447         struct platform_device *pdev;
 448
 449         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 450                 return 0;
 451
 452         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 453         return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
 454 }
 455 device_initcall(efi_load_efivars);
 456 #endif
 457
 458 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 459
 460 #define UEFI_PARAM(name, prop, field)                      \
 461         {                                                  \
 462                 { name },                                  \
 463                 { prop },                                  \
 464                 offsetof(struct efi_fdt_params, field),    \
 465                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 466         }
 467
 468 static __initdata struct {
 469         const char name[32];
 470         const char propname[32];
 471         int offset;
 472         int size;
 473 } dt_params[] = {
 474         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 475         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 476         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 477         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 478         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 479 };
 480
 481 struct param_info {
 482         int found;
 483         void *params;
 484 };
 485
 486 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 487                                        int depth, void *data)
 488 {
 489         struct param_info *info = data;
 490         const void *prop;
 491         void *dest;
 492         u64 val;
 493         int i, len;
 494
 495         if (depth != 1 || strcmp(uname, "chosen") != 0)
 496                 return 0;
 497
 498         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 499                 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
 500                 if (!prop)
 501                         return 0;
 502                 dest = info->params + dt_params[i].offset;
 503                 info->found++;
 504
 505                 val = of_read_number(prop, len / sizeof(u32));
 506
 507                 if (dt_params[i].size == sizeof(u32))
 508                         *(u32 *)dest = val;
 509                 else
 510                         *(u64 *)dest = val;
 511
 512                 if (efi_enabled(EFI_DBG))
 513                         pr_info("  %s: 0x%0*llx\n", dt_params[i].name,
 514                                 dt_params[i].size * 2, val);
 515         }
 516         return 1;
 517 }
 518
 519 int __init efi_get_fdt_params(struct efi_fdt_params *params)
 520 {
 521         struct param_info info;
 522         int ret;
 523
 524         pr_info("Getting EFI parameters from FDT:\n");
 525
 526         info.found = 0;
 527         info.params = params;
 528
 529         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 530         if (!info.found)
 531                 pr_info("UEFI not found.\n");
 532         else if (!ret)
 533                 pr_err("Can't find '%s' in device tree!\n",
 534                        dt_params[info.found].name);
 535
 536         return ret;
 537 }
 538 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 539
 540 static __initdata char memory_type_name[][20] = {
 541         "Reserved",
 542         "Loader Code",
 543         "Loader Data",
 544         "Boot Code",
 545         "Boot Data",
 546         "Runtime Code",
 547         "Runtime Data",
 548         "Conventional Memory",
 549         "Unusable Memory",
 550         "ACPI Reclaim Memory",
 551         "ACPI Memory NVS",
 552         "Memory Mapped I/O",
 553         "MMIO Port Space",
 554         "PAL Code"
 555 };
 556
 557 char * __init efi_md_typeattr_format(char *buf, size_t size,
 558                                      const efi_memory_desc_t *md)
 559 {
 560         char *pos;
 561         int type_len;
 562         u64 attr;
 563
 564         pos = buf;
 565         if (md->type >= ARRAY_SIZE(memory_type_name))
 566                 type_len = snprintf(pos, size, "[type=%u", md->type);
 567         else
 568                 type_len = snprintf(pos, size, "[%-*s",
 569                                     (int)(sizeof(memory_type_name[0]) - 1),
 570                                     memory_type_name[md->type]);
 571         if (type_len >= size)
 572                 return buf;
 573
 574         pos += type_len;
 575         size -= type_len;
 576
 577         attr = md->attribute;
 578         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 579                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
 580                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
 581                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
 582                 snprintf(pos, size, "|attr=0x%016llx]",
 583                          (unsigned long long)attr);
 584         else
 585                 snprintf(pos, size, "|%3s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 586                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 587                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
 588                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 589                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 590                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 591                          attr & EFI_MEMORY_RO      ? "RO"  : "",
 592                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 593                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 594                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 595                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 596                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 597         return buf;
 598 }
 599
 600 /*
 601  * efi_mem_attributes - lookup memmap attributes for physical address
 602  * @phys_addr: the physical address to lookup
 603  *
 604  * Search in the EFI memory map for the region covering
 605  * @phys_addr. Returns the EFI memory attributes if the region
 606  * was found in the memory map, 0 otherwise.
 607  *
 608  * Despite being marked __weak, most architectures should *not*
 609  * override this function. It is __weak solely for the benefit
 610  * of ia64 which has a funky EFI memory map that doesn't work
 611  * the same way as other architectures.
 612  */
 613 u64 __weak efi_mem_attributes(unsigned long phys_addr)
 614 {
 615         struct efi_memory_map *map;
 616         efi_memory_desc_t *md;
 617         void *p;
 618
 619         if (!efi_enabled(EFI_MEMMAP))
 620                 return 0;
 621
 622         map = efi.memmap;
 623         for (p = map->map; p < map->map_end; p += map->desc_size) {
 624                 md = p;
 625                 if ((md->phys_addr <= phys_addr) &&
 626                     (phys_addr < (md->phys_addr +
 627                     (md->num_pages << EFI_PAGE_SHIFT))))
 628                         return md->attribute;
 629         }
 630         return 0;
 631 }