Merge branch 'acpi-resources'

* acpi-resources: (23 commits)
  Merge branch 'pci/host-generic' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci into acpi-resources
  x86/irq, ACPI: Implement ACPI driver to support IOAPIC hotplug
  ACPI: Add interfaces to parse IOAPIC ID for IOAPIC hotplug
  x86/PCI: Refine the way to release PCI IRQ resources
  x86/PCI/ACPI: Use common ACPI resource interfaces to simplify implementation
  x86/PCI: Fix the range check for IO resources
  PCI: Use common resource list management code instead of private implementation
  resources: Move struct resource_list_entry from ACPI into resource core
  ACPI: Introduce helper function acpi_dev_filter_resource_type()
  ACPI: Add field offset to struct resource_list_entry
  ACPI: Translate resource into master side address for bridge window resources
  ACPI: Return translation offset when parsing ACPI address space resources
  ACPI: Enforce stricter checks for address space descriptors
  ACPI: Set flag IORESOURCE_UNSET for unassigned resources
  ACPI: Normalize return value of resource parser functions
  ACPI: Fix a bug in parsing ACPI Memory24 resource
  ACPI: Add prefetch decoding to the address space parser
  ACPI: Move the window flag logic to the combined parser
  ACPI: Unify the parsing of address_space and ext_address_space
  ACPI: Let the parser return false for disabled resources
  ...

10 files changed, 584 insertions, 159 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 8951cefb0a96..e6c3ddd92665 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -315,6 +315,12 @@ config ACPI_HOTPLUG_MEMORY
           To compile this driver as a module, choose M here:
           the module will be called acpi_memhotplug.
 
+config ACPI_HOTPLUG_IOAPIC
+        bool
+        depends on PCI
+        depends on X86_IO_APIC
+        default y
+
 config ACPI_SBS
         tristate "Smart Battery System"
         depends on X86
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 0071141b6bbc..b18cd2151ddb 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -70,6 +70,7 @@ obj-$(CONFIG_ACPI_PROCESSOR)	+= processor.o
 obj-y                           += container.o
 obj-$(CONFIG_ACPI_THERMAL)      += thermal.o
 obj-y                           += acpi_memhotplug.o
