Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux

This includes initial support for the recently published ACPI 5.0 spec.
In particular, support for the "hardware-reduced" bit that eliminates
the dependency on legacy hardware.

APEI has patches resulting from testing on real hardware.

Plus other random fixes.

* 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux: (52 commits)
  acpi/apei/einj: Add extensions to EINJ from rev 5.0 of acpi spec
  intel_idle: Split up and provide per CPU initialization func
  ACPI processor: Remove unneeded variable passed by acpi_processor_hotadd_init V2
  ACPI processor: Remove unneeded cpuidle_unregister_driver call
  intel idle: Make idle driver more robust
  intel_idle: Fix a cast to pointer from integer of different size warning in intel_idle
  ACPI: kernel-parameters.txt : Add intel_idle.max_cstate
  intel_idle: remove redundant local_irq_disable() call
  ACPI processor: Fix error path, also remove sysdev link
  ACPI: processor: fix acpi_get_cpuid for UP processor
  intel_idle: fix API misuse
  ACPI APEI: Convert atomicio routines
  ACPI: Export interfaces for ioremapping/iounmapping ACPI registers
  ACPI: Fix possible alignment issues with GAS 'address' references
  ACPI, ia64: Use SRAT table rev to use 8bit or 16/32bit PXM fields (ia64)
  ACPI, x86: Use SRAT table rev to use 8bit or 32bit PXM fields (x86/x86-64)
  ACPI: Store SRAT table revision
  ACPI, APEI, Resolve false conflict between ACPI NVS and APEI
  ACPI, Record ACPI NVS regions
  ACPI, APEI, EINJ, Refine the fix of resource conflict
  ...

6 files changed, 476 insertions, 82 deletions

diff --git a/drivers/acpi/apei/apei-base.c b/drivers/acpi/apei/apei-base.c
index 61540360d5c..e45350cb6ac 100644
--- a/drivers/acpi/apei/apei-base.c
+++ b/drivers/acpi/apei/apei-base.c
@@ -34,13 +34,13 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
+#include <linux/acpi_io.h>
 #include <linux/slab.h>
 #include <linux/io.h>
 #include <linux/kref.h>
 #include <linux/rculist.h>
 #include <linux/interrupt.h>
 #include <linux/debugfs.h>
-#include <acpi/atomicio.h>
 
 #include "apei-internal.h"
 
@@ -70,7 +70,7 @@ int __apei_exec_read_register(struct acpi_whea_header *entry, u64 *val)
 {
         int rc;
 
-        rc = acpi_atomic_read(val, &entry->register_region);
+        rc = apei_read(val, &entry->register_region);
         if (rc)
                 return rc;
         *val >>= entry->register_region.bit_offset;
@@ -116,13 +116,13 @@ int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val)
         val <<= entry->register_region.bit_offset;
         if (entry->flags & APEI_EXEC_PRESERVE_REGISTER) {
                 u64 valr = 0;
-                rc = acpi_atomic_read(&valr, &entry->register_region);
+                rc = apei_read(&valr, &entry->register_region);
                 if (rc)
                         return rc;
                 valr &= ~(entry->mask << entry->register_region.bit_offset);
                 val |= valr;
         }
-        rc = acpi_atomic_write(val, &entry->register_region);
+        rc = apei_write(val, &entry->register_region);
 
         return rc;
 }
@@ -243,7 +243,7 @@ static int pre_map_gar_callback(struct apei_exec_context *ctx,
         u8 ins = entry->instruction;
 
         if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
-                return acpi_pre_map_gar(&entry->register_region);
+                return acpi_os_map_generic_address(&entry->register_region);
 
         return 0;
 }
@@ -276,7 +276,7 @@ static int post_unmap_gar_callback(struct apei_exec_context *ctx,
         u8 ins = entry->instruction;
 
         if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
-                acpi_post_unmap_gar(&entry->register_region);
+                acpi_os_unmap_generic_address(&entry->register_region);
 
         return 0;
 }
@@ -421,6 +421,17 @@ static int apei_resources_merge(struct apei_resources *resources1,
         return 0;
 }
 
