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

/*
 * 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(__func__);
		}

		/* 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;
	struct dev_archdata *sd;
	const int *irqs;
	int i, n, len;
	unsigned long baseaddr;

	dev->prom_node = dp;

	regs = of_get_property(dp, "reg", &len);
	if (!regs)
		len = 0;
	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(__func__);
	}
	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);
			}
		}
	}

	sd = &dev->ofdev.dev.archdata;
	sd->prom_node = dp;
	sd->op = &dev->ofdev;
	sd->iommu = dev->bus->ofdev.dev.parent->archdata.iommu;

	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",
				    __func__);
			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
88278ca2	1	/*
1da177e4 LT	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);
74074dec	104	panic(__func__);
1da177e4	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;
3d6e4702	151	struct dev_archdata *sd;
8271f042	152	const int *irqs;
1da177e4 LT	153	int i, n, len;
	154	unsigned long baseaddr;
	155
942a6bdd	156	dev->prom_node = dp;
1da177e4	157
942a6bdd	158	regs = of_get_property(dp, "reg", &len);
9c908f97 DM	159	if (!regs)
9c908f97 DM	160	len = 0;
1da177e4 LT	161	if (len % sizeof(struct linux_prom_registers)) {
1da177e4 LT	162	prom_printf("UGH: proplen for %s was %d, need multiple of %d\n",
942a6bdd	163	dev->prom_node->name, len,
1da177e4	164	(int)sizeof(struct linux_prom_registers));
74074dec	165	panic(__func__);
1da177e4 LT	166	}
	167	dev->num_addrs = len / sizeof(struct linux_prom_registers);
	168
	169	for (i = 0; i < dev->num_addrs; i++) {
	170	/*
	171	* XXX Collect JE-1 PROM
	172	*
	173	* Example - JS-E with 3.11:
	174	* /ebus
	175	* regs
	176	* 0x00000000, 0x0, 0x00000000, 0x0, 0x00000000,
	177	* 0x82000010, 0x0, 0xf0000000, 0x0, 0x01000000,
	178	* 0x82000014, 0x0, 0x38800000, 0x0, 0x00800000,
	179	* ranges
	180	* 0x00, 0x00000000, 0x02000010, 0x0, 0x0, 0x01000000,
	181	* 0x01, 0x01000000, 0x02000014, 0x0, 0x0, 0x00800000,
	182	* /ebus/8042
	183	* regs
	184	* 0x00000001, 0x00300060, 0x00000008,
	185	* 0x00000001, 0x00300060, 0x00000008,
	186	*/
	187	n = regs[i].which_io;
	188	if (n >= 4) {
	189	/* XXX This is copied from old JE-1 by Gleb. */
	190	n = (regs[i].which_io - 0x10) >> 2;
	191	} else {
	192	;
	193	}
	194
	195	/*
	196	* XXX Now as we have regions, why don't we make an on-demand allocation...
	197	*/
	198	dev->resource[i].start = 0;
	199	if ((baseaddr = dev->bus->self->resource[n].start +
	200	regs[i].phys_addr) != 0) {
	201	/* dev->resource[i].name = dev->prom_name; */
	202	if ((baseaddr = (unsigned long) ioremap(baseaddr,
	203	regs[i].reg_size)) == 0) {
	204	panic("ebus: unable to remap dev %s",
942a6bdd	205	dev->prom_node->name);
1da177e4 LT	206	}
	207	}
	208	dev->resource[i].start = baseaddr; /* XXX Unaligned */
	209	}
	210
	211	for (i = 0; i < PROMINTR_MAX; i++)
	212	dev->irqs[i] = PCI_IRQ_NONE;
	213
