Merge branch 'FW_BUG' into test
[linux-2.6] / arch / sparc64 / kernel / ebus.c
1 /*
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 #include <linux/of_device.h>
18
19 #include <asm/system.h>
20 #include <asm/page.h>
21 #include <asm/ebus.h>
22 #include <asm/oplib.h>
23 #include <asm/prom.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         sd->numa_node = dev->bus->ofdev.dev.parent->archdata.numa_node;
400
401         dev->ofdev.node = dp;
402         dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
403         dev->ofdev.dev.bus = &ebus_bus_type;
404         dev_set_name(&dev->ofdev.dev, "ebus[%08x]", dp->node);
405
406         /* Register with core */
407         if (of_device_register(&dev->ofdev) != 0)
408                 printk(KERN_DEBUG "ebus: device registration error for %s!\n",
409                        dp->path_component_name);
410
411         dp = dp->child;
412         if (dp) {
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;
420                 fill_ebus_child(dp, child,
421                                 child_regs_nonstandard(dev));
422
423                 while ((dp = dp->sibling) != NULL) {
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;
430                         fill_ebus_child(dp, child,
431                                         child_regs_nonstandard(dev));
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
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)
444                         break;
445
446         *is_rio_p = !!(pdev && (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS));
447
448         return pdev;
449 }
450
451 void __init ebus_init(void)
452 {
453         struct linux_ebus_device *dev;
454         struct linux_ebus *ebus;
455         struct pci_dev *pdev;
456         struct device_node *dp;
457         int is_rio;
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
466         dp = pci_device_to_OF_node(pdev);
467
468         ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus));
469         ebus->next = NULL;
470         ebus->is_rio = is_rio;
471
472         while (dp) {
473                 struct device_node *child;
474
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 */
481                 if (!dp->child) {
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;
492                         dp = pci_device_to_OF_node(pdev);
493                         continue;
494                 }
495                 printk("ebus%d:", num_ebus);
496
497                 ebus->index = num_ebus;
498                 ebus->prom_node = dp;
499                 ebus->self = pdev;
500
501                 ebus->ofdev.node = dp;
502                 ebus->ofdev.dev.parent = &pdev->dev;
503                 ebus->ofdev.dev.bus = &ebus_bus_type;
504                 dev_set_name(&ebus->ofdev.dev, "ebus%d", num_ebus);
505
506                 /* Register with core */
507                 if (of_device_register(&ebus->ofdev) != 0)
508                         printk(KERN_DEBUG "ebus: device registration error for %s!\n",
509                                dp->path_component_name);
510
511
512                 child = dp->child;
513                 if (!child)
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;
522                 fill_ebus_device(child, dev);
523
524                 while ((child = child->sibling) != NULL) {
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;
531                         fill_ebus_device(child, dev);
532                 }
533
534         next_ebus:
535                 printk("\n");
536
537                 pdev = find_next_ebus(pdev, &is_rio);
538                 if (!pdev)
539                         break;
540
541                 dp = pci_device_to_OF_node(pdev);
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         }
549         pci_dev_put(pdev); /* XXX for the case, when ebusnd is 0, is it OK? */
550 }