+int apei_resources_add(struct apei_resources *resources,
+                       unsigned long start, unsigned long size,
+                       bool iomem)
+{
+        if (iomem)
+                return apei_res_add(&resources->iomem, start, size);
+        else
+                return apei_res_add(&resources->ioport, start, size);
+}
+EXPORT_SYMBOL_GPL(apei_resources_add);
+
 /*
  * EINJ has two groups of GARs (EINJ table entry and trigger table
  * entry), so common resources are subtracted from the trigger table
@@ -438,8 +449,19 @@ int apei_resources_sub(struct apei_resources *resources1,
 }
 EXPORT_SYMBOL_GPL(apei_resources_sub);
 
+static int apei_get_nvs_callback(__u64 start, __u64 size, void *data)
+{
+        struct apei_resources *resources = data;
+        return apei_res_add(&resources->iomem, start, size);
+}
+
+static int apei_get_nvs_resources(struct apei_resources *resources)
+{
+        return acpi_nvs_for_each_region(apei_get_nvs_callback, resources);
+}
+
 /*
- * IO memory/port rersource management mechanism is used to check
+ * IO memory/port resource management mechanism is used to check
  * whether memory/port area used by GARs conflicts with normal memory
  * or IO memory/port of devices.
  */
@@ -448,21 +470,35 @@ int apei_resources_request(struct apei_resources *resources,
 {
         struct apei_res *res, *res_bak = NULL;
         struct resource *r;
+        struct apei_resources nvs_resources;
         int rc;
 
         rc = apei_resources_sub(resources, &apei_resources_all);
         if (rc)
                 return rc;
 
+        /*
+         * Some firmware uses ACPI NVS region, that has been marked as
+         * busy, so exclude it from APEI resources to avoid false
+         * conflict.
+         */
+        apei_resources_init(&nvs_resources);
+        rc = apei_get_nvs_resources(&nvs_resources);
+        if (rc)
+                goto res_fini;
+        rc = apei_resources_sub(resources, &nvs_resources);
+        if (rc)
+                goto res_fini;
+
         rc = -EINVAL;
         list_for_each_entry(res, &resources->iomem, list) {
                 r = request_mem_region(res->start, res->end - res->start,
                                        desc);
                 if (!r) {
                         pr_err(APEI_PFX
-                "Can not request iomem region <%016llx-%016llx> for GARs.\n",
+                "Can not request [mem %#010llx-%#010llx] for %s registers\n",
                                (unsigned long long)res->start,
-                               (unsigned long long)res->end);
+                               (unsigned long long)res->end - 1, desc);
                         res_bak = res;
                         goto err_unmap_iomem;
                 }
@@ -472,9 +508,9 @@ int apei_resources_request(struct apei_resources *resources,
                 r = request_region(res->start, res->end - res->start, desc);
                 if (!r) {
                         pr_err(APEI_PFX
-                "Can not request ioport region <%016llx-%016llx> for GARs.\n",
+                "Can not request [io  %#06llx-%#06llx] for %s registers\n",
                                (unsigned long long)res->start,
-                               (unsigned long long)res->end);
+                               (unsigned long long)res->end - 1, desc);
                         res_bak = res;
                         goto err_unmap_ioport;
                 }
@@ -500,6 +536,8 @@ err_unmap_iomem:
                         break;
                 release_mem_region(res->start, res->end - res->start);
         }
+res_fini:
+        apei_resources_fini(&nvs_resources);
         return rc;
 }
 EXPORT_SYMBOL_GPL(apei_resources_request);
@@ -553,6 +591,96 @@ static int apei_check_gar(struct acpi_generic_address *reg, u64 *paddr)
         return 0;
 }
 
