acpi: Create subtable parsing infrastructure

Parsing entries in an ACPI table had assumed a generic header
structure. There is no standard ACPI header, though, so less common
layouts with different field sizes required custom parsers to go through
their subtable entry list.

Create the infrastructure for adding different table types so parsing
the entries array may be more reused for all ACPI system tables and
the common code doesn't need to be duplicated.

Reviewed-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Tested-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Signed-off-by: Keith Busch <keith.busch@intel.com>
Tested-by: Brice Goglin <Brice.Goglin@inria.fr>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 57 insertions, 10 deletions

diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index 8fccbe49612a..7553774a22b7 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -49,6 +49,15 @@ static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata;
 
 static int acpi_apic_instance __initdata;
 
+enum acpi_subtable_type {
+        ACPI_SUBTABLE_COMMON,
+};
+
+struct acpi_subtable_entry {
+        union acpi_subtable_headers *hdr;
+        enum acpi_subtable_type type;
+};
+
 /*
  * Disable table checksum verification for the early stage due to the size
  * limitation of the current x86 early mapping implementation.
@@ -217,6 +226,42 @@ void acpi_table_print_madt_entry(struct acpi_subtable_header *header)
         }
 }
 
+static unsigned long __init
+acpi_get_entry_type(struct acpi_subtable_entry *entry)
+{
+        switch (entry->type) {
+        case ACPI_SUBTABLE_COMMON:
+                return entry->hdr->common.type;
+        }
+        return 0;
+}
+
+static unsigned long __init
+acpi_get_entry_length(struct acpi_subtable_entry *entry)
+{
+        switch (entry->type) {
+        case ACPI_SUBTABLE_COMMON:
+                return entry->hdr->common.length;
+        }
+        return 0;
+}
+
+static unsigned long __init
+acpi_get_subtable_header_length(struct acpi_subtable_entry *entry)
+{
+        switch (entry->type) {
+        case ACPI_SUBTABLE_COMMON:
+                return sizeof(entry->hdr->common);
+        }
+        return 0;
+}
+
+static enum acpi_subtable_type __init
+acpi_get_subtable_type(char *id)
+{
+        return ACPI_SUBTABLE_COMMON;
+}
+
 /**
  * acpi_parse_entries_array - for each proc_num find a suitable subtable
  *
@@ -246,8 +291,8 @@ acpi_parse_entries_array(char *id, unsigned long table_size,
                 struct acpi_subtable_proc *proc, int proc_num,
                 unsigned int max_entries)
 {
-        struct acpi_subtable_header *entry;
-        unsigned long table_end;
+        struct acpi_subtable_entry entry;
+        unsigned long table_end, subtable_len, entry_len;
         int count = 0;
         int errs = 0;
         int i;
@@ -270,19 +315,20 @@ acpi_parse_entries_array(char *id, unsigned long table_size,
 
         /* Parse all entries looking for a match. */
 
-        entry = (struct acpi_subtable_header *)
+        entry.type = acpi_get_subtable_type(id);
+        entry.hdr = (union acpi_subtable_headers *)
             ((unsigned long)table_header + table_size);
+        subtable_len = acpi_get_subtable_header_length(&entry);
 
-        while (((unsigned long)entry) + sizeof(struct acpi_subtable_header) <
-               table_end) {
+        while (((unsigned long)entry.hdr) + subtable_len  < table_end) {
                 if (max_entries && count >= max_entries)
                         break;
 
                 for (i = 0; i < proc_num; i++) {
-                        if (entry->type != proc[i].id)
+                        if (acpi_get_entry_type(&entry) != proc[i].id)
                                 continue;
                         if (!proc[i].handler ||
-                             (!errs && proc[i].handler(entry, table_end))) {
+                             (!errs && proc[i].handler(entry.hdr, table_end))) {
                                 errs++;
                                 continue;
                         }
@@ -297,13 +343,14 @@ acpi_parse_entries_array(char *id, unsigned long table_size,
                  * If entry->length is 0, break from this loop to avoid
                  * infinite loop.
                  */
-                if (entry->length == 0) {
+                entry_len = acpi_get_entry_length(&entry);
+                if (entry_len == 0) {
                         pr_err("[%4.4s:0x%02x] Invalid zero length\n", id, proc->id);
                         return -EINVAL;
                 }
 
-                entry = (struct acpi_subtable_header *)
-                    ((unsigned long)entry + entry->length);
+                entry.hdr = (union acpi_subtable_headers *)
+                    ((unsigned long)entry.hdr + entry_len);
         }
 
         if (max_entries && count > max_entries) {