[mirror_ubuntu-artful-kernel.git] / arch / sparc / kernel / ebus.c

/* $Id: ebus.c,v 1.20 2002/01/05 01:13:43 davem Exp $
 * ebus.c: PCI to EBus bridge device.
 *
 * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
 *
 * Adopted for sparc by V. Roganov and G. Raiko.
 * Fixes for different platforms by Pete Zaitcev.
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/string.h>

#include <asm/system.h>
#include <asm/page.h>
#include <asm/pbm.h>
#include <asm/ebus.h>
#include <asm/io.h>
#include <asm/oplib.h>
#include <asm/prom.h>
#include <asm/bpp.h>

struct linux_ebus *ebus_chain = NULL;

/* We are together with pcic.c under CONFIG_PCI. */
extern unsigned int pcic_pin_to_irq(unsigned int, const char *name);

/*
 * IRQ Blacklist
 * Here we list PROMs and systems that are known to supply crap as IRQ numbers.
 */
struct ebus_device_irq {
	char *name;
	unsigned int pin;
};

struct ebus_system_entry {
	char *esname;
	struct ebus_device_irq *ipt;
};

static struct ebus_device_irq je1_1[] = {
	{ "8042",		 3 },
	{ "SUNW,CS4231",	 0 },
	{ "parallel",		 0 },
	{ "se",			 2 },
	{ NULL, 0 }
};

/*
 * Gleb's JE1 supplied reasonable pin numbers, but mine did not (OBP 2.32).
 * Blacklist the sucker... Note that Gleb's system will work.
 */
static struct ebus_system_entry ebus_blacklist[] = {
	{ "SUNW,JavaEngine1", je1_1 },
	{ NULL, NULL }
};

static struct ebus_device_irq *ebus_blackp = NULL;

/*
 */
static inline unsigned long ebus_alloc(size_t size)
{
	return (unsigned long)kmalloc(size, GFP_ATOMIC);
}

/*
 */
int __init ebus_blacklist_irq(const char *name)
{
	struct ebus_device_irq *dp;

	if ((dp = ebus_blackp) != NULL) {
		for (; dp->name != NULL; dp++) {
			if (strcmp(name, dp->name) == 0) {
				return pcic_pin_to_irq(dp->pin, name);
			}
		}
	}
	return 0;
}

void __init fill_ebus_child(struct device_node *dp,
			    struct linux_ebus_child *dev)
{
	const int *regs;
	const int *irqs;
	int i, len;

	dev->prom_node = dp;
	regs = of_get_property(dp, "reg", &len);
	if (!regs)
		len = 0;
	dev->num_addrs = len / sizeof(regs[0]);

	for (i = 0; i < dev->num_addrs; i++) {
		if (regs[i] >= dev->parent->num_addrs) {
			prom_printf("UGH: property for %s was %d, need < %d\n",
				    dev->prom_node->name, len,
				    dev->parent->num_addrs);
			panic(__FUNCTION__);
		}

		/* XXX resource */
		dev->resource[i].start =
			dev->parent->resource[regs[i]].start;
	}

	for (i = 0; i < PROMINTR_MAX; i++)
		dev->irqs[i] = PCI_IRQ_NONE;

	if ((dev->irqs[0] = ebus_blacklist_irq(dev->prom_node->name)) != 0) {
		dev->num_irqs = 1;
	} else {
		irqs = of_get_property(dp, "interrupts", &len);
		if (!irqs) {
			dev->num_irqs = 0;
			dev->irqs[0] = 0;
			if (dev->parent->num_irqs != 0) {
				dev->num_irqs = 1;
				dev->irqs[0] = dev->parent->irqs[0];
			}
		} else {
			dev->num_irqs = len / sizeof(irqs[0]);
			if (irqs[0] == 0 || irqs[0] >= 8) {
				/*
				 * XXX Zero is a valid pin number...
				 * This works as long as Ebus is not wired
				 * to INTA#.
				 */
				printk("EBUS: %s got bad irq %d from PROM\n",
				       dev->prom_node->name, irqs[0]);
				dev->num_irqs = 0;
				dev->irqs[0] = 0;
			} else {
				dev->irqs[0] =
					pcic_pin_to_irq(irqs[0],
							dev->prom_node->name);
			}
		}
	}
}