+/* read GAR in interrupt (including NMI) or process context */
+int apei_read(u64 *val, struct acpi_generic_address *reg)
+{
+        int rc;
+        u64 address;
+        u32 tmp, width = reg->bit_width;
+        acpi_status status;
+
+        rc = apei_check_gar(reg, &address);
+        if (rc)
+                return rc;
+
+        if (width == 64)
+                width = 32;     /* Break into two 32-bit transfers */
+
+        *val = 0;
+        switch(reg->space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+                status = acpi_os_read_memory((acpi_physical_address)
+                                             address, &tmp, width);
+                if (ACPI_FAILURE(status))
+                        return -EIO;
+                *val = tmp;
+
+                if (reg->bit_width == 64) {
+                        /* Read the top 32 bits */
+                        status = acpi_os_read_memory((acpi_physical_address)
+                                                     (address + 4), &tmp, 32);
+                        if (ACPI_FAILURE(status))
+                                return -EIO;
+                        *val |= ((u64)tmp << 32);
+                }
+                break;
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                status = acpi_os_read_port(address, (u32 *)val, reg->bit_width);
+                if (ACPI_FAILURE(status))
+                        return -EIO;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_read);
+
+/* write GAR in interrupt (including NMI) or process context */
+int apei_write(u64 val, struct acpi_generic_address *reg)
+{
+        int rc;
+        u64 address;
+        u32 width = reg->bit_width;
+        acpi_status status;
+
+        rc = apei_check_gar(reg, &address);
+        if (rc)
+                return rc;
+
+        if (width == 64)
+                width = 32;     /* Break into two 32-bit transfers */
+
+        switch (reg->space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+                status = acpi_os_write_memory((acpi_physical_address)
+                                              address, ACPI_LODWORD(val),
+                                              width);
+                if (ACPI_FAILURE(status))
+                        return -EIO;
+
+                if (reg->bit_width == 64) {
+                        status = acpi_os_write_memory((acpi_physical_address)
+                                                      (address + 4),
+                                                      ACPI_HIDWORD(val), 32);
+                        if (ACPI_FAILURE(status))
+                                return -EIO;
+                }
+                break;
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                status = acpi_os_write_port(address, val, reg->bit_width);
+                if (ACPI_FAILURE(status))
+                        return -EIO;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_write);
+
 static int collect_res_callback(struct apei_exec_context *ctx,
                                 struct acpi_whea_header *entry,
                                 void *data)
diff --git a/drivers/acpi/apei/apei-internal.h b/drivers/acpi/apei/apei-internal.h
index f57050e7a5e..cca240a3303 100644
--- a/drivers/acpi/apei/apei-internal.h
+++ b/drivers/acpi/apei/apei-internal.h
@@ -68,6 +68,9 @@ static inline int apei_exec_run_optional(struct apei_exec_context *ctx, u8 actio
 /* IP has been set in instruction function */
 #define APEI_EXEC_SET_IP        1
 
+int apei_read(u64 *val, struct acpi_generic_address *reg);
+int apei_write(u64 val, struct acpi_generic_address *reg);
+
 int __apei_exec_read_register(struct acpi_whea_header *entry, u64 *val);
 int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val);
 int apei_exec_read_register(struct apei_exec_context *ctx,
@@ -95,6 +98,9 @@ static inline void apei_resources_init(struct apei_resources *resources)
 }
 
 void apei_resources_fini(struct apei_resources *resources);
+int apei_resources_add(struct apei_resources *resources,
+                       unsigned long start, unsigned long size,
+                       bool iomem);
 int apei_resources_sub(struct apei_resources *resources1,
                        struct apei_resources *resources2);
 int apei_resources_request(struct apei_resources *resources,
diff --git a/drivers/acpi/apei/einj.c b/drivers/acpi/apei/einj.c
index 589b96c3870..5b898d4dda9 100644
--- a/drivers/acpi/apei/einj.c
+++ b/drivers/acpi/apei/einj.c
@@ -43,6 +43,42 @@
 #define FIRMWARE_TIMEOUT        (1 * NSEC_PER_MSEC)
 
 /*
+ * ACPI version 5 provides a SET_ERROR_TYPE_WITH_ADDRESS action.
+ */
+static int acpi5;
+
+struct set_error_type_with_address {
+        u32     type;
+        u32     vendor_extension;
+        u32     flags;
+        u32     apicid;
+        u64     memory_address;
+        u64     memory_address_range;
+        u32     pcie_sbdf;
+};
+enum {
+        SETWA_FLAGS_APICID = 1,
+        SETWA_FLAGS_MEM = 2,
+        SETWA_FLAGS_PCIE_SBDF = 4,
+};
+
+/*
+ * Vendor extensions for platform specific operations
+ */
+struct vendor_error_type_extension {
+        u32     length;
+        u32     pcie_sbdf;
+        u16     vendor_id;
+        u16     device_id;
+        u8      rev_id;
+        u8      reserved[3];
+};
+
+static u32 vendor_flags;
+static struct debugfs_blob_wrapper vendor_blob;
+static char vendor_dev[64];
+
+/*
  * Some BIOSes allow parameters to the SET_ERROR_TYPE entries in the
  * EINJ table through an unpublished extension. Use with caution as
  * most will ignore the parameter and make their own choice of address
@@ -103,7 +139,14 @@ static struct apei_exec_ins_type einj_ins_type[] = {
  */
 static DEFINE_MUTEX(einj_mutex);
 
-static struct einj_parameter *einj_param;
+static void *einj_param;
+
+#ifndef readq
+static inline __u64 readq(volatile void __iomem *addr)
+{
+        return ((__u64)readl(addr+4) << 32) + readl(addr);
+}
+#endif
 
 #ifndef writeq
 static inline void writeq(__u64 val, volatile void __iomem *addr)
@@ -158,10 +201,31 @@ static int einj_timedout(u64 *t)
         return 0;
 }
 
-static u64 einj_get_parameter_address(void)
+static void check_vendor_extension(u64 paddr,
+                                   struct set_error_type_with_address *v5param)
+{
+        int     offset = readl(&v5param->vendor_extension);
+        struct  vendor_error_type_extension *v;
+        u32     sbdf;
+
+        if (!offset)
+                return;
+        v = ioremap(paddr + offset, sizeof(*v));
+        if (!v)
+                return;
+        sbdf = readl(&v->pcie_sbdf);
+        sprintf(vendor_dev, "%x:%x:%x.%x vendor_id=%x device_id=%x rev_id=%x\n",
+                sbdf >> 24, (sbdf >> 16) & 0xff,
+                (sbdf >> 11) & 0x1f, (sbdf >> 8) & 0x7,
+                 readw(&v->vendor_id), readw(&v->device_id),
+                readb(&v->rev_id));
+        iounmap(v);
+}
+
+static void *einj_get_parameter_address(void)
 {
         int i;
-        u64 paddr = 0;
+        u64 paddrv4 = 0, paddrv5 = 0;
         struct acpi_whea_header *entry;
 
         entry = EINJ_TAB_ENTRY(einj_tab);
@@ -170,12 +234,40 @@ static u64 einj_get_parameter_address(void)
                     entry->instruction == ACPI_EINJ_WRITE_REGISTER &&
                     entry->register_region.space_id ==
                     ACPI_ADR_SPACE_SYSTEM_MEMORY)
-                        memcpy(&paddr, &entry->register_region.address,
-                               sizeof(paddr));
+                        memcpy(&paddrv4, &entry->register_region.address,
+                               sizeof(paddrv4));
+                if (entry->action == ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS &&
+                    entry->instruction == ACPI_EINJ_WRITE_REGISTER &&
+                    entry->register_region.space_id ==
+                    ACPI_ADR_SPACE_SYSTEM_MEMORY)
+                        memcpy(&paddrv5, &entry->register_region.address,
+                               sizeof(paddrv5));
                 entry++;
         }
+        if (paddrv5) {
+                struct set_error_type_with_address *v5param;
+
+                v5param = ioremap(paddrv5, sizeof(*v5param));
+                if (v5param) {
+                        acpi5 = 1;
+                        check_vendor_extension(paddrv5, v5param);
+                        return v5param;
+                }
+        }
+        if (paddrv4) {
+                struct einj_parameter *v4param;
+
+                v4param = ioremap(paddrv4, sizeof(*v4param));
+                if (!v4param)
+                        return 0;
+                if (readq(&v4param->reserved1) || readq(&v4param->reserved2)) {
+                        iounmap(v4param);
+                        return 0;
+                }
+                return v4param;
+        }
 
-        return paddr;
+        return 0;
 }
 
 /* do sanity check to trigger table */
