x86/boot/e820: Prefix the E820_* type names with "E820_TYPE_"

So there's a number of constants that start with "E820" but which
are not types - these create a confusing mixture when seen together
with 'enum e820_type' values:

	E820MAP
	E820NR
	E820_X_MAX
	E820MAX

To better differentiate the 'enum e820_type' values prefix them
with E820_TYPE_.

No change in functionality.

Cc: Alex Thorlton <athorlton@sgi.com>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Huang, Ying <ying.huang@intel.com>
Cc: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Paul Jackson <pj@sgi.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Tejun Heo <tj@kernel.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Wei Yang <richard.weiyang@gmail.com>
Cc: Yinghai Lu <yinghai@kernel.org>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>

20 files changed, 123 insertions, 123 deletions

diff --git a/arch/x86/boot/compressed/eboot.c b/arch/x86/boot/compressed/eboot.c
index 04c406f9aee3..4cfba2f79dfd 100644
--- a/arch/x86/boot/compressed/eboot.c
+++ b/arch/x86/boot/compressed/eboot.c
@@ -944,15 +944,15 @@ static efi_status_t setup_e820(struct boot_params *params,
                 case EFI_MEMORY_MAPPED_IO:
                 case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
                 case EFI_PAL_CODE:
-                        e820_type = E820_RESERVED;
+                        e820_type = E820_TYPE_RESERVED;
                         break;
 
                 case EFI_UNUSABLE_MEMORY:
-                        e820_type = E820_UNUSABLE;
+                        e820_type = E820_TYPE_UNUSABLE;
                         break;
 
                 case EFI_ACPI_RECLAIM_MEMORY:
-                        e820_type = E820_ACPI;
+                        e820_type = E820_TYPE_ACPI;
                         break;
 
                 case EFI_LOADER_CODE:
@@ -960,15 +960,15 @@ static efi_status_t setup_e820(struct boot_params *params,
                 case EFI_BOOT_SERVICES_CODE:
                 case EFI_BOOT_SERVICES_DATA:
                 case EFI_CONVENTIONAL_MEMORY:
-                        e820_type = E820_RAM;
+                        e820_type = E820_TYPE_RAM;
                         break;
 
                 case EFI_ACPI_MEMORY_NVS:
-                        e820_type = E820_NVS;
+                        e820_type = E820_TYPE_NVS;
                         break;
 
                 case EFI_PERSISTENT_MEMORY:
-                        e820_type = E820_PMEM;
+                        e820_type = E820_TYPE_PMEM;
                         break;
 
                 default:
diff --git a/arch/x86/boot/compressed/kaslr.c b/arch/x86/boot/compressed/kaslr.c
index a47f832664f2..e8155eab5474 100644
--- a/arch/x86/boot/compressed/kaslr.c
+++ b/arch/x86/boot/compressed/kaslr.c
@@ -435,7 +435,7 @@ static void process_e820_entry(struct e820_entry *entry,
         unsigned long start_orig;
 
         /* Skip non-RAM entries. */
-        if (entry->type != E820_RAM)
+        if (entry->type != E820_TYPE_RAM)
                 return;
 
         /* On 32-bit, ignore entries entirely above our maximum. */
diff --git a/arch/x86/include/asm/gart.h b/arch/x86/include/asm/gart.h
index 2a3ff2ac4686..1d268098ac2e 100644
--- a/arch/x86/include/asm/gart.h
+++ b/arch/x86/include/asm/gart.h
@@ -97,7 +97,7 @@ static inline int aperture_valid(u64 aper_base, u32 aper_size, u32 min_size)
                 printk(KERN_INFO "Aperture beyond 4GB. Ignoring.\n");
                 return 0;
         }
-        if (e820__mapped_any(aper_base, aper_base + aper_size, E820_RAM)) {
+        if (e820__mapped_any(aper_base, aper_base + aper_size, E820_TYPE_RAM)) {
                 printk(KERN_INFO "Aperture pointing to e820 RAM. Ignoring.\n");
                 return 0;
         }
diff --git a/arch/x86/include/uapi/asm/e820/types.h b/arch/x86/include/uapi/asm/e820/types.h
index 65c7a1beab22..29391386b63f 100644
--- a/arch/x86/include/uapi/asm/e820/types.h
+++ b/arch/x86/include/uapi/asm/e820/types.h
@@ -7,12 +7,12 @@
 #ifndef __ASSEMBLY__
 
 enum e820_type {
-        E820_RAM                = 1,
-        E820_RESERVED           = 2,
-        E820_ACPI               = 3,
-        E820_NVS                = 4,
-        E820_UNUSABLE           = 5,
-        E820_PMEM               = 7,
+        E820_TYPE_RAM           = 1,
+        E820_TYPE_RESERVED      = 2,
+        E820_TYPE_ACPI          = 3,
+        E820_TYPE_NVS           = 4,
+        E820_TYPE_UNUSABLE      = 5,
+        E820_TYPE_PMEM          = 7,
 
         /*
          * This is a non-standardized way to represent ADR or
@@ -25,7 +25,7 @@ enum e820_type {
          *   type of memory, but newer versions switched to 12 as
          *   6 was assigned differently. Some time they will learn... )
          */
-        E820_PRAM               = 12,
+        E820_TYPE_PRAM          = 12,
 
         /*
          * Reserved RAM used by the kernel itself if
@@ -34,7 +34,7 @@ enum e820_type {
          * and so should not include any memory that the BIOS
          * might alter over the S3 transition:
          */
-        E820_RESERVED_KERN      = 128,
+        E820_TYPE_RESERVED_KERN = 128,
 };
 
 /*
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 31b350c6a3b1..873552718270 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -1715,6 +1715,6 @@ int __acpi_release_global_lock(unsigned int *lock)
 
 void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)
 {
-        e820__range_add(addr, size, E820_ACPI);
+        e820__range_add(addr, size, E820_TYPE_ACPI);
         e820__update_table_print();
 }
diff --git a/arch/x86/kernel/aperture_64.c b/arch/x86/kernel/aperture_64.c
index 883485684435..ef2859f9fcce 100644
--- a/arch/x86/kernel/aperture_64.c
+++ b/arch/x86/kernel/aperture_64.c
@@ -307,11 +307,11 @@ void __init early_gart_iommu_check(void)
 
         if (gart_fix_e820 && !fix && aper_enabled) {
                 if (e820__mapped_any(aper_base, aper_base + aper_size,
-                                    E820_RAM)) {
+                                    E820_TYPE_RAM)) {
                         /* reserve it, so we can reuse it in second kernel */
                         pr_info("e820: reserve [mem %#010Lx-%#010Lx] for GART\n",
                                 aper_base, aper_base + aper_size - 1);
-                        e820__range_add(aper_base, aper_size, E820_RESERVED);
+                        e820__range_add(aper_base, aper_size, E820_TYPE_RESERVED);
                         e820__update_table_print();
                 }
         }
diff --git a/arch/x86/kernel/cpu/mtrr/cleanup.c b/arch/x86/kernel/cpu/mtrr/cleanup.c
index 244aaa988ecd..765afd599039 100644
--- a/arch/x86/kernel/cpu/mtrr/cleanup.c
+++ b/arch/x86/kernel/cpu/mtrr/cleanup.c
@@ -860,7 +860,7 @@ real_trim_memory(unsigned long start_pfn, unsigned long limit_pfn)
         trim_size <<= PAGE_SHIFT;
         trim_size -= trim_start;
 
-        return e820__range_update(trim_start, trim_size, E820_RAM, E820_RESERVED);
+        return e820__range_update(trim_start, trim_size, E820_TYPE_RAM, E820_TYPE_RESERVED);
 }
 
 /**
diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c
index 11f7eb1e2506..5feba9a21130 100644
--- a/arch/x86/kernel/crash.c
+++ b/arch/x86/kernel/crash.c
@@ -575,17 +575,17 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
         /* Add first 640K segment */
         ei.addr = image->arch.backup_src_start;
         ei.size = image->arch.backup_src_sz;
