[deliverable/linux.git] / arch / sparc64 / kernel / ebus.c

/* $Id: ebus.c,v 1.64 2001/11/08 04:41:33 davem Exp $
 * ebus.c: PCI to EBus bridge device.
 *
 * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
 * Copyright (C) 1999  David S. Miller (davem@redhat.com)
 */

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

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

/* EBUS dma library. */

#define EBDMA_CSR	0x00UL	/* Control/Status */
#define EBDMA_ADDR	0x04UL	/* DMA Address */
#define EBDMA_COUNT	0x08UL	/* DMA Count */

#define EBDMA_CSR_INT_PEND	0x00000001
#define EBDMA_CSR_ERR_PEND	0x00000002
#define EBDMA_CSR_DRAIN		0x00000004
#define EBDMA_CSR_INT_EN	0x00000010
#define EBDMA_CSR_RESET		0x00000080
#define EBDMA_CSR_WRITE		0x00000100
#define EBDMA_CSR_EN_DMA	0x00000200
#define EBDMA_CSR_CYC_PEND	0x00000400
#define EBDMA_CSR_DIAG_RD_DONE	0x00000800
#define EBDMA_CSR_DIAG_WR_DONE	0x00001000
#define EBDMA_CSR_EN_CNT	0x00002000
#define EBDMA_CSR_TC		0x00004000
#define EBDMA_CSR_DIS_CSR_DRN	0x00010000
#define EBDMA_CSR_BURST_SZ_MASK	0x000c0000
#define EBDMA_CSR_BURST_SZ_1	0x00080000
#define EBDMA_CSR_BURST_SZ_4	0x00000000
#define EBDMA_CSR_BURST_SZ_8	0x00040000
#define EBDMA_CSR_BURST_SZ_16	0x000c0000
#define EBDMA_CSR_DIAG_EN	0x00100000
#define EBDMA_CSR_DIS_ERR_PEND	0x00400000
#define EBDMA_CSR_TCI_DIS	0x00800000
#define EBDMA_CSR_EN_NEXT	0x01000000
#define EBDMA_CSR_DMA_ON	0x02000000
#define EBDMA_CSR_A_LOADED	0x04000000
#define EBDMA_CSR_NA_LOADED	0x08000000
#define EBDMA_CSR_DEV_ID_MASK	0xf0000000

#define EBUS_DMA_RESET_TIMEOUT	10000

static void __ebus_dma_reset(struct ebus_dma_info *p, int no_drain)
{
	int i;
	u32 val = 0;

	writel(EBDMA_CSR_RESET, p->regs + EBDMA_CSR);
	udelay(1);

	if (no_drain)
		return;

	for (i = EBUS_DMA_RESET_TIMEOUT; i > 0; i--) {
		val = readl(p->regs + EBDMA_CSR);

		if (!(val & (EBDMA_CSR_DRAIN | EBDMA_CSR_CYC_PEND)))
			break;
		udelay(10);
	}
}

static irqreturn_t ebus_dma_irq(int irq, void *dev_id)
{
	struct ebus_dma_info *p = dev_id;
	unsigned long flags;
	u32 csr = 0;

	spin_lock_irqsave(&p->lock, flags);
	csr = readl(p->regs + EBDMA_CSR);
	writel(csr, p->regs + EBDMA_CSR);
	spin_unlock_irqrestore(&p->lock, flags);

	if (csr & EBDMA_CSR_ERR_PEND) {
		printk(KERN_CRIT "ebus_dma(%s): DMA error!\n", p->name);
		p->callback(p, EBUS_DMA_EVENT_ERROR, p->client_cookie);
		return IRQ_HANDLED;
	} else if (csr & EBDMA_CSR_INT_PEND) {
		p->callback(p,
			    (csr & EBDMA_CSR_TC) ?
			    EBUS_DMA_EVENT_DMA : EBUS_DMA_EVENT_DEVICE,
			    p->client_cookie);
		return IRQ_HANDLED;
	}

	return IRQ_NONE;

}

int ebus_dma_register(struct ebus_dma_info *p)
{
	u32 csr;

	if (!p->regs)
		return -EINVAL;
	if (p->flags & ~(EBUS_DMA_FLAG_USE_EBDMA_HANDLER |
			 EBUS_DMA_FLAG_TCI_DISABLE))
		return -EINVAL;
	if ((p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) && !p->callback)
		return -EINVAL;
	if (!strlen(p->name))
		return -EINVAL;

	__ebus_dma_reset(p, 1);

	csr = EBDMA_CSR_BURST_SZ_16 | EBDMA_CSR_EN_CNT;

	if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE)
		csr |= EBDMA_CSR_TCI_DIS;

	writel(csr, p->regs + EBDMA_CSR);

	return 0;
}
EXPORT_SYMBOL(ebus_dma_register);

