Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 564 insertions, 0 deletions

diff --git a/drivers/sbus/sbus.c b/drivers/sbus/sbus.c
new file mode 100644
index 000000000000..5d30a3ebfccd
--- /dev/null
+++ b/drivers/sbus/sbus.c
@@ -0,0 +1,564 @@
+/* $Id: sbus.c,v 1.100 2002/01/24 15:36:24 davem Exp $
+ * sbus.c:  SBus support routines.
+ *
+ * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+
+#include <asm/system.h>
+#include <asm/sbus.h>
+#include <asm/dma.h>
+#include <asm/oplib.h>
+#include <asm/bpp.h>
+#include <asm/irq.h>
+
+struct sbus_bus *sbus_root = NULL;
+
+static struct linux_prom_irqs irqs[PROMINTR_MAX] __initdata = { { 0 } };
+#ifdef CONFIG_SPARC32
+static int interrupts[PROMINTR_MAX] __initdata = { 0 };
+#endif
+
+#ifdef CONFIG_PCI
+extern int pcic_present(void);
+#endif
+
+/* Perhaps when I figure out more about the iommu we'll put a
+ * device registration routine here that probe_sbus() calls to
+ * setup the iommu for each Sbus.
+ */
+
+/* We call this for each SBus device, and fill the structure based
+ * upon the prom device tree.  We return the start of memory after
+ * the things we have allocated.
+ */
+
+/* #define DEBUG_FILL */
+
+static void __init fill_sbus_device(int prom_node, struct sbus_dev *sdev)
+{
+        unsigned long address, base;
+        int len;
+
+        sdev->prom_node = prom_node;
+        prom_getstring(prom_node, "name",
+                       sdev->prom_name, sizeof(sdev->prom_name));
+        address = prom_getint(prom_node, "address");
+        len = prom_getproperty(prom_node, "reg",
+                               (char *) sdev->reg_addrs,
+                               sizeof(sdev->reg_addrs));
+        if (len == -1) {
+                sdev->num_registers = 0;
+                goto no_regs;
+        }
+
+        if (len % sizeof(struct linux_prom_registers)) {
+                prom_printf("fill_sbus_device: proplen for regs of %s "
+                            " was %d, need multiple of %d\n",
+                            sdev->prom_name, len,
+                            (int) sizeof(struct linux_prom_registers));
+                prom_halt();
+        }
+        if (len > (sizeof(struct linux_prom_registers) * PROMREG_MAX)) {
+                prom_printf("fill_sbus_device: Too many register properties "
+                            "for device %s, len=%d\n",
+                            sdev->prom_name, len);
+                prom_halt();
+        }
+        sdev->num_registers = len / sizeof(struct linux_prom_registers);
+        sdev->ranges_applied = 0;
+
+        base = (unsigned long) sdev->reg_addrs[0].phys_addr;
+
+        /* Compute the slot number. */
+        if (base >= SUN_SBUS_BVADDR && sparc_cpu_model == sun4m) {
+                sdev->slot = sbus_dev_slot(base);
+        } else {
+                sdev->slot = sdev->reg_addrs[0].which_io;
+        }
+
+no_regs:
+        len = prom_getproperty(prom_node, "ranges",
+                               (char *)sdev->device_ranges,
+                               sizeof(sdev->device_ranges));
+        if (len == -1) {
+                sdev->num_device_ranges = 0;
+                goto no_ranges;
+        }
+        if (len % sizeof(struct linux_prom_ranges)) {
+                prom_printf("fill_sbus_device: proplen for ranges of %s "
+                            " was %d, need multiple of %d\n",
+                            sdev->prom_name, len,
+                            (int) sizeof(struct linux_prom_ranges));
+                prom_halt();
+        }
+        if (len > (sizeof(struct linux_prom_ranges) * PROMREG_MAX)) {
+                prom_printf("fill_sbus_device: Too many range properties "
+                            "for device %s, len=%d\n",
+                            sdev->prom_name, len);
+                prom_halt();
+        }
+        sdev->num_device_ranges =
+                len / sizeof(struct linux_prom_ranges);
+
+no_ranges:
+        /* XXX Unfortunately, IRQ issues are very arch specific.
+         * XXX Pull this crud out into an arch specific area
+         * XXX at some point. -DaveM
+         */
+#ifdef CONFIG_SPARC64
+        len = prom_getproperty(prom_node, "interrupts",
+                               (char *) irqs, sizeof(irqs));
+        if (len == -1 || len == 0) {
+                sdev->irqs[0] = 0;
+                sdev->num_irqs = 0;
+        } else {
+                unsigned int pri = irqs[0].pri;
+
+                sdev->num_irqs = 1;
+                if (pri < 0x20)
+                        pri += sdev->slot * 8;
+
+                sdev->irqs[0] = sbus_build_irq(sdev->bus, pri);
+        }
+#endif /* CONFIG_SPARC64 */
+
+#ifdef CONFIG_SPARC32
+        len = prom_getproperty(prom_node, "intr",
+                               (char *)irqs, sizeof(irqs));
+        if (len != -1) {
+                sdev->num_irqs = len / 8;
+                if (sdev->num_irqs == 0) {
+                        sdev->irqs[0] = 0;
+                } else if (sparc_cpu_model == sun4d) {
+                        extern unsigned int sun4d_build_irq(struct sbus_dev *sdev, int irq);
+
+                        for (len = 0; len < sdev->num_irqs; len++)
+                                sdev->irqs[len] = sun4d_build_irq(sdev, irqs[len].pri);
+                } else {
+                        for (len = 0; len < sdev->num_irqs; len++)
+                                sdev->irqs[len] = irqs[len].pri;
+                }
+        } else {
+                /* No "intr" node found-- check for "interrupts" node.
+                 * This node contains SBus interrupt levels, not IPLs
+                 * as in "intr", and no vector values.  We convert 
+                 * SBus interrupt levels to PILs (platform specific).
+                 */
+                len = prom_getproperty(prom_node, "interrupts", 
+                                        (char *)interrupts, sizeof(interrupts));
+                if (len == -1) {
+                        sdev->irqs[0] = 0;
+                        sdev->num_irqs = 0;
+                } else {
+                        sdev->num_irqs = len / sizeof(int);
+                        for (len = 0; len < sdev->num_irqs; len++) {
+                                sdev->irqs[len] = sbint_to_irq(sdev, interrupts[len]);
+                        }
+                }
+        } 
+#endif /* CONFIG_SPARC32 */
+}
+
+/* This routine gets called from whoever needs the sbus first, to scan
+ * the SBus device tree.  Currently it just prints out the devices
+ * found on the bus and builds trees of SBUS structs and attached
+ * devices.
+ */
+
+extern void iommu_init(int iommu_node, struct sbus_bus *sbus);
+extern void iounit_init(int sbi_node, int iounit_node, struct sbus_bus *sbus);
+void sun4_init(void);
+#ifdef CONFIG_SUN_AUXIO
+extern void auxio_probe(void);
+#endif
+
+static void __init sbus_do_child_siblings(int start_node,
+                                          struct sbus_dev *child,
+                                          struct sbus_dev *parent,
+                                          struct sbus_bus *sbus)
+{
+        struct sbus_dev *this_dev = child;
+        int this_node = start_node;
+
+        /* Child already filled in, just need to traverse siblings. */
+        child->child = NULL;
+        child->parent = parent;
+        while((this_node = prom_getsibling(this_node)) != 0) {
+                this_dev->next = kmalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
+                this_dev = this_dev->next;
+                this_dev->next = NULL;
+                this_dev->parent = parent;
+
+                this_dev->bus = sbus;
+                fill_sbus_device(this_node, this_dev);
+
+                if(prom_getchild(this_node)) {
+                        this_dev->child = kmalloc(sizeof(struct sbus_dev),
+                                                  GFP_ATOMIC);
+                        this_dev->child->bus = sbus;
+                        this_dev->child->next = NULL;
+                        fill_sbus_device(prom_getchild(this_node), this_dev->child);
+                        sbus_do_child_siblings(prom_getchild(this_node),
+                                               this_dev->child, this_dev, sbus);
+                } else {
+                        this_dev->child = NULL;
+                }
+        }
+}
+
+/*
+ * XXX This functions appears to be a distorted version of
+ * prom_sbus_ranges_init(), with all sun4d stuff cut away.
+ * Ask DaveM what is going on here, how is sun4d supposed to work... XXX
+ */
+/* added back sun4d patch from Thomas Bogendoerfer - should be OK (crn) */
+
+static void __init sbus_bus_ranges_init(int parent_node, struct sbus_bus *sbus)
+{
+        int len;
+
+        len = prom_getproperty(sbus->prom_node, "ranges",
+                               (char *) sbus->sbus_ranges,
+                               sizeof(sbus->sbus_ranges));
+        if (len == -1 || len == 0) {
+                sbus->num_sbus_ranges = 0;
+                return;
+        }
+        sbus->num_sbus_ranges = len / sizeof(struct linux_prom_ranges);
+#ifdef CONFIG_SPARC32
+        if (sparc_cpu_model == sun4d) {
+                struct linux_prom_ranges iounit_ranges[PROMREG_MAX];
+                int num_iounit_ranges;
+
+                len = prom_getproperty(parent_node, "ranges",
+                                       (char *) iounit_ranges,
+                                       sizeof (iounit_ranges));
+                if (len != -1) {
+                        num_iounit_ranges = (len/sizeof(struct linux_prom_ranges));
+                        prom_adjust_ranges (sbus->sbus_ranges, sbus->num_sbus_ranges, iounit_ranges, num_iounit_ranges);
+                }
+        }
+#endif
+}
+
+static void __init __apply_ranges_to_regs(struct linux_prom_ranges *ranges,
+                                          int num_ranges,
+                                          struct linux_prom_registers *regs,
+                                          int num_regs)
+{
+        if (num_ranges) {
+                int regnum;
+
+                for (regnum = 0; regnum < num_regs; regnum++) {
+                        int rngnum;
+
+                        for (rngnum = 0; rngnum < num_ranges; rngnum++) {
+                                if (regs[regnum].which_io == ranges[rngnum].ot_child_space)
+                                        break;
+                        }
+                        if (rngnum == num_ranges) {
+                                /* We used to flag this as an error.  Actually
+                                 * some devices do not report the regs as we expect.
+                                 * For example, see SUNW,pln device.  In that case
+                                 * the reg property is in a format internal to that
+                                 * node, ie. it is not in the SBUS register space
+                                 * per se. -DaveM
+                                 */
+                                return;
+                        }
+                        regs[regnum].which_io = ranges[rngnum].ot_parent_space;
+                        regs[regnum].phys_addr -= ranges[rngnum].ot_child_base;
+                        regs[regnum].phys_addr += ranges[rngnum].ot_parent_base;
+                }
+        }
+}
+
+static void __init __fixup_regs_sdev(struct sbus_dev *sdev)
+{
+        if (sdev->num_registers != 0) {
+                struct sbus_dev *parent = sdev->parent;
+                int i;
+
+                while (parent != NULL) {
+                        __apply_ranges_to_regs(parent->device_ranges,
+                                               parent->num_device_ranges,
+                                               sdev->reg_addrs,
+                                               sdev->num_registers);
+
+                        parent = parent->parent;
+                }
+
+                __apply_ranges_to_regs(sdev->bus->sbus_ranges,
+                                       sdev->bus->num_sbus_ranges,
+                                       sdev->reg_addrs,
+                                       sdev->num_registers);
+
+                for (i = 0; i < sdev->num_registers; i++) {
+                        struct resource *res = &sdev->resource[i];
+
+                        res->start = sdev->reg_addrs[i].phys_addr;
+                        res->end = (res->start +
+                                    (unsigned long)sdev->reg_addrs[i].reg_size - 1UL);
+                        res->flags = IORESOURCE_IO |
+                                (sdev->reg_addrs[i].which_io & 0xff);
+                }
+        }
+}
+
+static void __init sbus_fixup_all_regs(struct sbus_dev *first_sdev)
+{
+        struct sbus_dev *sdev;
+
+        for (sdev = first_sdev; sdev; sdev = sdev->next) {
+                if (sdev->child)
+                        sbus_fixup_all_regs(sdev->child);
+                __fixup_regs_sdev(sdev);
+        }
+}
+
+extern void register_proc_sparc_ioport(void);
+extern void firetruck_init(void);
+
+#ifdef CONFIG_SUN4
+extern void sun4_dvma_init(void);
+#endif
+
+static int __init sbus_init(void)
+{
+        int nd, this_sbus, sbus_devs, topnd, iommund;
+        unsigned int sbus_clock;
+        struct sbus_bus *sbus;
+        struct sbus_dev *this_dev;
+        int num_sbus = 0;  /* How many did we find? */
+
+#ifdef CONFIG_SPARC32
+        register_proc_sparc_ioport();
+#endif
+
+#ifdef CONFIG_SUN4
+        sun4_dvma_init();
+        return 0;
+#endif
+
+        topnd = prom_getchild(prom_root_node);
+        
+        /* Finding the first sbus is a special case... */
+        iommund = 0;
+        if(sparc_cpu_model == sun4u) {
+                nd = prom_searchsiblings(topnd, "sbus");
+                if(nd == 0) {
+#ifdef CONFIG_PCI
+                        if (!pcic_present()) {
+                                prom_printf("Neither SBUS nor PCI found.\n");
+                                prom_halt();
+                        } else {
+#ifdef CONFIG_SPARC64
+                                firetruck_init();
+#endif
+                        }
+                        return 0;
+#else
+                        prom_printf("YEEE, UltraSparc sbus not found\n");
+                        prom_halt();
+#endif
+                }
+        } else if(sparc_cpu_model == sun4d) {
+                if((iommund = prom_searchsiblings(topnd, "io-unit")) == 0 ||
+                   (nd = prom_getchild(iommund)) == 0 ||
+                   (nd = prom_searchsiblings(nd, "sbi")) == 0) {
+                        panic("sbi not found");
+                }
+        } else if((nd = prom_searchsiblings(topnd, "sbus")) == 0) {
+                if((iommund = prom_searchsiblings(topnd, "iommu")) == 0 ||
+                   (nd = prom_getchild(iommund)) == 0 ||
+                   (nd = prom_searchsiblings(nd, "sbus")) == 0) {
+#ifdef CONFIG_PCI
+                        if (!pcic_present()) {
+                                prom_printf("Neither SBUS nor PCI found.\n");
+                                prom_halt();
+                        }
+                        return 0;
+#else
+                        /* No reason to run further - the data access trap will occur. */
+                        panic("sbus not found");
+#endif
+                }
+        }
+
+        /* Ok, we've found the first one, allocate first SBus struct
+         * and place in chain.
+         */
+        sbus = sbus_root = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
+        sbus->next = NULL;
+        sbus->prom_node = nd;
+        this_sbus = nd;
+
+        if(iommund && sparc_cpu_model != sun4u && sparc_cpu_model != sun4d)
+                iommu_init(iommund, sbus);
+
+        /* Loop until we find no more SBUS's */
+        while(this_sbus) {
+#ifdef CONFIG_SPARC64
+                /* IOMMU hides inside SBUS/SYSIO prom node on Ultra. */
+                if(sparc_cpu_model == sun4u) {
+                        extern void sbus_iommu_init(int prom_node, struct sbus_bus *sbus);
+
+                        sbus_iommu_init(this_sbus, sbus);
+                }
+#endif /* CONFIG_SPARC64 */
+
+#ifdef CONFIG_SPARC32
+                if (sparc_cpu_model == sun4d)
+                        iounit_init(this_sbus, iommund, sbus);
+#endif /* CONFIG_SPARC32 */
+                printk("sbus%d: ", num_sbus);
+                sbus_clock = prom_getint(this_sbus, "clock-frequency");
+                if(sbus_clock == -1)
+                        sbus_clock = (25*1000*1000);
+                printk("Clock %d.%d MHz\n", (int) ((sbus_clock/1000)/1000),
+                       (int) (((sbus_clock/1000)%1000 != 0) ? 
+                              (((sbus_clock/1000)%1000) + 1000) : 0));
+
+                prom_getstring(this_sbus, "name",
+                               sbus->prom_name, sizeof(sbus->prom_name));
+                sbus->clock_freq = sbus_clock;
+#ifdef CONFIG_SPARC32
+                if (sparc_cpu_model == sun4d) {
+                        sbus->devid = prom_getint(iommund, "device-id");
+                        sbus->board = prom_getint(iommund, "board#");
+                }
+#endif
+                
+                sbus_bus_ranges_init(iommund, sbus);
+
+                sbus_devs = prom_getchild(this_sbus);
+                if (!sbus_devs) {
+                        sbus->devices = NULL;
+                        goto next_bus;
+                }
+
+                sbus->devices = kmalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
+
+                this_dev = sbus->devices;
+                this_dev->next = NULL;
+
+                this_dev->bus = sbus;
+                this_dev->parent = NULL;
+                fill_sbus_device(sbus_devs, this_dev);
+
+                /* Should we traverse for children? */
+                if(prom_getchild(sbus_devs)) {
+                        /* Allocate device node */
+                        this_dev->child = kmalloc(sizeof(struct sbus_dev),
+                                                  GFP_ATOMIC);
+                        /* Fill it */
+                        this_dev->child->bus = sbus;
+                        this_dev->child->next = NULL;
+                        fill_sbus_device(prom_getchild(sbus_devs),
+                                         this_dev->child);
+                        sbus_do_child_siblings(prom_getchild(sbus_devs),
+                                               this_dev->child,
+                                               this_dev,
+                                               sbus);
+                } else {
+                        this_dev->child = NULL;
+                }
+
+                while((sbus_devs = prom_getsibling(sbus_devs)) != 0) {
+                        /* Allocate device node */
+                        this_dev->next = kmalloc(sizeof(struct sbus_dev),
+                                                 GFP_ATOMIC);
+                        this_dev = this_dev->next;
+                        this_dev->next = NULL;
+
+                        /* Fill it */
+                        this_dev->bus = sbus;
+                        this_dev->parent = NULL;
+                        fill_sbus_device(sbus_devs, this_dev);
+
+                        /* Is there a child node hanging off of us? */
+                        if(prom_getchild(sbus_devs)) {
+                                /* Get new device struct */
+                                this_dev->child = kmalloc(sizeof(struct sbus_dev),
+                                                          GFP_ATOMIC);
+                                /* Fill it */
+                                this_dev->child->bus = sbus;
+                                this_dev->child->next = NULL;
+                                fill_sbus_device(prom_getchild(sbus_devs),
+                                                 this_dev->child);
+                                sbus_do_child_siblings(prom_getchild(sbus_devs),
+                                                       this_dev->child,
+                                                       this_dev,
+                                                       sbus);
+                        } else {
+                                this_dev->child = NULL;
+                        }
+                }
+
+                /* Walk all devices and apply parent ranges. */
+                sbus_fixup_all_regs(sbus->devices);
+
+                dvma_init(sbus);
+        next_bus:
+                num_sbus++;
+                if(sparc_cpu_model == sun4u) {
+                        this_sbus = prom_getsibling(this_sbus);
+                        if(!this_sbus)
+                                break;
+                        this_sbus = prom_searchsiblings(this_sbus, "sbus");
+                } else if(sparc_cpu_model == sun4d) {
+                        iommund = prom_getsibling(iommund);
+                        if(!iommund)
+                                break;
+                        iommund = prom_searchsiblings(iommund, "io-unit");
+                        if(!iommund)
+                                break;
+                        this_sbus = prom_searchsiblings(prom_getchild(iommund), "sbi");
+                } else {
+                        this_sbus = prom_getsibling(this_sbus);
+                        if(!this_sbus)
+                                break;
+                        this_sbus = prom_searchsiblings(this_sbus, "sbus");
+                }
+                if(this_sbus) {
+                        sbus->next = kmalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
+                        sbus = sbus->next;
+                        sbus->next = NULL;
+                        sbus->prom_node = this_sbus;
+                } else {
+                        break;
+                }
+        } /* while(this_sbus) */
+
+        if (sparc_cpu_model == sun4d) {
+                extern void sun4d_init_sbi_irq(void);
+                sun4d_init_sbi_irq();
+        }
+        
+#ifdef CONFIG_SPARC64
+        if (sparc_cpu_model == sun4u) {
+                firetruck_init();
+        }
+#endif
+#ifdef CONFIG_SUN_AUXIO
+        if (sparc_cpu_model == sun4u)
+                auxio_probe ();
+#endif
+#ifdef CONFIG_SPARC64
+        if (sparc_cpu_model == sun4u) {
+                extern void clock_probe(void);
+
+                clock_probe();
+        }
+#endif
+
+        return 0;
+}
+
+subsys_initcall(sbus_init);