-        ei.type = E820_RAM;
+        ei.type = E820_TYPE_RAM;
         add_e820_entry(params, &ei);
 
         /* Add ACPI tables */
-        cmd.type = E820_ACPI;
+        cmd.type = E820_TYPE_ACPI;
         flags = IORESOURCE_MEM | IORESOURCE_BUSY;
         walk_iomem_res_desc(IORES_DESC_ACPI_TABLES, flags, 0, -1, &cmd,
                        memmap_entry_callback);
 
         /* Add ACPI Non-volatile Storage */
-        cmd.type = E820_NVS;
+        cmd.type = E820_TYPE_NVS;
         walk_iomem_res_desc(IORES_DESC_ACPI_NV_STORAGE, flags, 0, -1, &cmd,
                         memmap_entry_callback);
 
@@ -593,7 +593,7 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
         if (crashk_low_res.end) {
                 ei.addr = crashk_low_res.start;
                 ei.size = crashk_low_res.end - crashk_low_res.start + 1;
-                ei.type = E820_RAM;
+                ei.type = E820_TYPE_RAM;
                 add_e820_entry(params, &ei);
         }
 
@@ -610,7 +610,7 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params)
                 if (ei.size < PAGE_SIZE)
                         continue;
                 ei.addr = cmem->ranges[i].start;
-                ei.type = E820_RAM;
+                ei.type = E820_TYPE_RAM;
                 add_e820_entry(params, &ei);
         }
 
diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c
index 79673843dc42..90dcd240a389 100644
--- a/arch/x86/kernel/e820.c
+++ b/arch/x86/kernel/e820.c
@@ -148,14 +148,14 @@ void __init e820__range_add(u64 start, u64 size, enum e820_type type)
 static void __init e820_print_type(enum e820_type type)
 {
         switch (type) {
-        case E820_RAM:                  /* Fall through: */
-        case E820_RESERVED_KERN:        pr_cont("usable");                      break;
-        case E820_RESERVED:             pr_cont("reserved");                    break;
-        case E820_ACPI:                 pr_cont("ACPI data");                   break;
-        case E820_NVS:                  pr_cont("ACPI NVS");                    break;
-        case E820_UNUSABLE:             pr_cont("unusable");                    break;
-        case E820_PMEM:                 /* Fall through: */
-        case E820_PRAM:                 pr_cont("persistent (type %u)", type);  break;
+        case E820_TYPE_RAM:             /* Fall through: */
+        case E820_TYPE_RESERVED_KERN:   pr_cont("usable");                      break;
+        case E820_TYPE_RESERVED:        pr_cont("reserved");                    break;
+        case E820_TYPE_ACPI:            pr_cont("ACPI data");                   break;
+        case E820_TYPE_NVS:             pr_cont("ACPI NVS");                    break;
+        case E820_TYPE_UNUSABLE:        pr_cont("unusable");                    break;
+        case E820_TYPE_PMEM:            /* Fall through: */
+        case E820_TYPE_PRAM:            pr_cont("persistent (type %u)", type);  break;
         default:                        pr_cont("type %u", type);               break;
         }
 }
@@ -340,7 +340,7 @@ int __init e820__update_table(struct e820_entry *biosmap, int max_nr_map, u32 *p
                 }
 
                 /* Continue building up new BIOS map based on this information: */