+obj-$(CONFIG_ACPI_HOTPLUG_IOAPIC) += ioapic.o
 obj-$(CONFIG_ACPI_BATTERY)      += battery.o
 obj-$(CONFIG_ACPI_SBS)          += sbshc.o
 obj-$(CONFIG_ACPI_SBS)          += sbs.o
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index 08fbff507dc4..02e835f3cf8a 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -307,7 +307,7 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
 {
         struct lpss_device_desc *dev_desc;
         struct lpss_private_data *pdata;
-        struct resource_list_entry *rentry;
+        struct resource_entry *rentry;
         struct list_head resource_list;
         struct platform_device *pdev;
         int ret;
@@ -327,12 +327,12 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
                 goto err_out;
 
         list_for_each_entry(rentry, &resource_list, node)
-                if (resource_type(&rentry->res) == IORESOURCE_MEM) {
+                if (resource_type(rentry->res) == IORESOURCE_MEM) {
                         if (dev_desc->prv_size_override)
                                 pdata->mmio_size = dev_desc->prv_size_override;
                         else
-                                pdata->mmio_size = resource_size(&rentry->res);
-                        pdata->mmio_base = ioremap(rentry->res.start,
+                                pdata->mmio_size = resource_size(rentry->res);
+                        pdata->mmio_base = ioremap(rentry->res->start,
                                                    pdata->mmio_size);
                         if (!pdata->mmio_base)
                                 goto err_out;
diff --git a/drivers/acpi/acpi_platform.c b/drivers/acpi/acpi_platform.c
index 6ba8beb6b9d2..1284138e42ab 100644
--- a/drivers/acpi/acpi_platform.c
+++ b/drivers/acpi/acpi_platform.c
@@ -45,7 +45,7 @@ struct platform_device *acpi_create_platform_device(struct acpi_device *adev)
         struct platform_device *pdev = NULL;
         struct acpi_device *acpi_parent;
         struct platform_device_info pdevinfo;
-        struct resource_list_entry *rentry;
+        struct resource_entry *rentry;
         struct list_head resource_list;
         struct resource *resources = NULL;
         int count;
@@ -71,7 +71,7 @@ struct platform_device *acpi_create_platform_device(struct acpi_device *adev)
                 }
                 count = 0;
                 list_for_each_entry(rentry, &resource_list, node)
-                        resources[count++] = rentry->res;
+                        resources[count++] = *rentry->res;
 
                 acpi_dev_free_resource_list(&resource_list);
         }
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 81ae69fde7d5..56b321aa2b1c 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -35,6 +35,13 @@ void acpi_int340x_thermal_init(void);
 int acpi_sysfs_init(void);
 void acpi_container_init(void);
 void acpi_memory_hotplug_init(void);
+#ifdef  CONFIG_ACPI_HOTPLUG_IOAPIC
+int acpi_ioapic_add(struct acpi_pci_root *root);
+int acpi_ioapic_remove(struct acpi_pci_root *root);
+#else
+static inline int acpi_ioapic_add(struct acpi_pci_root *root) { return 0; }
+static inline int acpi_ioapic_remove(struct acpi_pci_root *root) { return 0; }
+#endif
 #ifdef CONFIG_ACPI_DOCK
 void register_dock_dependent_device(struct acpi_device *adev,
                                     acpi_handle dshandle);
diff --git a/drivers/acpi/ioapic.c b/drivers/acpi/ioapic.c
new file mode 100644
index 000000000000..ccdc8db16bb8
--- /dev/null
+++ b/drivers/acpi/ioapic.c
@@ -0,0 +1,229 @@
+/*
+ * IOAPIC/IOxAPIC/IOSAPIC driver
+ *
+ * Copyright (C) 2009 Fujitsu Limited.
+ * (c) Copyright 2009 Hewlett-Packard Development Company, L.P.
+ *
+ * Copyright (C) 2014 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Based on original drivers/pci/ioapic.c
+ *      Yinghai Lu <yinghai@kernel.org>
+ *      Jiang Liu <jiang.liu@intel.com>
+ */
+
+/*
+ * This driver manages I/O APICs added by hotplug after boot.
+ * We try to claim all I/O APIC devices, but those present at boot were
+ * registered when we parsed the ACPI MADT.
+ */
+
+#define pr_fmt(fmt) "ACPI : IOAPIC: " fmt
+
+#include <linux/slab.h>
+#include <linux/acpi.h>
+#include <linux/pci.h>
+#include <acpi/acpi.h>
+
+struct acpi_pci_ioapic {
+        acpi_handle     root_handle;
+        acpi_handle     handle;
+        u32             gsi_base;
+        struct resource res;
+        struct pci_dev  *pdev;
+        struct list_head list;
+};
+
+static LIST_HEAD(ioapic_list);
+static DEFINE_MUTEX(ioapic_list_lock);
+
+static acpi_status setup_res(struct acpi_resource *acpi_res, void *data)
+{
+        struct resource *res = data;
+        struct resource_win win;
+
+        res->flags = 0;
+        if (acpi_dev_filter_resource_type(acpi_res, IORESOURCE_MEM) == 0)
+                return AE_OK;
+
+        if (!acpi_dev_resource_memory(acpi_res, res)) {
+                if (acpi_dev_resource_address_space(acpi_res, &win) ||
+                    acpi_dev_resource_ext_address_space(acpi_res, &win))
+                        *res = win.res;
+        }
+        if ((res->flags & IORESOURCE_PREFETCH) ||
+            (res->flags & IORESOURCE_DISABLED))
+                res->flags = 0;
+
+        return AE_CTRL_TERMINATE;
+}
+
+static bool acpi_is_ioapic(acpi_handle handle, char **type)
+{
+        acpi_status status;
+        struct acpi_device_info *info;
+        char *hid = NULL;
+        bool match = false;
+
+        if (!acpi_has_method(handle, "_GSB"))
+                return false;
+
+        status = acpi_get_object_info(handle, &info);
+        if (ACPI_SUCCESS(status)) {
+                if (info->valid & ACPI_VALID_HID)
+                        hid = info->hardware_id.string;
+                if (hid) {
+                        if (strcmp(hid, "ACPI0009") == 0) {
+                                *type = "IOxAPIC";
+                                match = true;
+                        } else if (strcmp(hid, "ACPI000A") == 0) {
+                                *type = "IOAPIC";
+                                match = true;
+                        }
+                }
+                kfree(info);
+        }
+
+        return match;
+}
+
+static acpi_status handle_ioapic_add(acpi_handle handle, u32 lvl,
+                                     void *context, void **rv)
+{
+        acpi_status status;
+        unsigned long long gsi_base;
+        struct acpi_pci_ioapic *ioapic;
+        struct pci_dev *dev = NULL;
+        struct resource *res = NULL;
+        char *type = NULL;
+
+        if (!acpi_is_ioapic(handle, &type))
+                return AE_OK;
+
+        mutex_lock(&ioapic_list_lock);
+        list_for_each_entry(ioapic, &ioapic_list, list)
+                if (ioapic->handle == handle) {
+                        mutex_unlock(&ioapic_list_lock);
+                        return AE_OK;
+                }
+
+        status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsi_base);
+        if (ACPI_FAILURE(status)) {
+                acpi_handle_warn(handle, "failed to evaluate _GSB method\n");
+                goto exit;
+        }
+
+        ioapic = kzalloc(sizeof(*ioapic), GFP_KERNEL);
+        if (!ioapic) {
+                pr_err("cannot allocate memory for new IOAPIC\n");
+                goto exit;
+        } else {
+                ioapic->root_handle = (acpi_handle)context;
+                ioapic->handle = handle;
+                ioapic->gsi_base = (u32)gsi_base;
+                INIT_LIST_HEAD(&ioapic->list);
+        }
+
+        if (acpi_ioapic_registered(handle, (u32)gsi_base))
+                goto done;
+
+        dev = acpi_get_pci_dev(handle);
+        if (dev && pci_resource_len(dev, 0)) {
+                if (pci_enable_device(dev) < 0)
+                        goto exit_put;
+                pci_set_master(dev);
+                if (pci_request_region(dev, 0, type))
+                        goto exit_disable;
+                res = &dev->resource[0];
+                ioapic->pdev = dev;
+        } else {
+                pci_dev_put(dev);
+                dev = NULL;
+
+                res = &ioapic->res;
+                acpi_walk_resources(handle, METHOD_NAME__CRS, setup_res, res);
+                if (res->flags == 0) {
+                        acpi_handle_warn(handle, "failed to get resource\n");
+                        goto exit_free;
+                } else if (request_resource(&iomem_resource, res)) {
+                        acpi_handle_warn(handle, "failed to insert resource\n");
+                        goto exit_free;
+                }
+        }
+
+        if (acpi_register_ioapic(handle, res->start, (u32)gsi_base)) {
+                acpi_handle_warn(handle, "failed to register IOAPIC\n");
+                goto exit_release;
+        }
+done:
+        list_add(&ioapic->list, &ioapic_list);
+        mutex_unlock(&ioapic_list_lock);
+
+        if (dev)
+                dev_info(&dev->dev, "%s at %pR, GSI %u\n",
+                         type, res, (u32)gsi_base);
+        else
+                acpi_handle_info(handle, "%s at %pR, GSI %u\n",
+                                 type, res, (u32)gsi_base);
+
+        return AE_OK;
+
+exit_release:
+        if (dev)
+                pci_release_region(dev, 0);
+        else
+                release_resource(res);
+exit_disable:
+        if (dev)
+                pci_disable_device(dev);
+exit_put:
+        pci_dev_put(dev);
+exit_free:
+        kfree(ioapic);
+exit:
+        mutex_unlock(&ioapic_list_lock);
+        *(acpi_status *)rv = AE_ERROR;
+        return AE_OK;
+}
+
+int acpi_ioapic_add(struct acpi_pci_root *root)
+{
+        acpi_status status, retval = AE_OK;
+
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, root->device->handle,
+                                     UINT_MAX, handle_ioapic_add, NULL,
+                                     root->device->handle, (void **)&retval);
+
+        return ACPI_SUCCESS(status) && ACPI_SUCCESS(retval) ? 0 : -ENODEV;
+}
+
+int acpi_ioapic_remove(struct acpi_pci_root *root)
+{
+        int retval = 0;
+        struct acpi_pci_ioapic *ioapic, *tmp;
+
+        mutex_lock(&ioapic_list_lock);
+        list_for_each_entry_safe(ioapic, tmp, &ioapic_list, list) {
+                if (root->device->handle != ioapic->root_handle)
+                        continue;
+
+                if (acpi_unregister_ioapic(ioapic->handle, ioapic->gsi_base))
+                        retval = -EBUSY;
+
+                if (ioapic->pdev) {
+                        pci_release_region(ioapic->pdev, 0);
+                        pci_disable_device(ioapic->pdev);
+                        pci_dev_put(ioapic->pdev);
+                } else if (ioapic->res.flags && ioapic->res.parent) {
+                        release_resource(&ioapic->res);
+                }
+                list_del(&ioapic->list);
+                kfree(ioapic);
+        }
+        mutex_unlock(&ioapic_list_lock);
+
+        return retval;
+}
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index b1def411c0b8..e7f718d6918a 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -485,14 +485,6 @@ void acpi_pci_irq_disable(struct pci_dev *dev)
         if (!pin || !dev->irq_managed || dev->irq <= 0)
                 return;
 