int ebus_dma_irq_enable(struct ebus_dma_info *p, int on)
{
	unsigned long flags;
	u32 csr;

	if (on) {
		if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) {
			if (request_irq(p->irq, ebus_dma_irq, IRQF_SHARED, p->name, p))
				return -EBUSY;
		}

		spin_lock_irqsave(&p->lock, flags);
		csr = readl(p->regs + EBDMA_CSR);
		csr |= EBDMA_CSR_INT_EN;
		writel(csr, p->regs + EBDMA_CSR);
		spin_unlock_irqrestore(&p->lock, flags);
	} else {
		spin_lock_irqsave(&p->lock, flags);
		csr = readl(p->regs + EBDMA_CSR);
		csr &= ~EBDMA_CSR_INT_EN;
		writel(csr, p->regs + EBDMA_CSR);
		spin_unlock_irqrestore(&p->lock, flags);

		if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) {
			free_irq(p->irq, p);
		}
	}

	return 0;
}
EXPORT_SYMBOL(ebus_dma_irq_enable);

void ebus_dma_unregister(struct ebus_dma_info *p)
{
	unsigned long flags;
	u32 csr;
	int irq_on = 0;

	spin_lock_irqsave(&p->lock, flags);
	csr = readl(p->regs + EBDMA_CSR);
	if (csr & EBDMA_CSR_INT_EN) {
		csr &= ~EBDMA_CSR_INT_EN;
		writel(csr, p->regs + EBDMA_CSR);
		irq_on = 1;
	}
	spin_unlock_irqrestore(&p->lock, flags);

	if (irq_on)
		free_irq(p->irq, p);
}
EXPORT_SYMBOL(ebus_dma_unregister);

int ebus_dma_request(struct ebus_dma_info *p, dma_addr_t bus_addr, size_t len)
{
	unsigned long flags;
	u32 csr;
	int err;

	if (len >= (1 << 24))
		return -EINVAL;

	spin_lock_irqsave(&p->lock, flags);
	csr = readl(p->regs + EBDMA_CSR);
	err = -EINVAL;
	if (!(csr & EBDMA_CSR_EN_DMA))
		goto out;
	err = -EBUSY;
	if (csr & EBDMA_CSR_NA_LOADED)
		goto out;

	writel(len,      p->regs + EBDMA_COUNT);
	writel(bus_addr, p->regs + EBDMA_ADDR);
	err = 0;

out:
	spin_unlock_irqrestore(&p->lock, flags);

	return err;
}
EXPORT_SYMBOL(ebus_dma_request);

void ebus_dma_prepare(struct ebus_dma_info *p, int write)
{
	unsigned long flags;
	u32 csr;

	spin_lock_irqsave(&p->lock, flags);
	__ebus_dma_reset(p, 0);

	csr = (EBDMA_CSR_INT_EN |
	       EBDMA_CSR_EN_CNT |
	       EBDMA_CSR_BURST_SZ_16 |
	       EBDMA_CSR_EN_NEXT);

	if (write)
		csr |= EBDMA_CSR_WRITE;
	if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE)
		csr |= EBDMA_CSR_TCI_DIS;

	writel(csr, p->regs + EBDMA_CSR);

	spin_unlock_irqrestore(&p->lock, flags);
}
EXPORT_SYMBOL(ebus_dma_prepare);

unsigned int ebus_dma_residue(struct ebus_dma_info *p)
{
	return readl(p->regs + EBDMA_COUNT);
}
EXPORT_SYMBOL(ebus_dma_residue);

unsigned int ebus_dma_addr(struct ebus_dma_info *p)
{
	return readl(p->regs + EBDMA_ADDR);
}
EXPORT_SYMBOL(ebus_dma_addr);

void ebus_dma_enable(struct ebus_dma_info *p, int on)
{
	unsigned long flags;
	u32 orig_csr, csr;

	spin_lock_irqsave(&p->lock, flags);
	orig_csr = csr = readl(p->regs + EBDMA_CSR);
	if (on)
		csr |= EBDMA_CSR_EN_DMA;
	else
		csr &= ~EBDMA_CSR_EN_DMA;
	if ((orig_csr & EBDMA_CSR_EN_DMA) !=
	    (csr & EBDMA_CSR_EN_DMA))
		writel(csr, p->regs + EBDMA_CSR);
	spin_unlock_irqrestore(&p->lock, flags);
}
EXPORT_SYMBOL(ebus_dma_enable);

struct linux_ebus *ebus_chain = NULL;

static inline void *ebus_alloc(size_t size)
{
	void *mem;

	mem = kzalloc(size, GFP_ATOMIC);
	if (!mem)
		panic("ebus_alloc: out of memory");
	return mem;
}