void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *dev)
{
	const struct linux_prom_registers *regs;
	struct linux_ebus_child *child;
	const int *irqs;
	int i, n, len;
	unsigned long baseaddr;

	dev->prom_node = dp;

	regs = of_get_property(dp, "reg", &len);
	if (len % sizeof(struct linux_prom_registers)) {
		prom_printf("UGH: proplen for %s was %d, need multiple of %d\n",
			    dev->prom_node->name, len,
			    (int)sizeof(struct linux_prom_registers));
		panic(__FUNCTION__);
	}
	dev->num_addrs = len / sizeof(struct linux_prom_registers);

	for (i = 0; i < dev->num_addrs; i++) {
		/*
		 * XXX Collect JE-1 PROM
		 * 
		 * Example - JS-E with 3.11:
		 *  /ebus
		 *      regs 
		 *        0x00000000, 0x0, 0x00000000, 0x0, 0x00000000,
		 *        0x82000010, 0x0, 0xf0000000, 0x0, 0x01000000,
		 *        0x82000014, 0x0, 0x38800000, 0x0, 0x00800000,
		 *      ranges
		 *        0x00, 0x00000000, 0x02000010, 0x0, 0x0, 0x01000000,
		 *        0x01, 0x01000000, 0x02000014, 0x0, 0x0, 0x00800000,
		 *  /ebus/8042
		 *      regs
		 *        0x00000001, 0x00300060, 0x00000008,
		 *        0x00000001, 0x00300060, 0x00000008,
		 */
		n = regs[i].which_io;
		if (n >= 4) {
			/* XXX This is copied from old JE-1 by Gleb. */
			n = (regs[i].which_io - 0x10) >> 2;
		} else {
			;
		}

/*
 * XXX Now as we have regions, why don't we make an on-demand allocation...
 */
		dev->resource[i].start = 0;
		if ((baseaddr = dev->bus->self->resource[n].start +
		    regs[i].phys_addr) != 0) {
			/* dev->resource[i].name = dev->prom_name; */
			if ((baseaddr = (unsigned long) ioremap(baseaddr,
			    regs[i].reg_size)) == 0) {
				panic("ebus: unable to remap dev %s",
				      dev->prom_node->name);
			}
		}
		dev->resource[i].start = baseaddr;	/* XXX Unaligned */
	}

	for (i = 0; i < PROMINTR_MAX; i++)
		dev->irqs[i] = PCI_IRQ_NONE;

	if ((dev->irqs[0] = ebus_blacklist_irq(dev->prom_node->name)) != 0) {
		dev->num_irqs = 1;
	} else {
		irqs = of_get_property(dp, "interrupts", &len);
		if (!irqs) {
			dev->num_irqs = 0;
			if ((dev->irqs[0] = dev->bus->self->irq) != 0) {
				dev->num_irqs = 1;
/* P3 */ /* printk("EBUS: child %s irq %d from parent\n", dev->prom_name, dev->irqs[0]); */
			}
		} else {
			dev->num_irqs = 1;  /* dev->num_irqs = len / sizeof(irqs[0]); */
			if (irqs[0] == 0 || irqs[0] >= 8) {
				/* See above for the parent. XXX */
				printk("EBUS: %s got bad irq %d from PROM\n",
				       dev->prom_node->name, irqs[0]);
				dev->num_irqs = 0;
				dev->irqs[0] = 0;
			} else {
				dev->irqs[0] =
					pcic_pin_to_irq(irqs[0],
							dev->prom_node->name);
			}
		}
	}

	dev->ofdev.node = dp;
	dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
	dev->ofdev.dev.bus = &ebus_bus_type;
	sprintf(dev->ofdev.dev.bus_id, "ebus[%08x]", dp->node);

	/* Register with core */
	if (of_device_register(&dev->ofdev) != 0)
		printk(KERN_DEBUG "ebus: device registration error for %s!\n",
		       dp->path_component_name);

	if ((dp = dp->child) != NULL) {
		dev->children = (struct linux_ebus_child *)
			ebus_alloc(sizeof(struct linux_ebus_child));

		child = dev->children;
		child->next = NULL;
		child->parent = dev;
		child->bus = dev->bus;
		fill_ebus_child(dp, child);

		while ((dp = dp->sibling) != NULL) {
			child->next = (struct linux_ebus_child *)
				ebus_alloc(sizeof(struct linux_ebus_child));

			child = child->next;
			child->next = NULL;
			child->parent = dev;
			child->bus = dev->bus;
			fill_ebus_child(dp, child);
		}
	}
}

