Patched in Tegra support.

8 files changed, 369 insertions, 171 deletions

diff --git a/drivers/pnp/base.h b/drivers/pnp/base.h
index ffd53e3eb92..fa4e0a5db3f 100644
--- a/drivers/pnp/base.h
+++ b/drivers/pnp/base.h
@@ -159,8 +159,6 @@ 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/interface.c b/drivers/pnp/interface.c
index 0c201317284..cfaf5b73540 100644
--- a/drivers/pnp/interface.c
+++ b/drivers/pnp/interface.c
@@ -298,39 +298,6 @@ static ssize_t pnp_show_current_resources(struct device *dmdev,
         return ret;
 }
 
-static char *pnp_get_resource_value(char *buf,
-                                    unsigned long type,
-                                    resource_size_t *start,
-                                    resource_size_t *end,
-                                    unsigned long *flags)
-{
-        if (start)
-                *start = 0;
-        if (end)
-                *end = 0;
-        if (flags)
-                *flags = 0;
-
-        /* TBD: allow for disabled resources */
-
-        buf = skip_spaces(buf);
-        if (start) {
-                *start = simple_strtoull(buf, &buf, 0);
-                if (end) {
-                        buf = skip_spaces(buf);
-                        if (*buf == '-') {
-                                buf = skip_spaces(buf + 1);
-                                *end = simple_strtoull(buf, &buf, 0);
-                        } else
-                                *end = *start;
-                }
-        }
-
-        /* TBD: allow for additional flags, e.g., IORESOURCE_WINDOW */
-
-        return buf;
-}
-
 static ssize_t pnp_set_current_resources(struct device *dmdev,
                                          struct device_attribute *attr,
                                          const char *ubuf, size_t count)
