[POWERPC] Rewrite IO allocation & mapping on powerpc64

This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64.  The main goals are:

 - Get rid of imalloc and use more common code where possible
 - Simplify the current mess so that PIO space is allocated and
   mapped in a single place for PCI bridges
 - Handle allocation constraints of PIO for all bridges including
   hot plugged ones within the 2GB space reserved for IO ports,
   so that devices on hotplugged busses will now work with drivers
   that assume IO ports fit in an int.
 - Cleanup and separate tracking of the ISA space in the reserved
   low 64K of IO space. No ISA -> Nothing mapped there.

I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)

With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.

This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)

A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).

imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.

I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.

This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.

Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>

5 files changed, 400 insertions, 246 deletions

diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index 3e779f07f21b..08ce7de7c768 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -65,7 +65,7 @@ obj-$(CONFIG_PPC_UDBG_16550)	+= legacy_serial.o udbg_16550.o
 module-$(CONFIG_PPC64)          += module_64.o
 obj-$(CONFIG_MODULES)           += $(module-y)
 
-pci64-$(CONFIG_PPC64)           += pci_64.o pci_dn.o
+pci64-$(CONFIG_PPC64)           += pci_64.o pci_dn.o isa-bridge.o
 pci32-$(CONFIG_PPC32)           := pci_32.o
 obj-$(CONFIG_PCI)               += $(pci64-y) $(pci32-y)
 obj-$(CONFIG_PCI_MSI)           += msi.o