static void __init fill_ebus_child(struct device_node *dp,
				   struct linux_ebus_child *dev,
				   int non_standard_regs)
{
	struct of_device *op;
	int *regs;
	int i, len;

	dev->prom_node = dp;
	printk(" (%s)", dp->name);

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

	if (non_standard_regs) {
		/* This is to handle reg properties which are not
		 * in the parent relative format.  One example are
		 * children of the i2c device on CompactPCI systems.
		 *
		 * So, for such devices we just record the property
		 * raw in the child resources.
		 */
		for (i = 0; i < dev->num_addrs; i++)
			dev->resource[i].start = regs[i];
	} else {
		for (i = 0; i < dev->num_addrs; i++) {
			int rnum = regs[i];
			if (rnum >= dev->parent->num_addrs) {
				prom_printf("UGH: property for %s was %d, need < %d\n",
					    dp->name, len, dev->parent->num_addrs);
				prom_halt();
			}
			dev->resource[i].start = dev->parent->resource[i].start;
			dev->resource[i].end = dev->parent->resource[i].end;
			dev->resource[i].flags = IORESOURCE_MEM;
			dev->resource[i].name = dp->name;
		}
	}

	op = of_find_device_by_node(dp);
	if (!op) {
		dev->num_irqs = 0;
	} else {
		dev->num_irqs = op->num_irqs;
		for (i = 0; i < dev->num_irqs; i++)
			dev->irqs[i] = op->irqs[i];
	}

	if (!dev->num_irqs) {
		/*
		 * Oh, well, some PROMs don't export interrupts
		 * property to children of EBus devices...
		 *
		 * Be smart about PS/2 keyboard and mouse.
		 */
		if (!strcmp(dev->parent->prom_node->name, "8042")) {
			if (!strcmp(dev->prom_node->name, "kb_ps2")) {
				dev->num_irqs = 1;
				dev->irqs[0] = dev->parent->irqs[0];
			} else {
				dev->num_irqs = 1;
				dev->irqs[0] = dev->parent->irqs[1];
			}
		}
	}
}

static int __init child_regs_nonstandard(struct linux_ebus_device *dev)
{
	if (!strcmp(dev->prom_node->name, "i2c") ||
	    !strcmp(dev->prom_node->name, "SUNW,lombus"))
		return 1;
	return 0;
}

static void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *dev)
{
	struct linux_ebus_child *child;
	struct of_device *op;
	int i, len;

	dev->prom_node = dp;

	printk(" [%s", dp->name);

	op = of_find_device_by_node(dp);
	if (!op) {
		dev->num_addrs = 0;
		dev->num_irqs = 0;
	} else {
		(void) of_get_property(dp, "reg", &len);
		dev->num_addrs = len / sizeof(struct linux_prom_registers);

		for (i = 0; i < dev->num_addrs; i++)
			memcpy(&dev->resource[i],
			       &op->resource[i],
			       sizeof(struct resource));

		dev->num_irqs = op->num_irqs;
		for (i = 0; i < dev->num_irqs; i++)
			dev->irqs[i] = op->irqs[i];
	}

	dev->ofdev.node = dp;
	dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
	dev->ofdev.dev.bus = &ebus_bus_type;
	strcpy(dev->ofdev.dev.bus_id, dp->path_component_name);

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

	dp = dp->child;
	if (dp) {
		printk(" ->");
		dev->children = 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,
				child_regs_nonstandard(dev));

		while ((dp = dp->sibling) != NULL) {
			child->next = 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,
					child_regs_nonstandard(dev));
		}
	}
	printk("]");
}

static struct pci_dev *find_next_ebus(struct pci_dev *start, int *is_rio_p)
{
	struct pci_dev *pdev = start;

	while ((pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_ANY_ID, pdev)))
		if (pdev->device == PCI_DEVICE_ID_SUN_EBUS ||
			pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS)
			break;

	*is_rio_p = !!(pdev && (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS));

	return pdev;
}

