6 files changed, 288 insertions, 46 deletions

diff --git a/drivers/acpi/apei/apei-base.c b/drivers/acpi/apei/apei-base.c
index 61540360d5ce..e45350cb6ac8 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 f57050e7a5e7..cca240a33038 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 31546fd21029..5b898d4dda99 100644
--- a/drivers/acpi/apei/einj.c
+++ b/drivers/acpi/apei/einj.c
@@ -286,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;
@@ -296,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));
@@ -324,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);
@@ -347,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;
@@ -460,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);
@@ -610,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;
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
index 631b9477b99c..8e8d786c5d23 100644
--- a/drivers/acpi/apei/erst.c
+++ b/drivers/acpi/apei/erst.c
@@ -1125,10 +1125,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 b8e08cb67a18..b3207e16670e 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 05fee06f4d6e..f709269d4932 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;