-                if (current_type != last_type || current_type == E820_PRAM) {
+                if (current_type != last_type || current_type == E820_TYPE_PRAM) {
                         if (last_type != 0)      {
                                 new_bios[new_bios_entry].size = change_point[chgidx]->addr - last_addr;
                                 /* Move forward only if the new size was non-zero: */
@@ -704,7 +704,7 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn)
 
                 pfn = PFN_DOWN(entry->addr + entry->size);
 
-                if (entry->type != E820_RAM && entry->type != E820_RESERVED_KERN)
+                if (entry->type != E820_TYPE_RAM && entry->type != E820_TYPE_RESERVED_KERN)
                         register_nosave_region(PFN_UP(entry->addr), pfn);
 
                 if (pfn >= limit_pfn)
@@ -724,7 +724,7 @@ static int __init e820_mark_nvs_memory(void)
         for (i = 0; i < e820_table->nr_entries; i++) {
                 struct e820_entry *entry = &e820_table->entries[i];
 
-                if (entry->type == E820_NVS)
+                if (entry->type == E820_TYPE_NVS)
                         acpi_nvs_register(entry->addr, entry->size);
         }
 
@@ -747,7 +747,7 @@ u64 __init e820__memblock_alloc_reserved(u64 size, u64 align)
 
         addr = __memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE);
         if (addr) {
-                e820__range_update_firmware(addr, size, E820_RAM, E820_RESERVED);
+                e820__range_update_firmware(addr, size, E820_TYPE_RAM, E820_TYPE_RESERVED);
                 pr_info("e820: update e820_table_firmware for e820__memblock_alloc_reserved()\n");
                 e820__update_table_firmware();
         }
@@ -805,12 +805,12 @@ static unsigned long __init e820_end_pfn(unsigned long limit_pfn, enum e820_type
 
 unsigned long __init e820_end_of_ram_pfn(void)
 {
-        return e820_end_pfn(MAX_ARCH_PFN, E820_RAM);
+        return e820_end_pfn(MAX_ARCH_PFN, E820_TYPE_RAM);
 }
 
 unsigned long __init e820_end_of_low_ram_pfn(void)
 {
-        return e820_end_pfn(1UL << (32 - PAGE_SHIFT), E820_RAM);
+        return e820_end_pfn(1UL << (32 - PAGE_SHIFT), E820_TYPE_RAM);
 }
 
 static void __init early_panic(char *msg)
@@ -846,7 +846,7 @@ static int __init parse_memopt(char *p)
         if (mem_size == 0)
                 return -EINVAL;
 
-        e820__range_remove(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
+        e820__range_remove(mem_size, ULLONG_MAX - mem_size, E820_TYPE_RAM, 1);
 
         return 0;
 }
@@ -882,18 +882,18 @@ static int __init parse_memmap_one(char *p)
         userdef = 1;
         if (*p == '@') {
                 start_at = memparse(p+1, &p);
-                e820__range_add(start_at, mem_size, E820_RAM);
+                e820__range_add(start_at, mem_size, E820_TYPE_RAM);
         } else if (*p == '#') {
                 start_at = memparse(p+1, &p);
-                e820__range_add(start_at, mem_size, E820_ACPI);
+                e820__range_add(start_at, mem_size, E820_TYPE_ACPI);
         } else if (*p == '$') {
                 start_at = memparse(p+1, &p);
-                e820__range_add(start_at, mem_size, E820_RESERVED);
+                e820__range_add(start_at, mem_size, E820_TYPE_RESERVED);
         } else if (*p == '!') {
                 start_at = memparse(p+1, &p);
-                e820__range_add(start_at, mem_size, E820_PRAM);
+                e820__range_add(start_at, mem_size, E820_TYPE_PRAM);
         } else {
-                e820__range_remove(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
+                e820__range_remove(mem_size, ULLONG_MAX - mem_size, E820_TYPE_RAM, 1);
         }
 
         return *p == '\0' ? 0 : -EINVAL;
@@ -926,7 +926,7 @@ void __init e820_reserve_setup_data(void)
 
         while (pa_data) {
                 data = early_memremap(pa_data, sizeof(*data));
-                e820__range_update(pa_data, sizeof(*data)+data->len, E820_RAM, E820_RESERVED_KERN);
+                e820__range_update(pa_data, sizeof(*data)+data->len, E820_TYPE_RAM, E820_TYPE_RESERVED_KERN);
                 pa_data = data->next;
                 early_memunmap(data, sizeof(*data));
         }
@@ -956,42 +956,42 @@ void __init e820__finish_early_params(void)
 static const char *__init e820_type_to_string(struct e820_entry *entry)
 {
         switch (entry->type) {
-        case E820_RESERVED_KERN: /* Fall-through: */
-        case E820_RAM:           return "System RAM";
-        case E820_ACPI:          return "ACPI Tables";
-        case E820_NVS:           return "ACPI Non-volatile Storage";
-        case E820_UNUSABLE:      return "Unusable memory";
-        case E820_PRAM:          return "Persistent Memory (legacy)";
-        case E820_PMEM:          return "Persistent Memory";
-        default:                 return "Reserved";
+        case E820_TYPE_RESERVED_KERN:   /* Fall-through: */
+        case E820_TYPE_RAM:             return "System RAM";
+        case E820_TYPE_ACPI:            return "ACPI Tables";
+        case E820_TYPE_NVS:             return "ACPI Non-volatile Storage";
+        case E820_TYPE_UNUSABLE:        return "Unusable memory";
+        case E820_TYPE_PRAM:            return "Persistent Memory (legacy)";
+        case E820_TYPE_PMEM:            return "Persistent Memory";
+        default:                        return "Reserved";
         }
 }
 
 static unsigned long __init e820_type_to_iomem_type(struct e820_entry *entry)
 {
         switch (entry->type) {
-        case E820_RESERVED_KERN: /* Fall-through: */
-        case E820_RAM:           return IORESOURCE_SYSTEM_RAM;
-        case E820_ACPI:          /* Fall-through: */
-        case E820_NVS:           /* Fall-through: */
-        case E820_UNUSABLE:      /* Fall-through: */
-        case E820_PRAM:          /* Fall-through: */
-        case E820_PMEM:          /* Fall-through: */
-        default:                 return IORESOURCE_MEM;
+        case E820_TYPE_RESERVED_KERN:   /* Fall-through: */
+        case E820_TYPE_RAM:             return IORESOURCE_SYSTEM_RAM;
+        case E820_TYPE_ACPI:            /* Fall-through: */
+        case E820_TYPE_NVS:             /* Fall-through: */
+        case E820_TYPE_UNUSABLE:        /* Fall-through: */
+        case E820_TYPE_PRAM:            /* Fall-through: */
+        case E820_TYPE_PMEM:            /* Fall-through: */
+        default:                        return IORESOURCE_MEM;
         }
 }
 
 static unsigned long __init e820_type_to_iores_desc(struct e820_entry *entry)
 {
         switch (entry->type) {
-        case E820_ACPI:          return IORES_DESC_ACPI_TABLES;
-        case E820_NVS:           return IORES_DESC_ACPI_NV_STORAGE;
-        case E820_PMEM:          return IORES_DESC_PERSISTENT_MEMORY;
-        case E820_PRAM:          return IORES_DESC_PERSISTENT_MEMORY_LEGACY;
-        case E820_RESERVED_KERN: /* Fall-through: */
-        case E820_RAM:           /* Fall-through: */
-        case E820_UNUSABLE:      /* Fall-through: */
-        default:                 return IORES_DESC_NONE;
+        case E820_TYPE_ACPI:            return IORES_DESC_ACPI_TABLES;
+        case E820_TYPE_NVS:             return IORES_DESC_ACPI_NV_STORAGE;
+        case E820_TYPE_PMEM:            return IORES_DESC_PERSISTENT_MEMORY;
+        case E820_TYPE_PRAM:            return IORES_DESC_PERSISTENT_MEMORY_LEGACY;
+        case E820_TYPE_RESERVED_KERN:   /* Fall-through: */
+        case E820_TYPE_RAM:             /* Fall-through: */
+        case E820_TYPE_UNUSABLE:        /* Fall-through: */
+        default:                        return IORES_DESC_NONE;
         }
 }
 
@@ -1006,9 +1006,9 @@ static bool __init do_mark_busy(u32 type, struct resource *res)
          * for exclusive use of a driver
          */
         switch (type) {
-        case E820_RESERVED:
-        case E820_PRAM:
-        case E820_PMEM:
+        case E820_TYPE_RESERVED:
+        case E820_TYPE_PRAM:
+        case E820_TYPE_PMEM:
                 return false;
         default:
                 return true;
@@ -1102,7 +1102,7 @@ void __init e820_reserve_resources_late(void)
                 struct e820_entry *entry = &e820_table->entries[i];
                 u64 start, end;
 
-                if (entry->type != E820_RAM)
+                if (entry->type != E820_TYPE_RAM)
                         continue;
 
                 start = entry->addr + entry->size;
@@ -1148,8 +1148,8 @@ char *__init e820__memory_setup_default(void)
                 }
 
                 e820_table->nr_entries = 0;
-                e820__range_add(0, LOWMEMSIZE(), E820_RAM);
-                e820__range_add(HIGH_MEMORY, mem_size << 10, E820_RAM);
+                e820__range_add(0, LOWMEMSIZE(), E820_TYPE_RAM);
+                e820__range_add(HIGH_MEMORY, mem_size << 10, E820_TYPE_RAM);
         }
 
         return who;
@@ -1198,7 +1198,7 @@ void __init e820__memblock_setup(void)
                 if (end != (resource_size_t)end)
                         continue;
 
-                if (entry->type != E820_RAM && entry->type != E820_RESERVED_KERN)
+                if (entry->type != E820_TYPE_RAM && entry->type != E820_TYPE_RESERVED_KERN)
                         continue;
 
                 memblock_add(entry->addr, entry->size);
diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c
index 81a10ab15be9..2220a4c03adf 100644
--- a/arch/x86/kernel/early-quirks.c
+++ b/arch/x86/kernel/early-quirks.c
@@ -546,7 +546,7 @@ intel_graphics_stolen(int num, int slot, int func,
                &base, &end);
 
         /* Mark this space as reserved */
-        e820__range_add(base, size, E820_RESERVED);
+        e820__range_add(base, size, E820_TYPE_RESERVED);
         e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries);
 }
 