-        /* Keep IOAPIC pin configuration when suspending */
-        if (dev->dev.power.is_prepared)
-                return;
-#ifdef  CONFIG_PM
-        if (dev->dev.power.runtime_status == RPM_SUSPENDING)
-                return;
-#endif
-
         entry = acpi_pci_irq_lookup(dev, pin);
         if (!entry)
                 return;
@@ -513,5 +505,6 @@ void acpi_pci_irq_disable(struct pci_dev *dev)
         if (gsi >= 0) {
                 acpi_unregister_gsi(gsi);
                 dev->irq_managed = 0;
+                dev->irq = 0;
         }
 }
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index e53e0f659204..68a5f712cd19 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -621,6 +621,7 @@ static int acpi_pci_root_add(struct acpi_device *device,
         if (hotadd) {
                 pcibios_resource_survey_bus(root->bus);
                 pci_assign_unassigned_root_bus_resources(root->bus);
+                acpi_ioapic_add(root);
         }
 
         pci_lock_rescan_remove();
@@ -644,6 +645,8 @@ static void acpi_pci_root_remove(struct acpi_device *device)
 
         pci_stop_root_bus(root->bus);
 
+        WARN_ON(acpi_ioapic_remove(root));
+
         device_set_run_wake(root->bus->bridge, false);
         pci_acpi_remove_bus_pm_notifier(device);
 
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 02e48394276c..7962651cdbd4 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -4,6 +4,10 @@
  *
  *      Alex Chiang <achiang@hp.com>
  *      - Unified x86/ia64 implementations
+ *
+ * I/O APIC hotplug support
+ *      Yinghai Lu <yinghai@kernel.org>
+ *      Jiang Liu <jiang.liu@intel.com>
  */
 #include <linux/export.h>
 #include <linux/acpi.h>
@@ -12,6 +16,21 @@
 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
 ACPI_MODULE_NAME("processor_core");
 
+static struct acpi_table_madt *get_madt_table(void)
+{
+        static struct acpi_table_madt *madt;
+        static int read_madt;
+
+        if (!read_madt) {
+                if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
+                                        (struct acpi_table_header **)&madt)))
+                        madt = NULL;
+                read_madt++;
+        }
+
+        return madt;
+}
+
 static int map_lapic_id(struct acpi_subtable_header *entry,
                  u32 acpi_id, int *apic_id)
 {
@@ -67,17 +86,10 @@ static int map_lsapic_id(struct acpi_subtable_header *entry,
 static int map_madt_entry(int type, u32 acpi_id)
 {
         unsigned long madt_end, entry;
-        static struct acpi_table_madt *madt;
-        static int read_madt;
         int phys_id = -1;       /* CPU hardware ID */
+        struct acpi_table_madt *madt;
 
-        if (!read_madt) {
-                if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
-                                        (struct acpi_table_header **)&madt)))
-                        madt = NULL;
-                read_madt++;
-        }
-
+        madt = get_madt_table();
         if (!madt)
                 return phys_id;
 
