Auto merge with /home/aegl/GIT/linus

3 files changed, 172 insertions, 30 deletions

diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 72dfd9e7de0f..cda06f88c66e 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -236,9 +236,7 @@ acpi_parse_iosapic (acpi_table_entry_header *header, const unsigned long end)
         if (BAD_MADT_ENTRY(iosapic, end))
                 return -EINVAL;
 
-        iosapic_init(iosapic->address, iosapic->global_irq_base);
-
-        return 0;
+        return iosapic_init(iosapic->address, iosapic->global_irq_base);
 }
 
 
@@ -772,7 +770,7 @@ EXPORT_SYMBOL(acpi_unmap_lsapic);
  
 
 #ifdef CONFIG_ACPI_NUMA
-acpi_status __init
+acpi_status __devinit
 acpi_map_iosapic (acpi_handle handle, u32 depth, void *context, void **ret)
 {
         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
@@ -825,4 +823,28 @@ acpi_map_iosapic (acpi_handle handle, u32 depth, void *context, void **ret)
         return AE_OK;
 }
 #endif /* CONFIG_NUMA */
+
+int
+acpi_register_ioapic (acpi_handle handle, u64 phys_addr, u32 gsi_base)
+{
+        int err;
+
+        if ((err = iosapic_init(phys_addr, gsi_base)))
+                return err;
+
+#if CONFIG_ACPI_NUMA
+        acpi_map_iosapic(handle, 0, NULL, NULL);
+#endif /* CONFIG_ACPI_NUMA */
+
+        return 0;
+}
+EXPORT_SYMBOL(acpi_register_ioapic);
+
+int
+acpi_unregister_ioapic (acpi_handle handle, u32 gsi_base)
+{
+        return iosapic_remove(gsi_base);
+}
+EXPORT_SYMBOL(acpi_unregister_ioapic);
+
 #endif /* CONFIG_ACPI_BOOT */
diff --git a/arch/ia64/kernel/iosapic.c b/arch/ia64/kernel/iosapic.c
index 88b014381df5..c170be095ccd 100644
--- a/arch/ia64/kernel/iosapic.c
+++ b/arch/ia64/kernel/iosapic.c
@@ -129,14 +129,13 @@ static struct iosapic {
         char __iomem    *addr;          /* base address of IOSAPIC */
         unsigned int    gsi_base;       /* first GSI assigned to this IOSAPIC */
         unsigned short  num_rte;        /* number of RTE in this IOSAPIC */
+        int             rtes_inuse;     /* # of RTEs in use on this IOSAPIC */
 #ifdef CONFIG_NUMA
         unsigned short  node;           /* numa node association via pxm */
 #endif
 } iosapic_lists[NR_IOSAPICS];
 
-static int num_iosapic;
-
-static unsigned char pcat_compat __initdata;    /* 8259 compatibility flag */
+static unsigned char pcat_compat __devinitdata; /* 8259 compatibility flag */
 
 static int iosapic_kmalloc_ok;
 static LIST_HEAD(free_rte_list);