@@ -194,8 +286,29 @@ static int einj_check_trigger_header(struct acpi_einj_trigger *trigger_tab)
         return 0;
 }
 
+static struct acpi_generic_address *einj_get_trigger_parameter_region(
+        struct acpi_einj_trigger *trigger_tab, u64 param1, u64 param2)
+{
+        int i;
+        struct acpi_whea_header *entry;
+
+        entry = (struct acpi_whea_header *)
+                ((char *)trigger_tab + sizeof(struct acpi_einj_trigger));
+        for (i = 0; i < trigger_tab->entry_count; i++) {
+                if (entry->action == ACPI_EINJ_TRIGGER_ERROR &&
+                entry->instruction == ACPI_EINJ_WRITE_REGISTER_VALUE &&
+                entry->register_region.space_id ==
+                        ACPI_ADR_SPACE_SYSTEM_MEMORY &&
+                (entry->register_region.address & param2) == (param1 & param2))
+                        return &entry->register_region;
+                entry++;
+        }
+
+        return NULL;
+}
 /* Execute instructions in trigger error action table */
-static int __einj_error_trigger(u64 trigger_paddr)
+static int __einj_error_trigger(u64 trigger_paddr, u32 type,
+                                u64 param1, u64 param2)
 {
         struct acpi_einj_trigger *trigger_tab = NULL;
         struct apei_exec_context trigger_ctx;
@@ -204,14 +317,16 @@ static int __einj_error_trigger(u64 trigger_paddr)
         struct resource *r;
         u32 table_size;
         int rc = -EIO;
+        struct acpi_generic_address *trigger_param_region = NULL;
 
         r = request_mem_region(trigger_paddr, sizeof(*trigger_tab),
                                "APEI EINJ Trigger Table");
         if (!r) {
                 pr_err(EINJ_PFX
-        "Can not request iomem region <%016llx-%016llx> for Trigger table.\n",
+        "Can not request [mem %#010llx-%#010llx] for Trigger table\n",
                        (unsigned long long)trigger_paddr,
-                       (unsigned long long)trigger_paddr+sizeof(*trigger_tab));
+                       (unsigned long long)trigger_paddr +
+                            sizeof(*trigger_tab) - 1);
                 goto out;
         }
         trigger_tab = ioremap_cache(trigger_paddr, sizeof(*trigger_tab));
