Merge branch 'for-linus' of master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6] / drivers / scsi / sun_esp.c
1 /* sun_esp.c: ESP front-end for Sparc SBUS systems.
2  *
3  * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
4  */
5
6 #include <linux/kernel.h>
7 #include <linux/types.h>
8 #include <linux/module.h>
9 #include <linux/init.h>
10
11 #include <asm/irq.h>
12 #include <asm/io.h>
13 #include <asm/dma.h>
14
15 #include <asm/sbus.h>
16
17 #include <scsi/scsi_host.h>
18
19 #include "esp_scsi.h"
20
21 #define DRV_MODULE_NAME         "sun_esp"
22 #define PFX DRV_MODULE_NAME     ": "
23 #define DRV_VERSION             "1.000"
24 #define DRV_MODULE_RELDATE      "April 19, 2007"
25
26 #define dma_read32(REG) \
27         sbus_readl(esp->dma_regs + (REG))
28 #define dma_write32(VAL, REG) \
29         sbus_writel((VAL), esp->dma_regs + (REG))
30
31 static int __devinit esp_sbus_find_dma(struct esp *esp, struct sbus_dev *dma_sdev)
32 {
33         struct sbus_dev *sdev = esp->dev;
34         struct sbus_dma *dma;
35
36         if (dma_sdev != NULL) {
37                 for_each_dvma(dma) {
38                         if (dma->sdev == dma_sdev)
39                                 break;
40                 }
41         } else {
42                 for_each_dvma(dma) {
43                         if (dma->sdev == NULL)
44                                 break;
45
46                         /* If bus + slot are the same and it has the
47                          * correct OBP name, it's ours.
48                          */
49                         if (sdev->bus == dma->sdev->bus &&
50                             sdev->slot == dma->sdev->slot &&
51                             (!strcmp(dma->sdev->prom_name, "dma") ||
52                              !strcmp(dma->sdev->prom_name, "espdma")))
53                                 break;
54                 }
55         }
56
57         if (dma == NULL) {
58                 printk(KERN_ERR PFX "[%s] Cannot find dma.\n",
59                        sdev->ofdev.node->full_name);
60                 return -ENODEV;
61         }
62         esp->dma = dma;
63         esp->dma_regs = dma->regs;
64
65         return 0;
66
67 }
68
69 static int __devinit esp_sbus_map_regs(struct esp *esp, int hme)
70 {
71         struct sbus_dev *sdev = esp->dev;
72         struct resource *res;
73
74         /* On HME, two reg sets exist, first is DVMA,
75          * second is ESP registers.
76          */
77         if (hme)
78                 res = &sdev->resource[1];
79         else
80                 res = &sdev->resource[0];
81
82         esp->regs = sbus_ioremap(res, 0, SBUS_ESP_REG_SIZE, "ESP");
83         if (!esp->regs)
84                 return -ENOMEM;
85
86         return 0;
87 }
88
89 static int __devinit esp_sbus_map_command_block(struct esp *esp)
90 {
91         struct sbus_dev *sdev = esp->dev;
92
93         esp->command_block = sbus_alloc_consistent(sdev, 16,
94                                                    &esp->command_block_dma);
95         if (!esp->command_block)
96                 return -ENOMEM;
97         return 0;
98 }
99
100 static int __devinit esp_sbus_register_irq(struct esp *esp)
101 {
102         struct Scsi_Host *host = esp->host;
103         struct sbus_dev *sdev = esp->dev;
104
105         host->irq = sdev->irqs[0];
106         return request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "ESP", esp);
107 }
108
109 static void __devinit esp_get_scsi_id(struct esp *esp)
110 {
111         struct sbus_dev *sdev = esp->dev;
112         struct device_node *dp = sdev->ofdev.node;
113
114         esp->scsi_id = of_getintprop_default(dp, "initiator-id", 0xff);
115         if (esp->scsi_id != 0xff)
116                 goto done;
117
118         esp->scsi_id = of_getintprop_default(dp, "scsi-initiator-id", 0xff);
119         if (esp->scsi_id != 0xff)
120                 goto done;
121
122         if (!sdev->bus) {
123                 /* SUN4 */
124                 esp->scsi_id = 7;
125                 goto done;
126         }
127
128         esp->scsi_id = of_getintprop_default(sdev->bus->ofdev.node,
129                                              "scsi-initiator-id", 7);
130
131 done:
132         esp->host->this_id = esp->scsi_id;
133         esp->scsi_id_mask = (1 << esp->scsi_id);
134 }
135
136 static void __devinit esp_get_differential(struct esp *esp)
137 {
138         struct sbus_dev *sdev = esp->dev;
139         struct device_node *dp = sdev->ofdev.node;
140
141         if (of_find_property(dp, "differential", NULL))
142                 esp->flags |= ESP_FLAG_DIFFERENTIAL;
143         else
144                 esp->flags &= ~ESP_FLAG_DIFFERENTIAL;
145 }
146
147 static void __devinit esp_get_clock_params(struct esp *esp)
148 {
149         struct sbus_dev *sdev = esp->dev;
150         struct device_node *dp = sdev->ofdev.node;
151         struct device_node *bus_dp;
152         int fmhz;
153
154         bus_dp = NULL;
155         if (sdev != NULL && sdev->bus != NULL)
156                 bus_dp = sdev->bus->ofdev.node;
157
158         fmhz = of_getintprop_default(dp, "clock-frequency", 0);
159         if (fmhz == 0)
160                 fmhz = (!bus_dp) ? 0 :
161                         of_getintprop_default(bus_dp, "clock-frequency", 0);
162
163         esp->cfreq = fmhz;
164 }
165
166 static void __devinit esp_get_bursts(struct esp *esp, struct sbus_dev *dma)
167 {
168         struct sbus_dev *sdev = esp->dev;
169         struct device_node *dp = sdev->ofdev.node;
170         u8 bursts;
171
172         bursts = of_getintprop_default(dp, "burst-sizes", 0xff);
173         if (dma) {
174                 struct device_node *dma_dp = dma->ofdev.node;
175                 u8 val = of_getintprop_default(dma_dp, "burst-sizes", 0xff);
176                 if (val != 0xff)
177                         bursts &= val;
178         }
179
180         if (sdev->bus) {
181                 u8 val = of_getintprop_default(sdev->bus->ofdev.node,
182                                                "burst-sizes", 0xff);
183                 if (val != 0xff)
184                         bursts &= val;
185         }
186
187         if (bursts == 0xff ||
188             (bursts & DMA_BURST16) == 0 ||
189             (bursts & DMA_BURST32) == 0)
190                 bursts = (DMA_BURST32 - 1);
191
192         esp->bursts = bursts;
193 }
194
195 static void __devinit esp_sbus_get_props(struct esp *esp, struct sbus_dev *espdma)
196 {
197         esp_get_scsi_id(esp);
198         esp_get_differential(esp);
199         esp_get_clock_params(esp);
200         esp_get_bursts(esp, espdma);
201 }
202
203 static void sbus_esp_write8(struct esp *esp, u8 val, unsigned long reg)
204 {
205         sbus_writeb(val, esp->regs + (reg * 4UL));
206 }
207
208 static u8 sbus_esp_read8(struct esp *esp, unsigned long reg)
209 {
210         return sbus_readb(esp->regs + (reg * 4UL));
211 }
212
213 static dma_addr_t sbus_esp_map_single(struct esp *esp, void *buf,
214                                       size_t sz, int dir)
215 {
216         return sbus_map_single(esp->dev, buf, sz, dir);
217 }
218
219 static int sbus_esp_map_sg(struct esp *esp, struct scatterlist *sg,
220                                   int num_sg, int dir)
221 {
222         return sbus_map_sg(esp->dev, sg, num_sg, dir);
223 }
224
225 static void sbus_esp_unmap_single(struct esp *esp, dma_addr_t addr,
226                                   size_t sz, int dir)
227 {
228         sbus_unmap_single(esp->dev, addr, sz, dir);
229 }
230
231 static void sbus_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
232                               int num_sg, int dir)
233 {
234         sbus_unmap_sg(esp->dev, sg, num_sg, dir);
235 }
236
237 static int sbus_esp_irq_pending(struct esp *esp)
238 {
239         if (dma_read32(DMA_CSR) & (DMA_HNDL_INTR | DMA_HNDL_ERROR))
240                 return 1;
241         return 0;
242 }
243
244 static void sbus_esp_reset_dma(struct esp *esp)
245 {
246         int can_do_burst16, can_do_burst32, can_do_burst64;
247         int can_do_sbus64, lim;
248         u32 val;
249
250         can_do_burst16 = (esp->bursts & DMA_BURST16) != 0;
251         can_do_burst32 = (esp->bursts & DMA_BURST32) != 0;
252         can_do_burst64 = 0;
253         can_do_sbus64 = 0;
254         if (sbus_can_dma_64bit(esp->dev))
255                 can_do_sbus64 = 1;
256         if (sbus_can_burst64(esp->sdev))
257                 can_do_burst64 = (esp->bursts & DMA_BURST64) != 0;
258
259         /* Put the DVMA into a known state. */
260         if (esp->dma->revision != dvmahme) {
261                 val = dma_read32(DMA_CSR);
262                 dma_write32(val | DMA_RST_SCSI, DMA_CSR);
263                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
264         }
265         switch (esp->dma->revision) {
266         case dvmahme:
267                 dma_write32(DMA_RESET_FAS366, DMA_CSR);
268                 dma_write32(DMA_RST_SCSI, DMA_CSR);
269
270                 esp->prev_hme_dmacsr = (DMA_PARITY_OFF | DMA_2CLKS |
271                                         DMA_SCSI_DISAB | DMA_INT_ENAB);
272
273                 esp->prev_hme_dmacsr &= ~(DMA_ENABLE | DMA_ST_WRITE |
274                                           DMA_BRST_SZ);
275
276                 if (can_do_burst64)
277                         esp->prev_hme_dmacsr |= DMA_BRST64;
278                 else if (can_do_burst32)
279                         esp->prev_hme_dmacsr |= DMA_BRST32;
280
281                 if (can_do_sbus64) {
282                         esp->prev_hme_dmacsr |= DMA_SCSI_SBUS64;
283                         sbus_set_sbus64(esp->dev, esp->bursts);
284                 }
285
286                 lim = 1000;
287                 while (dma_read32(DMA_CSR) & DMA_PEND_READ) {
288                         if (--lim == 0) {
289                                 printk(KERN_ALERT PFX "esp%d: DMA_PEND_READ "
290                                        "will not clear!\n",
291                                        esp->host->unique_id);
292                                 break;
293                         }
294                         udelay(1);
295                 }
296
297                 dma_write32(0, DMA_CSR);
298                 dma_write32(esp->prev_hme_dmacsr, DMA_CSR);
299
300                 dma_write32(0, DMA_ADDR);
301                 break;
302
303         case dvmarev2:
304                 if (esp->rev != ESP100) {
305                         val = dma_read32(DMA_CSR);
306                         dma_write32(val | DMA_3CLKS, DMA_CSR);
307                 }
308                 break;
309
310         case dvmarev3:
311                 val = dma_read32(DMA_CSR);
312                 val &= ~DMA_3CLKS;
313                 val |= DMA_2CLKS;
314                 if (can_do_burst32) {
315                         val &= ~DMA_BRST_SZ;
316                         val |= DMA_BRST32;
317                 }
318                 dma_write32(val, DMA_CSR);
319                 break;
320
321         case dvmaesc1:
322                 val = dma_read32(DMA_CSR);
323                 val |= DMA_ADD_ENABLE;
324                 val &= ~DMA_BCNT_ENAB;
325                 if (!can_do_burst32 && can_do_burst16) {
326                         val |= DMA_ESC_BURST;
327                 } else {
328                         val &= ~(DMA_ESC_BURST);
329                 }
330                 dma_write32(val, DMA_CSR);
331                 break;
332
333         default:
334                 break;
335         }
336
337         /* Enable interrupts.  */
338         val = dma_read32(DMA_CSR);
339         dma_write32(val | DMA_INT_ENAB, DMA_CSR);
340 }
341
342 static void sbus_esp_dma_drain(struct esp *esp)
343 {
344         u32 csr;
345         int lim;
346
347         if (esp->dma->revision == dvmahme)
348                 return;
349
350         csr = dma_read32(DMA_CSR);
351         if (!(csr & DMA_FIFO_ISDRAIN))
352                 return;
353
354         if (esp->dma->revision != dvmarev3 && esp->dma->revision != dvmaesc1)
355                 dma_write32(csr | DMA_FIFO_STDRAIN, DMA_CSR);
356
357         lim = 1000;
358         while (dma_read32(DMA_CSR) & DMA_FIFO_ISDRAIN) {
359                 if (--lim == 0) {
360                         printk(KERN_ALERT PFX "esp%d: DMA will not drain!\n",
361                                esp->host->unique_id);
362                         break;
363                 }
364                 udelay(1);
365         }
366 }
367
368 static void sbus_esp_dma_invalidate(struct esp *esp)
369 {
370         if (esp->dma->revision == dvmahme) {
371                 dma_write32(DMA_RST_SCSI, DMA_CSR);
372
373                 esp->prev_hme_dmacsr = ((esp->prev_hme_dmacsr |
374                                          (DMA_PARITY_OFF | DMA_2CLKS |
375                                           DMA_SCSI_DISAB | DMA_INT_ENAB)) &
376                                         ~(DMA_ST_WRITE | DMA_ENABLE));
377
378                 dma_write32(0, DMA_CSR);
379                 dma_write32(esp->prev_hme_dmacsr, DMA_CSR);
380
381                 /* This is necessary to avoid having the SCSI channel
382                  * engine lock up on us.
383                  */
384                 dma_write32(0, DMA_ADDR);
385         } else {
386                 u32 val;
387                 int lim;
388
389                 lim = 1000;
390                 while ((val = dma_read32(DMA_CSR)) & DMA_PEND_READ) {
391                         if (--lim == 0) {
392                                 printk(KERN_ALERT PFX "esp%d: DMA will not "
393                                        "invalidate!\n", esp->host->unique_id);
394                                 break;
395                         }
396                         udelay(1);
397                 }
398
399                 val &= ~(DMA_ENABLE | DMA_ST_WRITE | DMA_BCNT_ENAB);
400                 val |= DMA_FIFO_INV;
401                 dma_write32(val, DMA_CSR);
402                 val &= ~DMA_FIFO_INV;
403                 dma_write32(val, DMA_CSR);
404         }
405 }
406
407 static void sbus_esp_send_dma_cmd(struct esp *esp, u32 addr, u32 esp_count,
408                                   u32 dma_count, int write, u8 cmd)
409 {
410         u32 csr;
411
412         BUG_ON(!(cmd & ESP_CMD_DMA));
413
414         sbus_esp_write8(esp, (esp_count >> 0) & 0xff, ESP_TCLOW);
415         sbus_esp_write8(esp, (esp_count >> 8) & 0xff, ESP_TCMED);
416         if (esp->rev == FASHME) {
417                 sbus_esp_write8(esp, (esp_count >> 16) & 0xff, FAS_RLO);
418                 sbus_esp_write8(esp, 0, FAS_RHI);
419
420                 scsi_esp_cmd(esp, cmd);
421
422                 csr = esp->prev_hme_dmacsr;
423                 csr |= DMA_SCSI_DISAB | DMA_ENABLE;
424                 if (write)
425                         csr |= DMA_ST_WRITE;
426                 else
427                         csr &= ~DMA_ST_WRITE;
428                 esp->prev_hme_dmacsr = csr;
429
430                 dma_write32(dma_count, DMA_COUNT);
431                 dma_write32(addr, DMA_ADDR);
432                 dma_write32(csr, DMA_CSR);
433         } else {
434                 csr = dma_read32(DMA_CSR);
435                 csr |= DMA_ENABLE;
436                 if (write)
437                         csr |= DMA_ST_WRITE;
438                 else
439                         csr &= ~DMA_ST_WRITE;
440                 dma_write32(csr, DMA_CSR);
441                 if (esp->dma->revision == dvmaesc1) {
442                         u32 end = PAGE_ALIGN(addr + dma_count + 16U);
443                         dma_write32(end - addr, DMA_COUNT);
444                 }
445                 dma_write32(addr, DMA_ADDR);
446
447                 scsi_esp_cmd(esp, cmd);
448         }
449
450 }
451
452 static int sbus_esp_dma_error(struct esp *esp)
453 {
454         u32 csr = dma_read32(DMA_CSR);
455
456         if (csr & DMA_HNDL_ERROR)
457                 return 1;
458
459         return 0;
460 }
461
462 static const struct esp_driver_ops sbus_esp_ops = {
463         .esp_write8     =       sbus_esp_write8,
464         .esp_read8      =       sbus_esp_read8,
465         .map_single     =       sbus_esp_map_single,
466         .map_sg         =       sbus_esp_map_sg,
467         .unmap_single   =       sbus_esp_unmap_single,
468         .unmap_sg       =       sbus_esp_unmap_sg,
469         .irq_pending    =       sbus_esp_irq_pending,
470         .reset_dma      =       sbus_esp_reset_dma,
471         .dma_drain      =       sbus_esp_dma_drain,
472         .dma_invalidate =       sbus_esp_dma_invalidate,
473         .send_dma_cmd   =       sbus_esp_send_dma_cmd,
474         .dma_error      =       sbus_esp_dma_error,
475 };
476
477 static int __devinit esp_sbus_probe_one(struct device *dev,
478                                         struct sbus_dev *esp_dev,
479                                         struct sbus_dev *espdma,
480                                         struct sbus_bus *sbus,
481                                         int hme)
482 {
483         struct scsi_host_template *tpnt = &scsi_esp_template;
484         struct Scsi_Host *host;
485         struct esp *esp;
486         int err;
487
488         host = scsi_host_alloc(tpnt, sizeof(struct esp));
489
490         err = -ENOMEM;
491         if (!host)
492                 goto fail;
493
494         host->max_id = (hme ? 16 : 8);
495         esp = host_to_esp(host);
496
497         esp->host = host;
498         esp->dev = esp_dev;
499         esp->ops = &sbus_esp_ops;
500
501         if (hme)
502                 esp->flags |= ESP_FLAG_WIDE_CAPABLE;
503
504         err = esp_sbus_find_dma(esp, espdma);
505         if (err < 0)
506                 goto fail_unlink;
507
508         err = esp_sbus_map_regs(esp, hme);
509         if (err < 0)
510                 goto fail_unlink;
511
512         err = esp_sbus_map_command_block(esp);
513         if (err < 0)
514                 goto fail_unmap_regs;
515
516         err = esp_sbus_register_irq(esp);
517         if (err < 0)
518                 goto fail_unmap_command_block;
519
520         esp_sbus_get_props(esp, espdma);
521
522         /* Before we try to touch the ESP chip, ESC1 dma can
523          * come up with the reset bit set, so make sure that
524          * is clear first.
525          */
526         if (esp->dma->revision == dvmaesc1) {
527                 u32 val = dma_read32(DMA_CSR);
528
529                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
530         }
531
532         dev_set_drvdata(&esp_dev->ofdev.dev, esp);
533
534         err = scsi_esp_register(esp, dev);
535         if (err)
536                 goto fail_free_irq;
537
538         return 0;
539
540 fail_free_irq:
541         free_irq(host->irq, esp);
542 fail_unmap_command_block:
543         sbus_free_consistent(esp->dev, 16,
544                              esp->command_block,
545                              esp->command_block_dma);
546 fail_unmap_regs:
547         sbus_iounmap(esp->regs, SBUS_ESP_REG_SIZE);
548 fail_unlink:
549         scsi_host_put(host);
550 fail:
551         return err;
552 }
553
554 static int __devinit esp_sbus_probe(struct of_device *dev, const struct of_device_id *match)
555 {
556         struct sbus_dev *sdev = to_sbus_device(&dev->dev);
557         struct device_node *dp = dev->node;
558         struct sbus_dev *dma_sdev = NULL;
559         int hme = 0;
560
561         if (dp->parent &&
562             (!strcmp(dp->parent->name, "espdma") ||
563              !strcmp(dp->parent->name, "dma")))
564                 dma_sdev = sdev->parent;
565         else if (!strcmp(dp->name, "SUNW,fas")) {
566                 dma_sdev = sdev;
567                 hme = 1;
568         }
569
570         return esp_sbus_probe_one(&dev->dev, sdev, dma_sdev,
571                                   sdev->bus, hme);
572 }
573
574 static int __devexit esp_sbus_remove(struct of_device *dev)
575 {
576         struct esp *esp = dev_get_drvdata(&dev->dev);
577         unsigned int irq = esp->host->irq;
578         u32 val;
579
580         scsi_esp_unregister(esp);
581
582         /* Disable interrupts.  */
583         val = dma_read32(DMA_CSR);
584         dma_write32(val & ~DMA_INT_ENAB, DMA_CSR);
585
586         free_irq(irq, esp);
587         sbus_free_consistent(esp->dev, 16,
588                              esp->command_block,
589                              esp->command_block_dma);
590         sbus_iounmap(esp->regs, SBUS_ESP_REG_SIZE);
591
592         scsi_host_put(esp->host);
593
594         return 0;
595 }
596
597 static struct of_device_id esp_match[] = {
598         {
599                 .name = "SUNW,esp",
600         },
601         {
602                 .name = "SUNW,fas",
603         },
604         {
605                 .name = "esp",
606         },
607         {},
608 };
609 MODULE_DEVICE_TABLE(of, esp_match);
610
611 static struct of_platform_driver esp_sbus_driver = {
612         .name           = "esp",
613         .match_table    = esp_match,
614         .probe          = esp_sbus_probe,
615         .remove         = __devexit_p(esp_sbus_remove),
616 };
617
618 static int __init sunesp_init(void)
619 {
620         return of_register_driver(&esp_sbus_driver, &sbus_bus_type);
621 }
622
623 static void __exit sunesp_exit(void)
624 {
625         of_unregister_driver(&esp_sbus_driver);
626 }
627
628 MODULE_DESCRIPTION("Sun ESP SCSI driver");
629 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
630 MODULE_LICENSE("GPL");
631 MODULE_VERSION(DRV_VERSION);
632
633 module_init(sunesp_init);
634 module_exit(sunesp_exit);