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

/*
 * 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 dev_archdata *sd;
	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 {
		const int *regs = of_get_property(dp, "reg", &len);

		if (!regs)
			len = 0;
		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];
	}

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

	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
b00dc837	1	/*
1da177e4 LT	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;
3d6e4702	365	struct dev_archdata *sd;
2b1e5978 DM	366	struct of_device *op;
2b1e5978 DM	367	int i, len;
1da177e4	368
690c8fd3	369	dev->prom_node = dp;
1da177e4	370
690c8fd3 DM	371	printk(" [%s", dp->name);
690c8fd3 DM	372
2b1e5978 DM	373	op = of_find_device_by_node(dp);
2b1e5978 DM	374	if (!op) {
1da177e4	375	dev->num_addrs = 0;
1da177e4 LT	376	dev->num_irqs = 0;
1da177e4 LT	377	} else {
9c908f97 DM	378	const int *regs = of_get_property(dp, "reg", &len);
	379
	380	if (!regs)
	381	len = 0;
2b1e5978 DM	382	dev->num_addrs = len / sizeof(struct linux_prom_registers);
	383
	384	for (i = 0; i < dev->num_addrs; i++)
	385	memcpy(&dev->resource[i],
	386	&op->resource[i],
	387	sizeof(struct resource));
	388
	389	dev->num_irqs = op->num_irqs;
	390	for (i = 0; i < dev->num_irqs; i++)
	391	dev->irqs[i] = op->irqs[i];
1da177e4 LT	392	}
1da177e4 LT	393
3d6e4702 DM	394	sd = &dev->ofdev.dev.archdata;
	395	sd->prom_node = dp;
	396	sd->op = &dev->ofdev;
ad7ad57c DM	397	sd->iommu = dev->bus->ofdev.dev.parent->archdata.iommu;
ad7ad57c DM	398	sd->stc = dev->bus->ofdev.dev.parent->archdata.stc;
c1b1a5f1	399	sd->numa_node = dev->bus->ofdev.dev.parent->archdata.numa_node;
3d6e4702	400
a2bd4fd1 DM	401	dev->ofdev.node = dp;
	402	dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
	403	dev->ofdev.dev.bus = &ebus_bus_type;
f5ef9d11	404	sprintf(dev->ofdev.dev.bus_id, "ebus[%08x]", dp->node);
a2bd4fd1 DM	405
	406	/* Register with core */
	407	if (of_device_register(&dev->ofdev) != 0)
	408	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
f5ef9d11	409	dp->path_component_name);
a2bd4fd1	410
690c8fd3 DM	411	dp = dp->child;
690c8fd3 DM	412	if (dp) {
1da177e4 LT	413	printk(" ->");
	414	dev->children = ebus_alloc(sizeof(struct linux_ebus_child));
	415
	416	child = dev->children;
	417	child->next = NULL;
	418	child->parent = dev;
	419	child->bus = dev->bus;
2b1e5978	420	fill_ebus_child(dp, child,
690c8fd3	421	child_regs_nonstandard(dev));
1da177e4	422
690c8fd3	423	while ((dp = dp->sibling) != NULL) {
1da177e4 LT	424	child->next = ebus_alloc(sizeof(struct linux_ebus_child));
	425
	426	child = child->next;
	427	child->next = NULL;
	428	child->parent = dev;
	429	child->bus = dev->bus;
2b1e5978	430	fill_ebus_child(dp, child,
690c8fd3	431	child_regs_nonstandard(dev));
1da177e4 LT	432	}
	433	}
	434	printk("]");
	435	}
	436
	437	static struct pci_dev find_next_ebus(struct pci_dev start, int *is_rio_p)
	438	{
	439	struct pci_dev *pdev = start;
	440
d08fa1a2 JS	441	while ((pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_ANY_ID, pdev)))
	442	if (pdev->device == PCI_DEVICE_ID_SUN_EBUS \|\|
	443	pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS)