@@ -203,3 +215,96 @@ int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
         return acpi_map_cpuid(phys_id, acpi_id);
 }
 EXPORT_SYMBOL_GPL(acpi_get_cpuid);
+
+#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
+static int get_ioapic_id(struct acpi_subtable_header *entry, u32 gsi_base,
+                         u64 *phys_addr, int *ioapic_id)
+{
+        struct acpi_madt_io_apic *ioapic = (struct acpi_madt_io_apic *)entry;
+
+        if (ioapic->global_irq_base != gsi_base)
+                return 0;
+
+        *phys_addr = ioapic->address;
+        *ioapic_id = ioapic->id;
+        return 1;
+}
+
+static int parse_madt_ioapic_entry(u32 gsi_base, u64 *phys_addr)
+{
+        struct acpi_subtable_header *hdr;
+        unsigned long madt_end, entry;
+        struct acpi_table_madt *madt;
+        int apic_id = -1;
+
+        madt = get_madt_table();
+        if (!madt)
+                return apic_id;
+
+        entry = (unsigned long)madt;
+        madt_end = entry + madt->header.length;
+
+        /* Parse all entries looking for a match. */
+        entry += sizeof(struct acpi_table_madt);
+        while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
+                hdr = (struct acpi_subtable_header *)entry;
+                if (hdr->type == ACPI_MADT_TYPE_IO_APIC &&
+                    get_ioapic_id(hdr, gsi_base, phys_addr, &apic_id))
+                        break;
+                else
+                        entry += hdr->length;
+        }
+
+        return apic_id;
+}
+
+static int parse_mat_ioapic_entry(acpi_handle handle, u32 gsi_base,
+                                  u64 *phys_addr)
+{
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_subtable_header *header;
+        union acpi_object *obj;
+        int apic_id = -1;
+
+        if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
+                goto exit;
+
+        if (!buffer.length || !buffer.pointer)
+                goto exit;
+
+        obj = buffer.pointer;
+        if (obj->type != ACPI_TYPE_BUFFER ||
+            obj->buffer.length < sizeof(struct acpi_subtable_header))
+                goto exit;
+
+        header = (struct acpi_subtable_header *)obj->buffer.pointer;
+        if (header->type == ACPI_MADT_TYPE_IO_APIC)
+                get_ioapic_id(header, gsi_base, phys_addr, &apic_id);
+
+exit:
+        kfree(buffer.pointer);
+        return apic_id;
+}
+
+/**
+ * acpi_get_ioapic_id - Get IOAPIC ID and physical address matching @gsi_base
+ * @handle:     ACPI object for IOAPIC device
+ * @gsi_base:   GSI base to match with
+ * @phys_addr:  Pointer to store physical address of matching IOAPIC record
+ *
+ * Walk resources returned by ACPI_MAT method, then ACPI MADT table, to search
+ * for an ACPI IOAPIC record matching @gsi_base.
+ * Return IOAPIC id and store physical address in @phys_addr if found a match,
+ * otherwise return <0.
+ */
+int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr)
+{
+        int apic_id;
+
+        apic_id = parse_mat_ioapic_entry(handle, gsi_base, phys_addr);
+        if (apic_id == -1)
+                apic_id = parse_madt_ioapic_entry(gsi_base, phys_addr);
+
+        return apic_id;
+}
+#endif /* CONFIG_ACPI_HOTPLUG_IOAPIC */
diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
index d0a4d90c6bcc..4752b9939987 100644
--- a/drivers/acpi/resource.c
+++ b/drivers/acpi/resource.c
@@ -34,21 +34,34 @@
 #define valid_IRQ(i) (true)
 #endif
 