void __init ebus_init(void)
{
	const struct linux_prom_pci_registers *regs;
	struct linux_pbm_info *pbm;
	struct linux_ebus_device *dev;
	struct linux_ebus *ebus;
	struct ebus_system_entry *sp;
	struct pci_dev *pdev;
	struct pcidev_cookie *cookie;
	struct device_node *dp;
	struct resource *p;
	unsigned short pci_command;
	int len, reg, nreg;
	int num_ebus = 0;

	dp = of_find_node_by_path("/");
	for (sp = ebus_blacklist; sp->esname != NULL; sp++) {
		if (strcmp(dp->name, sp->esname) == 0) {
			ebus_blackp = sp->ipt;
			break;
		}
	}

	pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_EBUS, NULL);
	if (!pdev)
		return;

	cookie = pdev->sysdata;
	dp = cookie->prom_node;

	ebus_chain = ebus = (struct linux_ebus *)
			ebus_alloc(sizeof(struct linux_ebus));
	ebus->next = NULL;

	while (dp) {
		struct device_node *nd;

		ebus->prom_node = dp;
		ebus->self = pdev;
		ebus->parent = pbm = cookie->pbm;

		/* Enable BUS Master. */
		pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
		pci_command |= PCI_COMMAND_MASTER;
		pci_write_config_word(pdev, PCI_COMMAND, pci_command);

		regs = of_get_property(dp, "reg", &len);
		if (!regs) {
			prom_printf("%s: can't find reg property\n",
				    __FUNCTION__);
			prom_halt();
		}
		nreg = len / sizeof(struct linux_prom_pci_registers);

		p = &ebus->self->resource[0];
		for (reg = 0; reg < nreg; reg++) {
			if (!(regs[reg].which_io & 0x03000000))
				continue;

			(p++)->start = regs[reg].phys_lo;
		}

		ebus->ofdev.node = dp;
		ebus->ofdev.dev.parent = &pdev->dev;
		ebus->ofdev.dev.bus = &ebus_bus_type;
		sprintf(ebus->ofdev.dev.bus_id, "ebus%d", num_ebus);

		/* Register with core */
		if (of_device_register(&ebus->ofdev) != 0)
			printk(KERN_DEBUG "ebus: device registration error for %s!\n",
			       dp->path_component_name);


		nd = dp->child;
		if (!nd)
			goto next_ebus;

		ebus->devices = (struct linux_ebus_device *)
				ebus_alloc(sizeof(struct linux_ebus_device));

		dev = ebus->devices;
		dev->next = NULL;
		dev->children = NULL;
		dev->bus = ebus;
		fill_ebus_device(nd, dev);

		while ((nd = nd->sibling) != NULL) {
			dev->next = (struct linux_ebus_device *)
				ebus_alloc(sizeof(struct linux_ebus_device));

			dev = dev->next;
			dev->next = NULL;
			dev->children = NULL;
			dev->bus = ebus;
			fill_ebus_device(nd, dev);
		}

	next_ebus:
		pdev = pci_get_device(PCI_VENDOR_ID_SUN,
				       PCI_DEVICE_ID_SUN_EBUS, pdev);
		if (!pdev)
			break;

		cookie = pdev->sysdata;
		dp = cookie->prom_node;

		ebus->next = (struct linux_ebus *)
			ebus_alloc(sizeof(struct linux_ebus));
		ebus = ebus->next;
		ebus->next = NULL;
		++num_ebus;
	}
	if (pdev)
		pci_dev_put(pdev);
}
Commit	Line	Data
1da177e4 LT	1	/* $Id: ebus.c,v 1.20 2002/01/05 01:13:43 davem Exp $
	2	* ebus.c: PCI to EBus bridge device.
	3	*
	4	* Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
	5	*
	6	* Adopted for sparc by V. Roganov and G. Raiko.
	7	* Fixes for different platforms by Pete Zaitcev.
	8	*/
	9
