1 files changed, 56 insertions, 346 deletions

diff --git a/arch/sparc64/kernel/pci_sun4v.c b/arch/sparc64/kernel/pci_sun4v.c
index ec22cd61ec8c..94295c219329 100644
--- a/arch/sparc64/kernel/pci_sun4v.c
+++ b/arch/sparc64/kernel/pci_sun4v.c
@@ -1,6 +1,6 @@
 /* pci_sun4v.c: SUN4V specific PCI controller support.
  *
- * Copyright (C) 2006 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 2006, 2007 David S. Miller (davem@davemloft.net)
  */
 
 #include <linux/kernel.h>
@@ -29,7 +29,7 @@
 
 #define PGLIST_NENTS    (PAGE_SIZE / sizeof(u64))
 
-struct pci_iommu_batch {
+struct iommu_batch {
         struct pci_dev  *pdev;          /* Device mapping is for.       */
         unsigned long   prot;           /* IOMMU page protections       */
         unsigned long   entry;          /* Index into IOTSB.            */
@@ -37,12 +37,12 @@ struct pci_iommu_batch {
         unsigned long   npages;         /* Number of pages in list.     */
 };
 
-static DEFINE_PER_CPU(struct pci_iommu_batch, pci_iommu_batch);
+static DEFINE_PER_CPU(struct iommu_batch, pci_iommu_batch);
 
 /* Interrupts must be disabled.  */
 static inline void pci_iommu_batch_start(struct pci_dev *pdev, unsigned long prot, unsigned long entry)
 {
-        struct pci_iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
+        struct iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
 
         p->pdev         = pdev;
         p->prot         = prot;
@@ -51,10 +51,10 @@ static inline void pci_iommu_batch_start(struct pci_dev *pdev, unsigned long pro
 }
 
 /* Interrupts must be disabled.  */
-static long pci_iommu_batch_flush(struct pci_iommu_batch *p)
+static long pci_iommu_batch_flush(struct iommu_batch *p)
 {
-        struct pcidev_cookie *pcp = p->pdev->sysdata;
-        unsigned long devhandle = pcp->pbm->devhandle;
+        struct pci_pbm_info *pbm = p->pdev->dev.archdata.host_controller;
+        unsigned long devhandle = pbm->devhandle;
         unsigned long prot = p->prot;
         unsigned long entry = p->entry;
         u64 *pglist = p->pglist;
@@ -89,7 +89,7 @@ static long pci_iommu_batch_flush(struct pci_iommu_batch *p)
 /* Interrupts must be disabled.  */
 static inline long pci_iommu_batch_add(u64 phys_page)
 {
-        struct pci_iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
+        struct iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
 
         BUG_ON(p->npages >= PGLIST_NENTS);
 
@@ -103,14 +103,14 @@ static inline long pci_iommu_batch_add(u64 phys_page)
 /* Interrupts must be disabled.  */
 static inline long pci_iommu_batch_end(void)
 {
-        struct pci_iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
+        struct iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
 
         BUG_ON(p->npages >= PGLIST_NENTS);
 
         return pci_iommu_batch_flush(p);
 }
 
-static long pci_arena_alloc(struct pci_iommu_arena *arena, unsigned long npages)
+static long pci_arena_alloc(struct iommu_arena *arena, unsigned long npages)
 {
         unsigned long n, i, start, end, limit;
         int pass;
@@ -149,7 +149,7 @@ again:
         return n;
 }
 
-static void pci_arena_free(struct pci_iommu_arena *arena, unsigned long base, unsigned long npages)
+static void pci_arena_free(struct iommu_arena *arena, unsigned long base, unsigned long npages)
 {
         unsigned long i;
 
@@ -159,8 +159,7 @@ static void pci_arena_free(struct pci_iommu_arena *arena, unsigned long base, un
 
 static void *pci_4v_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp, gfp_t gfp)
 {
-        struct pcidev_cookie *pcp;
-        struct pci_iommu *iommu;
+        struct iommu *iommu;
         unsigned long flags, order, first_page, npages, n;
         void *ret;
         long entry;
@@ -178,8 +177,7 @@ static void *pci_4v_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr
 
         memset((char *)first_page, 0, PAGE_SIZE << order);
 
-        pcp = pdev->sysdata;
-        iommu = pcp->pbm->iommu;
+        iommu = pdev->dev.archdata.iommu;
 
         spin_lock_irqsave(&iommu->lock, flags);
         entry = pci_arena_alloc(&iommu->arena, npages);
@@ -226,15 +224,15 @@ arena_alloc_fail:
 
 static void pci_4v_free_consistent(struct pci_dev *pdev, size_t size, void *cpu, dma_addr_t dvma)
 {
-        struct pcidev_cookie *pcp;
-        struct pci_iommu *iommu;
+        struct pci_pbm_info *pbm;
+        struct iommu *iommu;
         unsigned long flags, order, npages, entry;
         u32 devhandle;
 
         npages = IO_PAGE_ALIGN(size) >> IO_PAGE_SHIFT;
-        pcp = pdev->sysdata;
-        iommu = pcp->pbm->iommu;
-        devhandle = pcp->pbm->devhandle;
+        iommu = pdev->dev.archdata.iommu;
+        pbm = pdev->dev.archdata.host_controller;
+        devhandle = pbm->devhandle;
         entry = ((dvma - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
 
         spin_lock_irqsave(&iommu->lock, flags);
@@ -259,16 +257,14 @@ static void pci_4v_free_consistent(struct pci_dev *pdev, size_t size, void *cpu,
 
 static dma_addr_t pci_4v_map_single(struct pci_dev *pdev, void *ptr, size_t sz, int direction)
 {
-        struct pcidev_cookie *pcp;
-        struct pci_iommu *iommu;
+        struct iommu *iommu;
         unsigned long flags, npages, oaddr;
         unsigned long i, base_paddr;
         u32 bus_addr, ret;
         unsigned long prot;
         long entry;
 
-        pcp = pdev->sysdata;
-        iommu = pcp->pbm->iommu;
+        iommu = pdev->dev.archdata.iommu;
 
         if (unlikely(direction == PCI_DMA_NONE))
                 goto bad;
@@ -324,8 +320,8 @@ iommu_map_fail:
 
 static void pci_4v_unmap_single(struct pci_dev *pdev, dma_addr_t bus_addr, size_t sz, int direction)
 {
-        struct pcidev_cookie *pcp;
-        struct pci_iommu *iommu;
+        struct pci_pbm_info *pbm;
+        struct iommu *iommu;
         unsigned long flags, npages;
         long entry;
         u32 devhandle;
@@ -336,9 +332,9 @@ static void pci_4v_unmap_single(struct pci_dev *pdev, dma_addr_t bus_addr, size_
                 return;
         }
 
-        pcp = pdev->sysdata;
-        iommu = pcp->pbm->iommu;
-        devhandle = pcp->pbm->devhandle;
+        iommu = pdev->dev.archdata.iommu;
+        pbm = pdev->dev.archdata.host_controller;
+        devhandle = pbm->devhandle;
 
         npages = IO_PAGE_ALIGN(bus_addr + sz) - (bus_addr & IO_PAGE_MASK);
         npages >>= IO_PAGE_SHIFT;
@@ -460,8 +456,7 @@ iommu_map_failed:
 
 static int pci_4v_map_sg(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int direction)
 {
-        struct pcidev_cookie *pcp;
-        struct pci_iommu *iommu;
+        struct iommu *iommu;
         unsigned long flags, npages, prot;
         u32 dma_base;
         struct scatterlist *sgtmp;
@@ -480,8 +475,7 @@ static int pci_4v_map_sg(struct pci_dev *pdev, struct scatterlist *sglist, int n
                 return 1;
         }
 
-        pcp = pdev->sysdata;
-        iommu = pcp->pbm->iommu;
+        iommu = pdev->dev.archdata.iommu;
         
         if (unlikely(direction == PCI_DMA_NONE))
                 goto bad;
@@ -537,8 +531,8 @@ iommu_map_failed:
 
 static void pci_4v_unmap_sg(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int direction)
 {
-        struct pcidev_cookie *pcp;
-        struct pci_iommu *iommu;
+        struct pci_pbm_info *pbm;
+        struct iommu *iommu;
         unsigned long flags, i, npages;
         long entry;
         u32 devhandle, bus_addr;
@@ -548,9 +542,9 @@ static void pci_4v_unmap_sg(struct pci_dev *pdev, struct scatterlist *sglist, in
                         WARN_ON(1);
         }
 
-        pcp = pdev->sysdata;
-        iommu = pcp->pbm->iommu;
-        devhandle = pcp->pbm->devhandle;
+        iommu = pdev->dev.archdata.iommu;
+        pbm = pdev->dev.archdata.host_controller;
+        devhandle = pbm->devhandle;
         
         bus_addr = sglist->dma_address & IO_PAGE_MASK;
 
@@ -589,7 +583,7 @@ static void pci_4v_dma_sync_sg_for_cpu(struct pci_dev *pdev, struct scatterlist
         /* Nothing to do... */
 }
 
-struct pci_iommu_ops pci_sun4v_iommu_ops = {
+const struct pci_iommu_ops pci_sun4v_iommu_ops = {
         .alloc_consistent               = pci_4v_alloc_consistent,
         .free_consistent                = pci_4v_free_consistent,
         .map_single                     = pci_4v_map_single,
@@ -600,132 +594,12 @@ struct pci_iommu_ops pci_sun4v_iommu_ops = {
         .dma_sync_sg_for_cpu            = pci_4v_dma_sync_sg_for_cpu,
 };
 
-/* SUN4V PCI configuration space accessors. */
-
-struct pdev_entry {
-        struct pdev_entry       *next;
-        u32                     devhandle;
-        unsigned int            bus;
-        unsigned int            device;
-        unsigned int            func;
-};
-
-#define PDEV_HTAB_SIZE  16
-#define PDEV_HTAB_MASK  (PDEV_HTAB_SIZE - 1)
-static struct pdev_entry *pdev_htab[PDEV_HTAB_SIZE];
-
-static inline unsigned int pdev_hashfn(u32 devhandle, unsigned int bus, unsigned int device, unsigned int func)
-{
-        unsigned int val;
-
-        val = (devhandle ^ (devhandle >> 4));
-        val ^= bus;
-        val ^= device;
-        val ^= func;
-
-        return val & PDEV_HTAB_MASK;
-}
-
-static int pdev_htab_add(u32 devhandle, unsigned int bus, unsigned int device, unsigned int func)
-{
-        struct pdev_entry *p = kmalloc(sizeof(*p), GFP_KERNEL);
-        struct pdev_entry **slot;
-
-        if (!p)
-                return -ENOMEM;
-
-        slot = &pdev_htab[pdev_hashfn(devhandle, bus, device, func)];
-        p->next = *slot;
-        *slot = p;
-
-        p->devhandle = devhandle;
-        p->bus = bus;
-        p->device = device;
-        p->func = func;
-
-        return 0;
-}
-
-/* Recursively descend into the OBP device tree, rooted at toplevel_node,
- * looking for a PCI device matching bus and devfn.
- */
-static int obp_find(struct device_node *toplevel_node, unsigned int bus, unsigned int devfn)
-{
-        toplevel_node = toplevel_node->child;
-
-        while (toplevel_node != NULL) {
-                struct linux_prom_pci_registers *regs;
-                struct property *prop;
-                int ret;
-
-                ret = obp_find(toplevel_node, bus, devfn);
-                if (ret != 0)
-                        return ret;
-
-                prop = of_find_property(toplevel_node, "reg", NULL);
-                if (!prop)
-                        goto next_sibling;
-
-                regs = prop->value;
-                if (((regs->phys_hi >> 16) & 0xff) == bus &&
-                    ((regs->phys_hi >> 8) & 0xff) == devfn)
-                        break;
-
-        next_sibling:
-                toplevel_node = toplevel_node->sibling;
-        }
-
-        return toplevel_node != NULL;
-}
-
-static int pdev_htab_populate(struct pci_pbm_info *pbm)
-{
-        u32 devhandle = pbm->devhandle;
-        unsigned int bus;
-
-        for (bus = pbm->pci_first_busno; bus <= pbm->pci_last_busno; bus++) {
-                unsigned int devfn;
-
-                for (devfn = 0; devfn < 256; devfn++) {
-                        unsigned int device = PCI_SLOT(devfn);
-                        unsigned int func = PCI_FUNC(devfn);
-
-                        if (obp_find(pbm->prom_node, bus, devfn)) {
-                                int err = pdev_htab_add(devhandle, bus,
-                                                        device, func);
-                                if (err)
-                                        return err;
-                        }
-                }
-        }
-
-        return 0;
-}
-
-static struct pdev_entry *pdev_find(u32 devhandle, unsigned int bus, unsigned int device, unsigned int func)
-{
-        struct pdev_entry *p;
-
-        p = pdev_htab[pdev_hashfn(devhandle, bus, device, func)];
-        while (p) {
-                if (p->devhandle == devhandle &&
-                    p->bus == bus &&
-                    p->device == device &&
-                    p->func == func)
-                        break;
-
-                p = p->next;
-        }
-
-        return p;
-}
-
 static inline int pci_sun4v_out_of_range(struct pci_pbm_info *pbm, unsigned int bus, unsigned int device, unsigned int func)
 {
         if (bus < pbm->pci_first_busno ||
             bus > pbm->pci_last_busno)
                 return 1;
-        return pdev_find(pbm->devhandle, bus, device, func) == NULL;
+        return 0;
 }
 
 static int pci_sun4v_read_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
@@ -738,6 +612,9 @@ static int pci_sun4v_read_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
         unsigned int func = PCI_FUNC(devfn);
         unsigned long ret;
 
+        if (bus_dev == pbm->pci_bus && devfn == 0x00)
+                return pci_host_bridge_read_pci_cfg(bus_dev, devfn, where,
+                                                    size, value);
         if (pci_sun4v_out_of_range(pbm, bus, device, func)) {
                 ret = ~0UL;
         } else {
@@ -776,6 +653,9 @@ static int pci_sun4v_write_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
         unsigned int func = PCI_FUNC(devfn);
         unsigned long ret;
 
+        if (bus_dev == pbm->pci_bus && devfn == 0x00)
+                return pci_host_bridge_write_pci_cfg(bus_dev, devfn, where,
+                                                     size, value);
         if (pci_sun4v_out_of_range(pbm, bus, device, func)) {
                 /* Do nothing. */
         } else {
@@ -800,27 +680,7 @@ static struct pci_ops pci_sun4v_ops = {
 static void pbm_scan_bus(struct pci_controller_info *p,
                          struct pci_pbm_info *pbm)
 {
-        struct pcidev_cookie *cookie = kzalloc(sizeof(*cookie), GFP_KERNEL);
-
-        if (!cookie) {
-                prom_printf("%s: Critical allocation failure.\n", pbm->name);
-                prom_halt();
-        }
-
-        /* All we care about is the PBM. */
-        cookie->pbm = pbm;
-
-        pbm->pci_bus = pci_scan_bus(pbm->pci_first_busno, p->pci_ops, pbm);
-#if 0
-        pci_fixup_host_bridge_self(pbm->pci_bus);
-        pbm->pci_bus->self->sysdata = cookie;
-#endif
-        pci_fill_in_pbm_cookies(pbm->pci_bus, pbm, pbm->prom_node);
-        pci_record_assignments(pbm, pbm->pci_bus);
-        pci_assign_unassigned(pbm, pbm->pci_bus);
-        pci_fixup_irq(pbm, pbm->pci_bus);
-        pci_determine_66mhz_disposition(pbm, pbm->pci_bus);
-        pci_setup_busmastering(pbm, pbm->pci_bus);
+        pbm->pci_bus = pci_scan_one_pbm(pbm);
 }
 
 static void pci_sun4v_scan_bus(struct pci_controller_info *p)
@@ -844,130 +704,10 @@ static void pci_sun4v_scan_bus(struct pci_controller_info *p)
         /* XXX register error interrupt handlers XXX */
 }
 
-static void pci_sun4v_base_address_update(struct pci_dev *pdev, int resource)
-{
-        struct pcidev_cookie *pcp = pdev->sysdata;
-        struct pci_pbm_info *pbm = pcp->pbm;
-        struct resource *res, *root;
-        u32 reg;
-        int where, size, is_64bit;
-
-        res = &pdev->resource[resource];
-        if (resource < 6) {
-                where = PCI_BASE_ADDRESS_0 + (resource * 4);
-        } else if (resource == PCI_ROM_RESOURCE) {
-                where = pdev->rom_base_reg;
-        } else {
-                /* Somebody might have asked allocation of a non-standard resource */
-                return;
-        }
-
-        /* XXX 64-bit MEM handling is not %100 correct... XXX */
-        is_64bit = 0;
-        if (res->flags & IORESOURCE_IO)
-                root = &pbm->io_space;
-        else {
-                root = &pbm->mem_space;
-                if ((res->flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
-                    == PCI_BASE_ADDRESS_MEM_TYPE_64)
-                        is_64bit = 1;
-        }
-
-        size = res->end - res->start;
-        pci_read_config_dword(pdev, where, &reg);
-        reg = ((reg & size) |
-               (((u32)(res->start - root->start)) & ~size));
-        if (resource == PCI_ROM_RESOURCE) {
-                reg |= PCI_ROM_ADDRESS_ENABLE;
-                res->flags |= IORESOURCE_ROM_ENABLE;
-        }
-        pci_write_config_dword(pdev, where, reg);
-
-        /* This knows that the upper 32-bits of the address
-         * must be zero.  Our PCI common layer enforces this.
-         */
-        if (is_64bit)
-                pci_write_config_dword(pdev, where + 4, 0);
-}
-
-static void pci_sun4v_resource_adjust(struct pci_dev *pdev,
-                                      struct resource *res,
-                                      struct resource *root)
-{
-        res->start += root->start;
-        res->end += root->start;
-}
-
-/* Use ranges property to determine where PCI MEM, I/O, and Config
- * space are for this PCI bus module.
- */
-static void pci_sun4v_determine_mem_io_space(struct pci_pbm_info *pbm)
-{
-        int i, saw_mem, saw_io;
-
-        saw_mem = saw_io = 0;
-        for (i = 0; i < pbm->num_pbm_ranges; i++) {
-                struct linux_prom_pci_ranges *pr = &pbm->pbm_ranges[i];
-                unsigned long a;
-                int type;
-
-                type = (pr->child_phys_hi >> 24) & 0x3;
-                a = (((unsigned long)pr->parent_phys_hi << 32UL) |
-                     ((unsigned long)pr->parent_phys_lo  <<  0UL));
-
-                switch (type) {
-                case 1:
-                        /* 16-bit IO space, 16MB */
-                        pbm->io_space.start = a;
-                        pbm->io_space.end = a + ((16UL*1024UL*1024UL) - 1UL);
-                        pbm->io_space.flags = IORESOURCE_IO;
-                        saw_io = 1;
-                        break;
-
-                case 2:
-                        /* 32-bit MEM space, 2GB */
-                        pbm->mem_space.start = a;
-                        pbm->mem_space.end = a + (0x80000000UL - 1UL);
-                        pbm->mem_space.flags = IORESOURCE_MEM;
-                        saw_mem = 1;
-                        break;
-
-                case 3:
-                        /* XXX 64-bit MEM handling XXX */
-
-                default:
-                        break;
-                };
-        }
-
-        if (!saw_io || !saw_mem) {
-                prom_printf("%s: Fatal error, missing %s PBM range.\n",
-                            pbm->name,
-                            (!saw_io ? "IO" : "MEM"));
-                prom_halt();
-        }
-
-        printk("%s: PCI IO[%lx] MEM[%lx]\n",
-               pbm->name,
-               pbm->io_space.start,
-               pbm->mem_space.start);
-}
-
-static void pbm_register_toplevel_resources(struct pci_controller_info *p,
-                                            struct pci_pbm_info *pbm)
-{
-        pbm->io_space.name = pbm->mem_space.name = pbm->name;
-
-        request_resource(&ioport_resource, &pbm->io_space);
-        request_resource(&iomem_resource, &pbm->mem_space);
-        pci_register_legacy_regions(&pbm->io_space,
-                                    &pbm->mem_space);
-}
-
 static unsigned long probe_existing_entries(struct pci_pbm_info *pbm,
-                                            struct pci_iommu *iommu)
+                                            struct iommu *iommu)
 {
-        struct pci_iommu_arena *arena = &iommu->arena;
+        struct iommu_arena *arena = &iommu->arena;
         unsigned long i, cnt = 0;
         u32 devhandle;
 
@@ -994,7 +734,7 @@ static unsigned long probe_existing_entries(struct pci_pbm_info *pbm,
 
 static void pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
 {
-        struct pci_iommu *iommu = pbm->iommu;
+        struct iommu *iommu = pbm->iommu;
         struct property *prop;
         unsigned long num_tsb_entries, sz;
         u32 vdma[2], dma_mask, dma_offset;
@@ -1281,7 +1021,7 @@ h_error:
 
 static void pci_sun4v_msi_init(struct pci_pbm_info *pbm)
 {
-        u32 *val;
+        const u32 *val;
         int len;
 
         val = of_get_property(pbm->prom_node, "#msi-eqs", &len);
@@ -1289,16 +1029,16 @@ static void pci_sun4v_msi_init(struct pci_pbm_info *pbm)
                 goto no_msi;
         pbm->msiq_num = *val;
         if (pbm->msiq_num) {
-                struct msiq_prop {
+                const struct msiq_prop {
                         u32 first_msiq;
                         u32 num_msiq;
                         u32 first_devino;
                 } *mqp;
-                struct msi_range_prop {
+                const struct msi_range_prop {
                         u32 first_msi;
                         u32 num_msi;
                 } *mrng;
-                struct addr_range_prop {
+                const struct addr_range_prop {
                         u32 msi32_high;
                         u32 msi32_low;
                         u32 msi32_len;
@@ -1410,8 +1150,7 @@ static int pci_sun4v_setup_msi_irq(unsigned int *virt_irq_p,
                                    struct pci_dev *pdev,
                                    struct msi_desc *entry)
 {
-        struct pcidev_cookie *pcp = pdev->sysdata;
-        struct pci_pbm_info *pbm = pcp->pbm;
+        struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
         unsigned long devino, msiqid;
         struct msi_msg msg;
         int msi_num, err;
@@ -1455,7 +1194,7 @@ static int pci_sun4v_setup_msi_irq(unsigned int *virt_irq_p,
         if (pci_sun4v_msi_setvalid(pbm->devhandle, msi_num, HV_MSIVALID_VALID))
                 goto out_err;
 
-        pcp->msi_num = msi_num;
+        pdev->dev.archdata.msi_num = msi_num;
 
         if (entry->msi_attrib.is_64) {
                 msg.address_hi = pbm->msi64_start >> 32;
@@ -1484,12 +1223,11 @@ out_err:
 static void pci_sun4v_teardown_msi_irq(unsigned int virt_irq,
                                        struct pci_dev *pdev)
 {
-        struct pcidev_cookie *pcp = pdev->sysdata;
-        struct pci_pbm_info *pbm = pcp->pbm;
+        struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
         unsigned long msiqid, err;
         unsigned int msi_num;
 
-        msi_num = pcp->msi_num;
+        msi_num = pdev->dev.archdata.msi_num;
         err = pci_sun4v_msi_getmsiq(pbm->devhandle, msi_num, &msiqid);
         if (err) {
                 printk(KERN_ERR "%s: getmsiq gives error %lu\n",
@@ -1516,8 +1254,6 @@ static void pci_sun4v_msi_init(struct pci_pbm_info *pbm)
 static void pci_sun4v_pbm_init(struct pci_controller_info *p, struct device_node *dp, u32 devhandle)
 {
         struct pci_pbm_info *pbm;
-        struct property *prop;
-        int len, i;
 
         if (devhandle & 0x40)
                 pbm = &p->pbm_B;
@@ -1526,7 +1262,6 @@ static void pci_sun4v_pbm_init(struct pci_controller_info *p, struct device_node
 
         pbm->parent = p;
         pbm->prom_node = dp;
-        pbm->pci_first_slot = 1;
 
         pbm->devhandle = devhandle;
 
@@ -1534,39 +1269,17 @@ static void pci_sun4v_pbm_init(struct pci_controller_info *p, struct device_node
 
         printk("%s: SUN4V PCI Bus Module\n", pbm->name);
 
-        prop = of_find_property(dp, "ranges", &len);
-        pbm->pbm_ranges = prop->value;
-        pbm->num_pbm_ranges =
-                (len / sizeof(struct linux_prom_pci_ranges));
-
-        /* Mask out the top 8 bits of the ranges, leaving the real
-         * physical address.
-         */
-        for (i = 0; i < pbm->num_pbm_ranges; i++)
-                pbm->pbm_ranges[i].parent_phys_hi &= 0x0fffffff;
-
-        pci_sun4v_determine_mem_io_space(pbm);
-        pbm_register_toplevel_resources(p, pbm);
-
-        prop = of_find_property(dp, "interrupt-map", &len);
-        pbm->pbm_intmap = prop->value;
-        pbm->num_pbm_intmap =
-                (len / sizeof(struct linux_prom_pci_intmap));
-
-        prop = of_find_property(dp, "interrupt-map-mask", NULL);
-        pbm->pbm_intmask = prop->value;
+        pci_determine_mem_io_space(pbm);
 
         pci_sun4v_get_bus_range(pbm);
         pci_sun4v_iommu_init(pbm);
         pci_sun4v_msi_init(pbm);
-
-        pdev_htab_populate(pbm);
 }
 
 void sun4v_pci_init(struct device_node *dp, char *model_name)
 {
         struct pci_controller_info *p;
-        struct pci_iommu *iommu;
+        struct iommu *iommu;
         struct property *prop;
         struct linux_prom64_registers *regs;
         u32 devhandle;
@@ -1606,13 +1319,13 @@ void sun4v_pci_init(struct device_node *dp, char *model_name)
         if (!p)
                 goto fatal_memory_error;
 
-        iommu = kzalloc(sizeof(struct pci_iommu), GFP_ATOMIC);
+        iommu = kzalloc(sizeof(struct iommu), GFP_ATOMIC);
         if (!iommu)
                 goto fatal_memory_error;
 
         p->pbm_A.iommu = iommu;
 
-        iommu = kzalloc(sizeof(struct pci_iommu), GFP_ATOMIC);
+        iommu = kzalloc(sizeof(struct iommu), GFP_ATOMIC);
         if (!iommu)
                 goto fatal_memory_error;
 
@@ -1622,11 +1335,8 @@ void sun4v_pci_init(struct device_node *dp, char *model_name)
         pci_controller_root = p;
 
         p->index = pci_num_controllers++;
-        p->pbms_same_domain = 0;
 
         p->scan_bus = pci_sun4v_scan_bus;
-        p->base_address_update = pci_sun4v_base_address_update;
-        p->resource_adjust = pci_sun4v_resource_adjust;
 #ifdef CONFIG_PCI_MSI
         p->setup_msi_irq = pci_sun4v_setup_msi_irq;
         p->teardown_msi_irq = pci_sun4v_teardown_msi_irq;