-static unsigned long acpi_dev_memresource_flags(u64 len, u8 write_protect,
-                                                bool window)
+static bool acpi_dev_resource_len_valid(u64 start, u64 end, u64 len, bool io)
 {
-        unsigned long flags = IORESOURCE_MEM;
+        u64 reslen = end - start + 1;
 
-        if (len == 0)
-                flags |= IORESOURCE_DISABLED;
+        /*
+         * CHECKME: len might be required to check versus a minimum
+         * length as well. 1 for io is fine, but for memory it does
+         * not make any sense at all.
+         */
+        if (len && reslen && reslen == len && start <= end)
+                return true;
 
-        if (write_protect == ACPI_READ_WRITE_MEMORY)
-                flags |= IORESOURCE_MEM_WRITEABLE;
+        pr_info("ACPI: invalid or unassigned resource %s [%016llx - %016llx] length [%016llx]\n",
+                io ? "io" : "mem", start, end, len);
+
+        return false;
+}
+
+static void acpi_dev_memresource_flags(struct resource *res, u64 len,
+                                       u8 write_protect)
+{
+        res->flags = IORESOURCE_MEM;
 
-        if (window)
-                flags |= IORESOURCE_WINDOW;
+        if (!acpi_dev_resource_len_valid(res->start, res->end, len, false))
+                res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET;
 
-        return flags;
+        if (write_protect == ACPI_READ_WRITE_MEMORY)
+                res->flags |= IORESOURCE_MEM_WRITEABLE;
 }
 
 static void acpi_dev_get_memresource(struct resource *res, u64 start, u64 len,
@@ -56,7 +69,7 @@ static void acpi_dev_get_memresource(struct resource *res, u64 start, u64 len,
 {
         res->start = start;
         res->end = start + len - 1;
-        res->flags = acpi_dev_memresource_flags(len, write_protect, false);
+        acpi_dev_memresource_flags(res, len, write_protect);
 }
 
 /**
@@ -67,6 +80,11 @@ static void acpi_dev_get_memresource(struct resource *res, u64 start, u64 len,
  * Check if the given ACPI resource object represents a memory resource and
  * if that's the case, use the information in it to populate the generic
  * resource object pointed to by @res.
+ *
+ * Return:
+ * 1) false with res->flags setting to zero: not the expected resource type
+ * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource
+ * 3) true: valid assigned resource
  */
 bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res)
 {
@@ -77,60 +95,52 @@ bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res)
         switch (ares->type) {
         case ACPI_RESOURCE_TYPE_MEMORY24:
                 memory24 = &ares->data.memory24;
-                if (!memory24->minimum && !memory24->address_length)
-                        return false;
-                acpi_dev_get_memresource(res, memory24->minimum,
-                                         memory24->address_length,
+                acpi_dev_get_memresource(res, memory24->minimum << 8,
+                                         memory24->address_length << 8,
                                          memory24->write_protect);
                 break;
         case ACPI_RESOURCE_TYPE_MEMORY32:
                 memory32 = &ares->data.memory32;
-                if (!memory32->minimum && !memory32->address_length)
-                        return false;
                 acpi_dev_get_memresource(res, memory32->minimum,
                                          memory32->address_length,
                                          memory32->write_protect);
                 break;
         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
                 fixed_memory32 = &ares->data.fixed_memory32;
-                if (!fixed_memory32->address && !fixed_memory32->address_length)
-                        return false;
                 acpi_dev_get_memresource(res, fixed_memory32->address,
                                          fixed_memory32->address_length,
                                          fixed_memory32->write_protect);
                 break;
         default:
+                res->flags = 0;
                 return false;
         }
-        return true;
+
+        return !(res->flags & IORESOURCE_DISABLED);
 }
 EXPORT_SYMBOL_GPL(acpi_dev_resource_memory);
 
-static unsigned int acpi_dev_ioresource_flags(u64 start, u64 end, u8 io_decode,
-                                              bool window)
+static void acpi_dev_ioresource_flags(struct resource *res, u64 len,
+                                      u8 io_decode)
 {
-        int flags = IORESOURCE_IO;
+        res->flags = IORESOURCE_IO;
 
-        if (io_decode == ACPI_DECODE_16)
-                flags |= IORESOURCE_IO_16BIT_ADDR;
+        if (!acpi_dev_resource_len_valid(res->start, res->end, len, true))
+                res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET;
 
-        if (start > end || end >= 0x10003)
-                flags |= IORESOURCE_DISABLED;
+        if (res->end >= 0x10003)
+                res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET;
 
-        if (window)
-                flags |= IORESOURCE_WINDOW;
-
-        return flags;
+        if (io_decode == ACPI_DECODE_16)
+                res->flags |= IORESOURCE_IO_16BIT_ADDR;
 }
 
 static void acpi_dev_get_ioresource(struct resource *res, u64 start, u64 len,
                                     u8 io_decode)
 {
-        u64 end = start + len - 1;
-
         res->start = start;
-        res->end = end;
-        res->flags = acpi_dev_ioresource_flags(start, end, io_decode, false);
+        res->end = start + len - 1;
+        acpi_dev_ioresource_flags(res, len, io_decode);
 }
 
 /**
@@ -141,6 +151,11 @@ static void acpi_dev_get_ioresource(struct resource *res, u64 start, u64 len,
  * Check if the given ACPI resource object represents an I/O resource and
  * if that's the case, use the information in it to populate the generic
  * resource object pointed to by @res.
+ *
+ * Return:
+ * 1) false with res->flags setting to zero: not the expected resource type
+ * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource
+ * 3) true: valid assigned resource
  */
 bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res)
 {
@@ -150,135 +165,143 @@ bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res)
         switch (ares->type) {
         case ACPI_RESOURCE_TYPE_IO:
                 io = &ares->data.io;
-                if (!io->minimum && !io->address_length)
-                        return false;
                 acpi_dev_get_ioresource(res, io->minimum,
                                         io->address_length,
                                         io->io_decode);
                 break;
         case ACPI_RESOURCE_TYPE_FIXED_IO:
                 fixed_io = &ares->data.fixed_io;
-                if (!fixed_io->address && !fixed_io->address_length)
-                        return false;
                 acpi_dev_get_ioresource(res, fixed_io->address,
                                         fixed_io->address_length,
                                         ACPI_DECODE_10);
                 break;
         default:
+                res->flags = 0;
                 return false;
         }
