ACPI: Move device resources interpretation code from PNP to ACPI core

Move some code used for parsing ACPI device resources from the PNP
subsystem to the ACPI core, so that other bus types (platform, SPI,
I2C) can use the same routines for parsing resources in a consistent
way, without duplicating code.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com>

6 files changed, 454 insertions, 264 deletions

diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 227c82bbe9a1..3223edfb23b6 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -32,6 +32,7 @@ acpi-$(CONFIG_ACPI_SLEEP)	+= proc.o
 #
 acpi-y                          += bus.o glue.o
 acpi-y                          += scan.o
+acpi-y                          += resource.o
 acpi-y                          += processor_core.o
 acpi-y                          += ec.o
 acpi-$(CONFIG_ACPI_DOCK)        += dock.o
diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
new file mode 100644
index 000000000000..3e7fd349e29d
--- /dev/null
+++ b/drivers/acpi/resource.c
@@ -0,0 +1,393 @@
+/*
+ * drivers/acpi/resource.c - ACPI device resources interpretation.
+ *
+ * Copyright (C) 2012, Intel Corp.
+ * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  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.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#include <linux/acpi.h>
+#include <linux/device.h>
+#include <linux/export.h>
+#include <linux/ioport.h>
+
+#ifdef CONFIG_X86
+#define valid_IRQ(i) (((i) != 0) && ((i) != 2))
+#else
+#define valid_IRQ(i) (true)
+#endif
+
+static unsigned long acpi_dev_memresource_flags(u64 len, u8 write_protect,
+                                                bool window)
+{
+        unsigned long flags = IORESOURCE_MEM;
+
+        if (len == 0)
+                flags |= IORESOURCE_DISABLED;
+
+        if (write_protect == ACPI_READ_WRITE_MEMORY)
+                flags |= IORESOURCE_MEM_WRITEABLE;
+
+        if (window)
+                flags |= IORESOURCE_WINDOW;
+
+        return flags;
+}
+
+static void acpi_dev_get_memresource(struct resource *res, u64 start, u64 len,
+                                     u8 write_protect)
+{
+        res->start = start;
+        res->end = start + len - 1;
+        res->flags = acpi_dev_memresource_flags(len, write_protect, false);
+}
+
+/**
+ * acpi_dev_resource_memory - Extract ACPI memory resource information.
+ * @ares: Input ACPI resource object.
+ * @res: Output generic resource object.
+ *
+ * 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.
+ */
+bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res)
+{
+        struct acpi_resource_memory24 *memory24;
+        struct acpi_resource_memory32 *memory32;
+        struct acpi_resource_fixed_memory32 *fixed_memory32;
+
+        switch (ares->type) {
+        case ACPI_RESOURCE_TYPE_MEMORY24:
+                memory24 = &ares->data.memory24;
+                acpi_dev_get_memresource(res, memory24->minimum,
+                                         memory24->address_length,
+                                         memory24->write_protect);
+                break;
+        case ACPI_RESOURCE_TYPE_MEMORY32:
+                memory32 = &ares->data.memory32;
+                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;
+                acpi_dev_get_memresource(res, fixed_memory32->address,
+                                         fixed_memory32->address_length,
+                                         fixed_memory32->write_protect);
+                break;
+        default:
+                return false;
+        }
+        return true;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_resource_memory);
+
+static unsigned int acpi_dev_ioresource_flags(u64 start, u64 end, u8 io_decode,
+                                              bool window)
+{
+        int flags = IORESOURCE_IO;
+
+        if (io_decode == ACPI_DECODE_16)
+                flags |= IORESOURCE_IO_16BIT_ADDR;
+
+        if (start > end || end >= 0x10003)
+                flags |= IORESOURCE_DISABLED;
+
+        if (window)
+                flags |= IORESOURCE_WINDOW;
+
+        return flags;
+}
+
+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);
+}
+
+/**
+ * acpi_dev_resource_io - Extract ACPI I/O resource information.
+ * @ares: Input ACPI resource object.
+ * @res: Output generic resource object.
+ *
+ * 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.
+ */
+bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res)
+{
+        struct acpi_resource_io *io;
+        struct acpi_resource_fixed_io *fixed_io;
+
+        switch (ares->type) {
+        case ACPI_RESOURCE_TYPE_IO:
+                io = &ares->data.io;
+                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;
+                acpi_dev_get_ioresource(res, fixed_io->address,
+                                        fixed_io->address_length,
+                                        ACPI_DECODE_10);
+                break;
+        default:
+                return false;
+        }
+        return true;
+}
+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)
+{
+        acpi_status status;
+        struct acpi_resource_address64 addr;
+        bool window;
+        u64 len;
+        u8 io_decode;
+
+        switch (ares->type) {
+        case ACPI_RESOURCE_TYPE_ADDRESS16:
+        case ACPI_RESOURCE_TYPE_ADDRESS32:
+        case ACPI_RESOURCE_TYPE_ADDRESS64:
+                break;
+        default:
+                return false;
+        }
+
+        status = acpi_resource_to_address64(ares, &addr);
+        if (ACPI_FAILURE(status))
+                return true;
+
+        res->start = addr.minimum;
+        res->end = addr.maximum;
+        window = addr.producer_consumer == ACPI_PRODUCER;
+
+        switch(addr.resource_type) {
+        case ACPI_MEMORY_RANGE:
+                len = addr.maximum - addr.minimum + 1;
+                res->flags = acpi_dev_memresource_flags(len,
+                                                addr.info.mem.write_protect,
+                                                window);
+                break;
+        case ACPI_IO_RANGE:
+                io_decode = addr.granularity == 0xfff ?
+                                ACPI_DECODE_10 : ACPI_DECODE_16;
+                res->flags = acpi_dev_ioresource_flags(addr.minimum,
+                                                       addr.maximum,
+                                                       io_decode, window);
+                break;
+        case ACPI_BUS_NUMBER_RANGE:
+                res->flags = IORESOURCE_BUS;
+                break;
+        default:
+                res->flags = 0;
+        }
+
+        return true;
+}
+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.
+ *
+ * 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.
+ */
+bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
+                                         struct resource *res)
+{
+        struct acpi_resource_extended_address64 *ext_addr;
+        bool window;
+        u64 len;
+        u8 io_decode;
+
+        if (ares->type != ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64)
+                return false;
+
+        ext_addr = &ares->data.ext_address64;
+
+        res->start = ext_addr->minimum;
+        res->end = ext_addr->maximum;
+        window = ext_addr->producer_consumer == ACPI_PRODUCER;
+
+        switch(ext_addr->resource_type) {
+        case ACPI_MEMORY_RANGE:
+                len = ext_addr->maximum - ext_addr->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->granularity == 0xfff ?
+                                ACPI_DECODE_10 : ACPI_DECODE_16;
+                res->flags = acpi_dev_ioresource_flags(ext_addr->minimum,
+                                                       ext_addr->maximum,
+                                                       io_decode, window);
+                break;
+        case ACPI_BUS_NUMBER_RANGE:
+                res->flags = IORESOURCE_BUS;
+                break;
+        default:
+                res->flags = 0;
+        }
+
+        return true;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space);
+
+/**
+ * acpi_dev_irq_flags - Determine IRQ resource flags.
+ * @triggering: Triggering type as provided by ACPI.
+ * @polarity: Interrupt polarity as provided by ACPI.
+ * @shareable: Whether or not the interrupt is shareable.
+ */
+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
+{
+        unsigned long flags;
+
+        if (triggering == ACPI_LEVEL_SENSITIVE)
+                flags = polarity == ACPI_ACTIVE_LOW ?
+                        IORESOURCE_IRQ_LOWLEVEL : IORESOURCE_IRQ_HIGHLEVEL;
+        else
+                flags = polarity == ACPI_ACTIVE_LOW ?
+                        IORESOURCE_IRQ_LOWEDGE : IORESOURCE_IRQ_HIGHEDGE;
+
+        if (shareable == ACPI_SHARED)
+                flags |= IORESOURCE_IRQ_SHAREABLE;
+
+        return flags | IORESOURCE_IRQ;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_irq_flags);
+
+static void acpi_dev_irqresource_disabled(struct resource *res, u32 gsi)
+{
+        res->start = gsi;
+        res->end = gsi;
+        res->flags = IORESOURCE_IRQ | IORESOURCE_DISABLED;
+}
+
+static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
+                                     u8 triggering, u8 polarity, u8 shareable)
+{
+        int irq, p, t;
+
+        if (!valid_IRQ(gsi)) {
+                acpi_dev_irqresource_disabled(res, gsi);
+                return;
+        }
+
+        /*
+         * In IO-APIC mode, use overrided attribute. Two reasons:
+         * 1. BIOS bug in DSDT
+         * 2. BIOS uses IO-APIC mode Interrupt Source Override
+         */
+        if (!acpi_get_override_irq(gsi, &t, &p)) {
+                u8 trig = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
+                u8 pol = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
+
+                if (triggering != trig || polarity != pol) {
+                        pr_warning("ACPI: IRQ %d override to %s, %s\n", gsi,
+                                   t ? "edge" : "level", p ? "low" : "high");
+                        triggering = trig;
+                        polarity = pol;
+                }
+        }
+
+        res->flags = acpi_dev_irq_flags(triggering, polarity, shareable);
+        irq = acpi_register_gsi(NULL, gsi, triggering, polarity);
+        if (irq >= 0) {
+                res->start = irq;
+                res->end = irq;
+        } else {
+                acpi_dev_irqresource_disabled(res, gsi);
+        }
+}
+
+/**
+ * acpi_dev_resource_interrupt - Extract ACPI interrupt resource information.
+ * @ares: Input ACPI resource object.
+ * @index: Index into the array of GSIs represented by the resource.
+ * @res: Output generic resource object.
+ *
+ * Check if the given ACPI resource object represents an interrupt resource
+ * and @index does not exceed the resource's interrupt count (true is returned
+ * in that case regardless of the results of the other checks)).  If that's the
+ * case, register the GSI corresponding to @index from the array of interrupts
+ * 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.
+ */
+bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
+                                 struct resource *res)
+{
+        struct acpi_resource_irq *irq;
+        struct acpi_resource_extended_irq *ext_irq;
+
+        switch (ares->type) {
+        case ACPI_RESOURCE_TYPE_IRQ:
+                /*
+                 * Per spec, only one interrupt per descriptor is allowed in
+                 * _CRS, but some firmware violates this, so parse them all.
+                 */
+                irq = &ares->data.irq;
+                if (index >= irq->interrupt_count) {
+                        acpi_dev_irqresource_disabled(res, 0);
+                        return false;
+                }
+                acpi_dev_get_irqresource(res, irq->interrupts[index],
+                                         irq->triggering, irq->polarity,
+                                         irq->sharable);
+                break;
+        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
+                ext_irq = &ares->data.extended_irq;
+                if (index >= ext_irq->interrupt_count) {
+                        acpi_dev_irqresource_disabled(res, 0);
+                        return false;
+                }
+                acpi_dev_get_irqresource(res, ext_irq->interrupts[index],
+                                         ext_irq->triggering, ext_irq->polarity,
+                                         ext_irq->sharable);
+                break;
+        default:
+                return false;
+        }
+
+        return true;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_resource_interrupt);
diff --git a/drivers/pnp/base.h b/drivers/pnp/base.h
index fa4e0a5db3f8..ffd53e3eb92f 100644
--- a/drivers/pnp/base.h
+++ b/drivers/pnp/base.h
@@ -159,6 +159,8 @@ struct pnp_resource {
 
 void pnp_free_resource(struct pnp_resource *pnp_res);
 
+struct pnp_resource *pnp_add_resource(struct pnp_dev *dev,
+                                      struct resource *res);
 struct pnp_resource *pnp_add_irq_resource(struct pnp_dev *dev, int irq,
                                           int flags);
 struct pnp_resource *pnp_add_dma_resource(struct pnp_dev *dev, int dma,
diff --git a/drivers/pnp/pnpacpi/rsparser.c b/drivers/pnp/pnpacpi/rsparser.c
index 5be4a392a3ae..b8f4ea7b27fc 100644
--- a/drivers/pnp/pnpacpi/rsparser.c
+++ b/drivers/pnp/pnpacpi/rsparser.c
@@ -28,37 +28,6 @@
 #include "../base.h"
 #include "pnpacpi.h"
 
-#ifdef CONFIG_IA64
-#define valid_IRQ(i) (1)
-#else
-#define valid_IRQ(i) (((i) != 0) && ((i) != 2))
-#endif
-
-/*
- * Allocated Resources
- */
-static int irq_flags(int triggering, int polarity, int shareable)
-{
-        int flags;
-
-        if (triggering == ACPI_LEVEL_SENSITIVE) {
-                if (polarity == ACPI_ACTIVE_LOW)
-                        flags = IORESOURCE_IRQ_LOWLEVEL;
-                else
-                        flags = IORESOURCE_IRQ_HIGHLEVEL;
-        } else {
-                if (polarity == ACPI_ACTIVE_LOW)
-                        flags = IORESOURCE_IRQ_LOWEDGE;
-                else
-                        flags = IORESOURCE_IRQ_HIGHEDGE;
-        }
-
-        if (shareable == ACPI_SHARED)
-                flags |= IORESOURCE_IRQ_SHAREABLE;
-
-        return flags;
-}
-
 static void decode_irq_flags(struct pnp_dev *dev, int flags, int *triggering,
                              int *polarity, int *shareable)
 {
@@ -94,45 +63,6 @@ static void decode_irq_flags(struct pnp_dev *dev, int flags, int *triggering,
                 *shareable = ACPI_EXCLUSIVE;
 }
 
-static void pnpacpi_parse_allocated_irqresource(struct pnp_dev *dev,
-                                                u32 gsi, int triggering,
-                                                int polarity, int shareable)
-{
-        int irq, flags;
-        int p, t;
-
-        if (!valid_IRQ(gsi)) {
-                pnp_add_irq_resource(dev, gsi, IORESOURCE_DISABLED);
-                return;
-        }
-
-        /*
-         * in IO-APIC mode, use overrided attribute. Two reasons:
-         * 1. BIOS bug in DSDT
-         * 2. BIOS uses IO-APIC mode Interrupt Source Override
-         */
-        if (!acpi_get_override_irq(gsi, &t, &p)) {
-                t = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
-                p = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
-
-                if (triggering != t || polarity != p) {
-                        dev_warn(&dev->dev, "IRQ %d override to %s, %s\n",
-                                gsi, t ? "edge":"level", p ? "low":"high");
-                        triggering = t;
-                        polarity = p;
-                }
-        }
-
-        flags = irq_flags(triggering, polarity, shareable);
-        irq = acpi_register_gsi(&dev->dev, gsi, triggering, polarity);
-        if (irq >= 0)
-                pcibios_penalize_isa_irq(irq, 1);
-        else
-                flags |= IORESOURCE_DISABLED;
-
-        pnp_add_irq_resource(dev, irq, flags);
-}
-
 static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
                      int transfer)
 {
@@ -177,21 +107,16 @@ static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
         return flags;
 }
 
-static void pnpacpi_parse_allocated_ioresource(struct pnp_dev *dev, u64 start,
-                                               u64 len, int io_decode,
-                                               int window)
-{
-        int flags = 0;
-        u64 end = start + len - 1;
+/*
+ * Allocated Resources
+ */
 
-        if (io_decode == ACPI_DECODE_16)
-                flags |= IORESOURCE_IO_16BIT_ADDR;
-        if (len == 0 || end >= 0x10003)
-                flags |= IORESOURCE_DISABLED;
-        if (window)
-                flags |= IORESOURCE_WINDOW;
+static void pnpacpi_add_irqresource(struct pnp_dev *dev, struct resource *r)
+{
+        if (!(r->flags & IORESOURCE_DISABLED))
+                pcibios_penalize_isa_irq(r->start, 1);
 
-        pnp_add_io_resource(dev, start, end, flags);
+        pnp_add_resource(dev, r);
 }
 
 /*
@@ -249,130 +174,49 @@ static void pnpacpi_parse_allocated_vendor(struct pnp_dev *dev,
         }
 }
 
-static void pnpacpi_parse_allocated_memresource(struct pnp_dev *dev,
-                                                u64 start, u64 len,
-                                                int write_protect, int window)
-{
-        int flags = 0;
-        u64 end = start + len - 1;
-
-        if (len == 0)
-                flags |= IORESOURCE_DISABLED;
-        if (write_protect == ACPI_READ_WRITE_MEMORY)
-                flags |= IORESOURCE_MEM_WRITEABLE;
-        if (window)
-                flags |= IORESOURCE_WINDOW;
-
-        pnp_add_mem_resource(dev, start, end, flags);
-}
-
-static void pnpacpi_parse_allocated_busresource(struct pnp_dev *dev,
-                                                u64 start, u64 len)
-{
-        u64 end = start + len - 1;
-
-        pnp_add_bus_resource(dev, start, end);
-}
-
-static void pnpacpi_parse_allocated_address_space(struct pnp_dev *dev,
-                                                  struct acpi_resource *res)
-{
-        struct acpi_resource_address64 addr, *p = &addr;
-        acpi_status status;
-        int window;
-        u64 len;
-
-        status = acpi_resource_to_address64(res, p);
-        if (!ACPI_SUCCESS(status)) {
-                dev_warn(&dev->dev, "failed to convert resource type %d\n",
-                         res->type);
-                return;
-        }
-
-        /* Windows apparently computes length rather than using _LEN */
-        len = p->maximum - p->minimum + 1;
-        window = (p->producer_consumer == ACPI_PRODUCER) ? 1 : 0;
-
-        if (p->resource_type == ACPI_MEMORY_RANGE)
-                pnpacpi_parse_allocated_memresource(dev, p->minimum, len,
-                        p->info.mem.write_protect, window);
-        else if (p->resource_type == ACPI_IO_RANGE)
-                pnpacpi_parse_allocated_ioresource(dev, p->minimum, len,
-                        p->granularity == 0xfff ? ACPI_DECODE_10 :
-                                ACPI_DECODE_16, window);
-        else if (p->resource_type == ACPI_BUS_NUMBER_RANGE)
-                pnpacpi_parse_allocated_busresource(dev, p->minimum, len);
-}
-
-static void pnpacpi_parse_allocated_ext_address_space(struct pnp_dev *dev,
-                                                      struct acpi_resource *res)
-{
-        struct acpi_resource_extended_address64 *p = &res->data.ext_address64;
-        int window;
-        u64 len;
-
-        /* Windows apparently computes length rather than using _LEN */
-        len = p->maximum - p->minimum + 1;
-        window = (p->producer_consumer == ACPI_PRODUCER) ? 1 : 0;
-
-        if (p->resource_type == ACPI_MEMORY_RANGE)
-                pnpacpi_parse_allocated_memresource(dev, p->minimum, len,
-                        p->info.mem.write_protect, window);
-        else if (p->resource_type == ACPI_IO_RANGE)
-                pnpacpi_parse_allocated_ioresource(dev, p->minimum, len,
-                        p->granularity == 0xfff ? ACPI_DECODE_10 :
-                                ACPI_DECODE_16, window);
-        else if (p->resource_type == ACPI_BUS_NUMBER_RANGE)
-                pnpacpi_parse_allocated_busresource(dev, p->minimum, len);
-}
-
 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
                                               void *data)
 {
         struct pnp_dev *dev = data;
-        struct acpi_resource_irq *irq;
         struct acpi_resource_dma *dma;
-        struct acpi_resource_io *io;
-        struct acpi_resource_fixed_io *fixed_io;
         struct acpi_resource_vendor_typed *vendor_typed;
-        struct acpi_resource_memory24 *memory24;
-        struct acpi_resource_memory32 *memory32;
-        struct acpi_resource_fixed_memory32 *fixed_memory32;
-        struct acpi_resource_extended_irq *extended_irq;
+        struct resource r;
         int i, flags;
 
-        switch (res->type) {
-        case ACPI_RESOURCE_TYPE_IRQ:
-                /*
-                 * Per spec, only one interrupt per descriptor is allowed in
-                 * _CRS, but some firmware violates this, so parse them all.
-                 */
-                irq = &res->data.irq;
-                if (irq->interrupt_count == 0)
-                        pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
-                else {
-                        for (i = 0; i < irq->interrupt_count; i++) {
-                                pnpacpi_parse_allocated_irqresource(dev,
-                                        irq->interrupts[i],
-                                        irq->triggering,
-                                        irq->polarity,
-                                    irq->sharable);
-                        }
+        if (acpi_dev_resource_memory(res, &r)
+            || acpi_dev_resource_io(res, &r)
+            || acpi_dev_resource_address_space(res, &r)
+            || acpi_dev_resource_ext_address_space(res, &r)) {
+                pnp_add_resource(dev, &r);
+                return AE_OK;
+        }
 
+        r.flags = 0;
+        if (acpi_dev_resource_interrupt(res, 0, &r)) {
+                pnpacpi_add_irqresource(dev, &r);
+                for (i = 1; acpi_dev_resource_interrupt(res, i, &r); i++)
+                        pnpacpi_add_irqresource(dev, &r);
+
+                if (i > 1) {
                         /*
                          * The IRQ encoder puts a single interrupt in each
                          * descriptor, so if a _CRS descriptor has more than
                          * one interrupt, we won't be able to re-encode it.
                          */
-                        if (pnp_can_write(dev) && irq->interrupt_count > 1) {
+                        if (pnp_can_write(dev)) {
                                 dev_warn(&dev->dev, "multiple interrupts in "
                                          "_CRS descriptor; configuration can't "
                                          "be changed\n");
                                 dev->capabilities &= ~PNP_WRITE;
                         }
                 }
-                break;
+                return AE_OK;
+        } else if (r.flags & IORESOURCE_DISABLED) {
+                pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
+                return AE_OK;
+        }
 
+        switch (res->type) {
         case ACPI_RESOURCE_TYPE_DMA:
                 dma = &res->data.dma;
                 if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
@@ -383,26 +227,10 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
                 pnp_add_dma_resource(dev, dma->channels[0], flags);
                 break;
 
-        case ACPI_RESOURCE_TYPE_IO:
-                io = &res->data.io;
-                pnpacpi_parse_allocated_ioresource(dev,
-                        io->minimum,
-                        io->address_length,
-                        io->io_decode, 0);
-                break;
-
         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
                 break;
 
-        case ACPI_RESOURCE_TYPE_FIXED_IO:
-                fixed_io = &res->data.fixed_io;
-                pnpacpi_parse_allocated_ioresource(dev,
-                        fixed_io->address,
-                        fixed_io->address_length,
-                        ACPI_DECODE_10, 0);
-                break;
-
         case ACPI_RESOURCE_TYPE_VENDOR:
                 vendor_typed = &res->data.vendor_typed;
                 pnpacpi_parse_allocated_vendor(dev, vendor_typed);
@@ -411,66 +239,6 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
         case ACPI_RESOURCE_TYPE_END_TAG:
                 break;
 
-        case ACPI_RESOURCE_TYPE_MEMORY24:
-                memory24 = &res->data.memory24;
-                pnpacpi_parse_allocated_memresource(dev,
-                        memory24->minimum,
-                        memory24->address_length,
-                        memory24->write_protect, 0);
-                break;
-        case ACPI_RESOURCE_TYPE_MEMORY32:
-                memory32 = &res->data.memory32;
-                pnpacpi_parse_allocated_memresource(dev,
-                        memory32->minimum,
-                        memory32->address_length,
-                        memory32->write_protect, 0);
-                break;
-        case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
-                fixed_memory32 = &res->data.fixed_memory32;
-                pnpacpi_parse_allocated_memresource(dev,
-                        fixed_memory32->address,
-                        fixed_memory32->address_length,
-                        fixed_memory32->write_protect, 0);
-                break;
-        case ACPI_RESOURCE_TYPE_ADDRESS16:
-        case ACPI_RESOURCE_TYPE_ADDRESS32:
-        case ACPI_RESOURCE_TYPE_ADDRESS64:
-                pnpacpi_parse_allocated_address_space(dev, res);
-                break;
-
-        case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
-                pnpacpi_parse_allocated_ext_address_space(dev, res);
-                break;
-
-        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
-                extended_irq = &res->data.extended_irq;
-
-                if (extended_irq->interrupt_count == 0)
-                        pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
-                else {
-                        for (i = 0; i < extended_irq->interrupt_count; i++) {
-                                pnpacpi_parse_allocated_irqresource(dev,
-                                        extended_irq->interrupts[i],
-                                        extended_irq->triggering,
-                                        extended_irq->polarity,
-                                        extended_irq->sharable);
-                        }
-
-                        /*
-                         * The IRQ encoder puts a single interrupt in each
-                         * descriptor, so if a _CRS descriptor has more than
-                         * one interrupt, we won't be able to re-encode it.
-                         */
-                        if (pnp_can_write(dev) &&
-                            extended_irq->interrupt_count > 1) {
-                                dev_warn(&dev->dev, "multiple interrupts in "
-                                         "_CRS descriptor; configuration can't "
-                                         "be changed\n");
-                                dev->capabilities &= ~PNP_WRITE;
-                        }
-                }
-                break;
-
         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
                 break;
 
@@ -531,7 +299,7 @@ static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
                 if (p->interrupts[i])
                         __set_bit(p->interrupts[i], map.bits);
 
-        flags = irq_flags(p->triggering, p->polarity, p->sharable);
+        flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
         pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
@@ -555,7 +323,7 @@ static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
                 }
         }
 
-        flags = irq_flags(p->triggering, p->polarity, p->sharable);
+        flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
         pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
diff --git a/drivers/pnp/resource.c b/drivers/pnp/resource.c
index b0ecacbe53b1..3e6db1c1dc29 100644
--- a/drivers/pnp/resource.c
+++ b/drivers/pnp/resource.c
@@ -503,6 +503,22 @@ static struct pnp_resource *pnp_new_resource(struct pnp_dev *dev)
         return pnp_res;
 }
 
+struct pnp_resource *pnp_add_resource(struct pnp_dev *dev,
+                                      struct resource *res)
+{
+        struct pnp_resource *pnp_res;
+
+        pnp_res = pnp_new_resource(dev);
+        if (!pnp_res) {
+                dev_err(&dev->dev, "can't add resource %pR\n", res);
+                return NULL;
+        }
+
+        pnp_res->res = *res;
+        dev_dbg(&dev->dev, "%pR\n", res);
+        return pnp_res;
+}
+
 struct pnp_resource *pnp_add_irq_resource(struct pnp_dev *dev, int irq,
                                           int flags)
 {
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 48761cb481db..16fcaf8dad3d 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -251,6 +251,16 @@ extern int pnpacpi_disabled;
 
 #define PXM_INVAL       (-1)
 
+bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res);
+bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res);
+bool acpi_dev_resource_address_space(struct acpi_resource *ares,
+                                     struct resource *res);
+bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
+                                         struct resource *res);
+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
+bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
+                                 struct resource *res);
+
 int acpi_check_resource_conflict(const struct resource *res);
 
 int acpi_check_region(resource_size_t start, resource_size_t n,