diff --git a/arch/x86/kernel/kexec-bzimage64.c b/arch/x86/kernel/kexec-bzimage64.c
index a8c9563557c9..3e43a7d3b191 100644
--- a/arch/x86/kernel/kexec-bzimage64.c
+++ b/arch/x86/kernel/kexec-bzimage64.c
@@ -232,7 +232,7 @@ setup_boot_parameters(struct kimage *image, struct boot_params *params,
         nr_e820_entries = params->e820_entries;
 
         for (i = 0; i < nr_e820_entries; i++) {
-                if (params->e820_table[i].type != E820_RAM)
+                if (params->e820_table[i].type != E820_TYPE_RAM)
                         continue;
                 start = params->e820_table[i].addr;
                 end = params->e820_table[i].addr + params->e820_table[i].size - 1;
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 0e70a7bbeeef..074c86a0ee86 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -119,7 +119,7 @@
  * max_low_pfn_mapped: highest direct mapped pfn under 4GB
  * max_pfn_mapped:     highest direct mapped pfn over 4GB
  *
- * The direct mapping only covers E820_RAM regions, so the ranges and gaps are
+ * The direct mapping only covers E820_TYPE_RAM regions, so the ranges and gaps are
  * represented by pfn_mapped
  */
 unsigned long max_low_pfn_mapped;
@@ -731,14 +731,14 @@ static void __init trim_bios_range(void)
          * since some BIOSes are known to corrupt low memory.  See the
          * Kconfig help text for X86_RESERVE_LOW.
          */
-        e820__range_update(0, PAGE_SIZE, E820_RAM, E820_RESERVED);
+        e820__range_update(0, PAGE_SIZE, E820_TYPE_RAM, E820_TYPE_RESERVED);
 
         /*
          * special case: Some BIOSen report the PC BIOS
          * area (640->1Mb) as ram even though it is not.
          * take them out.
          */
-        e820__range_remove(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_RAM, 1);
+        e820__range_remove(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_TYPE_RAM, 1);
 
         e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries);
 }