-        return true;
+
+        return !(res->flags & IORESOURCE_DISABLED);
 }
 EXPORT_SYMBOL_GPL(acpi_dev_resource_io);
 
-/**
- * acpi_dev_resource_address_space - Extract ACPI address space information.
- * @ares: Input ACPI resource object.
- * @res: Output generic resource object.
- *
- * Check if the given ACPI resource object represents an address space resource
- * and if that's the case, use the information in it to populate the generic
- * resource object pointed to by @res.
- */
-bool acpi_dev_resource_address_space(struct acpi_resource *ares,
-                                     struct resource *res)
+static bool acpi_decode_space(struct resource_win *win,
+                              struct acpi_resource_address *addr,
+                              struct acpi_address64_attribute *attr)
 {
-        acpi_status status;
-        struct acpi_resource_address64 addr;
-        bool window;
-        u64 len;
-        u8 io_decode;
+        u8 iodec = attr->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16;
+        bool wp = addr->info.mem.write_protect;
+        u64 len = attr->address_length;
+        struct resource *res = &win->res;
 
-        switch (ares->type) {
-        case ACPI_RESOURCE_TYPE_ADDRESS16:
-        case ACPI_RESOURCE_TYPE_ADDRESS32:
-        case ACPI_RESOURCE_TYPE_ADDRESS64:
-                break;
-        default:
-                return false;
-        }
+        /*
+         * Filter out invalid descriptor according to ACPI Spec 5.0, section
+         * 6.4.3.5 Address Space Resource Descriptors.
+         */
+        if ((addr->min_address_fixed != addr->max_address_fixed && len) ||
+            (addr->min_address_fixed && addr->max_address_fixed && !len))
+                pr_debug("ACPI: Invalid address space min_addr_fix %d, max_addr_fix %d, len %llx\n",
+                         addr->min_address_fixed, addr->max_address_fixed, len);
 
-        status = acpi_resource_to_address64(ares, &addr);
-        if (ACPI_FAILURE(status))
-                return false;
+        res->start = attr->minimum;
+        res->end = attr->maximum;
 
-        res->start = addr.address.minimum;
-        res->end = addr.address.maximum;
-        window = addr.producer_consumer == ACPI_PRODUCER;
+        /*
+         * For bridges that translate addresses across the bridge,
+         * translation_offset is the offset that must be added to the
+         * address on the secondary side to obtain the address on the
+         * primary side. Non-bridge devices must list 0 for all Address
+         * Translation offset bits.
+         */
+        if (addr->producer_consumer == ACPI_PRODUCER) {
+                res->start += attr->translation_offset;
+                res->end += attr->translation_offset;
+        } else if (attr->translation_offset) {
+                pr_debug("ACPI: translation_offset(%lld) is invalid for non-bridge device.\n",
+                         attr->translation_offset);
+        }
 
-        switch(addr.resource_type) {
+        switch (addr->resource_type) {
         case ACPI_MEMORY_RANGE:
-                len = addr.address.maximum - addr.address.minimum + 1;
-                res->flags = acpi_dev_memresource_flags(len,
-                                                addr.info.mem.write_protect,
-                                                window);
+                acpi_dev_memresource_flags(res, len, wp);
                 break;
         case ACPI_IO_RANGE:
-                io_decode = addr.address.granularity == 0xfff ?
-                                ACPI_DECODE_10 : ACPI_DECODE_16;
-                res->flags = acpi_dev_ioresource_flags(addr.address.minimum,
-                                                       addr.address.maximum,
-                                                       io_decode, window);
+                acpi_dev_ioresource_flags(res, len, iodec);
                 break;
         case ACPI_BUS_NUMBER_RANGE:
                 res->flags = IORESOURCE_BUS;
                 break;
         default:
-                res->flags = 0;
+                return false;
         }
 
-        return true;
+        win->offset = attr->translation_offset;
+
+        if (addr->producer_consumer == ACPI_PRODUCER)
+                res->flags |= IORESOURCE_WINDOW;
+
+        if (addr->info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
+                res->flags |= IORESOURCE_PREFETCH;
+
+        return !(res->flags & IORESOURCE_DISABLED);
+}
+
+/**
+ * acpi_dev_resource_address_space - Extract ACPI address space information.
+ * @ares: Input ACPI resource object.
+ * @win: Output generic resource object.
+ *
+ * Check if the given ACPI resource object represents an address space resource
+ * and if that's the case, use the information in it to populate the generic
+ * resource object pointed to by @win.
+ *
+ * Return:
+ * 1) false with win->res.flags setting to zero: not the expected resource type
+ * 2) false with IORESOURCE_DISABLED in win->res.flags: valid unassigned
+ *    resource
+ * 3) true: valid assigned resource
+ */
+bool acpi_dev_resource_address_space(struct acpi_resource *ares,
+                                     struct resource_win *win)
+{
+        struct acpi_resource_address64 addr;
+
+        win->res.flags = 0;
+        if (ACPI_FAILURE(acpi_resource_to_address64(ares, &addr)))
+                return false;
+
+        return acpi_decode_space(win, (struct acpi_resource_address *)&addr,
+                                 &addr.address);
 }
 EXPORT_SYMBOL_GPL(acpi_dev_resource_address_space);
 
 /**
  * acpi_dev_resource_ext_address_space - Extract ACPI address space information.
  * @ares: Input ACPI resource object.
- * @res: Output generic resource object.
+ * @win: Output generic resource object.
  *
  * Check if the given ACPI resource object represents an extended address space
  * resource and if that's the case, use the information in it to populate the
- * generic resource object pointed to by @res.
+ * generic resource object pointed to by @win.
+ *
+ * Return:
+ * 1) false with win->res.flags setting to zero: not the expected resource type
+ * 2) false with IORESOURCE_DISABLED in win->res.flags: valid unassigned
+ *    resource
+ * 3) true: valid assigned resource
  */
 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
-                                         struct resource *res)
+                                         struct resource_win *win)
 {
         struct acpi_resource_extended_address64 *ext_addr;
-        bool window;
-        u64 len;
-        u8 io_decode;
 
+        win->res.flags = 0;
         if (ares->type != ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64)
                 return false;
 
         ext_addr = &ares->data.ext_address64;
 
-        res->start = ext_addr->address.minimum;
-        res->end = ext_addr->address.maximum;
-        window = ext_addr->producer_consumer == ACPI_PRODUCER;
-
-        switch(ext_addr->resource_type) {
-        case ACPI_MEMORY_RANGE:
-                len = ext_addr->address.maximum - ext_addr->address.minimum + 1;
-                res->flags = acpi_dev_memresource_flags(len,
-                                        ext_addr->info.mem.write_protect,
-                                        window);
-                break;
-        case ACPI_IO_RANGE:
-                io_decode = ext_addr->address.granularity == 0xfff ?
-                                ACPI_DECODE_10 : ACPI_DECODE_16;
-                res->flags = acpi_dev_ioresource_flags(ext_addr->address.minimum,
-                                                       ext_addr->address.maximum,
-                                                       io_decode, window);
-                break;
-        case ACPI_BUS_NUMBER_RANGE:
-                res->flags = IORESOURCE_BUS;
-                break;
-        default:
-                res->flags = 0;
-        }
-
-        return true;
+        return acpi_decode_space(win, (struct acpi_resource_address *)ext_addr,
+                                 &ext_addr->address);
 }
 EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space);
 