void __init ebus_init(void)
{
	struct pci_pbm_info *pbm;
	struct linux_ebus_device *dev;
	struct linux_ebus *ebus;
	struct pci_dev *pdev;
	struct pcidev_cookie *cookie;
	struct device_node *dp;
	int is_rio;
	int num_ebus = 0;

	pdev = find_next_ebus(NULL, &is_rio);
	if (!pdev) {
		printk("ebus: No EBus's found.\n");
		return;
	}

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

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

	while (dp) {
		struct device_node *child;

		/* SUNW,pci-qfe uses four empty ebuses on it.
		   I think we should not consider them here,
		   as they have half of the properties this
		   code expects and once we do PCI hot-plug,
		   we'd have to tweak with the ebus_chain
		   in the runtime after initialization. -jj */
		if (!dp->child) {
			pdev = find_next_ebus(pdev, &is_rio);
			if (!pdev) {
				if (ebus == ebus_chain) {
					ebus_chain = NULL;
					printk("ebus: No EBus's found.\n");
					return;
				}
				break;
			}
			ebus->is_rio = is_rio;
			cookie = pdev->sysdata;
			dp = cookie->prom_node;
			continue;
		}
		printk("ebus%d:", num_ebus);

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

		ebus->ofdev.node = dp;
		ebus->ofdev.dev.parent = &pdev->dev;
		ebus->ofdev.dev.bus = &ebus_bus_type;
		strcpy(ebus->ofdev.dev.bus_id, dp->path_component_name);

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


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

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

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

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

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

	next_ebus:
		printk("\n");

		pdev = find_next_ebus(pdev, &is_rio);
		if (!pdev)
			break;

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

		ebus->next = ebus_alloc(sizeof(struct linux_ebus));
		ebus = ebus->next;
		ebus->next = NULL;
		ebus->is_rio = is_rio;
		++num_ebus;
	}
	pci_dev_put(pdev); /* XXX for the case, when ebusnd is 0, is it OK? */
}
Commit	Line	Data
1da177e4 LT	1	/* $Id: ebus.c,v 1.64 2001/11/08 04:41:33 davem Exp $
	2	* ebus.c: PCI to EBus bridge device.
	3	*
	4	* Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
	5	* Copyright (C) 1999 David S. Miller (davem@redhat.com)
	6	*/
	7
1da177e4 LT	8	#include <linux/module.h>
	9	#include <linux/kernel.h>
	10	#include <linux/types.h>
	11	#include <linux/init.h>
	12	#include <linux/slab.h>
	13	#include <linux/string.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/delay.h>
	16
	17	#include <asm/system.h>
	18	#include <asm/page.h>
	19	#include <asm/pbm.h>
	20	#include <asm/ebus.h>
	21	#include <asm/oplib.h>
2b1e5978 DM	22	#include <asm/prom.h>
2b1e5978 DM	23	#include <asm/of_device.h>
1da177e4 LT	24	#include <asm/bpp.h>
	25	#include <asm/irq.h>
	26
	27	/* EBUS dma library. */
	28
	29	#define EBDMA_CSR 0x00UL /* Control/Status */
	30	#define EBDMA_ADDR 0x04UL /* DMA Address */
	31	#define EBDMA_COUNT 0x08UL /* DMA Count */
	32
	33	#define EBDMA_CSR_INT_PEND 0x00000001
	34	#define EBDMA_CSR_ERR_PEND 0x00000002
	35	#define EBDMA_CSR_DRAIN 0x00000004
	36	#define EBDMA_CSR_INT_EN 0x00000010
	37	#define EBDMA_CSR_RESET 0x00000080
	38	#define EBDMA_CSR_WRITE 0x00000100
	39	#define EBDMA_CSR_EN_DMA 0x00000200
	40	#define EBDMA_CSR_CYC_PEND 0x00000400
	41	#define EBDMA_CSR_DIAG_RD_DONE 0x00000800
	42	#define EBDMA_CSR_DIAG_WR_DONE 0x00001000
	43	#define EBDMA_CSR_EN_CNT 0x00002000
	44	#define EBDMA_CSR_TC 0x00004000
	45	#define EBDMA_CSR_DIS_CSR_DRN 0x00010000
	46	#define EBDMA_CSR_BURST_SZ_MASK 0x000c0000
	47	#define EBDMA_CSR_BURST_SZ_1 0x00080000
	48	#define EBDMA_CSR_BURST_SZ_4 0x00000000
	49	#define EBDMA_CSR_BURST_SZ_8 0x00040000
	50	#define EBDMA_CSR_BURST_SZ_16 0x000c0000
	51	#define EBDMA_CSR_DIAG_EN 0x00100000
	52	#define EBDMA_CSR_DIS_ERR_PEND 0x00400000
	53	#define EBDMA_CSR_TCI_DIS 0x00800000
	54	#define EBDMA_CSR_EN_NEXT 0x01000000
	55	#define EBDMA_CSR_DMA_ON 0x02000000
	56	#define EBDMA_CSR_A_LOADED 0x04000000
	57	#define EBDMA_CSR_NA_LOADED 0x08000000
	58	#define EBDMA_CSR_DEV_ID_MASK 0xf0000000
	59
	60	#define EBUS_DMA_RESET_TIMEOUT 10000
	61
	62	static void __ebus_dma_reset(struct ebus_dma_info *p, int no_drain)
	63	{
	64	int i;
	65	u32 val = 0;
	66
	67	writel(EBDMA_CSR_RESET, p->regs + EBDMA_CSR);
	68	udelay(1);
	69
	70	if (no_drain)
	71	return;
	72
	73	for (i = EBUS_DMA_RESET_TIMEOUT; i > 0; i--) {
	74	val = readl(p->regs + EBDMA_CSR);
	75
	76	if (!(val & (EBDMA_CSR_DRAIN \| EBDMA_CSR_CYC_PEND)))
	77	break;
	78	udelay(10);
	79	}
	80	}
	81