1da177e4 LT	10	#include <linux/kernel.h>
	11	#include <linux/types.h>
	12	#include <linux/init.h>
	13	#include <linux/slab.h>
	14	#include <linux/string.h>
	15
	16	#include <asm/system.h>
	17	#include <asm/page.h>
	18	#include <asm/pbm.h>
	19	#include <asm/ebus.h>
	20	#include <asm/io.h>
	21	#include <asm/oplib.h>
942a6bdd	22	#include <asm/prom.h>
1da177e4 LT	23	#include <asm/bpp.h>
1da177e4 LT	24
e4fe342f	25	struct linux_ebus *ebus_chain = NULL;
1da177e4 LT	26
1da177e4 LT	27	/* We are together with pcic.c under CONFIG_PCI. */
ee5ac9dd	28	extern unsigned int pcic_pin_to_irq(unsigned int, const char *name);
1da177e4 LT	29
	30	/*
	31	* IRQ Blacklist
	32	* Here we list PROMs and systems that are known to supply crap as IRQ numbers.
	33	*/
	34	struct ebus_device_irq {
	35	char *name;
	36	unsigned int pin;
	37	};
	38
	39	struct ebus_system_entry {
	40	char *esname;
	41	struct ebus_device_irq *ipt;
	42	};
	43
	44	static struct ebus_device_irq je1_1[] = {
	45	{ "8042", 3 },
	46	{ "SUNW,CS4231", 0 },
	47	{ "parallel", 0 },
	48	{ "se", 2 },
e4fe342f	49	{ NULL, 0 }
1da177e4 LT	50	};
	51
	52	/*
	53	* Gleb's JE1 supplied reasonable pin numbers, but mine did not (OBP 2.32).
	54	* Blacklist the sucker... Note that Gleb's system will work.
	55	*/
	56	static struct ebus_system_entry ebus_blacklist[] = {
	57	{ "SUNW,JavaEngine1", je1_1 },
e4fe342f	58	{ NULL, NULL }
1da177e4 LT	59	};
	60
	61	static struct ebus_device_irq *ebus_blackp = NULL;
	62
	63	/*
	64	*/
	65	static inline unsigned long ebus_alloc(size_t size)
	66	{
	67	return (unsigned long)kmalloc(size, GFP_ATOMIC);
	68	}
	69
	70	/*
	71	*/
ee5ac9dd	72	int __init ebus_blacklist_irq(const char *name)
1da177e4 LT	73	{
	74	struct ebus_device_irq *dp;
	75
	76	if ((dp = ebus_blackp) != NULL) {
	77	for (; dp->name != NULL; dp++) {
	78	if (strcmp(name, dp->name) == 0) {
	79	return pcic_pin_to_irq(dp->pin, name);
	80	}
	81	}
	82	}
	83	return 0;
	84	}
	85
