214da1bd8a5132b5795a25a0b5a1823eea2613df
[linux-2.6.git] / 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/irq.h>
25 #include <asm/io.h>
26
27 /* EBUS dma library. */
28
29 #define EBDMA_CSR       0x00UL  /* Control/Status */
30 #define EBDMA_ADDR      0x04UL  /* DMA Address */
31 #define EBDMA_COUNT     0x08UL  /* DMA Count */
32
33 #define EBDMA_CSR_INT_PEND      0x00000001
34 #define EBDMA_CSR_ERR_PEND      0x00000002
35 #define EBDMA_CSR_DRAIN         0x00000004
36 #define EBDMA_CSR_INT_EN        0x00000010
37 #define EBDMA_CSR_RESET         0x00000080
38 #define EBDMA_CSR_WRITE         0x00000100
39 #define EBDMA_CSR_EN_DMA        0x00000200
40 #define EBDMA_CSR_CYC_PEND      0x00000400
41 #define EBDMA_CSR_DIAG_RD_DONE  0x00000800
42 #define EBDMA_CSR_DIAG_WR_DONE  0x00001000
43 #define EBDMA_CSR_EN_CNT        0x00002000
44 #define EBDMA_CSR_TC            0x00004000
45 #define EBDMA_CSR_DIS_CSR_DRN   0x00010000
46 #define EBDMA_CSR_BURST_SZ_MASK 0x000c0000
47 #define EBDMA_CSR_BURST_SZ_1    0x00080000
48 #define EBDMA_CSR_BURST_SZ_4    0x00000000
49 #define EBDMA_CSR_BURST_SZ_8    0x00040000
50 #define EBDMA_CSR_BURST_SZ_16   0x000c0000
51 #define EBDMA_CSR_DIAG_EN       0x00100000
52 #define EBDMA_CSR_DIS_ERR_PEND  0x00400000
53 #define EBDMA_CSR_TCI_DIS       0x00800000
54 #define EBDMA_CSR_EN_NEXT       0x01000000
55 #define EBDMA_CSR_DMA_ON        0x02000000
56 #define EBDMA_CSR_A_LOADED      0x04000000
57 #define EBDMA_CSR_NA_LOADED     0x08000000
58 #define EBDMA_CSR_DEV_ID_MASK   0xf0000000
59
60 #define EBUS_DMA_RESET_TIMEOUT  10000
61
62 static void __ebus_dma_reset(struct ebus_dma_info *p, int no_drain)
63 {
64         int i;
65         u32 val = 0;
66
67         writel(EBDMA_CSR_RESET, p->regs + EBDMA_CSR);
68         udelay(1);
69
70         if (no_drain)
71                 return;
72
73         for (i = EBUS_DMA_RESET_TIMEOUT; i > 0; i--) {
74                 val = readl(p->regs + EBDMA_CSR);
75
76                 if (!(val & (EBDMA_CSR_DRAIN | EBDMA_CSR_CYC_PEND)))
77                         break;
78                 udelay(10);
79         }
80 }
81
82 static irqreturn_t ebus_dma_irq(int irq, void *dev_id)
83 {
84         struct ebus_dma_info *p = dev_id;
85         unsigned long flags;
86         u32 csr = 0;
87
88         spin_lock_irqsave(&p->lock, flags);
89         csr = readl(p->regs + EBDMA_CSR);
90         writel(csr, p->regs + EBDMA_CSR);
91         spin_unlock_irqrestore(&p->lock, flags);
92
93         if (csr & EBDMA_CSR_ERR_PEND) {
94                 printk(KERN_CRIT "ebus_dma(%s): DMA error!\n", p->name);
95                 p->callback(p, EBUS_DMA_EVENT_ERROR, p->client_cookie);
96                 return IRQ_HANDLED;
97         } else if (csr & EBDMA_CSR_INT_PEND) {
98                 p->callback(p,
99                             (csr & EBDMA_CSR_TC) ?
100                             EBUS_DMA_EVENT_DMA : EBUS_DMA_EVENT_DEVICE,
101                             p->client_cookie);
102                 return IRQ_HANDLED;
103         }
104
105         return IRQ_NONE;
106
107 }
108
109 int ebus_dma_register(struct ebus_dma_info *p)
110 {
111         u32 csr;
112
113         if (!p->regs)
114                 return -EINVAL;
115         if (p->flags & ~(EBUS_DMA_FLAG_USE_EBDMA_HANDLER |
116                          EBUS_DMA_FLAG_TCI_DISABLE))
117                 return -EINVAL;
118         if ((p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) && !p->callback)
119                 return -EINVAL;
120         if (!strlen(p->name))
121                 return -EINVAL;
122
123         __ebus_dma_reset(p, 1);
124
125         csr = EBDMA_CSR_BURST_SZ_16 | EBDMA_CSR_EN_CNT;
126
127         if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE)
128                 csr |= EBDMA_CSR_TCI_DIS;
129
130         writel(csr, p->regs + EBDMA_CSR);
131
132         return 0;
133 }
134 EXPORT_SYMBOL(ebus_dma_register);
135
136 int ebus_dma_irq_enable(struct ebus_dma_info *p, int on)
137 {
138         unsigned long flags;
139         u32 csr;
140
141         if (on) {
142                 if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) {
143                         if (request_irq(p->irq, ebus_dma_irq, IRQF_SHARED, p->name, p))
144                                 return -EBUSY;
145                 }
146
147                 spin_lock_irqsave(&p->lock, flags);
148                 csr = readl(p->regs + EBDMA_CSR);
149                 csr |= EBDMA_CSR_INT_EN;
150                 writel(csr, p->regs + EBDMA_CSR);
151                 spin_unlock_irqrestore(&p->lock, flags);
152         } else {
153                 spin_lock_irqsave(&p->lock, flags);
154                 csr = readl(p->regs + EBDMA_CSR);
155                 csr &= ~EBDMA_CSR_INT_EN;
156                 writel(csr, p->regs + EBDMA_CSR);
157                 spin_unlock_irqrestore(&p->lock, flags);
158
159                 if (p->flags & EBUS_DMA_FLAG_USE_EBDMA_HANDLER) {
160                         free_irq(p->irq, p);
161                 }
162         }
163
164         return 0;
165 }
166 EXPORT_SYMBOL(ebus_dma_irq_enable);
167
168 void ebus_dma_unregister(struct ebus_dma_info *p)
169 {
170         unsigned long flags;
171         u32 csr;
172         int irq_on = 0;
173
174         spin_lock_irqsave(&p->lock, flags);
175         csr = readl(p->regs + EBDMA_CSR);
176         if (csr & EBDMA_CSR_INT_EN) {
177                 csr &= ~EBDMA_CSR_INT_EN;
178                 writel(csr, p->regs + EBDMA_CSR);
179                 irq_on = 1;
180         }
181         spin_unlock_irqrestore(&p->lock, flags);
182
183         if (irq_on)
184                 free_irq(p->irq, p);
185 }
186 EXPORT_SYMBOL(ebus_dma_unregister);
187
188 int ebus_dma_request(struct ebus_dma_info *p, dma_addr_t bus_addr, size_t len)
189 {
190         unsigned long flags;
191         u32 csr;
192         int err;
193
194         if (len >= (1 << 24))
195                 return -EINVAL;
196
197         spin_lock_irqsave(&p->lock, flags);
198         csr = readl(p->regs + EBDMA_CSR);
199         err = -EINVAL;
200         if (!(csr & EBDMA_CSR_EN_DMA))
201                 goto out;
202         err = -EBUSY;
203         if (csr & EBDMA_CSR_NA_LOADED)
204                 goto out;
205
206         writel(len,      p->regs + EBDMA_COUNT);
207         writel(bus_addr, p->regs + EBDMA_ADDR);
208         err = 0;
209
210 out:
211         spin_unlock_irqrestore(&p->lock, flags);
212
213         return err;
214 }
215 EXPORT_SYMBOL(ebus_dma_request);
216
217 void ebus_dma_prepare(struct ebus_dma_info *p, int write)
218 {
219         unsigned long flags;
220         u32 csr;
221
222         spin_lock_irqsave(&p->lock, flags);
223         __ebus_dma_reset(p, 0);
224
225         csr = (EBDMA_CSR_INT_EN |
226                EBDMA_CSR_EN_CNT |
227                EBDMA_CSR_BURST_SZ_16 |
228                EBDMA_CSR_EN_NEXT);
229
230         if (write)
231                 csr |= EBDMA_CSR_WRITE;
232         if (p->flags & EBUS_DMA_FLAG_TCI_DISABLE)
233                 csr |= EBDMA_CSR_TCI_DIS;
234
235         writel(csr, p->regs + EBDMA_CSR);
236
237         spin_unlock_irqrestore(&p->lock, flags);
238 }
239 EXPORT_SYMBOL(ebus_dma_prepare);
240
241 unsigned int ebus_dma_residue(struct ebus_dma_info *p)
242 {
243         return readl(p->regs + EBDMA_COUNT);
244 }
245 EXPORT_SYMBOL(ebus_dma_residue);
246
247 unsigned int ebus_dma_addr(struct ebus_dma_info *p)
248 {
249         return readl(p->regs + EBDMA_ADDR);
250 }
251 EXPORT_SYMBOL(ebus_dma_addr);
252
253 void ebus_dma_enable(struct ebus_dma_info *p, int on)
254 {
255         unsigned long flags;
256         u32 orig_csr, csr;
257
258         spin_lock_irqsave(&p->lock, flags);
259         orig_csr = csr = readl(p->regs + EBDMA_CSR);
260         if (on)
261                 csr |= EBDMA_CSR_EN_DMA;
262         else
263                 csr &= ~EBDMA_CSR_EN_DMA;
264         if ((orig_csr & EBDMA_CSR_EN_DMA) !=
265             (csr & EBDMA_CSR_EN_DMA))
266                 writel(csr, p->regs + EBDMA_CSR);
267         spin_unlock_irqrestore(&p->lock, flags);
268 }
269 EXPORT_SYMBOL(ebus_dma_enable);
270
271 struct linux_ebus *ebus_chain = NULL;
272
273 static inline void *ebus_alloc(size_t size)
274 {
275         void *mem;
276
277         mem = kzalloc(size, GFP_ATOMIC);
278         if (!mem)
279                 panic("ebus_alloc: out of memory");
280         return mem;
281 }
282
283 static void __init fill_ebus_child(struct device_node *dp,
284                                    struct linux_ebus_child *dev,
285                                    int non_standard_regs)
286 {
287         struct of_device *op;
288         const int *regs;
289         int i, len;
290
291         dev->prom_node = dp;
292         printk(" (%s)", dp->name);
293
294         regs = of_get_property(dp, "reg", &len);
295         if (!regs)
296                 dev->num_addrs = 0;
297         else
298                 dev->num_addrs = len / sizeof(regs[0]);
299
300         if (non_standard_regs) {
301                 /* This is to handle reg properties which are not
302                  * in the parent relative format.  One example are
303                  * children of the i2c device on CompactPCI systems.
304                  *
305                  * So, for such devices we just record the property
306                  * raw in the child resources.
307                  */
308                 for (i = 0; i < dev->num_addrs; i++)
309                         dev->resource[i].start = regs[i];
310         } else {
311                 for (i = 0; i < dev->num_addrs; i++) {
312                         int rnum = regs[i];
313                         if (rnum >= dev->parent->num_addrs) {
314                                 prom_printf("UGH: property for %s was %d, need < %d\n",
315                                             dp->name, len, dev->parent->num_addrs);
316                                 prom_halt();
317                         }
318                         dev->resource[i].start = dev->parent->resource[i].start;
319                         dev->resource[i].end = dev->parent->resource[i].end;
320                         dev->resource[i].flags = IORESOURCE_MEM;
321                         dev->resource[i].name = dp->name;
322                 }
323         }
324
325         op = of_find_device_by_node(dp);
326         if (!op) {
327                 dev->num_irqs = 0;
328         } else {
329                 dev->num_irqs = op->num_irqs;
330                 for (i = 0; i < dev->num_irqs; i++)
331                         dev->irqs[i] = op->irqs[i];
332         }
333
334         if (!dev->num_irqs) {
335                 /*
336                  * Oh, well, some PROMs don't export interrupts
337                  * property to children of EBus devices...
338                  *
339                  * Be smart about PS/2 keyboard and mouse.
340                  */
341                 if (!strcmp(dev->parent->prom_node->name, "8042")) {
342                         if (!strcmp(dev->prom_node->name, "kb_ps2")) {
343                                 dev->num_irqs = 1;
344                                 dev->irqs[0] = dev->parent->irqs[0];
345                         } else {
346                                 dev->num_irqs = 1;
347                                 dev->irqs[0] = dev->parent->irqs[1];
348                         }
349                 }
350         }
351 }
352
353 static int __init child_regs_nonstandard(struct linux_ebus_device *dev)
354 {
355         if (!strcmp(dev->prom_node->name, "i2c") ||
356             !strcmp(dev->prom_node->name, "SUNW,lombus"))
357                 return 1;
358         return 0;
359 }
360
361 static void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *dev)
362 {
363         struct linux_ebus_child *child;
364         struct dev_archdata *sd;
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                 const int *regs = of_get_property(dp, "reg", &len);
378
379                 if (!regs)
380                         len = 0;
381                 dev->num_addrs = len / sizeof(struct linux_prom_registers);
382
383                 for (i = 0; i < dev->num_addrs; i++)
384                         memcpy(&dev->resource[i],
385                                &op->resource[i],
386                                sizeof(struct resource));
387
388                 dev->num_irqs = op->num_irqs;
389                 for (i = 0; i < dev->num_irqs; i++)
390                         dev->irqs[i] = op->irqs[i];
391         }
392
393         sd = &dev->ofdev.dev.archdata;
394         sd->prom_node = dp;
395         sd->op = &dev->ofdev;
396         sd->iommu = dev->bus->ofdev.dev.parent->archdata.iommu;
397         sd->stc = dev->bus->ofdev.dev.parent->archdata.stc;
398         sd->numa_node = dev->bus->ofdev.dev.parent->archdata.numa_node;
399
400         dev->ofdev.node = dp;
401         dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
402         dev->ofdev.dev.bus = &ebus_bus_type;
403         dev_set_name(&dev->ofdev.dev, "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                 dev_set_name(&ebus->ofdev.dev, "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 }