6d24c8dc	82	static irqreturn_t ebus_dma_irq(int irq, void *dev_id)
1da177e4 LT	83	{
	84	struct ebus_dma_info *p = dev_id;
	85	unsigned long flags;
	86	u32 csr = 0;
	87
	88	spin_lock_irqsave(&p->lock, flags);
	89	csr = readl(p->regs + EBDMA_CSR);
	90	writel(csr, p->regs + EBDMA_CSR);
	91	spin_unlock_irqrestore(&p->lock, flags);
	92
	93	if (csr & EBDMA_CSR_ERR_PEND) {
	94	printk(KERN_CRIT "ebus_dma(%s): DMA error!\n", p->name);
	95	p->callback(p, EBUS_DMA_EVENT_ERROR, p->client_cookie);
	96	return IRQ_HANDLED;
	97	} else if (csr & EBDMA_CSR_INT_PEND) {
	98	p->callback(p,
	99	(csr & EBDMA_CSR_TC) ?
	100	EBUS_DMA_EVENT_DMA : EBUS_DMA_EVENT_DEVICE,
	101	p->client_cookie);
	102	return IRQ_HANDLED;
	103	}
	104
	105	return IRQ_NONE;
	106
	107	}
	108
	109	int ebus_dma_register(struct ebus_dma_info *p)
	110	{
	111	u32 csr;
	112
	113	if (!p->regs)
	114	return -EINVAL;
	115	if (p->flags & ~(EBUS_DMA_FLAG_USE_EBDMA_HANDLER \|
	116	EBUS_DMA_FLAG_TCI_DISABLE))
	117	return -EINVAL;
	118	if ((p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) && !p->callback)
	119	return -EINVAL;
	120	if (!strlen(p->name))
	121	return -EINVAL;
	122
	123	__ebus_dma_reset(p, 1);
	124
	125	csr = EBDMA_CSR_BURST_SZ_16 \| EBDMA_CSR_EN_CNT;
	126
	127	if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE)
	128	csr \|= EBDMA_CSR_TCI_DIS;
	129
	130	writel(csr, p->regs + EBDMA_CSR);
	131
	132	return 0;
	133	}
	134	EXPORT_SYMBOL(ebus_dma_register);
	135
	136	int ebus_dma_irq_enable(struct ebus_dma_info *p, int on)
	137	{
	138	unsigned long flags;
	139	u32 csr;
	140
	141	if (on) {
	142	if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) {
d356d7f4	143	if (request_irq(p->irq, ebus_dma_irq, IRQF_SHARED, p->name, p))
1da177e4 LT	144	return -EBUSY;
	145	}
	146
	147	spin_lock_irqsave(&p->lock, flags);
	148	csr = readl(p->regs + EBDMA_CSR);
	149	csr \|= EBDMA_CSR_INT_EN;
	150	writel(csr, p->regs + EBDMA_CSR);
	151	spin_unlock_irqrestore(&p->lock, flags);
	152	} else {
	153	spin_lock_irqsave(&p->lock, flags);
	154	csr = readl(p->regs + EBDMA_CSR);
	155	csr &= ~EBDMA_CSR_INT_EN;
	156	writel(csr, p->regs + EBDMA_CSR);
	157	spin_unlock_irqrestore(&p->lock, flags);
	158
	159	if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) {
	160	free_irq(p->irq, p);
	161	}
	162	}
	163
	164	return 0;
	165	}
	166	EXPORT_SYMBOL(ebus_dma_irq_enable);
	167
	168	void ebus_dma_unregister(struct ebus_dma_info *p)
	169	{
	170	unsigned long flags;
	171	u32 csr;
	172	int irq_on = 0;
	173
	174	spin_lock_irqsave(&p->lock, flags);
	175	csr = readl(p->regs + EBDMA_CSR);
	176	if (csr & EBDMA_CSR_INT_EN) {
	177	csr &= ~EBDMA_CSR_INT_EN;
	178	writel(csr, p->regs + EBDMA_CSR);
	179	irq_on = 1;
	180	}
	181	spin_unlock_irqrestore(&p->lock, flags);
	182
	183	if (irq_on)
	184	free_irq(p->irq, p);
	185	}
	186	EXPORT_SYMBOL(ebus_dma_unregister);
	187
	188	int ebus_dma_request(struct ebus_dma_info *p, dma_addr_t bus_addr, size_t len)
	189	{
	190	unsigned long flags;
	191	u32 csr;
	192	int err;
	193
	194	if (len >= (1 << 24))
	195	return -EINVAL;
	196
	197	spin_lock_irqsave(&p->lock, flags);
	198	csr = readl(p->regs + EBDMA_CSR);
	199	err = -EINVAL;
	200	if (!(csr & EBDMA_CSR_EN_DMA))
	201	goto out;
	202	err = -EBUSY;
	203	if (csr & EBDMA_CSR_NA_LOADED)
	204	goto out;
	205
	206	writel(len, p->regs + EBDMA_COUNT);
	207	writel(bus_addr, p->regs + EBDMA_ADDR);
208	err = 0;
209
210	out:
211	spin_unlock_irqrestore(&p->lock, flags);
212
213	return err;
214	}
215	EXPORT_SYMBOL(ebus_dma_request);
216
217	void ebus_dma_prepare(struct ebus_dma_info *p, int write)
218	{
219	unsigned long flags;
220	u32 csr;
221
222	spin_lock_irqsave(&p->lock, flags);
223	__ebus_dma_reset(p, 0);
224
225	csr = (EBDMA_CSR_INT_EN \|
226	EBDMA_CSR_EN_CNT \|
227	EBDMA_CSR_BURST_SZ_16 \|
228	EBDMA_CSR_EN_NEXT);
229
230	if (write)
231	csr \|= EBDMA_CSR_WRITE;
232	if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE)
233	csr \|= EBDMA_CSR_TCI_DIS;
234
235	writel(csr, p->regs + EBDMA_CSR);
236
237	spin_unlock_irqrestore(&p->lock, flags);
238	}
239	EXPORT_SYMBOL(ebus_dma_prepare);
240
241	unsigned int ebus_dma_residue(struct ebus_dma_info *p)
242	{
243	return readl(p->regs + EBDMA_COUNT);
244	}
245	EXPORT_SYMBOL(ebus_dma_residue);
246
247	unsigned int ebus_dma_addr(struct ebus_dma_info *p)
248	{
249	return readl(p->regs + EBDMA_ADDR);
250	}
251	EXPORT_SYMBOL(ebus_dma_addr);
252
253	void ebus_dma_enable(struct ebus_dma_info *p, int on)
254	{
255	unsigned long flags;
256	u32 orig_csr, csr;
257
258	spin_lock_irqsave(&p->lock, flags);
259	orig_csr = csr = readl(p->regs + EBDMA_CSR);
260	if (on)
261	csr \|= EBDMA_CSR_EN_DMA;
262	else
263	csr &= ~EBDMA_CSR_EN_DMA;
264	if ((orig_csr & EBDMA_CSR_EN_DMA) !=
265	(csr & EBDMA_CSR_EN_DMA))
266	writel(csr, p->regs + EBDMA_CSR);
267	spin_unlock_irqrestore(&p->lock, flags);
268	}
269	EXPORT_SYMBOL(ebus_dma_enable);
270
271	struct linux_ebus *ebus_chain = NULL;
272
1da177e4 LT	273	static inline void *ebus_alloc(size_t size)
	274	{
	275	void *mem;
	276
9132983a	277	mem = kzalloc(size, GFP_ATOMIC);
1da177e4 LT	278	if (!mem)
1da177e4 LT	279	panic("ebus_alloc: out of memory");
1da177e4 LT	280	return mem;
	281	}
	282