942a6bdd DM	86	void __init fill_ebus_child(struct device_node *dp,
942a6bdd DM	87	struct linux_ebus_child *dev)
1da177e4	88	{
8271f042 SR	89	const int *regs;
8271f042 SR	90	const int *irqs;
1da177e4 LT	91	int i, len;
1da177e4 LT	92
942a6bdd DM	93	dev->prom_node = dp;
	94	regs = of_get_property(dp, "reg", &len);
	95	if (!regs)
	96	len = 0;
1da177e4 LT	97	dev->num_addrs = len / sizeof(regs[0]);
	98
	99	for (i = 0; i < dev->num_addrs; i++) {
	100	if (regs[i] >= dev->parent->num_addrs) {
	101	prom_printf("UGH: property for %s was %d, need < %d\n",
942a6bdd DM	102	dev->prom_node->name, len,
942a6bdd DM	103	dev->parent->num_addrs);
1da177e4 LT	104	panic(__FUNCTION__);
1da177e4 LT	105	}
942a6bdd DM	106
	107	/* XXX resource */
	108	dev->resource[i].start =
	109	dev->parent->resource[regs[i]].start;
1da177e4 LT	110	}
	111
	112	for (i = 0; i < PROMINTR_MAX; i++)
	113	dev->irqs[i] = PCI_IRQ_NONE;
	114
942a6bdd	115	if ((dev->irqs[0] = ebus_blacklist_irq(dev->prom_node->name)) != 0) {
1da177e4	116	dev->num_irqs = 1;
1da177e4	117	} else {
942a6bdd DM	118	irqs = of_get_property(dp, "interrupts", &len);
942a6bdd DM	119	if (!irqs) {
1da177e4 LT	120	dev->num_irqs = 0;
1da177e4 LT	121	dev->irqs[0] = 0;
942a6bdd DM	122	if (dev->parent->num_irqs != 0) {
	123	dev->num_irqs = 1;
	124	dev->irqs[0] = dev->parent->irqs[0];
	125	}
1da177e4	126	} else {
942a6bdd DM	127	dev->num_irqs = len / sizeof(irqs[0]);
	128	if (irqs[0] == 0 \|\| irqs[0] >= 8) {
	129	/*
	130	* XXX Zero is a valid pin number...
	131	* This works as long as Ebus is not wired
	132	* to INTA#.
	133	*/
	134	printk("EBUS: %s got bad irq %d from PROM\n",
	135	dev->prom_node->name, irqs[0]);
	136	dev->num_irqs = 0;
	137	dev->irqs[0] = 0;
	138	} else {
	139	dev->irqs[0] =
	140	pcic_pin_to_irq(irqs[0],
	141	dev->prom_node->name);
	142	}
1da177e4 LT	143	}
	144	}
	145	}
	146