@@ -338,6 +305,7 @@ static ssize_t pnp_set_current_resources(struct device *dmdev,
         struct pnp_dev *dev = to_pnp_dev(dmdev);
         char *buf = (void *)ubuf;
         int retval = 0;
+        resource_size_t start, end;
 
         if (dev->status & PNP_ATTACHED) {
                 retval = -EBUSY;
@@ -381,10 +349,6 @@ static ssize_t pnp_set_current_resources(struct device *dmdev,
                 goto done;
         }
         if (!strnicmp(buf, "set", 3)) {
-                resource_size_t start;
-                resource_size_t end;
-                unsigned long flags;
-
                 if (dev->active)
                         goto done;
                 buf += 3;
@@ -393,37 +357,42 @@ static ssize_t pnp_set_current_resources(struct device *dmdev,
                 while (1) {
                         buf = skip_spaces(buf);
                         if (!strnicmp(buf, "io", 2)) {
-                                buf = pnp_get_resource_value(buf + 2,
-                                                             IORESOURCE_IO,
-                                                             &start, &end,
-                                                             &flags);
-                                pnp_add_io_resource(dev, start, end, flags);
-                        } else if (!strnicmp(buf, "mem", 3)) {
-                                buf = pnp_get_resource_value(buf + 3,
-                                                             IORESOURCE_MEM,
-                                                             &start, &end,
-                                                             &flags);
-                                pnp_add_mem_resource(dev, start, end, flags);
-                        } else if (!strnicmp(buf, "irq", 3)) {
-                                buf = pnp_get_resource_value(buf + 3,
-                                                             IORESOURCE_IRQ,
-                                                             &start, NULL,
-                                                             &flags);
-                                pnp_add_irq_resource(dev, start, flags);
-                        } else if (!strnicmp(buf, "dma", 3)) {
-                                buf = pnp_get_resource_value(buf + 3,
-                                                             IORESOURCE_DMA,
-                                                             &start, NULL,
-                                                             &flags);
-                                pnp_add_dma_resource(dev, start, flags);
-                        } else if (!strnicmp(buf, "bus", 3)) {
-                                buf = pnp_get_resource_value(buf + 3,
-                                                             IORESOURCE_BUS,
-                                                             &start, &end,
-                                                             NULL);
-                                pnp_add_bus_resource(dev, start, end);
-                        } else
-                                break;
+                                buf = skip_spaces(buf + 2);
+                                start = simple_strtoul(buf, &buf, 0);
+                                buf = skip_spaces(buf);
+                                if (*buf == '-') {
+                                        buf = skip_spaces(buf + 1);
+                                        end = simple_strtoul(buf, &buf, 0);
+                                } else
+                                        end = start;
+                                pnp_add_io_resource(dev, start, end, 0);
+                                continue;
+                        }
+                        if (!strnicmp(buf, "mem", 3)) {
+                                buf = skip_spaces(buf + 3);
+                                start = simple_strtoul(buf, &buf, 0);
+                                buf = skip_spaces(buf);
+                                if (*buf == '-') {
+                                        buf = skip_spaces(buf + 1);
+                                        end = simple_strtoul(buf, &buf, 0);
+                                } else
+                                        end = start;
+                                pnp_add_mem_resource(dev, start, end, 0);
+                                continue;
+                        }
+                        if (!strnicmp(buf, "irq", 3)) {
+                                buf = skip_spaces(buf + 3);
+                                start = simple_strtoul(buf, &buf, 0);
+                                pnp_add_irq_resource(dev, start, 0);
+                                continue;
+                        }
+                        if (!strnicmp(buf, "dma", 3)) {
+                                buf = skip_spaces(buf + 3);
+                                start = simple_strtoul(buf, &buf, 0);
+                                pnp_add_dma_resource(dev, start, 0);
+                                continue;
+                        }
+                        break;
                 }
                 mutex_unlock(&pnp_res_mutex);
                 goto done;
diff --git a/drivers/pnp/manager.c b/drivers/pnp/manager.c
index 95cebf0185d..ed9ce507149 100644
--- a/drivers/pnp/manager.c
+++ b/drivers/pnp/manager.c
@@ -18,27 +18,11 @@
 
 DEFINE_MUTEX(pnp_res_mutex);
 
-static struct resource *pnp_find_resource(struct pnp_dev *dev,
-                                          unsigned char rule,
-                                          unsigned long type,
-                                          unsigned int bar)
-{
-        struct resource *res = pnp_get_resource(dev, type, bar);
-
-        /* when the resource already exists, set its resource bits from rule */
-        if (res) {
-                res->flags &= ~IORESOURCE_BITS;
-                res->flags |= rule & IORESOURCE_BITS;
-        }
-
-        return res;
-}
-
 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
 {
         struct resource *res, local_res;
 
-        res = pnp_find_resource(dev, rule->flags, IORESOURCE_IO, idx);
+        res = pnp_get_resource(dev, IORESOURCE_IO, idx);
         if (res) {
                 pnp_dbg(&dev->dev, "  io %d already set to %#llx-%#llx "
                         "flags %#lx\n", idx, (unsigned long long) res->start,
@@ -81,7 +65,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
 {
         struct resource *res, local_res;
 
-        res = pnp_find_resource(dev, rule->flags, IORESOURCE_MEM, idx);
+        res = pnp_get_resource(dev, IORESOURCE_MEM, idx);
         if (res) {
                 pnp_dbg(&dev->dev, "  mem %d already set to %#llx-%#llx "
                         "flags %#lx\n", idx, (unsigned long long) res->start,
@@ -94,7 +78,6 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
         res->start = 0;
         res->end = 0;
 
-        /* ??? rule->flags restricted to 8 bits, all tests bogus ??? */
         if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
                 res->flags |= IORESOURCE_READONLY;
         if (rule->flags & IORESOURCE_MEM_CACHEABLE)
@@ -140,7 +123,7 @@ static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
                 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
         };
 
-        res = pnp_find_resource(dev, rule->flags, IORESOURCE_IRQ, idx);
+        res = pnp_get_resource(dev, IORESOURCE_IRQ, idx);
         if (res) {
                 pnp_dbg(&dev->dev, "  irq %d already set to %d flags %#lx\n",
                         idx, (int) res->start, res->flags);
@@ -199,7 +182,7 @@ static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
                 1, 3, 5, 6, 7, 0, 2, 4
         };
 
-        res = pnp_find_resource(dev, rule->flags, IORESOURCE_DMA, idx);
+        res = pnp_get_resource(dev, IORESOURCE_DMA, idx);
         if (res) {
                 pnp_dbg(&dev->dev, "  dma %d already set to %d flags %#lx\n",
                         idx, (int) res->start, res->flags);
diff --git a/drivers/pnp/pnpacpi/core.c b/drivers/pnp/pnpacpi/core.c
index 72e822e17d4..ca84d5099ce 100644
--- a/drivers/pnp/pnpacpi/core.c
+++ b/drivers/pnp/pnpacpi/core.c
@@ -19,7 +19,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include <linux/export.h>
 #include <linux/acpi.h>
 #include <linux/pnp.h>
 #include <linux/slab.h>
@@ -58,7 +57,7 @@ static inline int __init is_exclusive_device(struct acpi_device *dev)
         if (!(('0' <= (c) && (c) <= '9') || ('A' <= (c) && (c) <= 'F'))) \
                 return 0
 #define TEST_ALPHA(c) \
-        if (!('A' <= (c) && (c) <= 'Z')) \
+        if (!('@' <= (c) || (c) <= 'Z')) \
                 return 0
 static int __init ispnpidacpi(const char *id)
 {
@@ -95,9 +94,6 @@ static int pnpacpi_set_resources(struct pnp_dev *dev)
                 return -ENODEV;
         }
 
-        if (WARN_ON_ONCE(acpi_dev != dev->data))
-                dev->data = acpi_dev;
-
         ret = pnpacpi_build_resource_template(dev, &buffer);
         if (ret)
                 return ret;
@@ -173,8 +169,8 @@ static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state)
         }
 
         if (acpi_bus_power_manageable(handle)) {
-                int power_state = acpi_pm_device_sleep_state(&dev->dev, NULL,
-                                                             ACPI_STATE_D3);
+                int power_state = acpi_pm_device_sleep_state(&dev->dev, NULL);
+
                 if (power_state < 0)
                         power_state = (state.event == PM_EVENT_ON) ?
                                         ACPI_STATE_D0 : ACPI_STATE_D3;
@@ -245,10 +241,6 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
         char *pnpid;
         struct acpi_hardware_id *id;
 
-        /* Skip devices that are already bound */
-        if (device->physical_node_count)
-                return 0;
-
         /*
          * If a PnPacpi device is not present , the device
          * driver should not be loaded.
@@ -330,7 +322,7 @@ static int __init acpi_pnp_match(struct device *dev, void *_pnp)
         struct pnp_dev *pnp = _pnp;
 
         /* true means it matched */
-        return !acpi->physical_node_count
+        return !acpi_get_physical_device(acpi->handle)
             && compare_pnp_id(pnp->id, acpi_device_hid(acpi));
 }
 
diff --git a/drivers/pnp/pnpacpi/rsparser.c b/drivers/pnp/pnpacpi/rsparser.c
index b8f4ea7b27f..bbf3edd85be 100644
--- a/drivers/pnp/pnpacpi/rsparser.c
+++ b/drivers/pnp/pnpacpi/rsparser.c
@@ -28,6 +28,37 @@
 #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)
 {
@@ -63,6 +94,45 @@ 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)
 {
@@ -107,16 +177,21 @@ static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
         return flags;
 }
 
-/*
- * Allocated Resources
- */
-
-static void pnpacpi_add_irqresource(struct pnp_dev *dev, struct resource *r)
+static void pnpacpi_parse_allocated_ioresource(struct pnp_dev *dev, u64 start,
+                                               u64 len, int io_decode,
+                                               int window)
 {
-        if (!(r->flags & IORESOURCE_DISABLED))
-                pcibios_penalize_isa_irq(r->start, 1);
+        int flags = 0;
+        u64 end = start + len - 1;
+
+        if (io_decode == ACPI_DECODE_16)
+                flags |= IORESOURCE_IO_16BIT_ADDR;
+        if (len == 0 || end >= 0x10003)
+                flags |= IORESOURCE_DISABLED;
+        if (window)
+                flags |= IORESOURCE_WINDOW;
 
-        pnp_add_resource(dev, r);
+        pnp_add_io_resource(dev, start, end, flags);
 }
 
 /*
@@ -174,49 +249,130 @@ 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 resource r;
+        struct acpi_resource_memory24 *memory24;
+        struct acpi_resource_memory32 *memory32;
+        struct acpi_resource_fixed_memory32 *fixed_memory32;
+        struct acpi_resource_extended_irq *extended_irq;
         int i, flags;
 
-        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);
+        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 (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)) {
+                        if (pnp_can_write(dev) && irq->interrupt_count > 1) {
                                 dev_warn(&dev->dev, "multiple interrupts in "
                                          "_CRS descriptor; configuration can't "
                                          "be changed\n");
                                 dev->capabilities &= ~PNP_WRITE;
                         }
                 }
-                return AE_OK;
-        } else if (r.flags & IORESOURCE_DISABLED) {
-                pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
-                return AE_OK;
-        }
+                break;
 
-        switch (res->type) {
         case ACPI_RESOURCE_TYPE_DMA:
                 dma = &res->data.dma;
                 if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
@@ -227,10 +383,26 @@ 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);
@@ -239,6 +411,66 @@ 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;
 
@@ -277,12 +509,15 @@ static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev,
                                             struct acpi_resource_dma *p)
 {
         int i;
-        unsigned char map = 0, flags;
+        unsigned char map = 0, flags = 0;
+
+        if (p->channel_count == 0)
+                flags |= IORESOURCE_DISABLED;
 
         for (i = 0; i < p->channel_count; i++)
                 map |= 1 << p->channels[i];
 
-        flags = dma_flags(dev, p->type, p->bus_master, p->transfer);
+        flags |= dma_flags(dev, p->type, p->bus_master, p->transfer);
         pnp_register_dma_resource(dev, option_flags, map, flags);
 }
 
@@ -292,14 +527,17 @@ static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
 {
         int i;
         pnp_irq_mask_t map;
-        unsigned char flags;
+        unsigned char flags = 0;
+
+        if (p->interrupt_count == 0)
+                flags |= IORESOURCE_DISABLED;
 
         bitmap_zero(map.bits, PNP_IRQ_NR);
         for (i = 0; i < p->interrupt_count; i++)
                 if (p->interrupts[i])
                         __set_bit(p->interrupts[i], map.bits);
 
-        flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
+        flags |= irq_flags(p->triggering, p->polarity, p->sharable);
         pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
@@ -309,7 +547,10 @@ static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
 {
         int i;
         pnp_irq_mask_t map;
-        unsigned char flags;
+        unsigned char flags = 0;
+
+        if (p->interrupt_count == 0)
+                flags |= IORESOURCE_DISABLED;
 
         bitmap_zero(map.bits, PNP_IRQ_NR);
         for (i = 0; i < p->interrupt_count; i++) {
@@ -323,7 +564,7 @@ static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
                 }
         }
 
-        flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
+        flags |= irq_flags(p->triggering, p->polarity, p->sharable);
         pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
@@ -333,8 +574,11 @@ static __init void pnpacpi_parse_port_option(struct pnp_dev *dev,
 {
         unsigned char flags = 0;
 
+        if (io->address_length == 0)
+                flags |= IORESOURCE_DISABLED;
+
         if (io->io_decode == ACPI_DECODE_16)
-                flags = IORESOURCE_IO_16BIT_ADDR;
+                flags |= IORESOURCE_IO_16BIT_ADDR;
         pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum,
                                    io->alignment, io->address_length, flags);
 }
@@ -343,8 +587,13 @@ static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev,
                                         unsigned int option_flags,
                                         struct acpi_resource_fixed_io *io)
 {
+        unsigned char flags = 0;
+
+        if (io->address_length == 0)
+                flags |= IORESOURCE_DISABLED;
+
         pnp_register_port_resource(dev, option_flags, io->address, io->address,
-                                   0, io->address_length, IORESOURCE_IO_FIXED);
+                                   0, io->address_length, flags | IORESOURCE_IO_FIXED);
 }
 
 static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
@@ -353,8 +602,11 @@ static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
 {
         unsigned char flags = 0;
 
+        if (p->address_length == 0)
+                flags |= IORESOURCE_DISABLED;
+
         if (p->write_protect == ACPI_READ_WRITE_MEMORY)
-                flags = IORESOURCE_MEM_WRITEABLE;
+                flags |= IORESOURCE_MEM_WRITEABLE;
         pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
                                   p->alignment, p->address_length, flags);
 }
@@ -365,8 +617,11 @@ static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev,
 {
         unsigned char flags = 0;
 
+        if (p->address_length == 0)
+                flags |= IORESOURCE_DISABLED;
+
         if (p->write_protect == ACPI_READ_WRITE_MEMORY)
-                flags = IORESOURCE_MEM_WRITEABLE;
+                flags |= IORESOURCE_MEM_WRITEABLE;
         pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
                                   p->alignment, p->address_length, flags);
 }
@@ -377,8 +632,11 @@ static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev,
 {
         unsigned char flags = 0;
 
+        if (p->address_length == 0)
+                flags |= IORESOURCE_DISABLED;
+
         if (p->write_protect == ACPI_READ_WRITE_MEMORY)
-                flags = IORESOURCE_MEM_WRITEABLE;
+                flags |= IORESOURCE_MEM_WRITEABLE;
         pnp_register_mem_resource(dev, option_flags, p->address, p->address,
                                   0, p->address_length, flags);
 }
@@ -398,16 +656,19 @@ static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
                 return;
         }
 
+        if (p->address_length == 0)
+                flags |= IORESOURCE_DISABLED;
+
         if (p->resource_type == ACPI_MEMORY_RANGE) {
                 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
-                        flags = IORESOURCE_MEM_WRITEABLE;
+                        flags |= IORESOURCE_MEM_WRITEABLE;
                 pnp_register_mem_resource(dev, option_flags, p->minimum,
                                           p->minimum, 0, p->address_length,
                                           flags);
         } else if (p->resource_type == ACPI_IO_RANGE)
                 pnp_register_port_resource(dev, option_flags, p->minimum,
                                            p->minimum, 0, p->address_length,
-                                           IORESOURCE_IO_FIXED);
+                                           flags | IORESOURCE_IO_FIXED);
 }
 
 static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
@@ -417,16 +678,19 @@ static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
         struct acpi_resource_extended_address64 *p = &r->data.ext_address64;
         unsigned char flags = 0;
 
+        if (p->address_length == 0)
+                flags |= IORESOURCE_DISABLED;
+
         if (p->resource_type == ACPI_MEMORY_RANGE) {
                 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
-                        flags = IORESOURCE_MEM_WRITEABLE;
+                        flags |= IORESOURCE_MEM_WRITEABLE;
                 pnp_register_mem_resource(dev, option_flags, p->minimum,
                                           p->minimum, 0, p->address_length,
                                           flags);
         } else if (p->resource_type == ACPI_IO_RANGE)
                 pnp_register_port_resource(dev, option_flags, p->minimum,
                                            p->minimum, 0, p->address_length,
-                                           IORESOURCE_IO_FIXED);
+                                           flags | IORESOURCE_IO_FIXED);
 }
 
 struct acpipnp_parse_option_s {
diff --git a/drivers/pnp/pnpbios/bioscalls.c b/drivers/pnp/pnpbios/bioscalls.c
index 769d265b221..b859d16cf78 100644
--- a/drivers/pnp/pnpbios/bioscalls.c
+++ b/drivers/pnp/pnpbios/bioscalls.c
@@ -17,6 +17,7 @@
 
 #include <asm/page.h>
 #include <asm/desc.h>
+#include <asm/system.h>
 #include <asm/byteorder.h>
 
 #include "pnpbios.h"
diff --git a/drivers/pnp/pnpbios/core.c b/drivers/pnp/pnpbios/core.c
index 5d66e5585f9..cfe86853feb 100644
--- a/drivers/pnp/pnpbios/core.c
+++ b/drivers/pnp/pnpbios/core.c
@@ -65,6 +65,7 @@
 
 #include <asm/page.h>
 #include <asm/desc.h>
+#include <asm/system.h>
 #include <asm/byteorder.h>
 
 #include "../base.h"
@@ -91,6 +92,8 @@ struct pnp_dev_node_info node_info;
  *
  */
 
+#ifdef CONFIG_HOTPLUG
+
 static struct completion unload_sem;
 
 /*
@@ -197,6 +200,8 @@ static int pnp_dock_thread(void *unused)
         complete_and_exit(&unload_sem, 0);
 }
 
+#endif                          /* CONFIG_HOTPLUG */
+
 static int pnpbios_get_resources(struct pnp_dev *dev)
 {
         u8 nodenum = dev->number;
@@ -569,19 +574,21 @@ fs_initcall(pnpbios_init);
 
 static int __init pnpbios_thread_init(void)
 {
-        struct task_struct *task;
 #if defined(CONFIG_PPC)
         if (check_legacy_ioport(PNPBIOS_BASE))
                 return 0;
 #endif
         if (pnpbios_disabled)
                 return 0;
-
-        init_completion(&unload_sem);
-        task = kthread_run(pnp_dock_thread, NULL, "kpnpbiosd");
-        if (IS_ERR(task))
-                return PTR_ERR(task);
-
+#ifdef CONFIG_HOTPLUG
+        {
+                struct task_struct *task;
+                init_completion(&unload_sem);
+                task = kthread_run(pnp_dock_thread, NULL, "kpnpbiosd");
+                if (IS_ERR(task))
+                        return PTR_ERR(task);
+        }
+#endif
         return 0;
 }
 
diff --git a/drivers/pnp/resource.c b/drivers/pnp/resource.c
index 3e6db1c1dc2..b0ecacbe53b 100644
--- a/drivers/pnp/resource.c
+++ b/drivers/pnp/resource.c
@@ -503,22 +503,6 @@ 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)
 {