1/* $Id: ebus.c,v 1.1.1.1 2007/08/03 18:52:18 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/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#include <linux/pci.h>
17
18#include <asm/system.h>
19#include <asm/page.h>
20#include <asm/ebus.h>
21#include <asm/oplib.h>
22#include <asm/prom.h>
23#include <asm/of_device.h>
24#include <asm/bpp.h>
25#include <asm/irq.h>
26#include <asm/io.h>
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
63static 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
83static irqreturn_t ebus_dma_irq(int irq, void *dev_id)
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
110int 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}
135EXPORT_SYMBOL(ebus_dma_register);
136
137int 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) {
144			if (request_irq(p->irq, ebus_dma_irq, IRQF_SHARED, p->name, p))
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}
167EXPORT_SYMBOL(ebus_dma_irq_enable);
168
169void 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}
187EXPORT_SYMBOL(ebus_dma_unregister);
188
189int 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
211out:
212	spin_unlock_irqrestore(&p->lock, flags);
213
214	return err;
215}
216EXPORT_SYMBOL(ebus_dma_request);
217
218void 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}
240EXPORT_SYMBOL(ebus_dma_prepare);
241
242unsigned int ebus_dma_residue(struct ebus_dma_info *p)
243{
244	return readl(p->regs + EBDMA_COUNT);
245}
246EXPORT_SYMBOL(ebus_dma_residue);
247
248unsigned int ebus_dma_addr(struct ebus_dma_info *p)
249{
250	return readl(p->regs + EBDMA_ADDR);
251}
252EXPORT_SYMBOL(ebus_dma_addr);
253
254void 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}
270EXPORT_SYMBOL(ebus_dma_enable);
271
272struct linux_ebus *ebus_chain = NULL;
273
274static inline void *ebus_alloc(size_t size)
275{
276	void *mem;
277
278	mem = kzalloc(size, GFP_ATOMIC);
279	if (!mem)
280		panic("ebus_alloc: out of memory");
281	return mem;
282}
283
284static void __init fill_ebus_child(struct device_node *dp,
285				   struct linux_ebus_child *dev,
286				   int non_standard_regs)
287{
288	struct of_device *op;
289	const int *regs;
290	int i, len;
291
292	dev->prom_node = dp;
293	printk(" (%s)", dp->name);
294
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]);
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",
316					    dp->name, len, dev->parent->num_addrs);
317				prom_halt();
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;
322			dev->resource[i].name = dp->name;
323		}
324	}
325
326	op = of_find_device_by_node(dp);
327	if (!op) {
328		dev->num_irqs = 0;
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) {
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		 */
342		if (!strcmp(dev->parent->prom_node->name, "8042")) {
343			if (!strcmp(dev->prom_node->name, "kb_ps2")) {
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		}
351	}
352}
353
354static int __init child_regs_nonstandard(struct linux_ebus_device *dev)
355{
356	if (!strcmp(dev->prom_node->name, "i2c") ||
357	    !strcmp(dev->prom_node->name, "SUNW,lombus"))
358		return 1;
359	return 0;
360}
361
362static void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *dev)
363{
364	struct linux_ebus_child *child;
365	struct of_device *op;
366	int i, len;
367
368	dev->prom_node = dp;
369
370	printk(" [%s", dp->name);
371
372	op = of_find_device_by_node(dp);
373	if (!op) {
374		dev->num_addrs = 0;
375		dev->num_irqs = 0;
376	} else {
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];
388	}
389
390	dev->ofdev.node = dp;
391	dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
392	dev->ofdev.dev.bus = &ebus_bus_type;
393	sprintf(dev->ofdev.dev.bus_id, "ebus[%08x]", dp->node);
394
395	/* Register with core */
396	if (of_device_register(&dev->ofdev) != 0)
397		printk(KERN_DEBUG "ebus: device registration error for %s!\n",
398		       dp->path_component_name);
399
400	dp = dp->child;
401	if (dp) {
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;
409		fill_ebus_child(dp, child,
410				child_regs_nonstandard(dev));
411
412		while ((dp = dp->sibling) != NULL) {
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;
419			fill_ebus_child(dp, child,
420					child_regs_nonstandard(dev));
421		}
422	}
423	printk("]");
424}
425
426static struct pci_dev *find_next_ebus(struct pci_dev *start, int *is_rio_p)
427{
428	struct pci_dev *pdev = start;
429
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)
433			break;
434
435	*is_rio_p = !!(pdev && (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS));
436
437	return pdev;
438}
439
440void __init ebus_init(void)
441{
442	struct linux_ebus_device *dev;
443	struct linux_ebus *ebus;
444	struct pci_dev *pdev;
445	struct device_node *dp;
446	int is_rio;
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
455	dp = pci_device_to_OF_node(pdev);
456
457	ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus));
458	ebus->next = NULL;
459	ebus->is_rio = is_rio;
460
461	while (dp) {
462		struct device_node *child;
463
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 */
470		if (!dp->child) {
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;
481			dp = pci_device_to_OF_node(pdev);
482			continue;
483		}
484		printk("ebus%d:", num_ebus);
485
486		ebus->index = num_ebus;
487		ebus->prom_node = dp;
488		ebus->self = pdev;
489
490		ebus->ofdev.node = dp;
491		ebus->ofdev.dev.parent = &pdev->dev;
492		ebus->ofdev.dev.bus = &ebus_bus_type;
493		sprintf(ebus->ofdev.dev.bus_id, "ebus%d", num_ebus);
494
495		/* Register with core */
496		if (of_device_register(&ebus->ofdev) != 0)
497			printk(KERN_DEBUG "ebus: device registration error for %s!\n",
498			       dp->path_component_name);
499
500
501		child = dp->child;
502		if (!child)
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;
511		fill_ebus_device(child, dev);
512
513		while ((child = child->sibling) != NULL) {
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;
520			fill_ebus_device(child, dev);
521		}
522
523	next_ebus:
524		printk("\n");
525
526		pdev = find_next_ebus(pdev, &is_rio);
527		if (!pdev)
528			break;
529
530		dp = pci_device_to_OF_node(pdev);
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	}
538	pci_dev_put(pdev);
539}
540