@@ -232,9 +347,9 @@ static int __einj_error_trigger(u64 trigger_paddr)
                                "APEI EINJ Trigger Table");
         if (!r) {
                 pr_err(EINJ_PFX
-"Can not request iomem region <%016llx-%016llx> for Trigger Table Entry.\n",
-                       (unsigned long long)trigger_paddr+sizeof(*trigger_tab),
-                       (unsigned long long)trigger_paddr + table_size);
+"Can not request [mem %#010llx-%#010llx] for Trigger Table Entry\n",
+                       (unsigned long long)trigger_paddr + sizeof(*trigger_tab),
+                       (unsigned long long)trigger_paddr + table_size - 1);
                 goto out_rel_header;
         }
         iounmap(trigger_tab);
@@ -255,6 +370,30 @@ static int __einj_error_trigger(u64 trigger_paddr)
         rc = apei_resources_sub(&trigger_resources, &einj_resources);
         if (rc)
                 goto out_fini;
+        /*
+         * Some firmware will access target address specified in
+         * param1 to trigger the error when injecting memory error.
+         * This will cause resource conflict with regular memory.  So
+         * remove it from trigger table resources.
+         */
+        if (param_extension && (type & 0x0038) && param2) {
+                struct apei_resources addr_resources;
+                apei_resources_init(&addr_resources);
+                trigger_param_region = einj_get_trigger_parameter_region(
+                        trigger_tab, param1, param2);
+                if (trigger_param_region) {
+                        rc = apei_resources_add(&addr_resources,
+                                trigger_param_region->address,
+                                trigger_param_region->bit_width/8, true);
+                        if (rc)
+                                goto out_fini;
+                        rc = apei_resources_sub(&trigger_resources,
+                                        &addr_resources);
+                }
+                apei_resources_fini(&addr_resources);
+                if (rc)
+                        goto out_fini;
+        }
         rc = apei_resources_request(&trigger_resources, "APEI EINJ Trigger");
         if (rc)
                 goto out_fini;
@@ -293,12 +432,56 @@ static int __einj_error_inject(u32 type, u64 param1, u64 param2)
         if (rc)
                 return rc;
         apei_exec_ctx_set_input(&ctx, type);