@@ -750,18 +750,18 @@ static void __init e820_add_kernel_range(void)
         u64 size = __pa_symbol(_end) - start;
 
         /*
-         * Complain if .text .data and .bss are not marked as E820_RAM and
+         * Complain if .text .data and .bss are not marked as E820_TYPE_RAM and
          * attempt to fix it by adding the range. We may have a confused BIOS,
          * or the user may have used memmap=exactmap or memmap=xxM$yyM to
          * exclude kernel range. If we really are running on top non-RAM,
          * we will crash later anyways.
          */
-        if (e820__mapped_all(start, start + size, E820_RAM))
+        if (e820__mapped_all(start, start + size, E820_TYPE_RAM))
                 return;
 
-        pr_warn(".text .data .bss are not marked as E820_RAM!\n");
-        e820__range_remove(start, size, E820_RAM, 0);
-        e820__range_add(start, size, E820_RAM);
+        pr_warn(".text .data .bss are not marked as E820_TYPE_RAM!\n");
+        e820__range_remove(start, size, E820_TYPE_RAM, 0);
+        e820__range_add(start, size, E820_TYPE_RAM);
 }
 
 static unsigned reserve_low = CONFIG_X86_RESERVE_LOW << 10;
@@ -1031,8 +1031,8 @@ void __init setup_arch(char **cmdline_p)
         trim_bios_range();
 #ifdef CONFIG_X86_32
         if (ppro_with_ram_bug()) {
-                e820__range_update(0x70000000ULL, 0x40000ULL, E820_RAM,
-                                  E820_RESERVED);
+                e820__range_update(0x70000000ULL, 0x40000ULL, E820_TYPE_RAM,
+                                  E820_TYPE_RESERVED);
                 e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries);
                 printk(KERN_INFO "fixed physical RAM map:\n");
                 e820__print_table("bad_ppro");
diff --git a/arch/x86/kernel/tboot.c b/arch/x86/kernel/tboot.c
index 0e2dc3831970..ccccd335ae01 100644
--- a/arch/x86/kernel/tboot.c
+++ b/arch/x86/kernel/tboot.c
@@ -69,8 +69,8 @@ void __init tboot_probe(void)
          * set_fixmap(), to reduce chance of garbage value causing crash
          */
         if (!e820__mapped_any(boot_params.tboot_addr,
-                             boot_params.tboot_addr, E820_RESERVED)) {
-                pr_warning("non-0 tboot_addr but it is not of type E820_RESERVED\n");
+                             boot_params.tboot_addr, E820_TYPE_RESERVED)) {
+                pr_warning("non-0 tboot_addr but it is not of type E820_TYPE_RESERVED\n");
                 return;
         }
 