diff --git a/arch/powerpc/kernel/isa-bridge.c b/arch/powerpc/kernel/isa-bridge.c
new file mode 100644
index 000000000000..f0f49d1be3d5
--- /dev/null
+++ b/arch/powerpc/kernel/isa-bridge.c
@@ -0,0 +1,271 @@
+/*
+ * Routines for tracking a legacy ISA bridge
+ *
+ * Copyrigh 2007 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
+ *
+ * Some bits and pieces moved over from pci_64.c
+ *
+ * Copyrigh 2003 Anton Blanchard <anton@au.ibm.com>, IBM Corp.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#define DEBUG
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/string.h>
+#include <linux/init.h>
+#include <linux/mm.h>
+#include <linux/notifier.h>
+
+#include <asm/processor.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/pci-bridge.h>
+#include <asm/machdep.h>
+#include <asm/ppc-pci.h>
+#include <asm/firmware.h>
+
+unsigned long isa_io_base;      /* NULL if no ISA bus */
+EXPORT_SYMBOL(isa_io_base);
+
+/* Cached ISA bridge dev. */
+static struct device_node *isa_bridge_devnode;
+struct pci_dev *isa_bridge_pcidev;
+EXPORT_SYMBOL_GPL(isa_bridge_pcidev);
+
+#define ISA_SPACE_MASK 0x1
+#define ISA_SPACE_IO 0x1
+
+static void __devinit pci_process_ISA_OF_ranges(struct device_node *isa_node,
+                                                unsigned long phb_io_base_phys)
+{
+        /* We should get some saner parsing here and remove these structs */
+        struct pci_address {
+                u32 a_hi;
+                u32 a_mid;
+                u32 a_lo;
+        };
+
+        struct isa_address {
+                u32 a_hi;
+                u32 a_lo;
+        };
+
+        struct isa_range {
+                struct isa_address isa_addr;
+                struct pci_address pci_addr;
+                unsigned int size;
+        };
+
+        const struct isa_range *range;
+        unsigned long pci_addr;
+        unsigned int isa_addr;
+        unsigned int size;
+        int rlen = 0;
+
+        range = of_get_property(isa_node, "ranges", &rlen);
+        if (range == NULL || (rlen < sizeof(struct isa_range)))
+                goto inval_range;
+
+        /* From "ISA Binding to 1275"
+         * The ranges property is laid out as an array of elements,
+         * each of which comprises:
+         *   cells 0 - 1:       an ISA address
+         *   cells 2 - 4:       a PCI address
+         *                      (size depending on dev->n_addr_cells)
+         *   cell 5:            the size of the range
+         */
+        if ((range->isa_addr.a_hi && ISA_SPACE_MASK) != ISA_SPACE_IO) {
+                range++;
+                rlen -= sizeof(struct isa_range);
+                if (rlen < sizeof(struct isa_range))
+                        goto inval_range;
+        }
+        if ((range->isa_addr.a_hi && ISA_SPACE_MASK) != ISA_SPACE_IO)
+                goto inval_range;
+
+        isa_addr = range->isa_addr.a_lo;
+        pci_addr = (unsigned long) range->pci_addr.a_mid << 32 |
+                range->pci_addr.a_lo;
+
+        /* Assume these are both zero. Note: We could fix that and
+         * do a proper parsing instead ... oh well, that will do for
+         * now as nobody uses fancy mappings for ISA bridges
+         */
+        if ((pci_addr != 0) || (isa_addr != 0)) {
+                printk(KERN_ERR "unexpected isa to pci mapping: %s\n",
+                       __FUNCTION__);
+                return;
+        }
+
+        /* Align size and make sure it's cropped to 64K */
+        size = PAGE_ALIGN(range->size);
+        if (size > 0x10000)
+                size = 0x10000;
+
+        printk(KERN_ERR "no ISA IO ranges or unexpected isa range,"
+               "mapping 64k\n");
+
+        __ioremap_at(phb_io_base_phys, (void *)ISA_IO_BASE,
+                     size, _PAGE_NO_CACHE|_PAGE_GUARDED);
+        return;
+
+inval_range:
+        printk(KERN_ERR "no ISA IO ranges or unexpected isa range,"
+               "mapping 64k\n");
+        __ioremap_at(phb_io_base_phys, (void *)ISA_IO_BASE,
+                     0x10000, _PAGE_NO_CACHE|_PAGE_GUARDED);
+}
+
+
+/**
+ * isa_bridge_find_early - Find and map the ISA IO space early before
+ *                         main PCI discovery. This is optionally called by
+ *                         the arch code when adding PCI PHBs to get early
+ *                         access to ISA IO ports
+ */
+void __init isa_bridge_find_early(struct pci_controller *hose)
+{
+        struct device_node *np, *parent = NULL, *tmp;
+
+        /* If we already have an ISA bridge, bail off */
+        if (isa_bridge_devnode != NULL)
+                return;
+
+        /* For each "isa" node in the system. Note : we do a search by
+         * type and not by name. It might be better to do by name but that's
+         * what the code used to do and I don't want to break too much at
+         * once. We can look into changing that separately
+         */
+        for_each_node_by_type(np, "isa") {
+                /* Look for our hose being a parent */
+                for (parent = of_get_parent(np); parent;) {
+                        if (parent == hose->arch_data) {
+                                of_node_put(parent);
+                                break;
+                        }
+                        tmp = parent;
+                        parent = of_get_parent(parent);
+                        of_node_put(tmp);
+                }
+                if (parent != NULL)
+                        break;
+        }
+        if (np == NULL)
+                return;
+        isa_bridge_devnode = np;
+
+        /* Now parse the "ranges" property and setup the ISA mapping */
+        pci_process_ISA_OF_ranges(np, hose->io_base_phys);
+
+        /* Set the global ISA io base to indicate we have an ISA bridge */
+        isa_io_base = ISA_IO_BASE;
+
+        pr_debug("ISA bridge (early) is %s\n", np->full_name);
+}
+
+/**
+ * isa_bridge_find_late - Find and map the ISA IO space upon discovery of
+ *                        a new ISA bridge
+ */
+static void __devinit isa_bridge_find_late(struct pci_dev *pdev,
+                                           struct device_node *devnode)
+{
+        struct pci_controller *hose = pci_bus_to_host(pdev->bus);
+
+        /* Store ISA device node and PCI device */
+        isa_bridge_devnode = of_node_get(devnode);
+        isa_bridge_pcidev = pdev;
+
+        /* Now parse the "ranges" property and setup the ISA mapping */
+        pci_process_ISA_OF_ranges(devnode, hose->io_base_phys);
+
+        /* Set the global ISA io base to indicate we have an ISA bridge */
+        isa_io_base = ISA_IO_BASE;
+
+        pr_debug("ISA bridge (late) is %s on %s\n",
+                 devnode->full_name, pci_name(pdev));
+}
+
+/**
+ * isa_bridge_remove - Remove/unmap an ISA bridge
+ */
+static void isa_bridge_remove(void)
+{
+        pr_debug("ISA bridge removed !\n");
+
+        /* Clear the global ISA io base to indicate that we have no more
+         * ISA bridge. Note that drivers don't quite handle that, though
+         * we should probably do something about it. But do we ever really
+         * have ISA bridges being removed on machines using legacy devices ?
+         */
+        isa_io_base = ISA_IO_BASE;
+
+        /* Clear references to the bridge */
+        of_node_put(isa_bridge_devnode);
+        isa_bridge_devnode = NULL;
+        isa_bridge_pcidev = NULL;
+
+        /* Unmap the ISA area */
+        __iounmap_at((void *)ISA_IO_BASE, 0x10000);
+}
+
+/**
+ * isa_bridge_notify - Get notified of PCI devices addition/removal
+ */
+static int __devinit isa_bridge_notify(struct notifier_block *nb,
+                                       unsigned long action, void *data)
+{
+        struct device *dev = data;
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct device_node *devnode = pci_device_to_OF_node(pdev);
+
+        switch(action) {
+        case BUS_NOTIFY_ADD_DEVICE:
+                /* Check if we have an early ISA device, without PCI dev */
+                if (isa_bridge_devnode && isa_bridge_devnode == devnode &&
+                    !isa_bridge_pcidev) {
+                        pr_debug("ISA bridge PCI attached: %s\n",
+                                 pci_name(pdev));
+                        isa_bridge_pcidev = pdev;
+                }
+
+                /* Check if we have no ISA device, and this happens to be one,
+                 * register it as such if it has an OF device
+                 */
+                if (!isa_bridge_devnode && devnode && devnode->type &&
+                    !strcmp(devnode->type, "isa"))
+                        isa_bridge_find_late(pdev, devnode);
+
+                return 0;
+        case BUS_NOTIFY_DEL_DEVICE:
+                /* Check if this our existing ISA device */
+                if (pdev == isa_bridge_pcidev ||
+                    (devnode && devnode == isa_bridge_devnode))
+                        isa_bridge_remove();
+                return 0;
+        }
+        return 0;
+}
+
+static struct notifier_block isa_bridge_notifier = {
+        .notifier_call = isa_bridge_notify
+};
+
+/**
+ * isa_bridge_init - register to be notified of ISA bridge addition/removal
+ *
+ */
+static int __init isa_bridge_init(void)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                return 0;
+        bus_register_notifier(&pci_bus_type, &isa_bridge_notifier);
+        return 0;
+}
+arch_initcall(isa_bridge_init);
diff --git a/arch/powerpc/kernel/of_platform.c b/arch/powerpc/kernel/of_platform.c
index d454f61c9c7c..9536ed7f247c 100644
--- a/arch/powerpc/kernel/of_platform.c
+++ b/arch/powerpc/kernel/of_platform.c
@@ -427,14 +427,6 @@ static int __devinit of_pci_phb_probe(struct of_device *dev,
         /* Process "ranges" property */
         pci_process_bridge_OF_ranges(phb, dev->node, 0);
 
-        /* Setup IO space. We use the non-dynamic version of that code here,
-         * which doesn't quite support unplugging. Next kernel release will
-         * have a better fix for this.
-         * Note also that we don't do ISA, this will also be fixed with a
-         * more massive rework.
-         */
-        pci_setup_phb_io(phb, pci_io_base == 0);
-
         /* Init pci_dn data structures */
         pci_devs_phb_init_dynamic(phb);
 
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 249cca27a9b8..6ae67ebfab4d 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -11,7 +11,7 @@
  *      2 of the License, or (at your option) any later version.
  */
 
-#undef DEBUG
+#define DEBUG
 
 #include <linux/kernel.h>
 #include <linux/pci.h>
@@ -22,6 +22,7 @@
 #include <linux/list.h>
 #include <linux/syscalls.h>
 #include <linux/irq.h>
+#include <linux/vmalloc.h>
 
 #include <asm/processor.h>
 #include <asm/io.h>
@@ -41,35 +42,26 @@
 
 unsigned long pci_probe_only = 1;
 int pci_assign_all_buses = 0;
-static int pci_initial_scan_done;
 
 static void fixup_resource(struct resource *res, struct pci_dev *dev);
 static void do_bus_setup(struct pci_bus *bus);
-static void phbs_remap_io(void);
 
 /* pci_io_base -- the base address from which io bars are offsets.
  * This is the lowest I/O base address (so bar values are always positive),
  * and it *must* be the start of ISA space if an ISA bus exists because
- * ISA drivers use hard coded offsets.  If no ISA bus exists a dummy
- * page is mapped and isa_io_limit prevents access to it.
+ * ISA drivers use hard coded offsets.  If no ISA bus exists nothing
+ * is mapped on the first 64K of IO space
  */
-unsigned long isa_io_base;      /* NULL if no ISA bus */
-EXPORT_SYMBOL(isa_io_base);
-unsigned long pci_io_base;
+unsigned long pci_io_base = ISA_IO_BASE;
 EXPORT_SYMBOL(pci_io_base);
 
-void iSeries_pcibios_init(void);
-
 LIST_HEAD(hose_list);
 
 static struct dma_mapping_ops *pci_dma_ops;
 
+/* XXX kill that some day ... */
 int global_phb_number;          /* Global phb counter */
 
-/* Cached ISA bridge dev. */
-struct pci_dev *ppc64_isabridge_dev = NULL;
-EXPORT_SYMBOL_GPL(ppc64_isabridge_dev);
-
 void set_pci_dma_ops(struct dma_mapping_ops *dma_ops)
 {
         pci_dma_ops = dma_ops;
@@ -100,7 +92,7 @@ void  pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region
                 return;
 
         if (res->flags & IORESOURCE_IO)
-                offset = (unsigned long)hose->io_base_virt - pci_io_base;
+                offset = (unsigned long)hose->io_base_virt - _IO_BASE;
 
         if (res->flags & IORESOURCE_MEM)
                 offset = hose->pci_mem_offset;
@@ -119,7 +111,7 @@ void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
                 return;
 
         if (res->flags & IORESOURCE_IO)
-                offset = (unsigned long)hose->io_base_virt - pci_io_base;
+                offset = (unsigned long)hose->io_base_virt - _IO_BASE;
 
         if (res->flags & IORESOURCE_MEM)
                 offset = hose->pci_mem_offset;
@@ -156,7 +148,7 @@ void pcibios_align_resource(void *data, struct resource *res,
 
         if (res->flags & IORESOURCE_IO) {
                 unsigned long offset = (unsigned long)hose->io_base_virt -
-                                        pci_io_base;
+                                        _IO_BASE;
                 /* Make sure we start at our min on all hoses */
                 if (start - offset < PCIBIOS_MIN_IO)
                         start = PCIBIOS_MIN_IO + offset;
@@ -535,10 +527,16 @@ void __devinit scan_phb(struct pci_controller *hose)
         bus->secondary = hose->first_busno;
         hose->bus = bus;
 
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                pcibios_map_io_space(bus);
+
         bus->resource[0] = res = &hose->io_resource;
-        if (res->flags && request_resource(&ioport_resource, res))
+        if (res->flags && request_resource(&ioport_resource, res)) {
                 printk(KERN_ERR "Failed to request PCI IO region "
                        "on PCI domain %04x\n", hose->global_number);
+                DBG("res->start = 0x%016lx, res->end = 0x%016lx\n",
+                    res->start, res->end);
+        }
 
         for (i = 0; i < 3; ++i) {
                 res = &hose->mem_resources[i];
@@ -596,17 +594,6 @@ static int __init pcibios_init(void)
         if (ppc_md.pcibios_fixup)
                 ppc_md.pcibios_fixup();
 
-        /* Cache the location of the ISA bridge (if we have one) */
-        ppc64_isabridge_dev = pci_get_class(PCI_CLASS_BRIDGE_ISA << 8, NULL);
-        if (ppc64_isabridge_dev != NULL)
-                printk(KERN_DEBUG "ISA bridge at %s\n", pci_name(ppc64_isabridge_dev));
-
-        if (!firmware_has_feature(FW_FEATURE_ISERIES))
-                /* map in PCI I/O space */
-                phbs_remap_io();
-
-        pci_initial_scan_done = 1;
-
         printk(KERN_DEBUG "PCI: Probing PCI hardware done\n");
 
         return 0;
@@ -711,7 +698,7 @@ static struct resource *__pci_mmap_make_offset(struct pci_dev *dev,
 #endif
                 res_bit = IORESOURCE_MEM;
         } else {
-                io_offset = (unsigned long)hose->io_base_virt - pci_io_base;
+                io_offset = (unsigned long)hose->io_base_virt - _IO_BASE;
                 *offset += io_offset;
                 res_bit = IORESOURCE_IO;
         }
@@ -881,76 +868,6 @@ void pcibios_add_platform_entries(struct pci_dev *pdev)
         device_create_file(&pdev->dev, &dev_attr_devspec);
 }
 
-#define ISA_SPACE_MASK 0x1
-#define ISA_SPACE_IO 0x1
-
-static void __devinit pci_process_ISA_OF_ranges(struct device_node *isa_node,
-                                      unsigned long phb_io_base_phys,
-                                      void __iomem * phb_io_base_virt)
-{
-        /* Remove these asap */
-
-        struct pci_address {
-                u32 a_hi;
-                u32 a_mid;
-                u32 a_lo;
-        };
-
-        struct isa_address {
-                u32 a_hi;
-                u32 a_lo;
-        };
-
-        struct isa_range {
-                struct isa_address isa_addr;
-                struct pci_address pci_addr;
-                unsigned int size;
-        };
-
-        const struct isa_range *range;
-        unsigned long pci_addr;
-        unsigned int isa_addr;
-        unsigned int size;
-        int rlen = 0;
-
-        range = of_get_property(isa_node, "ranges", &rlen);
-        if (range == NULL || (rlen < sizeof(struct isa_range))) {
-                printk(KERN_ERR "no ISA ranges or unexpected isa range size,"
-                       "mapping 64k\n");
-                __ioremap_explicit(phb_io_base_phys,
-                                   (unsigned long)phb_io_base_virt,
-                                   0x10000, _PAGE_NO_CACHE | _PAGE_GUARDED);
-                return; 
-        }
-        
-        /* From "ISA Binding to 1275"
-         * The ranges property is laid out as an array of elements,
-         * each of which comprises:
-         *   cells 0 - 1:       an ISA address
-         *   cells 2 - 4:       a PCI address 
-         *                      (size depending on dev->n_addr_cells)
-         *   cell 5:            the size of the range
-         */
-        if ((range->isa_addr.a_hi && ISA_SPACE_MASK) == ISA_SPACE_IO) {
-                isa_addr = range->isa_addr.a_lo;
-                pci_addr = (unsigned long) range->pci_addr.a_mid << 32 | 
-                        range->pci_addr.a_lo;
-
-                /* Assume these are both zero */
-                if ((pci_addr != 0) || (isa_addr != 0)) {
-                        printk(KERN_ERR "unexpected isa to pci mapping: %s\n",
-                                        __FUNCTION__);
-                        return;
-                }
-                
-                size = PAGE_ALIGN(range->size);
-
-                __ioremap_explicit(phb_io_base_phys, 
-                                   (unsigned long) phb_io_base_virt, 
-                                   size, _PAGE_NO_CACHE | _PAGE_GUARDED);
-        }
-}
-
 void __devinit pci_process_bridge_OF_ranges(struct pci_controller *hose,
                                             struct device_node *dev, int prim)
 {
@@ -1045,155 +962,122 @@ void __devinit pci_process_bridge_OF_ranges(struct pci_controller *hose,
         }
 }
 
-void __devinit pci_setup_phb_io(struct pci_controller *hose, int primary)
+#ifdef CONFIG_HOTPLUG
+
+int pcibios_unmap_io_space(struct pci_bus *bus)
 {
-        unsigned long size = hose->pci_io_size;
-        unsigned long io_virt_offset;
-        struct resource *res;
-        struct device_node *isa_dn;
+        struct pci_controller *hose;
 
-        if (size == 0)
-                return;
+        WARN_ON(bus == NULL);
 
-        hose->io_base_virt = reserve_phb_iospace(size);
-        DBG("phb%d io_base_phys 0x%lx io_base_virt 0x%lx\n",
-                hose->global_number, hose->io_base_phys,
-                (unsigned long) hose->io_base_virt);
-
-        if (primary) {
-                pci_io_base = (unsigned long)hose->io_base_virt;
-                isa_dn = of_find_node_by_type(NULL, "isa");
-                if (isa_dn) {
-                        isa_io_base = pci_io_base;
-                        pci_process_ISA_OF_ranges(isa_dn, hose->io_base_phys,
-                                                hose->io_base_virt);
-                        of_node_put(isa_dn);
-                }
-        }
+        /* If this is not a PHB, we only flush the hash table over
+         * the area mapped by this bridge. We don't play with the PTE
+         * mappings since we might have to deal with sub-page alignemnts
+         * so flushing the hash table is the only sane way to make sure
+         * that no hash entries are covering that removed bridge area
+         * while still allowing other busses overlapping those pages
+         */
+        if (bus->self) {
+                struct resource *res = bus->resource[0];
 
-        io_virt_offset = (unsigned long)hose->io_base_virt - pci_io_base;
-        res = &hose->io_resource;
-        res->start += io_virt_offset;
-        res->end += io_virt_offset;
+                DBG("IO unmapping for PCI-PCI bridge %s\n",
+                    pci_name(bus->self));
 
-        /* If this is called after the initial PCI scan, then we need to
-         * proceed to IO mappings now
-         */
-        if (pci_initial_scan_done)
-                __ioremap_explicit(hose->io_base_phys,
-                                   (unsigned long)hose->io_base_virt,
-                                   hose->pci_io_size,
-                                   _PAGE_NO_CACHE | _PAGE_GUARDED);
-}
+                __flush_hash_table_range(&init_mm, res->start + _IO_BASE,
+                                         res->end - res->start + 1);
+                return 0;
+        }
 
-void __devinit pci_setup_phb_io_dynamic(struct pci_controller *hose,
-                                        int primary)
-{
-        unsigned long size = hose->pci_io_size;
-        unsigned long io_virt_offset;
-        struct resource *res;
+        /* Get the host bridge */
+        hose = pci_bus_to_host(bus);
 
-        if (size == 0)
-                return;
+        /* Check if we have IOs allocated */
+        if (hose->io_base_alloc == 0)
+                return 0;
 
-        hose->io_base_virt = __ioremap(hose->io_base_phys, size,
-                                        _PAGE_NO_CACHE | _PAGE_GUARDED);
-        DBG("phb%d io_base_phys 0x%lx io_base_virt 0x%lx\n",
-                hose->global_number, hose->io_base_phys,
-                (unsigned long) hose->io_base_virt);
+        DBG("IO unmapping for PHB %s\n",
+            ((struct device_node *)hose->arch_data)->full_name);
+        DBG("  alloc=0x%p\n", hose->io_base_alloc);
 
-        if (primary)
-                pci_io_base = (unsigned long)hose->io_base_virt;
+        /* This is a PHB, we fully unmap the IO area */
+        vunmap(hose->io_base_alloc);
 
-        io_virt_offset = (unsigned long)hose->io_base_virt - pci_io_base;
-        res = &hose->io_resource;
-        res->start += io_virt_offset;
-        res->end += io_virt_offset;
+        return 0;
 }
+EXPORT_SYMBOL_GPL(pcibios_unmap_io_space);
 
+#endif /* CONFIG_HOTPLUG */
 
-static int get_bus_io_range(struct pci_bus *bus, unsigned long *start_phys,
-                                unsigned long *start_virt, unsigned long *size)
+int __devinit pcibios_map_io_space(struct pci_bus *bus)
 {
-        struct pci_controller *hose = pci_bus_to_host(bus);
-        struct resource *res;
-
-        if (bus->self)
-                res = bus->resource[0];
-        else
-                /* Root Bus */
-                res = &hose->io_resource;
-
-        if (res->end == 0 && res->start == 0)
-                return 1;
+        struct vm_struct *area;
+        unsigned long phys_page;
+        unsigned long size_page;
+        unsigned long io_virt_offset;
+        struct pci_controller *hose;
 
-        *start_virt = pci_io_base + res->start;
-        *start_phys = *start_virt + hose->io_base_phys
-                - (unsigned long) hose->io_base_virt;
+        WARN_ON(bus == NULL);
 
-        if (res->end > res->start)
-                *size = res->end - res->start + 1;
-        else {
-                printk("%s(): unexpected region 0x%lx->0x%lx\n",
-                       __FUNCTION__, res->start, res->end);
-                return 1;
+        /* If this not a PHB, nothing to do, page tables still exist and
+         * thus HPTEs will be faulted in when needed
+         */
+        if (bus->self) {
+                DBG("IO mapping for PCI-PCI bridge %s\n",
+                    pci_name(bus->self));
+                DBG("  virt=0x%016lx...0x%016lx\n",
+                    bus->resource[0]->start + _IO_BASE,
+                    bus->resource[0]->end + _IO_BASE);
+                return 0;
         }
 
-        return 0;
-}
-
-int unmap_bus_range(struct pci_bus *bus)
-{
-        unsigned long start_phys;
-        unsigned long start_virt;
-        unsigned long size;
-
-        if (!bus) {
-                printk(KERN_ERR "%s() expected bus\n", __FUNCTION__);
-                return 1;
-        }
-        
-        if (get_bus_io_range(bus, &start_phys, &start_virt, &size))
-                return 1;
-        if (__iounmap_explicit((void __iomem *) start_virt, size))
-                return 1;
+        /* Get the host bridge */
+        hose = pci_bus_to_host(bus);
+        phys_page = _ALIGN_DOWN(hose->io_base_phys, PAGE_SIZE);
+        size_page = _ALIGN_UP(hose->pci_io_size, PAGE_SIZE);
 
-        return 0;
-}
-EXPORT_SYMBOL(unmap_bus_range);
+        /* Make sure IO area address is clear */
+        hose->io_base_alloc = NULL;
 
-int remap_bus_range(struct pci_bus *bus)
-{
-        unsigned long start_phys;
-        unsigned long start_virt;
-        unsigned long size;
+        /* If there's no IO to map on that bus, get away too */
+        if (hose->pci_io_size == 0 || hose->io_base_phys == 0)
+                return 0;
 
-        if (!bus) {
-                printk(KERN_ERR "%s() expected bus\n", __FUNCTION__);
-                return 1;
-        }
-        
-        
-        if (get_bus_io_range(bus, &start_phys, &start_virt, &size))
-                return 1;
-        if (start_phys == 0)
-                return 1;
-        printk(KERN_DEBUG "mapping IO %lx -> %lx, size: %lx\n", start_phys, start_virt, size);
-        if (__ioremap_explicit(start_phys, start_virt, size,
-                               _PAGE_NO_CACHE | _PAGE_GUARDED))
-                return 1;
+        /* Let's allocate some IO space for that guy. We don't pass
+         * VM_IOREMAP because we don't care about alignment tricks that
+         * the core does in that case. Maybe we should due to stupid card
+         * with incomplete address decoding but I'd rather not deal with
+         * those outside of the reserved 64K legacy region.
+         */
+        area = __get_vm_area(size_page, 0, PHB_IO_BASE, PHB_IO_END);
+        if (area == NULL)
+                return -ENOMEM;
+        hose->io_base_alloc = area->addr;
+        hose->io_base_virt = (void __iomem *)(area->addr +
+                                              hose->io_base_phys - phys_page);
+
+        DBG("IO mapping for PHB %s\n",
+            ((struct device_node *)hose->arch_data)->full_name);
+        DBG("  phys=0x%016lx, virt=0x%p (alloc=0x%p)\n",
+            hose->io_base_phys, hose->io_base_virt, hose->io_base_alloc);
+        DBG("  size=0x%016lx (alloc=0x%016lx)\n",
+            hose->pci_io_size, size_page);
+
+        /* Establish the mapping */
+        if (__ioremap_at(phys_page, area->addr, size_page,
+                         _PAGE_NO_CACHE | _PAGE_GUARDED) == NULL)
+                return -ENOMEM;
+
+        /* Fixup hose IO resource */
+        io_virt_offset = (unsigned long)hose->io_base_virt - _IO_BASE;
+        hose->io_resource.start += io_virt_offset;
+        hose->io_resource.end += io_virt_offset;
+
+        DBG("  hose->io_resource=0x%016lx...0x%016lx\n",
+            hose->io_resource.start, hose->io_resource.end);
 
         return 0;
 }
-EXPORT_SYMBOL(remap_bus_range);
-
-static void phbs_remap_io(void)
-{
-        struct pci_controller *hose, *tmp;
-
-        list_for_each_entry_safe(hose, tmp, &hose_list, list_node)
-                remap_bus_range(hose->bus);
-}
+EXPORT_SYMBOL_GPL(pcibios_map_io_space);
 
 static void __devinit fixup_resource(struct resource *res, struct pci_dev *dev)
 {
@@ -1201,8 +1085,7 @@ static void __devinit fixup_resource(struct resource *res, struct pci_dev *dev)
         unsigned long offset;
 
         if (res->flags & IORESOURCE_IO) {
-                offset = (unsigned long)hose->io_base_virt - pci_io_base;
-
+                offset = (unsigned long)hose->io_base_virt - _IO_BASE;
                 res->start += offset;
                 res->end += offset;
         } else if (res->flags & IORESOURCE_MEM) {
@@ -1217,9 +1100,20 @@ void __devinit pcibios_fixup_device_resources(struct pci_dev *dev,
         /* Update device resources.  */
         int i;
 
-        for (i = 0; i < PCI_NUM_RESOURCES; i++)
-                if (dev->resource[i].flags)
-                        fixup_resource(&dev->resource[i], dev);
+        DBG("%s: Fixup resources:\n", pci_name(dev));
+        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
+                struct resource *res = &dev->resource[i];
+                if (!res->flags)
+                        continue;
+
+                DBG("  0x%02x < %08lx:0x%016lx...0x%016lx\n",
+                    i, res->flags, res->start, res->end);
+
+                fixup_resource(res, dev);
+
+                DBG("       > %08lx:0x%016lx...0x%016lx\n",
+                    res->flags, res->start, res->end);
+        }
 }
 EXPORT_SYMBOL(pcibios_fixup_device_resources);
 
@@ -1360,7 +1254,7 @@ void pci_resource_to_user(const struct pci_dev *dev, int bar,
                 return;
 
         if (rsrc->flags & IORESOURCE_IO)
-                offset = (unsigned long)hose->io_base_virt - pci_io_base;
+                offset = (unsigned long)hose->io_base_virt - _IO_BASE;
 
         /* We pass a fully fixed up address to userland for MMIO instead of
          * a BAR value because X is lame and expects to be able to use that
@@ -1410,7 +1304,7 @@ unsigned long pci_address_to_pio(phys_addr_t address)
                 if (address >= hose->io_base_phys &&
                     address < (hose->io_base_phys + hose->pci_io_size)) {
                         unsigned long base =
-                                (unsigned long)hose->io_base_virt - pci_io_base;
+                                (unsigned long)hose->io_base_virt - _IO_BASE;
                         return base + (address - hose->io_base_phys);
                 }
         }
diff --git a/arch/powerpc/kernel/rtas_pci.c b/arch/powerpc/kernel/rtas_pci.c
index f2286822be09..a5de6211b97a 100644
--- a/arch/powerpc/kernel/rtas_pci.c
+++ b/arch/powerpc/kernel/rtas_pci.c
@@ -278,10 +278,8 @@ void __init find_and_init_phbs(void)
 {
         struct device_node *node;
         struct pci_controller *phb;
-        unsigned int index;
         struct device_node *root = of_find_node_by_path("/");
 
-        index = 0;
         for (node = of_get_next_child(root, NULL);
              node != NULL;
              node = of_get_next_child(root, node)) {
@@ -295,8 +293,7 @@ void __init find_and_init_phbs(void)
                         continue;
                 rtas_setup_phb(phb);
                 pci_process_bridge_OF_ranges(phb, node, 0);
-                pci_setup_phb_io(phb, index == 0);
-                index++;
+                isa_bridge_find_early(phb);
         }
 
         of_node_put(root);
@@ -335,7 +332,7 @@ int pcibios_remove_root_bus(struct pci_controller *phb)
                 return 1;
         }
 
-        rc = unmap_bus_range(b);
+        rc = pcibios_unmap_io_space(b);
         if (rc) {
                 printk(KERN_ERR "%s: failed to unmap IO on bus %s\n",
                         __FUNCTION__, b->name);