2b1e5978 DM	283	static void __init fill_ebus_child(struct device_node *dp,
	284	struct linux_ebus_child *dev,
	285	int non_standard_regs)
1da177e4	286	{
2b1e5978	287	struct of_device *op;
690c8fd3	288	int *regs;
1da177e4 LT	289	int i, len;
1da177e4 LT	290
690c8fd3 DM	291	dev->prom_node = dp;
690c8fd3 DM	292	printk(" (%s)", dp->name);
1da177e4	293
690c8fd3 DM	294	regs = of_get_property(dp, "reg", &len);
	295	if (!regs)
	296	dev->num_addrs = 0;
	297	else
	298	dev->num_addrs = len / sizeof(regs[0]);
1da177e4 LT	299
	300	if (non_standard_regs) {
	301	/* This is to handle reg properties which are not
	302	* in the parent relative format. One example are
	303	* children of the i2c device on CompactPCI systems.
	304	*
	305	* So, for such devices we just record the property
	306	* raw in the child resources.
	307	*/
	308	for (i = 0; i < dev->num_addrs; i++)
	309	dev->resource[i].start = regs[i];
	310	} else {
	311	for (i = 0; i < dev->num_addrs; i++) {
	312	int rnum = regs[i];
	313	if (rnum >= dev->parent->num_addrs) {
	314	prom_printf("UGH: property for %s was %d, need < %d\n",
690c8fd3 DM	315	dp->name, len, dev->parent->num_addrs);
690c8fd3 DM	316	prom_halt();
1da177e4 LT	317	}
	318	dev->resource[i].start = dev->parent->resource[i].start;
	319	dev->resource[i].end = dev->parent->resource[i].end;
	320	dev->resource[i].flags = IORESOURCE_MEM;
690c8fd3	321	dev->resource[i].name = dp->name;
1da177e4 LT	322	}
	323	}
	324
2b1e5978 DM	325	op = of_find_device_by_node(dp);
2b1e5978 DM	326	if (!op) {
1da177e4	327	dev->num_irqs = 0;
2b1e5978 DM	328	} else {
	329	dev->num_irqs = op->num_irqs;
	330	for (i = 0; i < dev->num_irqs; i++)
	331	dev->irqs[i] = op->irqs[i];
	332	}
	333
	334	if (!dev->num_irqs) {
1da177e4 LT	335	/*
	336	* Oh, well, some PROMs don't export interrupts
	337	* property to children of EBus devices...
	338	*
	339	* Be smart about PS/2 keyboard and mouse.
	340	*/
690c8fd3 DM	341	if (!strcmp(dev->parent->prom_node->name, "8042")) {
690c8fd3 DM	342	if (!strcmp(dev->prom_node->name, "kb_ps2")) {
1da177e4 LT	343	dev->num_irqs = 1;
	344	dev->irqs[0] = dev->parent->irqs[0];
	345	} else {
	346	dev->num_irqs = 1;
	347	dev->irqs[0] = dev->parent->irqs[1];
	348	}
	349	}
1da177e4 LT	350	}
	351	}
	352
	353	static int __init child_regs_nonstandard(struct linux_ebus_device *dev)
	354	{
690c8fd3 DM	355	if (!strcmp(dev->prom_node->name, "i2c") \|\|
690c8fd3 DM	356	!strcmp(dev->prom_node->name, "SUNW,lombus"))
1da177e4 LT	357	return 1;
	358	return 0;
	359	}
	360