@@ -189,8 +189,8 @@ static int tboot_setup_sleep(void)
         tboot->num_mac_regions = 0;
 
         for (i = 0; i < e820_table->nr_entries; i++) {
-                if ((e820_table->entries[i].type != E820_RAM)
-                 && (e820_table->entries[i].type != E820_RESERVED_KERN))
+                if ((e820_table->entries[i].type != E820_TYPE_RAM)
+                 && (e820_table->entries[i].type != E820_TYPE_RESERVED_KERN))
                         continue;
 
                 add_mac_region(e820_table->entries[i].addr, e820_table->entries[i].size);
diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c
index 922671d3af85..158dfecdab72 100644
--- a/arch/x86/mm/init.c
+++ b/arch/x86/mm/init.c
@@ -430,7 +430,7 @@ unsigned long __ref init_memory_mapping(unsigned long start,
 
 /*
  * We need to iterate through the E820 memory map and create direct mappings
- * for only E820_RAM and E820_KERN_RESERVED regions. We cannot simply
+ * for only E820_TYPE_RAM and E820_KERN_RESERVED regions. We cannot simply
  * create direct mappings for all pfns from [0 to max_low_pfn) and
  * [4GB to max_pfn) because of possible memory holes in high addresses
  * that cannot be marked as UC by fixed/variable range MTRRs.
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index cfb119e4c4d1..94e033085f60 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -338,9 +338,9 @@ phys_pte_init(pte_t *pte_page, unsigned long paddr, unsigned long paddr_end,
                 if (paddr >= paddr_end) {
                         if (!after_bootmem &&
                             !e820__mapped_any(paddr & PAGE_MASK, paddr_next,
-                                             E820_RAM) &&
+                                             E820_TYPE_RAM) &&
                             !e820__mapped_any(paddr & PAGE_MASK, paddr_next,
-                                             E820_RESERVED_KERN))
+                                             E820_TYPE_RESERVED_KERN))
                                 set_pte(pte, __pte(0));
                         continue;
                 }
@@ -393,9 +393,9 @@ phys_pmd_init(pmd_t *pmd_page, unsigned long paddr, unsigned long paddr_end,
                 if (paddr >= paddr_end) {
                         if (!after_bootmem &&
                             !e820__mapped_any(paddr & PMD_MASK, paddr_next,
-                                             E820_RAM) &&
+                                             E820_TYPE_RAM) &&
                             !e820__mapped_any(paddr & PMD_MASK, paddr_next,
-                                             E820_RESERVED_KERN))
+                                             E820_TYPE_RESERVED_KERN))
                                 set_pmd(pmd, __pmd(0));
                         continue;
                 }
@@ -479,9 +479,9 @@ phys_pud_init(pud_t *pud_page, unsigned long paddr, unsigned long paddr_end,
                 if (paddr >= paddr_end) {
                         if (!after_bootmem &&
                             !e820__mapped_any(paddr & PUD_MASK, paddr_next,
-                                             E820_RAM) &&
+                                             E820_TYPE_RAM) &&
                             !e820__mapped_any(paddr & PUD_MASK, paddr_next,
-                                             E820_RESERVED_KERN))
+                                             E820_TYPE_RESERVED_KERN))
                                 set_pud(pud, __pud(0));
                         continue;
                 }
diff --git a/arch/x86/pci/mmconfig-shared.c b/arch/x86/pci/mmconfig-shared.c
index 696b050bdc45..96057e4b6121 100644
--- a/arch/x86/pci/mmconfig-shared.c
+++ b/arch/x86/pci/mmconfig-shared.c
@@ -452,7 +452,7 @@ static int __ref is_mmconf_reserved(check_reserved_t is_reserved,
         int num_buses;
         char *method = with_e820 ? "E820" : "ACPI motherboard resources";
 
-        while (!is_reserved(addr, addr + size, E820_RESERVED)) {
+        while (!is_reserved(addr, addr + size, E820_TYPE_RESERVED)) {
                 size >>= 1;
                 if (size < (16UL<<20))
                         break;
diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index d97c05ee9664..14d0a6b1eee1 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -140,21 +140,21 @@ static void __init do_add_efi_memmap(void)
                 case EFI_BOOT_SERVICES_DATA:
                 case EFI_CONVENTIONAL_MEMORY:
                         if (md->attribute & EFI_MEMORY_WB)
-                                e820_type = E820_RAM;
+                                e820_type = E820_TYPE_RAM;
                         else
-                                e820_type = E820_RESERVED;
+                                e820_type = E820_TYPE_RESERVED;
                         break;
                 case EFI_ACPI_RECLAIM_MEMORY:
-                        e820_type = E820_ACPI;
+                        e820_type = E820_TYPE_ACPI;
                         break;
                 case EFI_ACPI_MEMORY_NVS:
-                        e820_type = E820_NVS;
+                        e820_type = E820_TYPE_NVS;
                         break;
                 case EFI_UNUSABLE_MEMORY:
-                        e820_type = E820_UNUSABLE;
+                        e820_type = E820_TYPE_UNUSABLE;
                         break;
                 case EFI_PERSISTENT_MEMORY:
-                        e820_type = E820_PMEM;
+                        e820_type = E820_TYPE_PMEM;
                         break;
                 default:
                         /*
@@ -162,7 +162,7 @@ static void __init do_add_efi_memmap(void)
                          * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
                          * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
                          */
-                        e820_type = E820_RESERVED;
+                        e820_type = E820_TYPE_RESERVED;
                         break;
                 }
                 e820__range_add(start, size, e820_type);
diff --git a/arch/x86/platform/efi/quirks.c b/arch/x86/platform/efi/quirks.c
index d4acd1668d36..3c8d8e511fd4 100644
--- a/arch/x86/platform/efi/quirks.c
+++ b/arch/x86/platform/efi/quirks.c
@@ -242,14 +242,14 @@ void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size)
  * else. We must only reserve (and then free) regions:
  *
  * - Not within any part of the kernel