1da177e4	444	break;
1da177e4	445
d08fa1a2	446	*is_rio_p = !!(pdev && (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS));
1da177e4 LT	447
	448	return pdev;
	449	}
	450
	451	void __init ebus_init(void)
	452	{
1da177e4 LT	453	struct linux_ebus_device *dev;
	454	struct linux_ebus *ebus;
	455	struct pci_dev *pdev;
690c8fd3 DM	456	struct device_node *dp;
690c8fd3 DM	457	int is_rio;
1da177e4 LT	458	int num_ebus = 0;
	459
	460	pdev = find_next_ebus(NULL, &is_rio);
	461	if (!pdev) {
	462	printk("ebus: No EBus's found.\n");
	463	return;
	464	}
	465
1327e9b6	466	dp = pci_device_to_OF_node(pdev);
1da177e4 LT	467
	468	ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus));
	469	ebus->next = NULL;
	470	ebus->is_rio = is_rio;
	471
690c8fd3 DM	472	while (dp) {
	473	struct device_node *child;
	474
1da177e4 LT	475	/* SUNW,pci-qfe uses four empty ebuses on it.
	476	I think we should not consider them here,
	477	as they have half of the properties this
	478	code expects and once we do PCI hot-plug,
	479	we'd have to tweak with the ebus_chain
	480	in the runtime after initialization. -jj */
690c8fd3	481	if (!dp->child) {
1da177e4 LT	482	pdev = find_next_ebus(pdev, &is_rio);
	483	if (!pdev) {
	484	if (ebus == ebus_chain) {
	485	ebus_chain = NULL;
	486	printk("ebus: No EBus's found.\n");
	487	return;
	488	}
	489	break;
	490	}
	491	ebus->is_rio = is_rio;
1327e9b6	492	dp = pci_device_to_OF_node(pdev);
1da177e4 LT	493	continue;
	494	}
	495	printk("ebus%d:", num_ebus);
	496
1da177e4	497	ebus->index = num_ebus;
690c8fd3	498	ebus->prom_node = dp;
1da177e4	499	ebus->self = pdev;
1da177e4	500
a2bd4fd1 DM	501	ebus->ofdev.node = dp;
	502	ebus->ofdev.dev.parent = &pdev->dev;
	503	ebus->ofdev.dev.bus = &ebus_bus_type;
f5ef9d11	504	sprintf(ebus->ofdev.dev.bus_id, "ebus%d", num_ebus);
a2bd4fd1 DM	505
	506	/* Register with core */
	507	if (of_device_register(&ebus->ofdev) != 0)
	508	printk(KERN_DEBUG "ebus: device registration error for %s!\n",
f5ef9d11	509	dp->path_component_name);
a2bd4fd1 DM	510
a2bd4fd1 DM	511
690c8fd3 DM	512	child = dp->child;
690c8fd3 DM	513	if (!child)
1da177e4 LT	514	goto next_ebus;
	515
	516	ebus->devices = ebus_alloc(sizeof(struct linux_ebus_device));
	517
	518	dev = ebus->devices;
	519	dev->next = NULL;
	520	dev->children = NULL;
	521	dev->bus = ebus;
690c8fd3	522	fill_ebus_device(child, dev);
1da177e4	523
690c8fd3	524	while ((child = child->sibling) != NULL) {
1da177e4 LT	525	dev->next = ebus_alloc(sizeof(struct linux_ebus_device));
	526
	527	dev = dev->next;
	528	dev->next = NULL;
	529	dev->children = NULL;
	530	dev->bus = ebus;
690c8fd3	531	fill_ebus_device(child, dev);
1da177e4 LT	532	}
	533
	534	next_ebus:
	535	printk("\n");
	536
	537	pdev = find_next_ebus(pdev, &is_rio);
	538	if (!pdev)
	539	break;
	540
1327e9b6	541	dp = pci_device_to_OF_node(pdev);
1da177e4 LT	542
	543	ebus->next = ebus_alloc(sizeof(struct linux_ebus));
	544	ebus = ebus->next;
	545	ebus->next = NULL;
	546	ebus->is_rio = is_rio;
	547	++num_ebus;
	548	}
d08fa1a2	549	pci_dev_put(pdev); /* XXX for the case, when ebusnd is 0, is it OK? */
1da177e4	550	}