2b1e5978	361	static void __init fill_ebus_device(struct device_node dp, struct linux_ebus_device dev)
1da177e4	362	{
1da177e4	363	struct linux_ebus_child *child;
2b1e5978 DM	364	struct of_device *op;
2b1e5978 DM	365	int i, len;
1da177e4	366
690c8fd3	367	dev->prom_node = dp;
1da177e4	368
690c8fd3 DM	369	printk(" [%s", dp->name);
690c8fd3 DM	370
2b1e5978 DM	371	op = of_find_device_by_node(dp);
2b1e5978 DM	372	if (!op) {
1da177e4	373	dev->num_addrs = 0;
1da177e4 LT	374	dev->num_irqs = 0;
1da177e4 LT	375	} else {
2b1e5978 DM	376	(void) of_get_property(dp, "reg", &len);
	377	dev->num_addrs = len / sizeof(struct linux_prom_registers);
	378
	379	for (i = 0; i < dev->num_addrs; i++)
	380	memcpy(&dev->resource[i],
	381	&op->resource[i],
	382	sizeof(struct resource));
	383
	384	dev->num_irqs = op->num_irqs;
	385	for (i = 0; i < dev->num_irqs; i++)
	386	dev->irqs[i] = op->irqs[i];
1da177e4 LT	387	}
1da177e4 LT	388
a2bd4fd1 DM	389	dev->ofdev.node = dp;
	390	dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
	391	dev->ofdev.dev.bus = &ebus_bus_type;
	392	strcpy(dev->ofdev.dev.bus_id, dp->path_component_name);
	393
	394	/* Register with core */
	395	if (of_device_register(&dev->ofdev) != 0)
	396	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
	397	dev->ofdev.dev.bus_id);
	398
690c8fd3 DM	399	dp = dp->child;
690c8fd3 DM	400	if (dp) {
1da177e4 LT	401	printk(" ->");
	402	dev->children = ebus_alloc(sizeof(struct linux_ebus_child));
	403
	404	child = dev->children;
	405	child->next = NULL;
	406	child->parent = dev;
	407	child->bus = dev->bus;
2b1e5978	408	fill_ebus_child(dp, child,
690c8fd3	409	child_regs_nonstandard(dev));
1da177e4	410
690c8fd3	411	while ((dp = dp->sibling) != NULL) {
1da177e4 LT	412	child->next = ebus_alloc(sizeof(struct linux_ebus_child));
	413
	414	child = child->next;
	415	child->next = NULL;
	416	child->parent = dev;
	417	child->bus = dev->bus;
2b1e5978	418	fill_ebus_child(dp, child,
690c8fd3	419	child_regs_nonstandard(dev));
1da177e4 LT	420	}
	421	}
	422	printk("]");
	423	}
	424
	425	static struct pci_dev find_next_ebus(struct pci_dev start, int *is_rio_p)
	426	{
	427	struct pci_dev *pdev = start;
	428
d08fa1a2 JS	429	while ((pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_ANY_ID, pdev)))
	430	if (pdev->device == PCI_DEVICE_ID_SUN_EBUS \|\|
	431	pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS)