-        rc = apei_exec_run(&ctx, ACPI_EINJ_SET_ERROR_TYPE);
-        if (rc)
-                return rc;
-        if (einj_param) {
-                writeq(param1, &einj_param->param1);
-                writeq(param2, &einj_param->param2);
+        if (acpi5) {
+                struct set_error_type_with_address *v5param = einj_param;
+
+                writel(type, &v5param->type);
+                if (type & 0x80000000) {
+                        switch (vendor_flags) {
+                        case SETWA_FLAGS_APICID:
+                                writel(param1, &v5param->apicid);
+                                break;
+                        case SETWA_FLAGS_MEM:
+                                writeq(param1, &v5param->memory_address);
+                                writeq(param2, &v5param->memory_address_range);
+                                break;
+                        case SETWA_FLAGS_PCIE_SBDF:
+                                writel(param1, &v5param->pcie_sbdf);
+                                break;
+                        }
+                        writel(vendor_flags, &v5param->flags);
+                } else {
+                        switch (type) {
+                        case ACPI_EINJ_PROCESSOR_CORRECTABLE:
+                        case ACPI_EINJ_PROCESSOR_UNCORRECTABLE:
+                        case ACPI_EINJ_PROCESSOR_FATAL:
+                                writel(param1, &v5param->apicid);
+                                writel(SETWA_FLAGS_APICID, &v5param->flags);
+                                break;
+                        case ACPI_EINJ_MEMORY_CORRECTABLE:
+                        case ACPI_EINJ_MEMORY_UNCORRECTABLE:
+                        case ACPI_EINJ_MEMORY_FATAL:
+                                writeq(param1, &v5param->memory_address);
+                                writeq(param2, &v5param->memory_address_range);
+                                writel(SETWA_FLAGS_MEM, &v5param->flags);
+                                break;
+                        case ACPI_EINJ_PCIX_CORRECTABLE:
+                        case ACPI_EINJ_PCIX_UNCORRECTABLE:
+                        case ACPI_EINJ_PCIX_FATAL:
+                                writel(param1, &v5param->pcie_sbdf);
+                                writel(SETWA_FLAGS_PCIE_SBDF, &v5param->flags);
+                                break;
+                        }
+                }
+        } else {
+                rc = apei_exec_run(&ctx, ACPI_EINJ_SET_ERROR_TYPE);
+                if (rc)
+                        return rc;
+                if (einj_param) {
+                        struct einj_parameter *v4param = einj_param;
+                        writeq(param1, &v4param->param1);
+                        writeq(param2, &v4param->param2);
+                }
         }
         rc = apei_exec_run(&ctx, ACPI_EINJ_EXECUTE_OPERATION);
         if (rc)
@@ -324,7 +507,7 @@ static int __einj_error_inject(u32 type, u64 param1, u64 param2)
         if (rc)
                 return rc;
         trigger_paddr = apei_exec_ctx_get_output(&ctx);
-        rc = __einj_error_trigger(trigger_paddr);
+        rc = __einj_error_trigger(trigger_paddr, type, param1, param2);
         if (rc)
                 return rc;
         rc = apei_exec_run_optional(&ctx, ACPI_EINJ_END_OPERATION);
@@ -408,15 +591,25 @@ static int error_type_set(void *data, u64 val)
 {
         int rc;
         u32 available_error_type = 0;
+        u32 tval, vendor;
+
+        /*
+         * Vendor defined types have 0x80000000 bit set, and
+         * are not enumerated by ACPI_EINJ_GET_ERROR_TYPE
+         */
+        vendor = val & 0x80000000;
+        tval = val & 0x7fffffff;
 
         /* Only one error type can be specified */
-        if (val & (val - 1))
-                return -EINVAL;
-        rc = einj_get_available_error_type(&available_error_type);
-        if (rc)
-                return rc;
-        if (!(val & available_error_type))
+        if (tval & (tval - 1))
                 return -EINVAL;
+        if (!vendor) {
+                rc = einj_get_available_error_type(&available_error_type);
+                if (rc)
+                        return rc;
+                if (!(val & available_error_type))
+                        return -EINVAL;
+        }
         error_type = val;
 
         return 0;
@@ -455,7 +648,6 @@ static int einj_check_table(struct acpi_table_einj *einj_tab)
 static int __init einj_init(void)
 {
         int rc;
-        u64 param_paddr;
         acpi_status status;
         struct dentry *fentry;
         struct apei_exec_context ctx;
@@ -465,10 +657,9 @@ static int __init einj_init(void)
 
         status = acpi_get_table(ACPI_SIG_EINJ, 0,
                                 (struct acpi_table_header **)&einj_tab);
-        if (status == AE_NOT_FOUND) {
-                pr_info(EINJ_PFX "Table is not found!\n");
+        if (status == AE_NOT_FOUND)
                 return -ENODEV;
-        } else if (ACPI_FAILURE(status)) {
+        else if (ACPI_FAILURE(status)) {
                 const char *msg = acpi_format_exception(status);
                 pr_err(EINJ_PFX "Failed to get table, %s\n", msg);
                 return -EINVAL;
@@ -509,23 +700,30 @@ static int __init einj_init(void)
         rc = apei_exec_pre_map_gars(&ctx);
         if (rc)
                 goto err_release;
-        if (param_extension) {
-                param_paddr = einj_get_parameter_address();
-                if (param_paddr) {
-                        einj_param = ioremap(param_paddr, sizeof(*einj_param));
-                        rc = -ENOMEM;
-                        if (!einj_param)
-                                goto err_unmap;
-                        fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR,
-                                                    einj_debug_dir, &error_param1);
-                        if (!fentry)
-                                goto err_unmap;
-                        fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR,
-                                                    einj_debug_dir, &error_param2);
-                        if (!fentry)
-                                goto err_unmap;
-                } else
-                        pr_warn(EINJ_PFX "Parameter extension is not supported.\n");
+
+        einj_param = einj_get_parameter_address();
+        if ((param_extension || acpi5) && einj_param) {
+                fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR,
+                                            einj_debug_dir, &error_param1);
+                if (!fentry)
+                        goto err_unmap;
+                fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR,
+                                            einj_debug_dir, &error_param2);
+                if (!fentry)
+                        goto err_unmap;
+        }
+
+        if (vendor_dev[0]) {
+                vendor_blob.data = vendor_dev;
+                vendor_blob.size = strlen(vendor_dev);
+                fentry = debugfs_create_blob("vendor", S_IRUSR,
+                                             einj_debug_dir, &vendor_blob);
+                if (!fentry)
+                        goto err_unmap;
+                fentry = debugfs_create_x32("vendor_flags", S_IRUSR | S_IWUSR,
+                                            einj_debug_dir, &vendor_flags);
+                if (!fentry)
+                        goto err_unmap;
         }
 
         pr_info(EINJ_PFX "Error INJection is initialized.\n");
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
index 6a9e3bad13f..eb9fab5b96e 100644
--- a/drivers/acpi/apei/erst.c
+++ b/drivers/acpi/apei/erst.c
@@ -1127,10 +1127,9 @@ static int __init erst_init(void)
 
         status = acpi_get_table(ACPI_SIG_ERST, 0,
                                 (struct acpi_table_header **)&erst_tab);
-        if (status == AE_NOT_FOUND) {
-                pr_info(ERST_PFX "Table is not found!\n");
+        if (status == AE_NOT_FOUND)
                 goto err;
-        } else if (ACPI_FAILURE(status)) {
+        else if (ACPI_FAILURE(status)) {
                 const char *msg = acpi_format_exception(status);
                 pr_err(ERST_PFX "Failed to get table, %s\n", msg);
                 rc = -EINVAL;
diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
index ebaf037a787..9b3cac0abec 100644
--- a/drivers/acpi/apei/ghes.c
+++ b/drivers/acpi/apei/ghes.c
@@ -33,6 +33,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
+#include <linux/acpi_io.h>
 #include <linux/io.h>
 #include <linux/interrupt.h>
 #include <linux/timer.h>
@@ -45,8 +46,9 @@
 #include <linux/irq_work.h>
 #include <linux/llist.h>
 #include <linux/genalloc.h>
+#include <linux/pci.h>
+#include <linux/aer.h>
 #include <acpi/apei.h>
-#include <acpi/atomicio.h>
 #include <acpi/hed.h>
 #include <asm/mce.h>
 #include <asm/tlbflush.h>
@@ -299,7 +301,7 @@ static struct ghes *ghes_new(struct acpi_hest_generic *generic)
         if (!ghes)
                 return ERR_PTR(-ENOMEM);
         ghes->generic = generic;
-        rc = acpi_pre_map_gar(&generic->error_status_address);
+        rc = acpi_os_map_generic_address(&generic->error_status_address);
         if (rc)
                 goto err_free;
         error_block_length = generic->error_block_length;
@@ -319,7 +321,7 @@ static struct ghes *ghes_new(struct acpi_hest_generic *generic)
         return ghes;
 
 err_unmap:
-        acpi_post_unmap_gar(&generic->error_status_address);
+        acpi_os_unmap_generic_address(&generic->error_status_address);
 err_free:
         kfree(ghes);
         return ERR_PTR(rc);
@@ -328,7 +330,7 @@ err_free:
 static void ghes_fini(struct ghes *ghes)
 {
         kfree(ghes->estatus);
-        acpi_post_unmap_gar(&ghes->generic->error_status_address);
+        acpi_os_unmap_generic_address(&ghes->generic->error_status_address);
 }
 
 enum {
@@ -399,7 +401,7 @@ static int ghes_read_estatus(struct ghes *ghes, int silent)
         u32 len;
         int rc;
 
-        rc = acpi_atomic_read(&buf_paddr, &g->error_status_address);
+        rc = apei_read(&buf_paddr, &g->error_status_address);
         if (rc) {
                 if (!silent && printk_ratelimit())
                         pr_warning(FW_WARN GHES_PFX
@@ -476,6 +478,27 @@ static void ghes_do_proc(const struct acpi_hest_generic_status *estatus)
                         }
 #endif
                 }
+#ifdef CONFIG_ACPI_APEI_PCIEAER
+                else if (!uuid_le_cmp(*(uuid_le *)gdata->section_type,
+                                      CPER_SEC_PCIE)) {
+                        struct cper_sec_pcie *pcie_err;
+                        pcie_err = (struct cper_sec_pcie *)(gdata+1);
+                        if (sev == GHES_SEV_RECOVERABLE &&
+                            sec_sev == GHES_SEV_RECOVERABLE &&
+                            pcie_err->validation_bits & CPER_PCIE_VALID_DEVICE_ID &&
+                            pcie_err->validation_bits & CPER_PCIE_VALID_AER_INFO) {
+                                unsigned int devfn;
+                                int aer_severity;
+                                devfn = PCI_DEVFN(pcie_err->device_id.device,
+                                                  pcie_err->device_id.function);
+                                aer_severity = cper_severity_to_aer(sev);
+                                aer_recover_queue(pcie_err->device_id.segment,
+                                                  pcie_err->device_id.bus,
+                                                  devfn, aer_severity);
+                        }
+
+                }
+#endif
         }
 }
 
@@ -483,16 +506,22 @@ static void __ghes_print_estatus(const char *pfx,
                                  const struct acpi_hest_generic *generic,
                                  const struct acpi_hest_generic_status *estatus)
 {
+        static atomic_t seqno;
+        unsigned int curr_seqno;
+        char pfx_seq[64];
+
         if (pfx == NULL) {
                 if (ghes_severity(estatus->error_severity) <=
                     GHES_SEV_CORRECTED)
-                        pfx = KERN_WARNING HW_ERR;
+                        pfx = KERN_WARNING;
                 else
-                        pfx = KERN_ERR HW_ERR;
+                        pfx = KERN_ERR;
         }
+        curr_seqno = atomic_inc_return(&seqno);
+        snprintf(pfx_seq, sizeof(pfx_seq), "%s{%u}" HW_ERR, pfx, curr_seqno);
         printk("%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
-               pfx, generic->header.source_id);
-        apei_estatus_print(pfx, estatus);
+               pfx_seq, generic->header.source_id);
+        apei_estatus_print(pfx_seq, estatus);
 }
 
 static int ghes_print_estatus(const char *pfx,
@@ -711,26 +740,34 @@ static int ghes_notify_sci(struct notifier_block *this,
         return ret;
 }
 
+static struct llist_node *llist_nodes_reverse(struct llist_node *llnode)
+{
+        struct llist_node *next, *tail = NULL;
+
+        while (llnode) {
+                next = llnode->next;
+                llnode->next = tail;
+                tail = llnode;
+                llnode = next;
+        }
+
+        return tail;
+}
+
 static void ghes_proc_in_irq(struct irq_work *irq_work)
 {
-        struct llist_node *llnode, *next, *tail = NULL;
+        struct llist_node *llnode, *next;
         struct ghes_estatus_node *estatus_node;
         struct acpi_hest_generic *generic;
         struct acpi_hest_generic_status *estatus;
         u32 len, node_len;
 
+        llnode = llist_del_all(&ghes_estatus_llist);
         /*
          * Because the time order of estatus in list is reversed,
          * revert it back to proper order.
          */
-        llnode = llist_del_all(&ghes_estatus_llist);
-        while (llnode) {
-                next = llnode->next;
-                llnode->next = tail;
-                tail = llnode;
-                llnode = next;
-        }
-        llnode = tail;
+        llnode = llist_nodes_reverse(llnode);
         while (llnode) {
                 next = llnode->next;
                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
@@ -750,6 +787,32 @@ static void ghes_proc_in_irq(struct irq_work *irq_work)
         }
 }
 
+static void ghes_print_queued_estatus(void)
+{
+        struct llist_node *llnode;
+        struct ghes_estatus_node *estatus_node;
+        struct acpi_hest_generic *generic;
+        struct acpi_hest_generic_status *estatus;
+        u32 len, node_len;
+
+        llnode = llist_del_all(&ghes_estatus_llist);
+        /*
+         * Because the time order of estatus in list is reversed,
+         * revert it back to proper order.
+         */
+        llnode = llist_nodes_reverse(llnode);
+        while (llnode) {
+                estatus_node = llist_entry(llnode, struct ghes_estatus_node,
+                                           llnode);
+                estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
+                len = apei_estatus_len(estatus);
+                node_len = GHES_ESTATUS_NODE_LEN(len);
+                generic = estatus_node->generic;
+                ghes_print_estatus(NULL, generic, estatus);
+                llnode = llnode->next;
+        }
+}
+
 static int ghes_notify_nmi(unsigned int cmd, struct pt_regs *regs)
 {
         struct ghes *ghes, *ghes_global = NULL;
@@ -775,7 +838,8 @@ static int ghes_notify_nmi(unsigned int cmd, struct pt_regs *regs)
 
         if (sev_global >= GHES_SEV_PANIC) {
                 oops_begin();
-                __ghes_print_estatus(KERN_EMERG HW_ERR, ghes_global->generic,
+                ghes_print_queued_estatus();
+                __ghes_print_estatus(KERN_EMERG, ghes_global->generic,
                                      ghes_global->estatus);
                 /* reboot to log the error! */
                 if (panic_timeout == 0)
diff --git a/drivers/acpi/apei/hest.c b/drivers/acpi/apei/hest.c
index ee7fddc4665..7f00cf38098 100644
--- a/drivers/acpi/apei/hest.c
+++ b/drivers/acpi/apei/hest.c
@@ -221,10 +221,9 @@ void __init acpi_hest_init(void)
 
         status = acpi_get_table(ACPI_SIG_HEST, 0,
                                 (struct acpi_table_header **)&hest_tab);
-        if (status == AE_NOT_FOUND) {
-                pr_info(HEST_PFX "Table not found.\n");
+        if (status == AE_NOT_FOUND)
                 goto err;
-        } else if (ACPI_FAILURE(status)) {
+        else if (ACPI_FAILURE(status)) {
                 const char *msg = acpi_format_exception(status);
                 pr_err(HEST_PFX "Failed to get table, %s\n", msg);
                 rc = -EINVAL;