@@ -310,7 +333,7 @@ static void acpi_dev_irqresource_disabled(struct resource *res, u32 gsi)
 {
         res->start = gsi;
         res->end = gsi;
-        res->flags = IORESOURCE_IRQ | IORESOURCE_DISABLED;
+        res->flags = IORESOURCE_IRQ | IORESOURCE_DISABLED | IORESOURCE_UNSET;
 }
 
 static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
@@ -369,6 +392,11 @@ static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
  * represented by the resource and populate the generic resource object pointed
  * to by @res accordingly.  If the registration of the GSI is not successful,
  * IORESOURCE_DISABLED will be set it that object's flags.
+ *
+ * Return:
+ * 1) false with res->flags setting to zero: not the expected resource type
+ * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource
+ * 3) true: valid assigned resource
  */
 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
                                  struct resource *res)
@@ -402,6 +430,7 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
                                          ext_irq->sharable, false);
                 break;
         default:
+                res->flags = 0;
                 return false;
         }
 
@@ -415,12 +444,7 @@ EXPORT_SYMBOL_GPL(acpi_dev_resource_interrupt);
  */
 void acpi_dev_free_resource_list(struct list_head *list)
 {
-        struct resource_list_entry *rentry, *re;
-
-        list_for_each_entry_safe(rentry, re, list, node) {
-                list_del(&rentry->node);
-                kfree(rentry);
-        }
+        resource_list_free(list);
 }
 EXPORT_SYMBOL_GPL(acpi_dev_free_resource_list);
 