- * - Not the BIOS reserved area (E820_RESERVED, E820_NVS, etc)
+ * - Not the BIOS reserved area (E820_TYPE_RESERVED, E820_TYPE_NVS, etc)
  */
 static bool can_free_region(u64 start, u64 size)
 {
         if (start + size > __pa_symbol(_text) && start <= __pa_symbol(_end))
                 return false;
 
-        if (!e820__mapped_all(start, start+size, E820_RAM))
+        if (!e820__mapped_all(start, start+size, E820_TYPE_RAM))
                 return false;
 
         return true;
@@ -282,7 +282,7 @@ void __init efi_reserve_boot_services(void)
                  * A good example of a critical region that must not be
                  * freed is page zero (first 4Kb of memory), which may
                  * contain boot services code/data but is marked
-                 * E820_RESERVED by trim_bios_range().
+                 * E820_TYPE_RESERVED by trim_bios_range().
                  */
                 if (!already_reserved) {
                         memblock_reserve(start, size);
diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
index a634723e660f..625ceafeb7a0 100644
--- a/arch/x86/xen/setup.c
+++ b/arch/x86/xen/setup.c
@@ -206,7 +206,7 @@ static unsigned long __init xen_find_pfn_range(unsigned long *min_pfn)
                 unsigned long s_pfn;
                 unsigned long e_pfn;
 
-                if (entry->type != E820_RAM)
+                if (entry->type != E820_TYPE_RAM)
                         continue;
 
                 e_pfn = PFN_DOWN(entry->addr + entry->size);
@@ -473,11 +473,11 @@ static unsigned long __init xen_foreach_remap_area(unsigned long nr_pages,
          */
         for (i = 0; i < xen_e820_table_entries; i++, entry++) {
                 phys_addr_t end = entry->addr + entry->size;
-                if (entry->type == E820_RAM || i == xen_e820_table_entries - 1) {
+                if (entry->type == E820_TYPE_RAM || i == xen_e820_table_entries - 1) {
                         unsigned long start_pfn = PFN_DOWN(start);
                         unsigned long end_pfn = PFN_UP(end);
 
-                        if (entry->type == E820_RAM)
+                        if (entry->type == E820_TYPE_RAM)
                                 end_pfn = PFN_UP(entry->addr);
 
                         if (start_pfn < end_pfn)
@@ -591,7 +591,7 @@ static void __init xen_align_and_add_e820_region(phys_addr_t start,
         phys_addr_t end = start + size;
 
         /* Align RAM regions to page boundaries. */
-        if (type == E820_RAM) {
+        if (type == E820_TYPE_RAM) {
                 start = PAGE_ALIGN(start);
                 end &= ~((phys_addr_t)PAGE_SIZE - 1);
         }
@@ -605,8 +605,8 @@ static void __init xen_ignore_unusable(void)
         unsigned int i;
 
         for (i = 0; i < xen_e820_table_entries; i++, entry++) {
-                if (entry->type == E820_UNUSABLE)
-                        entry->type = E820_RAM;
+                if (entry->type == E820_TYPE_UNUSABLE)
+                        entry->type = E820_TYPE_RAM;
         }
 }
 
@@ -623,7 +623,7 @@ bool __init xen_is_e820_reserved(phys_addr_t start, phys_addr_t size)
         entry = xen_e820_table;
 
         for (mapcnt = 0; mapcnt < xen_e820_table_entries; mapcnt++) {
-                if (entry->type == E820_RAM && entry->addr <= start &&
+                if (entry->type == E820_TYPE_RAM && entry->addr <= start &&
                     (entry->addr + entry->size) >= end)
                         return false;
 
@@ -648,7 +648,7 @@ phys_addr_t __init xen_find_free_area(phys_addr_t size)
         struct e820_entry *entry = xen_e820_table;
 
         for (mapcnt = 0; mapcnt < xen_e820_table_entries; mapcnt++, entry++) {
-                if (entry->type != E820_RAM || entry->size < size)
+                if (entry->type != E820_TYPE_RAM || entry->size < size)
                         continue;
                 start = entry->addr;
                 for (addr = start; addr < start + size; addr += PAGE_SIZE) {
@@ -764,7 +764,7 @@ char * __init xen_memory_setup(void)
                 xen_e820_table[0].size = mem_end;
                 /* 8MB slack (to balance backend allocations). */
                 xen_e820_table[0].size += 8ULL << 20;
-                xen_e820_table[0].type = E820_RAM;
+                xen_e820_table[0].type = E820_TYPE_RAM;
                 rc = 0;
         }
         BUG_ON(rc);
@@ -819,7 +819,7 @@ char * __init xen_memory_setup(void)
                 chunk_size = size;
                 type = xen_e820_table[i].type;
 
-                if (type == E820_RAM) {
+                if (type == E820_TYPE_RAM) {
                         if (addr < mem_end) {
                                 chunk_size = min(size, mem_end - addr);
                         } else if (extra_pages) {
@@ -859,7 +859,7 @@ char * __init xen_memory_setup(void)
          * about in there.
          */
         e820__range_add(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS,
-                        E820_RESERVED);
+                        E820_TYPE_RESERVED);
 
         e820__update_table(e820_table->entries, ARRAY_SIZE(e820_table->entries), &e820_table->nr_entries);
 
diff --git a/tools/lguest/lguest.c b/tools/lguest/lguest.c
index 3819e23a173e..4e38ea02ef0f 100644
--- a/tools/lguest/lguest.c
+++ b/tools/lguest/lguest.c
@@ -3339,7 +3339,7 @@ int main(int argc, char *argv[])
          * simple, single region.
          */
         boot->e820_entries = 1;
-        boot->e820_table[0] = ((struct e820_entry) { 0, mem, E820_RAM });
+        boot->e820_table[0] = ((struct e820_entry) { 0, mem, E820_TYPE_RAM });
         /*
          * The boot header contains a command line pointer: we put the command
          * line after the boot header.