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