1da177e4	432	break;
1da177e4	433
d08fa1a2	434	*is_rio_p = !!(pdev && (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS));
1da177e4 LT	435
	436	return pdev;
	437	}
	438
	439	void __init ebus_init(void)
	440	{
	441	struct pci_pbm_info *pbm;
	442	struct linux_ebus_device *dev;
	443	struct linux_ebus *ebus;
	444	struct pci_dev *pdev;
	445	struct pcidev_cookie *cookie;
690c8fd3 DM	446	struct device_node *dp;
690c8fd3 DM	447	int is_rio;
1da177e4 LT	448	int num_ebus = 0;
	449
	450	pdev = find_next_ebus(NULL, &is_rio);
	451	if (!pdev) {
	452	printk("ebus: No EBus's found.\n");
	453	return;
	454	}
	455
	456	cookie = pdev->sysdata;
690c8fd3	457	dp = cookie->prom_node;
1da177e4 LT	458
	459	ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus));
	460	ebus->next = NULL;
	461	ebus->is_rio = is_rio;
	462
690c8fd3 DM	463	while (dp) {
	464	struct device_node *child;
	465
1da177e4 LT	466	/* SUNW,pci-qfe uses four empty ebuses on it.
	467	I think we should not consider them here,
	468	as they have half of the properties this
	469	code expects and once we do PCI hot-plug,
	470	we'd have to tweak with the ebus_chain
	471	in the runtime after initialization. -jj */
690c8fd3	472	if (!dp->child) {
1da177e4 LT	473	pdev = find_next_ebus(pdev, &is_rio);
	474	if (!pdev) {
	475	if (ebus == ebus_chain) {
	476	ebus_chain = NULL;
	477	printk("ebus: No EBus's found.\n");
	478	return;
	479	}
	480	break;
	481	}
	482	ebus->is_rio = is_rio;
	483	cookie = pdev->sysdata;
690c8fd3	484	dp = cookie->prom_node;
1da177e4 LT	485	continue;
	486	}
	487	printk("ebus%d:", num_ebus);
	488
1da177e4	489	ebus->index = num_ebus;
690c8fd3	490	ebus->prom_node = dp;
1da177e4 LT	491	ebus->self = pdev;
	492	ebus->parent = pbm = cookie->pbm;
	493
a2bd4fd1 DM	494	ebus->ofdev.node = dp;
	495	ebus->ofdev.dev.parent = &pdev->dev;
	496	ebus->ofdev.dev.bus = &ebus_bus_type;
	497	strcpy(ebus->ofdev.dev.bus_id, dp->path_component_name);
	498
	499	/* Register with core */
	500	if (of_device_register(&ebus->ofdev) != 0)
	501	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
	502	ebus->ofdev.dev.bus_id);
	503
	504
690c8fd3 DM	505	child = dp->child;
690c8fd3 DM	506	if (!child)
1da177e4 LT	507	goto next_ebus;
	508
	509	ebus->devices = ebus_alloc(sizeof(struct linux_ebus_device));
	510
	511	dev = ebus->devices;
	512	dev->next = NULL;
	513	dev->children = NULL;
	514	dev->bus = ebus;
690c8fd3	515	fill_ebus_device(child, dev);
1da177e4	516
690c8fd3	517	while ((child = child->sibling) != NULL) {
1da177e4 LT	518	dev->next = ebus_alloc(sizeof(struct linux_ebus_device));
	519
	520	dev = dev->next;
	521	dev->next = NULL;
	522	dev->children = NULL;
	523	dev->bus = ebus;
690c8fd3	524	fill_ebus_device(child, dev);
1da177e4 LT	525	}
	526
	527	next_ebus:
	528	printk("\n");
	529
	530	pdev = find_next_ebus(pdev, &is_rio);
	531	if (!pdev)
	532	break;
	533
	534	cookie = pdev->sysdata;
690c8fd3	535	dp = cookie->prom_node;
1da177e4 LT	536
	537	ebus->next = ebus_alloc(sizeof(struct linux_ebus));
	538	ebus = ebus->next;
	539	ebus->next = NULL;
	540	ebus->is_rio = is_rio;
	541	++num_ebus;
	542	}
d08fa1a2	543	pci_dev_put(pdev); /* XXX for the case, when ebusnd is 0, is it OK? */
1da177e4	544	}