942a6bdd	214	if ((dev->irqs[0] = ebus_blacklist_irq(dev->prom_node->name)) != 0) {
1da177e4	215	dev->num_irqs = 1;
1da177e4	216	} else {
942a6bdd DM	217	irqs = of_get_property(dp, "interrupts", &len);
942a6bdd DM	218	if (!irqs) {
1da177e4	219	dev->num_irqs = 0;
942a6bdd DM	220	if ((dev->irqs[0] = dev->bus->self->irq) != 0) {
	221	dev->num_irqs = 1;
	222	/* P3 / / printk("EBUS: child %s irq %d from parent\n", dev->prom_name, dev->irqs[0]); */
	223	}
1da177e4	224	} else {
942a6bdd DM	225	dev->num_irqs = 1; /* dev->num_irqs = len / sizeof(irqs[0]); */
	226	if (irqs[0] == 0 \|\| irqs[0] >= 8) {
	227	/* See above for the parent. XXX */
	228	printk("EBUS: %s got bad irq %d from PROM\n",
	229	dev->prom_node->name, irqs[0]);
	230	dev->num_irqs = 0;
	231	dev->irqs[0] = 0;
	232	} else {
	233	dev->irqs[0] =
	234	pcic_pin_to_irq(irqs[0],
	235	dev->prom_node->name);
	236	}
1da177e4 LT	237	}
	238	}
	239
3d6e4702 DM	240	sd = &dev->ofdev.dev.archdata;
	241	sd->prom_node = dp;
	242	sd->op = &dev->ofdev;
3ac4c949	243	sd->iommu = dev->bus->ofdev.dev.parent->archdata.iommu;
3d6e4702	244
fd531431 DM	245	dev->ofdev.node = dp;
	246	dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
	247	dev->ofdev.dev.bus = &ebus_bus_type;
f5ef9d11	248	sprintf(dev->ofdev.dev.bus_id, "ebus[%08x]", dp->node);
fd531431 DM	249
	250	/* Register with core */
	251	if (of_device_register(&dev->ofdev) != 0)
	252	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
f5ef9d11	253	dp->path_component_name);
fd531431	254
942a6bdd	255	if ((dp = dp->child) != NULL) {
1da177e4 LT	256	dev->children = (struct linux_ebus_child *)
	257	ebus_alloc(sizeof(struct linux_ebus_child));
	258
	259	child = dev->children;
e4fe342f	260	child->next = NULL;
1da177e4 LT	261	child->parent = dev;
1da177e4 LT	262	child->bus = dev->bus;
942a6bdd	263	fill_ebus_child(dp, child);
1da177e4	264
942a6bdd	265	while ((dp = dp->sibling) != NULL) {
1da177e4 LT	266	child->next = (struct linux_ebus_child *)
	267	ebus_alloc(sizeof(struct linux_ebus_child));
	268
	269	child = child->next;
e4fe342f	270	child->next = NULL;
1da177e4 LT	271	child->parent = dev;
1da177e4 LT	272	child->bus = dev->bus;
942a6bdd	273	fill_ebus_child(dp, child);
1da177e4 LT	274	}
	275	}
	276	}
	277
	278	void __init ebus_init(void)
	279	{
8271f042	280	const struct linux_prom_pci_registers *regs;
1da177e4 LT	281	struct linux_pbm_info *pbm;
	282	struct linux_ebus_device *dev;
	283	struct linux_ebus *ebus;
	284	struct ebus_system_entry *sp;
	285	struct pci_dev *pdev;
	286	struct pcidev_cookie *cookie;
942a6bdd	287	struct device_node *dp;
cc9bd99e	288	struct resource *p;
1da177e4	289	unsigned short pci_command;
942a6bdd	290	int len, reg, nreg;
1da177e4 LT	291	int num_ebus = 0;
1da177e4 LT	292
942a6bdd	293	dp = of_find_node_by_path("/");
1da177e4	294	for (sp = ebus_blacklist; sp->esname != NULL; sp++) {
942a6bdd	295	if (strcmp(dp->name, sp->esname) == 0) {
1da177e4 LT	296	ebus_blackp = sp->ipt;
	297	break;
	298	}
	299	}
	300
e4fe342f	301	pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_EBUS, NULL);
942a6bdd	302	if (!pdev)
1da177e4	303	return;
942a6bdd	304
1da177e4	305	cookie = pdev->sysdata;
942a6bdd	306	dp = cookie->prom_node;
1da177e4 LT	307
	308	ebus_chain = ebus = (struct linux_ebus *)
	309	ebus_alloc(sizeof(struct linux_ebus));