942a6bdd	147	void __init fill_ebus_device(struct device_node dp, struct linux_ebus_device dev)
1da177e4	148	{
8271f042	149	const struct linux_prom_registers *regs;
1da177e4	150	struct linux_ebus_child *child;
8271f042	151	const int *irqs;
1da177e4 LT	152	int i, n, len;
	153	unsigned long baseaddr;
	154
942a6bdd	155	dev->prom_node = dp;
1da177e4	156
942a6bdd	157	regs = of_get_property(dp, "reg", &len);
1da177e4 LT	158	if (len % sizeof(struct linux_prom_registers)) {
1da177e4 LT	159	prom_printf("UGH: proplen for %s was %d, need multiple of %d\n",
942a6bdd	160	dev->prom_node->name, len,
1da177e4 LT	161	(int)sizeof(struct linux_prom_registers));
	162	panic(__FUNCTION__);
	163	}
	164	dev->num_addrs = len / sizeof(struct linux_prom_registers);
	165
	166	for (i = 0; i < dev->num_addrs; i++) {
	167	/*
	168	* XXX Collect JE-1 PROM
	169	*
	170	* Example - JS-E with 3.11:
	171	* /ebus
	172	* regs
	173	* 0x00000000, 0x0, 0x00000000, 0x0, 0x00000000,
	174	* 0x82000010, 0x0, 0xf0000000, 0x0, 0x01000000,
	175	* 0x82000014, 0x0, 0x38800000, 0x0, 0x00800000,
	176	* ranges
	177	* 0x00, 0x00000000, 0x02000010, 0x0, 0x0, 0x01000000,
	178	* 0x01, 0x01000000, 0x02000014, 0x0, 0x0, 0x00800000,
	179	* /ebus/8042
	180	* regs
	181	* 0x00000001, 0x00300060, 0x00000008,
	182	* 0x00000001, 0x00300060, 0x00000008,
	183	*/
	184	n = regs[i].which_io;
	185	if (n >= 4) {
	186	/* XXX This is copied from old JE-1 by Gleb. */
	187	n = (regs[i].which_io - 0x10) >> 2;
	188	} else {
	189	;
	190	}
	191
	192	/*
	193	* XXX Now as we have regions, why don't we make an on-demand allocation...
	194	*/
	195	dev->resource[i].start = 0;
	196	if ((baseaddr = dev->bus->self->resource[n].start +
	197	regs[i].phys_addr) != 0) {
	198	/* dev->resource[i].name = dev->prom_name; */
	199	if ((baseaddr = (unsigned long) ioremap(baseaddr,
	200	regs[i].reg_size)) == 0) {
	201	panic("ebus: unable to remap dev %s",
942a6bdd	202	dev->prom_node->name);
1da177e4 LT	203	}
	204	}
	205	dev->resource[i].start = baseaddr; /* XXX Unaligned */
	206	}
	207
	208	for (i = 0; i < PROMINTR_MAX; i++)
	209	dev->irqs[i] = PCI_IRQ_NONE;
	210
942a6bdd	211	if ((dev->irqs[0] = ebus_blacklist_irq(dev->prom_node->name)) != 0) {
1da177e4	212	dev->num_irqs = 1;
1da177e4	213	} else {
942a6bdd DM	214	irqs = of_get_property(dp, "interrupts", &len);
942a6bdd DM	215	if (!irqs) {
1da177e4	216	dev->num_irqs = 0;
942a6bdd DM	217	if ((dev->irqs[0] = dev->bus->self->irq) != 0) {
	218	dev->num_irqs = 1;
	219	/* P3 / / printk("EBUS: child %s irq %d from parent\n", dev->prom_name, dev->irqs[0]); */
	220	}
1da177e4	221	} else {
942a6bdd DM	222	dev->num_irqs = 1; /* dev->num_irqs = len / sizeof(irqs[0]); */
	223	if (irqs[0] == 0 \|\| irqs[0] >= 8) {
	224	/* See above for the parent. XXX */
	225	printk("EBUS: %s got bad irq %d from PROM\n",
	226	dev->prom_node->name, irqs[0]);
	227	dev->num_irqs = 0;
	228	dev->irqs[0] = 0;
	229	} else {
	230	dev->irqs[0] =
	231	pcic_pin_to_irq(irqs[0],
	232	dev->prom_node->name);
	233	}
1da177e4 LT	234	}
	235	}
	236
fd531431 DM	237	dev->ofdev.node = dp;
	238	dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
	239	dev->ofdev.dev.bus = &ebus_bus_type;
f5ef9d11	240	sprintf(dev->ofdev.dev.bus_id, "ebus[%08x]", dp->node);
fd531431 DM	241
	242	/* Register with core */
	243	if (of_device_register(&dev->ofdev) != 0)
	244	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
f5ef9d11	245	dp->path_component_name);
fd531431	246
942a6bdd	247	if ((dp = dp->child) != NULL) {
1da177e4 LT	248	dev->children = (struct linux_ebus_child *)
	249	ebus_alloc(sizeof(struct linux_ebus_child));
	250
	251	child = dev->children;
e4fe342f	252	child->next = NULL;
1da177e4 LT	253	child->parent = dev;
1da177e4 LT	254	child->bus = dev->bus;
942a6bdd	255	fill_ebus_child(dp, child);
1da177e4	256
942a6bdd	257	while ((dp = dp->sibling) != NULL) {
1da177e4 LT	258	child->next = (struct linux_ebus_child *)
	259	ebus_alloc(sizeof(struct linux_ebus_child));
	260
	261	child = child->next;
e4fe342f	262	child->next = NULL;
1da177e4 LT	263	child->parent = dev;
1da177e4 LT	264	child->bus = dev->bus;
942a6bdd	265	fill_ebus_child(dp, child);
1da177e4 LT	266	}
	267	}
	268	}
	269
	270	void __init ebus_init(void)
	271	{
8271f042	272	const struct linux_prom_pci_registers *regs;
1da177e4 LT	273	struct linux_pbm_info *pbm;
	274	struct linux_ebus_device *dev;
	275	struct linux_ebus *ebus;
	276	struct ebus_system_entry *sp;
	277	struct pci_dev *pdev;
	278	struct pcidev_cookie *cookie;
942a6bdd	279	struct device_node *dp;
cc9bd99e	280	struct resource *p;
1da177e4	281	unsigned short pci_command;
942a6bdd	282	int len, reg, nreg;
1da177e4 LT	283	int num_ebus = 0;
1da177e4 LT	284
942a6bdd	285	dp = of_find_node_by_path("/");
1da177e4	286	for (sp = ebus_blacklist; sp->esname != NULL; sp++) {
942a6bdd	287	if (strcmp(dp->name, sp->esname) == 0) {
1da177e4 LT	288	ebus_blackp = sp->ipt;
	289	break;
	290	}
	291	}
	292
e4fe342f	293	pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_EBUS, NULL);
942a6bdd	294	if (!pdev)
1da177e4	295	return;
942a6bdd	296
1da177e4	297	cookie = pdev->sysdata;
942a6bdd	298	dp = cookie->prom_node;
1da177e4 LT	299
	300	ebus_chain = ebus = (struct linux_ebus *)
	301	ebus_alloc(sizeof(struct linux_ebus));