@@ -432,18 +456,19 @@ struct res_proc_context {
         int error;
 };
 
-static acpi_status acpi_dev_new_resource_entry(struct resource *r,
+static acpi_status acpi_dev_new_resource_entry(struct resource_win *win,
                                                struct res_proc_context *c)
 {
-        struct resource_list_entry *rentry;
+        struct resource_entry *rentry;
 
-        rentry = kmalloc(sizeof(*rentry), GFP_KERNEL);
+        rentry = resource_list_create_entry(NULL, 0);
         if (!rentry) {
                 c->error = -ENOMEM;
                 return AE_NO_MEMORY;
         }
-        rentry->res = *r;
-        list_add_tail(&rentry->node, c->list);
+        *rentry->res = win->res;
+        rentry->offset = win->offset;
+        resource_list_add_tail(rentry, c->list);
         c->count++;
         return AE_OK;
 }
@@ -452,7 +477,8 @@ static acpi_status acpi_dev_process_resource(struct acpi_resource *ares,
                                              void *context)
 {
         struct res_proc_context *c = context;
-        struct resource r;
+        struct resource_win win;
+        struct resource *res = &win.res;
         int i;
 
         if (c->preproc) {
@@ -467,18 +493,18 @@ static acpi_status acpi_dev_process_resource(struct acpi_resource *ares,
                 }
         }
 
-        memset(&r, 0, sizeof(r));
+        memset(&win, 0, sizeof(win));
 
-        if (acpi_dev_resource_memory(ares, &r)
-            || acpi_dev_resource_io(ares, &r)
-            || acpi_dev_resource_address_space(ares, &r)
-            || acpi_dev_resource_ext_address_space(ares, &r))
-                return acpi_dev_new_resource_entry(&r, c);
+        if (acpi_dev_resource_memory(ares, res)
+            || acpi_dev_resource_io(ares, res)
+            || acpi_dev_resource_address_space(ares, &win)
+            || acpi_dev_resource_ext_address_space(ares, &win))
+                return acpi_dev_new_resource_entry(&win, c);
 
-        for (i = 0; acpi_dev_resource_interrupt(ares, i, &r); i++) {
+        for (i = 0; acpi_dev_resource_interrupt(ares, i, res); i++) {
                 acpi_status status;
 
-                status = acpi_dev_new_resource_entry(&r, c);
+                status = acpi_dev_new_resource_entry(&win, c);
                 if (ACPI_FAILURE(status))
                         return status;
         }
@@ -503,7 +529,7 @@ static acpi_status acpi_dev_process_resource(struct acpi_resource *ares,
  * returned as the final error code.
  *
  * The resultant struct resource objects are put on the list pointed to by
- * @list, that must be empty initially, as members of struct resource_list_entry
+ * @list, that must be empty initially, as members of struct resource_entry
  * objects.  Callers of this routine should use %acpi_dev_free_resource_list() to
  * free that list.
  *
@@ -538,3 +564,58 @@ int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
         return c.count;
 }
 EXPORT_SYMBOL_GPL(acpi_dev_get_resources);
+
+/**
+ * acpi_dev_filter_resource_type - Filter ACPI resource according to resource
+ *                                 types
+ * @ares: Input ACPI resource object.
+ * @types: Valid resource types of IORESOURCE_XXX
+ *
+ * This is a hepler function to support acpi_dev_get_resources(), which filters
+ * ACPI resource objects according to resource types.
+ */
+int acpi_dev_filter_resource_type(struct acpi_resource *ares,
+                                  unsigned long types)
+{
+        unsigned long type = 0;
+
+        switch (ares->type) {
+        case ACPI_RESOURCE_TYPE_MEMORY24:
+        case ACPI_RESOURCE_TYPE_MEMORY32:
+        case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
+                type = IORESOURCE_MEM;
+                break;
+        case ACPI_RESOURCE_TYPE_IO:
+        case ACPI_RESOURCE_TYPE_FIXED_IO:
+                type = IORESOURCE_IO;
+                break;
+        case ACPI_RESOURCE_TYPE_IRQ:
+        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
+                type = IORESOURCE_IRQ;
+                break;
+        case ACPI_RESOURCE_TYPE_DMA:
+        case ACPI_RESOURCE_TYPE_FIXED_DMA:
+                type = IORESOURCE_DMA;
+                break;
+        case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
+                type = IORESOURCE_REG;
+                break;
+        case ACPI_RESOURCE_TYPE_ADDRESS16:
+        case ACPI_RESOURCE_TYPE_ADDRESS32:
+        case ACPI_RESOURCE_TYPE_ADDRESS64:
+        case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
+                if (ares->data.address.resource_type == ACPI_MEMORY_RANGE)
+                        type = IORESOURCE_MEM;
+                else if (ares->data.address.resource_type == ACPI_IO_RANGE)
+                        type = IORESOURCE_IO;
+                else if (ares->data.address.resource_type ==
+                         ACPI_BUS_NUMBER_RANGE)
+                        type = IORESOURCE_BUS;
+                break;
+        default:
+                break;
+        }
+
+        return (type & types) ? 0 : 1;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_filter_resource_type);