Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=01f94c4a6ced476ce69b895426fc29bfc48c69bd
Commit:     01f94c4a6ced476ce69b895426fc29bfc48c69bd
Parent:     a378fd0ee8ea6af5dafd0ab3d634f22b926b5ac4
Author:     David S. Miller <[EMAIL PROTECTED]>
AuthorDate: Sun Mar 4 12:53:19 2007 -0800
Committer:  David S. Miller <[EMAIL PROTECTED]>
CommitDate: Thu Apr 26 01:55:10 2007 -0700

    [SPARC64]: Fix sabre pci controllers with new probing scheme.
    
    The SIMBA APB bridge is strange, it is a PCI bridge but it lacks
    some standard OF properties, in particular it lacks a 'ranges'
    property.
    
    What you have to do is read the IO and MEM range registers in
    the APB bridge to determine the ranges handled by each bridge.
    So fill in the bus resources by doing that.
    
    Since we now handle this quirk in the generic PCI and OF device
    probing layers, we can flat out eliminate all of that code from
    the sabre pci controller driver.
    
    In fact we can thus eliminate completely another quirk of the sabre
    driver.  It tried to make the two APB bridges look like PBMs but that
    makes zero sense now (and it's questionable whether it ever made sense).
    So now just use pbm_A and probe the whole PCI hierarchy using that as
    the root.
    
    This simplification allows many future cleanups to occur.
    
    Also, I've found yet another quirk that needs to be worked around
    while testing this.  You can't use the 'class-code' OF firmware
    property, especially for IDE controllers.  We have to read the value
    out of PCI config space or else we'll see the value the device was
    showing before it was programmed into native mode.
    
    I'm starting to think it might be wise to just read all of the values
    out of PCI config space instead of using the OF properties. :-/
    
    Signed-off-by: David S. Miller <[EMAIL PROTECTED]>
---
 arch/sparc64/kernel/of_device.c |   29 ++++
 arch/sparc64/kernel/pci.c       |   80 +++++++++-
 arch/sparc64/kernel/pci_sabre.c |  340 +++++++--------------------------------
 3 files changed, 165 insertions(+), 284 deletions(-)

diff --git a/arch/sparc64/kernel/of_device.c b/arch/sparc64/kernel/of_device.c
index 6b87981..8964eac 100644
--- a/arch/sparc64/kernel/of_device.c
+++ b/arch/sparc64/kernel/of_device.c
@@ -317,6 +317,11 @@ static unsigned int of_bus_default_get_flags(const u32 
*addr)
 static int of_bus_pci_match(struct device_node *np)
 {
        if (!strcmp(np->type, "pci") || !strcmp(np->type, "pciex")) {
+               char *model = of_get_property(np, "model", NULL);
+
+               if (model && !strcmp(model, "SUNW,simba"))
+                       return 0;
+
                /* Do not do PCI specific frobbing if the
                 * PCI bridge lacks a ranges property.  We
                 * want to pass it through up to the next
@@ -332,6 +337,21 @@ static int of_bus_pci_match(struct device_node *np)
        return 0;
 }
 
+static int of_bus_simba_match(struct device_node *np)
+{
+       char *model = of_get_property(np, "model", NULL);
+
+       if (model && !strcmp(model, "SUNW,simba"))
+               return 1;
+       return 0;
+}
+
+static int of_bus_simba_map(u32 *addr, const u32 *range,
+                           int na, int ns, int pna)
+{
+       return 0;
+}
+
 static void of_bus_pci_count_cells(struct device_node *np,
                                   int *addrc, int *sizec)
 {
@@ -436,6 +456,15 @@ static struct of_bus of_busses[] = {
                .map = of_bus_pci_map,
                .get_flags = of_bus_pci_get_flags,
        },
+       /* SIMBA */
+       {
+               .name = "simba",
+               .addr_prop_name = "assigned-addresses",
+               .match = of_bus_simba_match,
+               .count_cells = of_bus_pci_count_cells,
+               .map = of_bus_simba_map,
+               .get_flags = of_bus_pci_get_flags,
+       },
        /* SBUS */
        {
                .name = "sbus",
diff --git a/arch/sparc64/kernel/pci.c b/arch/sparc64/kernel/pci.c
index 425e883..b63341c 100644
--- a/arch/sparc64/kernel/pci.c
+++ b/arch/sparc64/kernel/pci.c
@@ -26,6 +26,7 @@
 #include <asm/ebus.h>
 #include <asm/isa.h>
 #include <asm/prom.h>
+#include <asm/apb.h>
 
 #include "pci_impl.h"
 
@@ -372,6 +373,7 @@ struct pci_dev *of_create_pci_dev(struct pci_pbm_info *pbm,
        struct dev_archdata *sd;
        struct pci_dev *dev;
        const char *type;
+       u32 class;
 
        dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
        if (!dev)
@@ -409,7 +411,15 @@ struct pci_dev *of_create_pci_dev(struct pci_pbm_info *pbm,
 
        sprintf(pci_name(dev), "%04x:%02x:%02x.%d", pci_domain_nr(bus),
                dev->bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn));
-       dev->class = of_getintprop_default(node, "class-code", 0);
+
+       /* dev->class = of_getintprop_default(node, "class-code", 0); */
+       /* We can't actually use the firmware value, we have to read what
+        * is in the register right now.  One reason is that in the case
+        * of IDE interfaces the firmware can sample the value before the
+        * the IDE interface is programmed into native mode.
+        */
+       pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
+       dev->class = class >> 8;
 
        printk("    class: 0x%x\n", dev->class);
 
@@ -440,6 +450,53 @@ struct pci_dev *of_create_pci_dev(struct pci_pbm_info *pbm,
        return dev;
 }
 
+static void __init apb_calc_first_last(u8 map, u32 *first_p, u32 *last_p)
+{
+       u32 idx, first, last;
+
+       first = 8;
+       last = 0;
+       for (idx = 0; idx < 8; idx++) {
+               if ((map & (1 << idx)) != 0) {
+                       if (first > idx)
+                               first = idx;
+                       if (last < idx)
+                               last = idx;
+               }
+       }
+
+       *first_p = first;
+       *last_p = last;
+}
+
+/* Cook up fake bus resources for SUNW,simba PCI bridges which lack
+ * a proper 'ranges' property.
+ */
+static void __init apb_fake_ranges(struct pci_dev *dev,
+                                  struct pci_bus *bus,
+                                  struct pci_pbm_info *pbm)
+{
+       struct resource *res;
+       u32 first, last;
+       u8 map;
+
+       pci_read_config_byte(dev, APB_IO_ADDRESS_MAP, &map);
+       apb_calc_first_last(map, &first, &last);
+       res = bus->resource[0];
+       res->start = (first << 21);
+       res->end = (last << 21) + ((1 << 21) - 1);
+       res->flags = IORESOURCE_IO;
+       pbm->parent->resource_adjust(dev, res, &pbm->io_space);
+
+       pci_read_config_byte(dev, APB_MEM_ADDRESS_MAP, &map);
+       apb_calc_first_last(map, &first, &last);
+       res = bus->resource[1];
+       res->start = (first << 21);
+       res->end = (last << 21) + ((1 << 21) - 1);
+       res->flags = IORESOURCE_MEM;
+       pbm->parent->resource_adjust(dev, res, &pbm->mem_space);
+}
+
 static void __init pci_of_scan_bus(struct pci_pbm_info *pbm,
                                   struct device_node *node,
                                   struct pci_bus *bus);
@@ -452,7 +509,7 @@ void __devinit of_scan_pci_bridge(struct pci_pbm_info *pbm,
 {
        struct pci_bus *bus;
        const u32 *busrange, *ranges;
-       int len, i;
+       int len, i, simba;
        struct resource *res;
        unsigned int flags;
        u64 size;
@@ -467,10 +524,16 @@ void __devinit of_scan_pci_bridge(struct pci_pbm_info 
*pbm,
                return;
        }
        ranges = of_get_property(node, "ranges", &len);
+       simba = 0;
        if (ranges == NULL) {
-               printk(KERN_DEBUG "Can't get ranges for PCI-PCI bridge %s\n",
-                      node->full_name);
-               return;
+               char *model = of_get_property(node, "model", NULL);
+               if (model && !strcmp(model, "SUNW,simba")) {
+                       simba = 1;
+               } else {
+                       printk(KERN_DEBUG "Can't get ranges for PCI-PCI bridge 
%s\n",
+                              node->full_name);
+                       return;
+               }
        }
 
        bus = pci_add_new_bus(dev->bus, dev, busrange[0]);
@@ -484,7 +547,7 @@ void __devinit of_scan_pci_bridge(struct pci_pbm_info *pbm,
        bus->subordinate = busrange[1];
        bus->bridge_ctl = 0;
 
-       /* parse ranges property */
+       /* parse ranges property, or cook one up by hand for Simba */
        /* PCI #address-cells == 3 and #size-cells == 2 always */
        res = &dev->resource[PCI_BRIDGE_RESOURCES];
        for (i = 0; i < PCI_NUM_RESOURCES - PCI_BRIDGE_RESOURCES; ++i) {
@@ -492,6 +555,10 @@ void __devinit of_scan_pci_bridge(struct pci_pbm_info *pbm,
                bus->resource[i] = res;
                ++res;
        }
+       if (simba) {
+               apb_fake_ranges(dev, bus, pbm);
+               goto simba_cont;
+       }
        i = 1;
        for (; len >= 32; len -= 32, ranges += 8) {
                struct resource *root;
@@ -529,6 +596,7 @@ void __devinit of_scan_pci_bridge(struct pci_pbm_info *pbm,
                 */
                pbm->parent->resource_adjust(dev, res, root);
        }
+simba_cont:
        sprintf(bus->name, "PCI Bus %04x:%02x", pci_domain_nr(bus),
                bus->number);
        printk("    bus name: %s\n", bus->name);
diff --git a/arch/sparc64/kernel/pci_sabre.c b/arch/sparc64/kernel/pci_sabre.c
index bbf6245..f4e3460 100644
--- a/arch/sparc64/kernel/pci_sabre.c
+++ b/arch/sparc64/kernel/pci_sabre.c
@@ -254,9 +254,6 @@ static int __sabre_out_of_range(struct pci_pbm_info *pbm,
                return 0;
 
        return ((pbm->parent == 0) ||
-               ((pbm == &pbm->parent->pbm_B) &&
-                (bus == pbm->pci_first_busno) &&
-                PCI_SLOT(devfn) > 8) ||
                ((pbm == &pbm->parent->pbm_A) &&
                 (bus == pbm->pci_first_busno) &&
                 PCI_SLOT(devfn) > 8));
@@ -800,12 +797,10 @@ static irqreturn_t sabre_pcierr_intr(int irq, void 
*dev_id)
        if (error_bits & (SABRE_PIOAFSR_PTA | SABRE_PIOAFSR_STA)) {
                sabre_check_iommu_error(p, afsr, afar);
                pci_scan_for_target_abort(p, &p->pbm_A, p->pbm_A.pci_bus);
-               pci_scan_for_target_abort(p, &p->pbm_B, p->pbm_B.pci_bus);
        }
-       if (error_bits & (SABRE_PIOAFSR_PMA | SABRE_PIOAFSR_SMA)) {
+       if (error_bits & (SABRE_PIOAFSR_PMA | SABRE_PIOAFSR_SMA))
                pci_scan_for_master_abort(p, &p->pbm_A, p->pbm_A.pci_bus);
-               pci_scan_for_master_abort(p, &p->pbm_B, p->pbm_B.pci_bus);
-       }
+
        /* For excessive retries, SABRE/PBM will abort the device
         * and there is no way to specifically check for excessive
         * retries in the config space status registers.  So what
@@ -813,10 +808,8 @@ static irqreturn_t sabre_pcierr_intr(int irq, void *dev_id)
         * abort events.
         */
 
-       if (error_bits & (SABRE_PIOAFSR_PPERR | SABRE_PIOAFSR_SPERR)) {
+       if (error_bits & (SABRE_PIOAFSR_PPERR | SABRE_PIOAFSR_SPERR))
                pci_scan_for_parity_error(p, &p->pbm_A, p->pbm_A.pci_bus);
-               pci_scan_for_parity_error(p, &p->pbm_B, p->pbm_B.pci_bus);
-       }
 
        return IRQ_HANDLED;
 }
@@ -935,44 +928,33 @@ static void apb_init(struct pci_controller_info *p, 
struct pci_bus *sabre_bus)
        struct pci_dev *pdev;
 
        list_for_each_entry(pdev, &sabre_bus->devices, bus_list) {
-
                if (pdev->vendor == PCI_VENDOR_ID_SUN &&
                    pdev->device == PCI_DEVICE_ID_SUN_SIMBA) {
-                       u32 word32;
                        u16 word16;
 
-                       sabre_read_pci_cfg(pdev->bus, pdev->devfn,
-                                          PCI_COMMAND, 2, &word32);
-                       word16 = (u16) word32;
+                       pci_read_config_word(pdev, PCI_COMMAND, &word16);
                        word16 |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY |
                                PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY |
                                PCI_COMMAND_IO;
-                       word32 = (u32) word16;
-                       sabre_write_pci_cfg(pdev->bus, pdev->devfn,
-                                           PCI_COMMAND, 2, word32);
+                       pci_write_config_word(pdev, PCI_COMMAND, word16);
 
                        /* Status register bits are "write 1 to clear". */
-                       sabre_write_pci_cfg(pdev->bus, pdev->devfn,
-                                           PCI_STATUS, 2, 0xffff);
-                       sabre_write_pci_cfg(pdev->bus, pdev->devfn,
-                                           PCI_SEC_STATUS, 2, 0xffff);
+                       pci_write_config_word(pdev, PCI_STATUS, 0xffff);
+                       pci_write_config_word(pdev, PCI_SEC_STATUS, 0xffff);
 
                        /* Use a primary/seconday latency timer value
                         * of 64.
                         */
-                       sabre_write_pci_cfg(pdev->bus, pdev->devfn,
-                                           PCI_LATENCY_TIMER, 1, 64);
-                       sabre_write_pci_cfg(pdev->bus, pdev->devfn,
-                                           PCI_SEC_LATENCY_TIMER, 1, 64);
+                       pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
+                       pci_write_config_byte(pdev, PCI_SEC_LATENCY_TIMER, 64);
 
                        /* Enable reporting/forwarding of master aborts,
                         * parity, and SERR.
                         */
-                       sabre_write_pci_cfg(pdev->bus, pdev->devfn,
-                                           PCI_BRIDGE_CONTROL, 1,
-                                           (PCI_BRIDGE_CTL_PARITY |
-                                            PCI_BRIDGE_CTL_SERR |
-                                            PCI_BRIDGE_CTL_MASTER_ABORT));
+                       pci_write_config_byte(pdev, PCI_BRIDGE_CONTROL,
+                                             (PCI_BRIDGE_CTL_PARITY |
+                                              PCI_BRIDGE_CTL_SERR |
+                                              PCI_BRIDGE_CTL_MASTER_ABORT));
                }
        }
 }
@@ -980,16 +962,13 @@ static void apb_init(struct pci_controller_info *p, 
struct pci_bus *sabre_bus)
 static void sabre_scan_bus(struct pci_controller_info *p)
 {
        static int once;
-       struct pci_bus *sabre_bus, *pbus;
-       struct pci_pbm_info *pbm;
-       int sabres_scanned;
+       struct pci_bus *pbus;
 
        /* The APB bridge speaks to the Sabre host PCI bridge
         * at 66Mhz, but the front side of APB runs at 33Mhz
         * for both segments.
         */
        p->pbm_A.is_66mhz_capable = 0;
-       p->pbm_B.is_66mhz_capable = 0;
 
        /* This driver has not been verified to handle
         * multiple SABREs yet, so trap this.
@@ -1003,36 +982,13 @@ static void sabre_scan_bus(struct pci_controller_info *p)
        }
        once++;
 
-       sabre_bus = pci_scan_one_pbm(&p->pbm_A);
-       if (!sabre_bus)
+       pbus = pci_scan_one_pbm(&p->pbm_A);
+       if (!pbus)
                return;
 
-       sabre_root_bus = sabre_bus;
-
-       apb_init(p, sabre_bus);
-
-       sabres_scanned = 0;
+       sabre_root_bus = pbus;
 
-       list_for_each_entry(pbus, &sabre_bus->children, node) {
-
-               if (pbus->number == p->pbm_A.pci_first_busno) {
-                       pbm = &p->pbm_A;
-               } else if (pbus->number == p->pbm_B.pci_first_busno) {
-                       pbm = &p->pbm_B;
-               } else
-                       continue;
-
-               sabres_scanned++;
-               pbus->sysdata = pbm;
-               pbm->pci_bus = pbus;
-       }
-
-       if (!sabres_scanned) {
-               /* Hummingbird, no APBs. */
-               pbm = &p->pbm_A;
-               sabre_bus->sysdata = pbm;
-               pbm->pci_bus = sabre_bus;
-       }
+       apb_init(p, pbus);
 
        sabre_register_error_handlers(p);
 }
@@ -1089,213 +1045,54 @@ static void sabre_iommu_init(struct 
pci_controller_info *p,
        sabre_write(p->pbm_A.controller_regs + SABRE_IOMMU_CONTROL, control);
 }
 
-static void pbm_register_toplevel_resources(struct pci_controller_info *p,
-                                           struct pci_pbm_info *pbm)
+static void sabre_pbm_init(struct pci_controller_info *p, struct device_node 
*dp, u32 dma_start, u32 dma_end)
 {
-       char *name = pbm->name;
-       unsigned long ibase = p->pbm_A.controller_regs + SABRE_IOSPACE;
-       unsigned long mbase = p->pbm_A.controller_regs + SABRE_MEMSPACE;
-       unsigned int devfn;
-       unsigned long first, last, i;
-       u8 *addr, map;
-
-       sprintf(name, "SABRE%d PBM%c",
-               p->index,
-               (pbm == &p->pbm_A ? 'A' : 'B'));
-       pbm->io_space.name = pbm->mem_space.name = name;
-
-       devfn = PCI_DEVFN(1, (pbm == &p->pbm_A) ? 0 : 1);
-       addr = sabre_pci_config_mkaddr(pbm, 0, devfn, APB_IO_ADDRESS_MAP);
-       map = 0;
-       pci_config_read8(addr, &map);
-
-       first = 8;
-       last = 0;
-       for (i = 0; i < 8; i++) {
-               if ((map & (1 << i)) != 0) {
-                       if (first > i)
-                               first = i;
-                       if (last < i)
-                               last = i;
-               }
-       }
-       pbm->io_space.start = ibase + (first << 21UL);
-       pbm->io_space.end   = ibase + (last << 21UL) + ((1 << 21UL) - 1);
+       struct pci_pbm_info *pbm;
+       struct resource *rp;
+
+       pbm = &p->pbm_A;
+       pbm->name = dp->full_name;
+       printk("%s: SABRE PCI Bus Module\n", pbm->name);
+
+       pbm->chip_type = PBM_CHIP_TYPE_SABRE;
+       pbm->parent = p;
+       pbm->prom_node = dp;
+       pbm->pci_first_slot = 1;
+       pbm->pci_first_busno = p->pci_first_busno;
+       pbm->pci_last_busno = p->pci_last_busno;
+
+       pbm->io_space.name = pbm->mem_space.name = pbm->name;
+
+       pbm->io_space.start = p->pbm_A.controller_regs + SABRE_IOSPACE;
+       pbm->io_space.end   = pbm->io_space.start + (1UL << 24) - 1UL;
        pbm->io_space.flags = IORESOURCE_IO;
 
-       addr = sabre_pci_config_mkaddr(pbm, 0, devfn, APB_MEM_ADDRESS_MAP);
-       map = 0;
-       pci_config_read8(addr, &map);
-
-       first = 8;
-       last = 0;
-       for (i = 0; i < 8; i++) {
-               if ((map & (1 << i)) != 0) {
-                       if (first > i)
-                               first = i;
-                       if (last < i)
-                               last = i;
-               }
-       }
-       pbm->mem_space.start = mbase + (first << 29UL);
-       pbm->mem_space.end   = mbase + (last << 29UL) + ((1 << 29UL) - 1);
+       pbm->mem_space.start = (p->pbm_A.controller_regs + SABRE_MEMSPACE);
+       pbm->mem_space.end = (pbm->mem_space.start + ((1UL << 32UL) - 1UL));
        pbm->mem_space.flags = IORESOURCE_MEM;
 
        if (request_resource(&ioport_resource, &pbm->io_space) < 0) {
-               prom_printf("Cannot register PBM-%c's IO space.\n",
-                           (pbm == &p->pbm_A ? 'A' : 'B'));
+               prom_printf("Cannot register Sabre's IO space.\n");
                prom_halt();
        }
        if (request_resource(&iomem_resource, &pbm->mem_space) < 0) {
-               prom_printf("Cannot register PBM-%c's MEM space.\n",
-                           (pbm == &p->pbm_A ? 'A' : 'B'));
+               prom_printf("Cannot register Sabre's MEM space.\n");
                prom_halt();
        }
 
-       /* Register legacy regions if this PBM covers that area. */
-       if (pbm->io_space.start == ibase &&
-           pbm->mem_space.start == mbase)
-               pci_register_legacy_regions(&pbm->io_space,
-                                           &pbm->mem_space);
-}
-
-static void sabre_pbm_init(struct pci_controller_info *p, struct device_node 
*dp, u32 dma_start, u32 dma_end)
-{
-       struct pci_pbm_info *pbm;
-       struct device_node *node;
-       struct property *prop;
-       u32 *busrange;
-       int len, simbas_found;
-
-       simbas_found = 0;
-       node = dp->child;
-       while (node != NULL) {
-               if (strcmp(node->name, "pci"))
-                       goto next_pci;
-
-               prop = of_find_property(node, "model", NULL);
-               if (!prop || strncmp(prop->value, "SUNW,simba", prop->length))
-                       goto next_pci;
-
-               simbas_found++;
-
-               prop = of_find_property(node, "bus-range", NULL);
-               busrange = prop->value;
-               if (busrange[0] == 1)
-                       pbm = &p->pbm_B;
-               else
-                       pbm = &p->pbm_A;
-
-               pbm->name = node->full_name;
-               printk("%s: SABRE PCI Bus Module\n", pbm->name);
-
-               pbm->chip_type = PBM_CHIP_TYPE_SABRE;
-               pbm->parent = p;
-               pbm->prom_node = node;
-               pbm->pci_first_slot = 1;
-               pbm->pci_first_busno = busrange[0];
-               pbm->pci_last_busno = busrange[1];
-
-               prop = of_find_property(node, "ranges", &len);
-               if (prop) {
-                       pbm->pbm_ranges = prop->value;
-                       pbm->num_pbm_ranges =
-                               (len / sizeof(struct linux_prom_pci_ranges));
-               } else {
-                       pbm->num_pbm_ranges = 0;
-               }
-
-               prop = of_find_property(node, "interrupt-map", &len);
-               if (prop) {
-                       pbm->pbm_intmap = prop->value;
-                       pbm->num_pbm_intmap =
-                               (len / sizeof(struct linux_prom_pci_intmap));
-
-                       prop = of_find_property(node, "interrupt-map-mask",
-                                               NULL);
-                       pbm->pbm_intmask = prop->value;
-               } else {
-                       pbm->num_pbm_intmap = 0;
-               }
-
-               pbm_register_toplevel_resources(p, pbm);
-
-       next_pci:
-               node = node->sibling;
-       }
-       if (simbas_found == 0) {
-               struct resource *rp;
-
-               /* No APBs underneath, probably this is a hummingbird
-                * system.
-                */
-               pbm = &p->pbm_A;
-               pbm->parent = p;
-               pbm->prom_node = dp;
-               pbm->pci_first_busno = p->pci_first_busno;
-               pbm->pci_last_busno = p->pci_last_busno;
-
-               prop = of_find_property(dp, "ranges", &len);
-               if (prop) {
-                       pbm->pbm_ranges = prop->value;
-                       pbm->num_pbm_ranges =
-                               (len / sizeof(struct linux_prom_pci_ranges));
-               } else {
-                       pbm->num_pbm_ranges = 0;
-               }
-
-               prop = of_find_property(dp, "interrupt-map", &len);
-               if (prop) {
-                       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;
-               } else {
-                       pbm->num_pbm_intmap = 0;
-               }
-
-               pbm->name = dp->full_name;
-               printk("%s: SABRE PCI Bus Module\n", pbm->name);
-
-               pbm->io_space.name = pbm->mem_space.name = pbm->name;
-
-               /* Hack up top-level resources. */
-               pbm->io_space.start = p->pbm_A.controller_regs + SABRE_IOSPACE;
-               pbm->io_space.end   = pbm->io_space.start + (1UL << 24) - 1UL;
-               pbm->io_space.flags = IORESOURCE_IO;
-
-               pbm->mem_space.start =
-                       (p->pbm_A.controller_regs + SABRE_MEMSPACE);
-               pbm->mem_space.end =
-                       (pbm->mem_space.start + ((1UL << 32UL) - 1UL));
-               pbm->mem_space.flags = IORESOURCE_MEM;
-
-               if (request_resource(&ioport_resource, &pbm->io_space) < 0) {
-                       prom_printf("Cannot register Hummingbird's IO 
space.\n");
-                       prom_halt();
-               }
-               if (request_resource(&iomem_resource, &pbm->mem_space) < 0) {
-                       prom_printf("Cannot register Hummingbird's MEM 
space.\n");
-                       prom_halt();
-               }
-
-               rp = kmalloc(sizeof(*rp), GFP_KERNEL);
-               if (!rp) {
-                       prom_printf("Cannot allocate IOMMU resource.\n");
-                       prom_halt();
-               }
-               rp->name = "IOMMU";
-               rp->start = pbm->mem_space.start + (unsigned long) dma_start;
-               rp->end = pbm->mem_space.start + (unsigned long) dma_end - 1UL;
-               rp->flags = IORESOURCE_BUSY;
-               request_resource(&pbm->mem_space, rp);
-
-               pci_register_legacy_regions(&pbm->io_space,
-                                           &pbm->mem_space);
+       rp = kmalloc(sizeof(*rp), GFP_KERNEL);
+       if (!rp) {
+               prom_printf("Cannot allocate IOMMU resource.\n");
+               prom_halt();
        }
+       rp->name = "IOMMU";
+       rp->start = pbm->mem_space.start + (unsigned long) dma_start;
+       rp->end = pbm->mem_space.start + (unsigned long) dma_end - 1UL;
+       rp->flags = IORESOURCE_BUSY;
+       request_resource(&pbm->mem_space, rp);
+
+       pci_register_legacy_regions(&pbm->io_space,
+                                   &pbm->mem_space);
 }
 
 void sabre_init(struct device_node *dp, char *model_name)
@@ -1303,7 +1100,6 @@ void sabre_init(struct device_node *dp, char *model_name)
        struct linux_prom64_registers *pr_regs;
        struct pci_controller_info *p;
        struct pci_iommu *iommu;
-       struct property *prop;
        int tsbsize;
        u32 *busrange;
        u32 *vdma;
@@ -1314,13 +1110,9 @@ void sabre_init(struct device_node *dp, char *model_name)
        if (!strcmp(model_name, "pci108e,a001"))
                hummingbird_p = 1;
        else if (!strcmp(model_name, "SUNW,sabre")) {
-               prop = of_find_property(dp, "compatible", NULL);
-               if (prop) {
-                       const char *compat = prop->value;
-
-                       if (!strcmp(compat, "pci108e,a001"))
-                               hummingbird_p = 1;
-               }
+               const char *compat = of_get_property(dp, "compatible", NULL);
+               if (compat && !strcmp(compat, "pci108e,a001"))
+                       hummingbird_p = 1;
                if (!hummingbird_p) {
                        struct device_node *dp;
 
@@ -1344,18 +1136,14 @@ void sabre_init(struct device_node *dp, char 
*model_name)
                prom_printf("SABRE: Error, kmalloc(pci_iommu) failed.\n");
                prom_halt();
        }
-       p->pbm_A.iommu = p->pbm_B.iommu = iommu;
+       p->pbm_A.iommu = iommu;
 
-       upa_portid = 0xff;
-       prop = of_find_property(dp, "upa-portid", NULL);
-       if (prop)
-               upa_portid = *(u32 *) prop->value;
+       upa_portid = of_getintprop_default(dp, "upa-portid", 0xff);
 
        p->next = pci_controller_root;
        pci_controller_root = p;
 
        p->pbm_A.portid = upa_portid;
-       p->pbm_B.portid = upa_portid;
        p->index = pci_num_controllers++;
        p->pbms_same_domain = 1;
        p->scan_bus = sabre_scan_bus;
@@ -1367,14 +1155,12 @@ void sabre_init(struct device_node *dp, char 
*model_name)
         * Map in SABRE register set and report the presence of this SABRE.
         */
        
-       prop = of_find_property(dp, "reg", NULL);
-       pr_regs = prop->value;
+       pr_regs = of_get_property(dp, "reg", NULL);
 
        /*
         * First REG in property is base of entire SABRE register space.
         */
        p->pbm_A.controller_regs = pr_regs[0].phys_addr;
-       p->pbm_B.controller_regs = pr_regs[0].phys_addr;
 
        /* Clear interrupts */
 
@@ -1392,11 +1178,10 @@ void sabre_init(struct device_node *dp, char 
*model_name)
                     SABRE_PCICTRL_ARBPARK | SABRE_PCICTRL_AEN));
 
        /* Now map in PCI config space for entire SABRE. */
-       p->pbm_A.config_space = p->pbm_B.config_space =
+       p->pbm_A.config_space =
                (p->pbm_A.controller_regs + SABRE_CONFIGSPACE);
 
-       prop = of_find_property(dp, "virtual-dma", NULL);
-       vdma = prop->value;
+       vdma = of_get_property(dp, "virtual-dma", NULL);
 
        dma_mask = vdma[0];
        switch(vdma[1]) {
@@ -1420,8 +1205,7 @@ void sabre_init(struct device_node *dp, char *model_name)
 
        sabre_iommu_init(p, tsbsize, vdma[0], dma_mask);
 
-       prop = of_find_property(dp, "bus-range", NULL);
-       busrange = prop->value;
+       busrange = of_get_property(dp, "bus-range", NULL);
        p->pci_first_busno = busrange[0];
        p->pci_last_busno = busrange[1];
 
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to