@@ -149,7 +148,7 @@ find_iosapic (unsigned int gsi)
 {
         int i;
 
-        for (i = 0; i < num_iosapic; i++) {
+        for (i = 0; i < NR_IOSAPICS; i++) {
                 if ((unsigned) (gsi - iosapic_lists[i].gsi_base) < iosapic_lists[i].num_rte)
                         return i;
         }
@@ -598,6 +597,7 @@ register_intr (unsigned int gsi, int vector, unsigned char delivery,
                 rte->refcnt++;
                 list_add_tail(&rte->rte_list, &iosapic_intr_info[vector].rtes);
                 iosapic_intr_info[vector].count++;
+                iosapic_lists[index].rtes_inuse++;
         }
         else if (vector_is_shared(vector)) {
                 struct iosapic_intr_info *info = &iosapic_intr_info[vector];
@@ -778,7 +778,7 @@ void
 iosapic_unregister_intr (unsigned int gsi)
 {
         unsigned long flags;
-        int irq, vector;
+        int irq, vector, index;
         irq_desc_t *idesc;
         u32 low32;
         unsigned long trigger, polarity;
@@ -819,6 +819,9 @@ iosapic_unregister_intr (unsigned int gsi)
                 list_del(&rte->rte_list);
                 iosapic_intr_info[vector].count--;
                 iosapic_free_rte(rte);
+                index = find_iosapic(gsi);
+                iosapic_lists[index].rtes_inuse--;
+                WARN_ON(iosapic_lists[index].rtes_inuse < 0);
 
                 trigger  = iosapic_intr_info[vector].trigger;
                 polarity = iosapic_intr_info[vector].polarity;
@@ -952,30 +955,86 @@ iosapic_system_init (int system_pcat_compat)
         }
 }
 
-void __init
+static inline int
+iosapic_alloc (void)
+{
+        int index;
+
+        for (index = 0; index < NR_IOSAPICS; index++)
+                if (!iosapic_lists[index].addr)
+                        return index;
+
+        printk(KERN_WARNING "%s: failed to allocate iosapic\n", __FUNCTION__);
+        return -1;
+}
+
+static inline void
+iosapic_free (int index)
+{
+        memset(&iosapic_lists[index], 0, sizeof(iosapic_lists[0]));
+}
+
+static inline int
+iosapic_check_gsi_range (unsigned int gsi_base, unsigned int ver)
+{
+        int index;
+        unsigned int gsi_end, base, end;
+
+        /* check gsi range */
+        gsi_end = gsi_base + ((ver >> 16) & 0xff);
+        for (index = 0; index < NR_IOSAPICS; index++) {
+                if (!iosapic_lists[index].addr)
+                        continue;
+
+                base = iosapic_lists[index].gsi_base;
+                end  = base + iosapic_lists[index].num_rte - 1;
+
+                if (gsi_base < base && gsi_end < base)
+                        continue;/* OK */
+
+                if (gsi_base > end && gsi_end > end)
+                        continue; /* OK */
+
+                return -EBUSY;
+        }
+        return 0;
+}
+
+int __devinit
 iosapic_init (unsigned long phys_addr, unsigned int gsi_base)
 {
-        int num_rte;
+        int num_rte, err, index;
         unsigned int isa_irq, ver;
         char __iomem *addr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&iosapic_lock, flags);
+        {
+                addr = ioremap(phys_addr, 0);
+                ver = iosapic_version(addr);
 
-        addr = ioremap(phys_addr, 0);
-        ver = iosapic_version(addr);
+                if ((err = iosapic_check_gsi_range(gsi_base, ver))) {
+                        iounmap(addr);
+                        spin_unlock_irqrestore(&iosapic_lock, flags);
+                        return err;
+                }
 
-        /*
-         * The MAX_REDIR register holds the highest input pin
-         * number (starting from 0).
-         * We add 1 so that we can use it for number of pins (= RTEs)
-         */
-        num_rte = ((ver >> 16) & 0xff) + 1;
+                /*
+                 * The MAX_REDIR register holds the highest input pin
+                 * number (starting from 0).
+                 * We add 1 so that we can use it for number of pins (= RTEs)
+                 */
+                num_rte = ((ver >> 16) & 0xff) + 1;
 
-        iosapic_lists[num_iosapic].addr = addr;
-        iosapic_lists[num_iosapic].gsi_base = gsi_base;
-        iosapic_lists[num_iosapic].num_rte = num_rte;
+                index = iosapic_alloc();
+                iosapic_lists[index].addr = addr;
+                iosapic_lists[index].gsi_base = gsi_base;
+                iosapic_lists[index].num_rte = num_rte;
 #ifdef CONFIG_NUMA
-        iosapic_lists[num_iosapic].node = MAX_NUMNODES;
+                iosapic_lists[index].node = MAX_NUMNODES;
 #endif
-        num_iosapic++;
+        }
+        spin_unlock_irqrestore(&iosapic_lock, flags);
 
         if ((gsi_base == 0) && pcat_compat) {
                 /*
@@ -986,10 +1045,43 @@ iosapic_init (unsigned long phys_addr, unsigned int gsi_base)
                 for (isa_irq = 0; isa_irq < 16; ++isa_irq)
                         iosapic_override_isa_irq(isa_irq, isa_irq, IOSAPIC_POL_HIGH, IOSAPIC_EDGE);
         }
+        return 0;
+}
+
+#ifdef CONFIG_HOTPLUG
+int
+iosapic_remove (unsigned int gsi_base)
+{
+        int index, err = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(&iosapic_lock, flags);
+        {
+                index = find_iosapic(gsi_base);
+                if (index < 0) {
+                        printk(KERN_WARNING "%s: No IOSAPIC for GSI base %u\n",
+                               __FUNCTION__, gsi_base);
+                        goto out;
+                }
+
+                if (iosapic_lists[index].rtes_inuse) {
+                        err = -EBUSY;
+                        printk(KERN_WARNING "%s: IOSAPIC for GSI base %u is busy\n",
+                               __FUNCTION__, gsi_base);
+                        goto out;
+                }
+
+                iounmap(iosapic_lists[index].addr);
+                iosapic_free(index);
+        }
+ out:
+        spin_unlock_irqrestore(&iosapic_lock, flags);
+        return err;
 }
+#endif /* CONFIG_HOTPLUG */
 
 #ifdef CONFIG_NUMA
-void __init
+void __devinit
 map_iosapic_to_node(unsigned int gsi_base, int node)
 {
         int index;
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index e3fc4edea113..720a861f88be 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -312,7 +312,7 @@ pci_acpi_scan_root(struct acpi_device *device, int domain, int bus)
         acpi_walk_resources(device->handle, METHOD_NAME__CRS, add_window,
                         &info);
 
-        pbus = pci_scan_bus(bus, &pci_root_ops, controller);
+        pbus = pci_scan_bus_parented(NULL, bus, &pci_root_ops, controller);
         if (pbus)
                 pcibios_setup_root_windows(pbus, controller);
 
@@ -373,6 +373,25 @@ void pcibios_bus_to_resource(struct pci_dev *dev,
         res->end = region->end + offset;
 }
 
+static int __devinit is_valid_resource(struct pci_dev *dev, int idx)
+{
+        unsigned int i, type_mask = IORESOURCE_IO | IORESOURCE_MEM;
+        struct resource *devr = &dev->resource[idx];
+
+        if (!dev->bus)
+                return 0;
+        for (i=0; i<PCI_BUS_NUM_RESOURCES; i++) {
+                struct resource *busr = dev->bus->resource[i];
+
+                if (!busr || ((busr->flags ^ devr->flags) & type_mask))
+                        continue;
+                if ((devr->start) && (devr->start >= busr->start) &&
+                                (devr->end <= busr->end))
+                        return 1;
+        }
+        return 0;
+}
+
 static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
 {
         struct pci_bus_region region;
@@ -386,7 +405,8 @@ static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
                 region.start = dev->resource[i].start;
                 region.end = dev->resource[i].end;
                 pcibios_bus_to_resource(dev, &dev->resource[i], &region);
-                pci_claim_resource(dev, i);
+                if ((is_valid_resource(dev, i)))
+                        pci_claim_resource(dev, i);
         }
 }
 
@@ -398,6 +418,10 @@ pcibios_fixup_bus (struct pci_bus *b)
 {
         struct pci_dev *dev;
 
+        if (b->self) {
+                pci_read_bridge_bases(b);
+                pcibios_fixup_device_resources(b->self);
+        }
         list_for_each_entry(dev, &b->devices, bus_list)
                 pcibios_fixup_device_resources(dev);
 
@@ -418,18 +442,24 @@ pcibios_enable_resources (struct pci_dev *dev, int mask)
         u16 cmd, old_cmd;
         int idx;
         struct resource *r;
+        unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM;
 
         if (!dev)
                 return -EINVAL;
 
         pci_read_config_word(dev, PCI_COMMAND, &cmd);
         old_cmd = cmd;
-        for (idx=0; idx<6; idx++) {
+        for (idx=0; idx<PCI_NUM_RESOURCES; idx++) {
                 /* Only set up the desired resources.  */
                 if (!(mask & (1 << idx)))
                         continue;
 
                 r = &dev->resource[idx];
+                if (!(r->flags & type_mask))
+                        continue;
+                if ((idx == PCI_ROM_RESOURCE) &&
+                                (!(r->flags & IORESOURCE_ROM_ENABLE)))
+                        continue;
                 if (!r->start && r->end) {
                         printk(KERN_ERR
                                "PCI: Device %s not available because of resource collisions\n",
@@ -441,8 +471,6 @@ pcibios_enable_resources (struct pci_dev *dev, int mask)
                 if (r->flags & IORESOURCE_MEM)
                         cmd |= PCI_COMMAND_MEMORY;
         }
-        if (dev->resource[PCI_ROM_RESOURCE].start)
-                cmd |= PCI_COMMAND_MEMORY;
         if (cmd != old_cmd) {
                 printk("PCI: Enabling device %s (%04x -> %04x)\n", pci_name(dev), old_cmd, cmd);
                 pci_write_config_word(dev, PCI_COMMAND, cmd);