e4fe342f	310	ebus->next = NULL;
1da177e4	311
942a6bdd DM	312	while (dp) {
942a6bdd DM	313	struct device_node *nd;
1da177e4	314
942a6bdd	315	ebus->prom_node = dp;
1da177e4 LT	316	ebus->self = pdev;
	317	ebus->parent = pbm = cookie->pbm;
	318
	319	/* Enable BUS Master. */
	320	pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
	321	pci_command \|= PCI_COMMAND_MASTER;
	322	pci_write_config_word(pdev, PCI_COMMAND, pci_command);
	323
942a6bdd DM	324	regs = of_get_property(dp, "reg", &len);
942a6bdd DM	325	if (!regs) {
1da177e4	326	prom_printf("%s: can't find reg property\n",
74074dec	327	__func__);
1da177e4 LT	328	prom_halt();
	329	}
	330	nreg = len / sizeof(struct linux_prom_pci_registers);
	331
cc9bd99e	332	p = &ebus->self->resource[0];
1da177e4 LT	333	for (reg = 0; reg < nreg; reg++) {
	334	if (!(regs[reg].which_io & 0x03000000))
	335	continue;
	336
cc9bd99e	337	(p++)->start = regs[reg].phys_lo;
1da177e4 LT	338	}
1da177e4 LT	339
fd531431 DM	340	ebus->ofdev.node = dp;
	341	ebus->ofdev.dev.parent = &pdev->dev;
	342	ebus->ofdev.dev.bus = &ebus_bus_type;
f5ef9d11	343	sprintf(ebus->ofdev.dev.bus_id, "ebus%d", num_ebus);
fd531431 DM	344
	345	/* Register with core */
	346	if (of_device_register(&ebus->ofdev) != 0)
	347	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
f5ef9d11	348	dp->path_component_name);
fd531431 DM	349
fd531431 DM	350
942a6bdd	351	nd = dp->child;
1da177e4 LT	352	if (!nd)
	353	goto next_ebus;
	354
	355	ebus->devices = (struct linux_ebus_device *)
	356	ebus_alloc(sizeof(struct linux_ebus_device));
	357
	358	dev = ebus->devices;
e4fe342f AV	359	dev->next = NULL;
e4fe342f AV	360	dev->children = NULL;
1da177e4 LT	361	dev->bus = ebus;
	362	fill_ebus_device(nd, dev);
	363
942a6bdd	364	while ((nd = nd->sibling) != NULL) {
1da177e4 LT	365	dev->next = (struct linux_ebus_device *)
	366	ebus_alloc(sizeof(struct linux_ebus_device));
	367
	368	dev = dev->next;
e4fe342f AV	369	dev->next = NULL;
e4fe342f AV	370	dev->children = NULL;
1da177e4 LT	371	dev->bus = ebus;
	372	fill_ebus_device(nd, dev);
	373	}
	374
	375	next_ebus:
	376	pdev = pci_get_device(PCI_VENDOR_ID_SUN,
	377	PCI_DEVICE_ID_SUN_EBUS, pdev);
	378	if (!pdev)
	379	break;
	380
	381	cookie = pdev->sysdata;
942a6bdd	382	dp = cookie->prom_node;
1da177e4 LT	383
	384	ebus->next = (struct linux_ebus *)
	385	ebus_alloc(sizeof(struct linux_ebus));
	386	ebus = ebus->next;
e4fe342f	387	ebus->next = NULL;
1da177e4 LT	388	++num_ebus;
	389	}
	390	if (pdev)
	391	pci_dev_put(pdev);
	392	}