e4fe342f	302	ebus->next = NULL;
1da177e4	303
942a6bdd DM	304	while (dp) {
942a6bdd DM	305	struct device_node *nd;
1da177e4	306
942a6bdd	307	ebus->prom_node = dp;
1da177e4 LT	308	ebus->self = pdev;
	309	ebus->parent = pbm = cookie->pbm;
	310
	311	/* Enable BUS Master. */
	312	pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
	313	pci_command \|= PCI_COMMAND_MASTER;
	314	pci_write_config_word(pdev, PCI_COMMAND, pci_command);
	315
942a6bdd DM	316	regs = of_get_property(dp, "reg", &len);
942a6bdd DM	317	if (!regs) {
1da177e4 LT	318	prom_printf("%s: can't find reg property\n",
	319	__FUNCTION__);
	320	prom_halt();
	321	}
	322	nreg = len / sizeof(struct linux_prom_pci_registers);
	323
cc9bd99e	324	p = &ebus->self->resource[0];
1da177e4 LT	325	for (reg = 0; reg < nreg; reg++) {
	326	if (!(regs[reg].which_io & 0x03000000))
	327	continue;
	328
cc9bd99e	329	(p++)->start = regs[reg].phys_lo;
1da177e4 LT	330	}
1da177e4 LT	331
fd531431 DM	332	ebus->ofdev.node = dp;
	333	ebus->ofdev.dev.parent = &pdev->dev;
	334	ebus->ofdev.dev.bus = &ebus_bus_type;
f5ef9d11	335	sprintf(ebus->ofdev.dev.bus_id, "ebus%d", num_ebus);
fd531431 DM	336
	337	/* Register with core */
	338	if (of_device_register(&ebus->ofdev) != 0)
	339	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
f5ef9d11	340	dp->path_component_name);
fd531431 DM	341
fd531431 DM	342
942a6bdd	343	nd = dp->child;
1da177e4 LT	344	if (!nd)
	345	goto next_ebus;
	346
	347	ebus->devices = (struct linux_ebus_device *)
	348	ebus_alloc(sizeof(struct linux_ebus_device));
	349
	350	dev = ebus->devices;
e4fe342f AV	351	dev->next = NULL;
e4fe342f AV	352	dev->children = NULL;
1da177e4 LT	353	dev->bus = ebus;
	354	fill_ebus_device(nd, dev);
	355
942a6bdd	356	while ((nd = nd->sibling) != NULL) {
1da177e4 LT	357	dev->next = (struct linux_ebus_device *)
	358	ebus_alloc(sizeof(struct linux_ebus_device));
	359
	360	dev = dev->next;
e4fe342f AV	361	dev->next = NULL;
e4fe342f AV	362	dev->children = NULL;
1da177e4 LT	363	dev->bus = ebus;
	364	fill_ebus_device(nd, dev);
	365	}
	366
	367	next_ebus:
	368	pdev = pci_get_device(PCI_VENDOR_ID_SUN,
	369	PCI_DEVICE_ID_SUN_EBUS, pdev);
	370	if (!pdev)
	371	break;
	372
	373	cookie = pdev->sysdata;
942a6bdd	374	dp = cookie->prom_node;
1da177e4 LT	375
	376	ebus->next = (struct linux_ebus *)
	377	ebus_alloc(sizeof(struct linux_ebus));
	378	ebus = ebus->next;
e4fe342f	379	ebus->next = NULL;
1da177e4 LT	380	++num_ebus;
	381	}
	382	if (pdev)
	383	pci_dev_put(pdev);
	384	}