[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 <linux/pci.h>

#include <asm/system.h>
#include <asm/page.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>
#include <asm/io.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;
	const 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;
	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);

	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 linux_ebus_device *dev;
	struct linux_ebus *ebus;
	struct pci_dev *pdev;
	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;
	}

	dp = pci_device_to_OF_node(pdev);

	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;
			dp = pci_device_to_OF_node(pdev);
			continue;
		}
		printk("ebus%d:", num_ebus);

		ebus->index = num_ebus;
		ebus->prom_node = dp;
		ebus->self = pdev;

		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);


		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;

		dp = pci_device_to_OF_node(pdev);

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