[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/config.h>
#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/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 pt_regs *regs)
{
	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, SA_SHIRQ, 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;

#ifdef CONFIG_SUN_AUXIO
extern void auxio_probe(void);
#endif

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 ebus_ranges_init(struct linux_ebus *ebus)
{
	struct linux_prom_ebus_ranges *rngs;
	int len;

	ebus->num_ebus_ranges = 0;
	rngs = of_get_property(ebus->prom_node, "ranges", &len);
	if (rngs) {
		memcpy(ebus->ebus_ranges, rngs, len);
		ebus->num_ebus_ranges =
			(len / sizeof(struct linux_prom_ebus_ranges));
	}
}

static void __init ebus_intmap_init(struct linux_ebus *ebus)
{
	struct linux_prom_ebus_intmap *imap;
	struct linux_prom_ebus_intmask *imask;
	int len;

	ebus->num_ebus_intmap = 0;
	imap = of_get_property(ebus->prom_node, "interrupt-map", &len);
	if (!imap)
		return;

	memcpy(ebus->ebus_intmap, imap, len);
	ebus->num_ebus_intmap = (len / sizeof(struct linux_prom_ebus_intmap));

	imask = of_get_property(ebus->prom_node, "interrupt-map-mask", &len);
	if (!imask) {
		prom_printf("EBUS: can't get interrupt-map-mask\n");
		prom_halt();
	}
	memcpy(&ebus->ebus_intmask, imask, sizeof(ebus->ebus_intmask));
}

int __init ebus_intmap_match(struct linux_ebus *ebus,
			     struct linux_prom_registers *reg,
			     int *interrupt)
{
	unsigned int hi, lo, irq;
	int i;

	if (!ebus->num_ebus_intmap)
		return 0;

	hi = reg->which_io & ebus->ebus_intmask.phys_hi;
	lo = reg->phys_addr & ebus->ebus_intmask.phys_lo;
	irq = *interrupt & ebus->ebus_intmask.interrupt;
	for (i = 0; i < ebus->num_ebus_intmap; i++) {
		if ((ebus->ebus_intmap[i].phys_hi == hi) &&
		    (ebus->ebus_intmap[i].phys_lo == lo) &&
		    (ebus->ebus_intmap[i].interrupt == irq)) {
			*interrupt = ebus->ebus_intmap[i].cinterrupt;
			return 0;
		}
	}
	return -1;
}

void __init fill_ebus_child(struct device_node *dp,
			    struct linux_prom_registers *preg,
			    struct linux_ebus_child *dev,
			    int non_standard_regs)
{
	int *regs;
	int *irqs;
	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;
		}
	}

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

	irqs = of_get_property(dp, "interrupts", &len);
	if (!irqs) {
		dev->num_irqs = 0;
		/*
		 * 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];
			}
		}
	} else {
		dev->num_irqs = len / sizeof(irqs[0]);
		for (i = 0; i < dev->num_irqs; i++) {
			struct pci_pbm_info *pbm = dev->bus->parent;
			struct pci_controller_info *p = pbm->parent;

			if (ebus_intmap_match(dev->bus, preg, &irqs[i]) != -1) {
				dev->irqs[i] = p->irq_build(pbm,
							    dev->bus->self,
							    irqs[i]);
			} else {
				/* If we get a bogus interrupt property, just
				 * record the raw value instead of punting.
				 */
				dev->irqs[i] = irqs[i];
			}
		}
	}
}

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

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

	dev->prom_node = dp;

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

	regs = of_get_property(dp, "reg", &len);
	if (!regs) {
		dev->num_addrs = 0;
		goto probe_interrupts;
	}

	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));
		prom_halt();
	}
	dev->num_addrs = len / sizeof(struct linux_prom_registers);

	for (i = 0; i < dev->num_addrs; i++) {
		/* XXX Learn how to interpret ebus ranges... -DaveM */
		if (regs[i].which_io >= 0x10)
			n = (regs[i].which_io - 0x10) >> 2;
		else
			n = regs[i].which_io;

		dev->resource[i].start  = dev->bus->self->resource[n].start;
		dev->resource[i].start += (unsigned long)regs[i].phys_addr;
		dev->resource[i].end    =
			(dev->resource[i].start + (unsigned long)regs[i].reg_size - 1UL);
		dev->resource[i].flags  = IORESOURCE_MEM;
		dev->resource[i].name   = dev->prom_node->name;
		request_resource(&dev->bus->self->resource[n],
				 &dev->resource[i]);
	}

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

	irqs = of_get_property(dp, "interrupts", &len);
	if (!irqs) {
		dev->num_irqs = 0;
	} else {
		dev->num_irqs = len / sizeof(irqs[0]);
		for (i = 0; i < dev->num_irqs; i++) {
			struct pci_pbm_info *pbm = dev->bus->parent;
			struct pci_controller_info *p = pbm->parent;

			if (ebus_intmap_match(dev->bus, &regs[0], &irqs[i]) != -1) {
				dev->irqs[i] = p->irq_build(pbm,
							    dev->bus->self,
							    irqs[i]);
			} else {
				/* If we get a bogus interrupt property, just
				 * record the raw value instead of punting.
				 */
				dev->irqs[i] = irqs[i];
			}
		}
	}

	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, regs, 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, regs, 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_ranges_init(ebus);
		ebus_intmap_init(ebus);

		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? */

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