Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / arch / sparc64 / kernel / ebus.c
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 static inline void *ebus_alloc(size_t size)
273 {
274         void *mem;
275
276         mem = kzalloc(size, GFP_ATOMIC);
277         if (!mem)
278                 panic("ebus_alloc: out of memory");
279         return mem;
280 }
281
282 int __init ebus_intmap_match(struct linux_ebus *ebus,
283                              struct linux_prom_registers *reg,
284                              int *interrupt)
285 {
286         struct linux_prom_ebus_intmap *imap;
287         struct linux_prom_ebus_intmask *imask;
288         unsigned int hi, lo, irq;
289         int i, len, n_imap;
290
291         imap = of_get_property(ebus->prom_node, "interrupt-map", &len);
292         if (!imap)
293                 return 0;
294         n_imap = len / sizeof(imap[0]);
295
296         imask = of_get_property(ebus->prom_node, "interrupt-map-mask", NULL);
297         if (!imask)
298                 return 0;
299
300         hi = reg->which_io & imask->phys_hi;
301         lo = reg->phys_addr & imask->phys_lo;
302         irq = *interrupt & imask->interrupt;
303         for (i = 0; i < n_imap; i++) {
304                 if ((imap[i].phys_hi == hi) &&
305                     (imap[i].phys_lo == lo) &&
306                     (imap[i].interrupt == irq)) {
307                         *interrupt = imap[i].cinterrupt;
308                         return 0;
309                 }
310         }
311         return -1;
312 }
313
314 void __init fill_ebus_child(struct device_node *dp,
315                             struct linux_prom_registers *preg,
316                             struct linux_ebus_child *dev,
317                             int non_standard_regs)
318 {
319         int *regs;
320         int *irqs;
321         int i, len;
322
323         dev->prom_node = dp;
324         printk(" (%s)", dp->name);
325
326         regs = of_get_property(dp, "reg", &len);
327         if (!regs)
328                 dev->num_addrs = 0;
329         else
330                 dev->num_addrs = len / sizeof(regs[0]);
331
332         if (non_standard_regs) {
333                 /* This is to handle reg properties which are not
334                  * in the parent relative format.  One example are
335                  * children of the i2c device on CompactPCI systems.
336                  *
337                  * So, for such devices we just record the property
338                  * raw in the child resources.
339                  */
340                 for (i = 0; i < dev->num_addrs; i++)
341                         dev->resource[i].start = regs[i];
342         } else {
343                 for (i = 0; i < dev->num_addrs; i++) {
344                         int rnum = regs[i];
345                         if (rnum >= dev->parent->num_addrs) {
346                                 prom_printf("UGH: property for %s was %d, need < %d\n",
347                                             dp->name, len, dev->parent->num_addrs);
348                                 prom_halt();
349                         }
350                         dev->resource[i].start = dev->parent->resource[i].start;
351                         dev->resource[i].end = dev->parent->resource[i].end;
352                         dev->resource[i].flags = IORESOURCE_MEM;
353                         dev->resource[i].name = dp->name;
354                 }
355         }
356
357         for (i = 0; i < PROMINTR_MAX; i++)
358                 dev->irqs[i] = PCI_IRQ_NONE;
359
360         irqs = of_get_property(dp, "interrupts", &len);
361         if (!irqs) {
362                 dev->num_irqs = 0;
363                 /*
364                  * Oh, well, some PROMs don't export interrupts
365                  * property to children of EBus devices...
366                  *
367                  * Be smart about PS/2 keyboard and mouse.
368                  */
369                 if (!strcmp(dev->parent->prom_node->name, "8042")) {
370                         if (!strcmp(dev->prom_node->name, "kb_ps2")) {
371                                 dev->num_irqs = 1;
372                                 dev->irqs[0] = dev->parent->irqs[0];
373                         } else {
374                                 dev->num_irqs = 1;
375                                 dev->irqs[0] = dev->parent->irqs[1];
376                         }
377                 }
378         } else {
379                 dev->num_irqs = len / sizeof(irqs[0]);
380                 for (i = 0; i < dev->num_irqs; i++) {
381                         struct pci_pbm_info *pbm = dev->bus->parent;
382                         struct pci_controller_info *p = pbm->parent;
383
384                         if (ebus_intmap_match(dev->bus, preg, &irqs[i]) != -1) {
385                                 dev->irqs[i] = p->irq_build(pbm,
386                                                             dev->bus->self,
387                                                             irqs[i]);
388                         } else {
389                                 /* If we get a bogus interrupt property, just
390                                  * record the raw value instead of punting.
391                                  */
392                                 dev->irqs[i] = irqs[i];
393                         }
394                 }
395         }
396 }
397
398 static int __init child_regs_nonstandard(struct linux_ebus_device *dev)
399 {
400         if (!strcmp(dev->prom_node->name, "i2c") ||
401             !strcmp(dev->prom_node->name, "SUNW,lombus"))
402                 return 1;
403         return 0;
404 }
405
406 void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *dev)
407 {
408         struct linux_prom_registers *regs;
409         struct linux_ebus_child *child;
410         int *irqs;
411         int i, n, len;
412
413         dev->prom_node = dp;
414
415         printk(" [%s", dp->name);
416
417         regs = of_get_property(dp, "reg", &len);
418         if (!regs) {
419                 dev->num_addrs = 0;
420                 goto probe_interrupts;
421         }
422
423         if (len % sizeof(struct linux_prom_registers)) {
424                 prom_printf("UGH: proplen for %s was %d, need multiple of %d\n",
425                             dev->prom_node->name, len,
426                             (int)sizeof(struct linux_prom_registers));
427                 prom_halt();
428         }
429         dev->num_addrs = len / sizeof(struct linux_prom_registers);
430
431         for (i = 0; i < dev->num_addrs; i++) {
432                 /* XXX Learn how to interpret ebus ranges... -DaveM */
433                 if (regs[i].which_io >= 0x10)
434                         n = (regs[i].which_io - 0x10) >> 2;
435                 else
436                         n = regs[i].which_io;
437
438                 dev->resource[i].start  = dev->bus->self->resource[n].start;
439                 dev->resource[i].start += (unsigned long)regs[i].phys_addr;
440                 dev->resource[i].end    =
441                         (dev->resource[i].start + (unsigned long)regs[i].reg_size - 1UL);
442                 dev->resource[i].flags  = IORESOURCE_MEM;
443                 dev->resource[i].name   = dev->prom_node->name;
444                 request_resource(&dev->bus->self->resource[n],
445                                  &dev->resource[i]);
446         }
447
448 probe_interrupts:
449         for (i = 0; i < PROMINTR_MAX; i++)
450                 dev->irqs[i] = PCI_IRQ_NONE;
451
452         irqs = of_get_property(dp, "interrupts", &len);
453         if (!irqs) {
454                 dev->num_irqs = 0;
455         } else {
456                 dev->num_irqs = len / sizeof(irqs[0]);
457                 for (i = 0; i < dev->num_irqs; i++) {
458                         struct pci_pbm_info *pbm = dev->bus->parent;
459                         struct pci_controller_info *p = pbm->parent;
460
461                         if (ebus_intmap_match(dev->bus, &regs[0], &irqs[i]) != -1) {
462                                 dev->irqs[i] = p->irq_build(pbm,
463                                                             dev->bus->self,
464                                                             irqs[i]);
465                         } else {
466                                 /* If we get a bogus interrupt property, just
467                                  * record the raw value instead of punting.
468                                  */
469                                 dev->irqs[i] = irqs[i];
470                         }
471                 }
472         }
473
474         dev->ofdev.node = dp;
475         dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
476         dev->ofdev.dev.bus = &ebus_bus_type;
477         strcpy(dev->ofdev.dev.bus_id, dp->path_component_name);
478
479         /* Register with core */
480         if (of_device_register(&dev->ofdev) != 0)
481                 printk(KERN_DEBUG "ebus: device registration error for %s!\n",
482                        dev->ofdev.dev.bus_id);
483
484         dp = dp->child;
485         if (dp) {
486                 printk(" ->");
487                 dev->children = ebus_alloc(sizeof(struct linux_ebus_child));
488
489                 child = dev->children;
490                 child->next = NULL;
491                 child->parent = dev;
492                 child->bus = dev->bus;
493                 fill_ebus_child(dp, regs, child,
494                                 child_regs_nonstandard(dev));
495
496                 while ((dp = dp->sibling) != NULL) {
497                         child->next = ebus_alloc(sizeof(struct linux_ebus_child));
498
499                         child = child->next;
500                         child->next = NULL;
501                         child->parent = dev;
502                         child->bus = dev->bus;
503                         fill_ebus_child(dp, regs, child,
504                                         child_regs_nonstandard(dev));
505                 }
506         }
507         printk("]");
508 }
509
510 static struct pci_dev *find_next_ebus(struct pci_dev *start, int *is_rio_p)
511 {
512         struct pci_dev *pdev = start;
513
514         while ((pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_ANY_ID, pdev)))
515                 if (pdev->device == PCI_DEVICE_ID_SUN_EBUS ||
516                         pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS)
517                         break;
518
519         *is_rio_p = !!(pdev && (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS));
520
521         return pdev;
522 }
523
524 void __init ebus_init(void)
525 {
526         struct pci_pbm_info *pbm;
527         struct linux_ebus_device *dev;
528         struct linux_ebus *ebus;
529         struct pci_dev *pdev;
530         struct pcidev_cookie *cookie;
531         struct device_node *dp;
532         int is_rio;
533         int num_ebus = 0;
534
535         pdev = find_next_ebus(NULL, &is_rio);
536         if (!pdev) {
537                 printk("ebus: No EBus's found.\n");
538                 return;
539         }
540
541         cookie = pdev->sysdata;
542         dp = cookie->prom_node;
543
544         ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus));
545         ebus->next = NULL;
546         ebus->is_rio = is_rio;
547
548         while (dp) {
549                 struct device_node *child;
550
551                 /* SUNW,pci-qfe uses four empty ebuses on it.
552                    I think we should not consider them here,
553                    as they have half of the properties this
554                    code expects and once we do PCI hot-plug,
555                    we'd have to tweak with the ebus_chain
556                    in the runtime after initialization. -jj */
557                 if (!dp->child) {
558                         pdev = find_next_ebus(pdev, &is_rio);
559                         if (!pdev) {
560                                 if (ebus == ebus_chain) {
561                                         ebus_chain = NULL;
562                                         printk("ebus: No EBus's found.\n");
563                                         return;
564                                 }
565                                 break;
566                         }
567                         ebus->is_rio = is_rio;
568                         cookie = pdev->sysdata;
569                         dp = cookie->prom_node;
570                         continue;
571                 }
572                 printk("ebus%d:", num_ebus);
573
574                 ebus->index = num_ebus;
575                 ebus->prom_node = dp;
576                 ebus->self = pdev;
577                 ebus->parent = pbm = cookie->pbm;
578
579                 ebus->ofdev.node = dp;
580                 ebus->ofdev.dev.parent = &pdev->dev;
581                 ebus->ofdev.dev.bus = &ebus_bus_type;
582                 strcpy(ebus->ofdev.dev.bus_id, dp->path_component_name);
583
584                 /* Register with core */
585                 if (of_device_register(&ebus->ofdev) != 0)
586                         printk(KERN_DEBUG "ebus: device registration error for %s!\n",
587                                ebus->ofdev.dev.bus_id);
588
589
590                 child = dp->child;
591                 if (!child)
592                         goto next_ebus;
593
594                 ebus->devices = ebus_alloc(sizeof(struct linux_ebus_device));
595
596                 dev = ebus->devices;
597                 dev->next = NULL;
598                 dev->children = NULL;
599                 dev->bus = ebus;
600                 fill_ebus_device(child, dev);
601
602                 while ((child = child->sibling) != NULL) {
603                         dev->next = ebus_alloc(sizeof(struct linux_ebus_device));
604
605                         dev = dev->next;
606                         dev->next = NULL;
607                         dev->children = NULL;
608                         dev->bus = ebus;
609                         fill_ebus_device(child, dev);
610                 }
611
612         next_ebus:
613                 printk("\n");
614
615                 pdev = find_next_ebus(pdev, &is_rio);
616                 if (!pdev)
617                         break;
618
619                 cookie = pdev->sysdata;
620                 dp = cookie->prom_node;
621
622                 ebus->next = ebus_alloc(sizeof(struct linux_ebus));
623                 ebus = ebus->next;
624                 ebus->next = NULL;
625                 ebus->is_rio = is_rio;
626                 ++num_ebus;
627         }
628         pci_dev_put(pdev); /* XXX for the case, when ebusnd is 0, is it OK? */
629 }