drivers/sbus/sbus.c - linux/kernel/git/davem/net-next - Git at Google

 /* $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);
	/* $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 = (2510001000);
	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);