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>

1 files changed, 393 insertions, 0 deletions

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);