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