?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nilfs2: unbreak compat ioctl
[zen-stable.git] / drivers / scsi / mac_esp.c
blob590ce1ef20167d407dde187924a9a0ccf2def68e
1 /* mac_esp.c: ESP front-end for Macintosh Quadra systems.
2 *
3 * Adapted from jazz_esp.c and the old mac_esp.c.
4 *
5 * The pseudo DMA algorithm is based on the one used in NetBSD.
6 * See sys/arch/mac68k/obio/esp.c for some background information.
7 *
8 * Copyright (C) 2007-2008 Finn Thain
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/platform_device.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/scatterlist.h>
19 #include <linux/delay.h>
20 #include <linux/io.h>
21 #include <linux/nubus.h>
22 #include <linux/slab.h>
23
24 #include <asm/irq.h>
25 #include <asm/dma.h>
26 #include <asm/macints.h>
27 #include <asm/macintosh.h>
28
29 #include <scsi/scsi_host.h>
30
31 #include "esp_scsi.h"
32
33 #define DRV_MODULE_NAME "mac_esp"
34 #define PFX DRV_MODULE_NAME ": "
35 #define DRV_VERSION "1.000"
36 #define DRV_MODULE_RELDATE "Sept 15, 2007"
37
38 #define MAC_ESP_IO_BASE 0x50F00000
39 #define MAC_ESP_REGS_QUADRA (MAC_ESP_IO_BASE + 0x10000)
40 #define MAC_ESP_REGS_QUADRA2 (MAC_ESP_IO_BASE + 0xF000)
41 #define MAC_ESP_REGS_QUADRA3 (MAC_ESP_IO_BASE + 0x18000)
42 #define MAC_ESP_REGS_SPACING 0x402
43 #define MAC_ESP_PDMA_REG 0xF9800024
44 #define MAC_ESP_PDMA_REG_SPACING 0x4
45 #define MAC_ESP_PDMA_IO_OFFSET 0x100
46
47 #define esp_read8(REG) mac_esp_read8(esp, REG)
48 #define esp_write8(VAL, REG) mac_esp_write8(esp, VAL, REG)
49
50 struct mac_esp_priv {
51 struct esp *esp;
52 void __iomem *pdma_regs;
53 void __iomem *pdma_io;
54 int error;
55 };
56 static struct esp *esp_chips[2];
57
58 #define MAC_ESP_GET_PRIV(esp) ((struct mac_esp_priv *) \
59 platform_get_drvdata((struct platform_device *) \
60 (esp->dev)))
61
62 static inline void mac_esp_write8(struct esp *esp, u8 val, unsigned long reg)
63 {
64 nubus_writeb(val, esp->regs + reg * 16);
65 }
66
67 static inline u8 mac_esp_read8(struct esp *esp, unsigned long reg)
68 {
69 return nubus_readb(esp->regs + reg * 16);
70 }
71
72 /* For pseudo DMA and PIO we need the virtual address
73 * so this address mapping is the identity mapping.
74 */
75
76 static dma_addr_t mac_esp_map_single(struct esp *esp, void *buf,
77 size_t sz, int dir)
78 {
79 return (dma_addr_t)buf;
80 }
81
82 static int mac_esp_map_sg(struct esp *esp, struct scatterlist *sg,
83 int num_sg, int dir)
84 {
85 int i;
86
87 for (i = 0; i < num_sg; i++)
88 sg[i].dma_address = (u32)sg_virt(&sg[i]);
89 return num_sg;
90 }
91
92 static void mac_esp_unmap_single(struct esp *esp, dma_addr_t addr,
93 size_t sz, int dir)
94 {
95 /* Nothing to do. */
96 }
97
98 static void mac_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
99 int num_sg, int dir)
100 {
101 /* Nothing to do. */
102 }
103
104 static void mac_esp_reset_dma(struct esp *esp)
105 {
106 /* Nothing to do. */
107 }
108
109 static void mac_esp_dma_drain(struct esp *esp)
110 {
111 /* Nothing to do. */
112 }
113
114 static void mac_esp_dma_invalidate(struct esp *esp)
115 {
116 /* Nothing to do. */
117 }
118
119 static int mac_esp_dma_error(struct esp *esp)
120 {
121 return MAC_ESP_GET_PRIV(esp)->error;
122 }
123
124 static inline int mac_esp_wait_for_empty_fifo(struct esp *esp)
125 {
126 struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
127 int i = 500000;
128
129 do {
130 if (!(esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES))
131 return 0;
132
133 if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
134 return 1;
135
136 udelay(2);
137 } while (--i);
138
139 printk(KERN_ERR PFX "FIFO is not empty (sreg %02x)\n",
140 esp_read8(ESP_STATUS));
141 mep->error = 1;
142 return 1;
143 }
144
145 static inline int mac_esp_wait_for_dreq(struct esp *esp)
146 {
147 struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
148 int i = 500000;
149
150 do {
151 if (mep->pdma_regs == NULL) {
152 if (mac_irq_pending(IRQ_MAC_SCSIDRQ))
153 return 0;
154 } else {
155 if (nubus_readl(mep->pdma_regs) & 0x200)
156 return 0;
157 }
158
159 if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
160 return 1;
161
162 udelay(2);
163 } while (--i);
164
165 printk(KERN_ERR PFX "PDMA timeout (sreg %02x)\n",
166 esp_read8(ESP_STATUS));
167 mep->error = 1;
168 return 1;
169 }
170
171 #define MAC_ESP_PDMA_LOOP(operands) \
172 asm volatile ( \
173 " tstw %1 \n" \
174 " jbeq 20f \n" \
175 "1: movew " operands " \n" \
176 "2: movew " operands " \n" \
177 "3: movew " operands " \n" \
178 "4: movew " operands " \n" \
179 "5: movew " operands " \n" \
180 "6: movew " operands " \n" \
181 "7: movew " operands " \n" \
182 "8: movew " operands " \n" \
183 "9: movew " operands " \n" \
184 "10: movew " operands " \n" \
185 "11: movew " operands " \n" \
186 "12: movew " operands " \n" \
187 "13: movew " operands " \n" \
188 "14: movew " operands " \n" \
189 "15: movew " operands " \n" \
190 "16: movew " operands " \n" \
191 " subqw #1,%1 \n" \
192 " jbne 1b \n" \
193 "20: tstw %2 \n" \
194 " jbeq 30f \n" \
195 "21: movew " operands " \n" \
196 " subqw #1,%2 \n" \
197 " jbne 21b \n" \
198 "30: tstw %3 \n" \
199 " jbeq 40f \n" \
200 "31: moveb " operands " \n" \
201 "32: nop \n" \
202 "40: \n" \
203 " \n" \
204 " .section __ex_table,\"a\" \n" \
205 " .align 4 \n" \
206 " .long 1b,40b \n" \
207 " .long 2b,40b \n" \
208 " .long 3b,40b \n" \
209 " .long 4b,40b \n" \
210 " .long 5b,40b \n" \
211 " .long 6b,40b \n" \
212 " .long 7b,40b \n" \
213 " .long 8b,40b \n" \
214 " .long 9b,40b \n" \
215 " .long 10b,40b \n" \
216 " .long 11b,40b \n" \
217 " .long 12b,40b \n" \
218 " .long 13b,40b \n" \
219 " .long 14b,40b \n" \
220 " .long 15b,40b \n" \
221 " .long 16b,40b \n" \
222 " .long 21b,40b \n" \
223 " .long 31b,40b \n" \
224 " .long 32b,40b \n" \
225 " .previous \n" \
226 : "+a" (addr), "+r" (count32), "+r" (count2) \
227 : "g" (count1), "a" (mep->pdma_io))
228
229 static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count,
230 u32 dma_count, int write, u8 cmd)
231 {
232 struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
233
234 mep->error = 0;
235
236 if (!write)
237 scsi_esp_cmd(esp, ESP_CMD_FLUSH);
238
239 esp_write8((esp_count >> 0) & 0xFF, ESP_TCLOW);
240 esp_write8((esp_count >> 8) & 0xFF, ESP_TCMED);
241
242 scsi_esp_cmd(esp, cmd);
243
244 do {
245 unsigned int count32 = esp_count >> 5;
246 unsigned int count2 = (esp_count & 0x1F) >> 1;
247 unsigned int count1 = esp_count & 1;
248 unsigned int start_addr = addr;
249
250 if (mac_esp_wait_for_dreq(esp))
251 break;
252
253 if (write) {
254 MAC_ESP_PDMA_LOOP("%4@,%0@+");
255
256 esp_count -= addr - start_addr;
257 } else {
258 unsigned int n;
259
260 MAC_ESP_PDMA_LOOP("%0@+,%4@");
261
262 if (mac_esp_wait_for_empty_fifo(esp))
263 break;
264
265 n = (esp_read8(ESP_TCMED) << 8) + esp_read8(ESP_TCLOW);
266 addr = start_addr + esp_count - n;
267 esp_count = n;
268 }
269 } while (esp_count);
270 }
271
272 /*
273 * Programmed IO routines follow.
274 */
275
276 static inline unsigned int mac_esp_wait_for_fifo(struct esp *esp)
277 {
278 int i = 500000;
279
280 do {
281 unsigned int fbytes = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
282
283 if (fbytes)
284 return fbytes;
285
286 udelay(2);
287 } while (--i);
288
289 printk(KERN_ERR PFX "FIFO is empty (sreg %02x)\n",
290 esp_read8(ESP_STATUS));
291 return 0;
292 }
293
294 static inline int mac_esp_wait_for_intr(struct esp *esp)
295 {
296 struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
297 int i = 500000;
298
299 do {
300 esp->sreg = esp_read8(ESP_STATUS);
301 if (esp->sreg & ESP_STAT_INTR)
302 return 0;
303
304 udelay(2);
305 } while (--i);
306
307 printk(KERN_ERR PFX "IRQ timeout (sreg %02x)\n", esp->sreg);
308 mep->error = 1;
309 return 1;
310 }
311
312 #define MAC_ESP_PIO_LOOP(operands, reg1) \
313 asm volatile ( \
314 "1: moveb " operands " \n" \
315 " subqw #1,%1 \n" \
316 " jbne 1b \n" \
317 : "+a" (addr), "+r" (reg1) \
318 : "a" (fifo))
319
320 #define MAC_ESP_PIO_FILL(operands, reg1) \
321 asm volatile ( \
322 " moveb " operands " \n" \
323 " moveb " operands " \n" \
324 " moveb " operands " \n" \
325 " moveb " operands " \n" \
326 " moveb " operands " \n" \
327 " moveb " operands " \n" \
328 " moveb " operands " \n" \
329 " moveb " operands " \n" \
330 " moveb " operands " \n" \
331 " moveb " operands " \n" \
332 " moveb " operands " \n" \
333 " moveb " operands " \n" \
334 " moveb " operands " \n" \
335 " moveb " operands " \n" \
336 " moveb " operands " \n" \
337 " moveb " operands " \n" \
338 " subqw #8,%1 \n" \
339 " subqw #8,%1 \n" \
340 : "+a" (addr), "+r" (reg1) \
341 : "a" (fifo))
342
343 #define MAC_ESP_FIFO_SIZE 16
344
345 static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
346 u32 dma_count, int write, u8 cmd)
347 {
348 struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
349 u8 *fifo = esp->regs + ESP_FDATA * 16;
350
351 cmd &= ~ESP_CMD_DMA;
352 mep->error = 0;
353
354 if (write) {
355 scsi_esp_cmd(esp, cmd);
356
357 while (1) {
358 unsigned int n;
359
360 n = mac_esp_wait_for_fifo(esp);
361 if (!n)
362 break;
363
364 if (n > esp_count)
365 n = esp_count;
366 esp_count -= n;
367
368 MAC_ESP_PIO_LOOP("%2@,%0@+", n);
369
370 if (!esp_count)
371 break;
372
373 if (mac_esp_wait_for_intr(esp))
374 break;
375
376 if (((esp->sreg & ESP_STAT_PMASK) != ESP_DIP) &&
377 ((esp->sreg & ESP_STAT_PMASK) != ESP_MIP))
378 break;
379
380 esp->ireg = esp_read8(ESP_INTRPT);
381 if ((esp->ireg & (ESP_INTR_DC | ESP_INTR_BSERV)) !=
382 ESP_INTR_BSERV)
383 break;
384
385 scsi_esp_cmd(esp, ESP_CMD_TI);
386 }
387 } else {
388 scsi_esp_cmd(esp, ESP_CMD_FLUSH);
389
390 if (esp_count >= MAC_ESP_FIFO_SIZE)
391 MAC_ESP_PIO_FILL("%0@+,%2@", esp_count);
392 else
393 MAC_ESP_PIO_LOOP("%0@+,%2@", esp_count);
394
395 scsi_esp_cmd(esp, cmd);
396
397 while (esp_count) {
398 unsigned int n;
399
400 if (mac_esp_wait_for_intr(esp))
401 break;
402
403 if (((esp->sreg & ESP_STAT_PMASK) != ESP_DOP) &&
404 ((esp->sreg & ESP_STAT_PMASK) != ESP_MOP))
405 break;
406
407 esp->ireg = esp_read8(ESP_INTRPT);
408 if ((esp->ireg & (ESP_INTR_DC | ESP_INTR_BSERV)) !=
409 ESP_INTR_BSERV)
410 break;
411
412 n = MAC_ESP_FIFO_SIZE -
413 (esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES);
414 if (n > esp_count)
415 n = esp_count;
416
417 if (n == MAC_ESP_FIFO_SIZE) {
418 MAC_ESP_PIO_FILL("%0@+,%2@", esp_count);
419 } else {
420 esp_count -= n;
421 MAC_ESP_PIO_LOOP("%0@+,%2@", n);
422 }
423
424 scsi_esp_cmd(esp, ESP_CMD_TI);
425 }
426 }
427 }
428
429 static int mac_esp_irq_pending(struct esp *esp)
430 {
431 if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
432 return 1;
433 return 0;
434 }
435
436 static u32 mac_esp_dma_length_limit(struct esp *esp, u32 dma_addr, u32 dma_len)
437 {
438 return dma_len > 0xFFFF ? 0xFFFF : dma_len;
439 }
440
441 static irqreturn_t mac_scsi_esp_intr(int irq, void *dev_id)
442 {
443 int got_intr;
444
445 /*
446 * This is an edge triggered IRQ, so we have to be careful to
447 * avoid missing a transition when it is shared by two ESP devices.
448 */
449
450 do {
451 got_intr = 0;
452 if (esp_chips[0] &&
453 (mac_esp_read8(esp_chips[0], ESP_STATUS) & ESP_STAT_INTR)) {
454 (void)scsi_esp_intr(irq, esp_chips[0]);
455 got_intr = 1;
456 }
457 if (esp_chips[1] &&
458 (mac_esp_read8(esp_chips[1], ESP_STATUS) & ESP_STAT_INTR)) {
459 (void)scsi_esp_intr(irq, esp_chips[1]);
460 got_intr = 1;
461 }
462 } while (got_intr);
463
464 return IRQ_HANDLED;
465 }
466
467 static struct esp_driver_ops mac_esp_ops = {
468 .esp_write8 = mac_esp_write8,
469 .esp_read8 = mac_esp_read8,
470 .map_single = mac_esp_map_single,
471 .map_sg = mac_esp_map_sg,
472 .unmap_single = mac_esp_unmap_single,
473 .unmap_sg = mac_esp_unmap_sg,
474 .irq_pending = mac_esp_irq_pending,
475 .dma_length_limit = mac_esp_dma_length_limit,
476 .reset_dma = mac_esp_reset_dma,
477 .dma_drain = mac_esp_dma_drain,
478 .dma_invalidate = mac_esp_dma_invalidate,
479 .send_dma_cmd = mac_esp_send_pdma_cmd,
480 .dma_error = mac_esp_dma_error,
481 };
482
483 static int __devinit esp_mac_probe(struct platform_device *dev)
484 {
485 struct scsi_host_template *tpnt = &scsi_esp_template;
486 struct Scsi_Host *host;
487 struct esp *esp;
488 int err;
489 struct mac_esp_priv *mep;
490
491 if (!MACH_IS_MAC)
492 return -ENODEV;
493
494 if (dev->id > 1)
495 return -ENODEV;
496
497 host = scsi_host_alloc(tpnt, sizeof(struct esp));
498
499 err = -ENOMEM;
500 if (!host)
501 goto fail;
502
503 host->max_id = 8;
504 host->use_clustering = DISABLE_CLUSTERING;
505 esp = shost_priv(host);
506
507 esp->host = host;
508 esp->dev = dev;
509
510 esp->command_block = kzalloc(16, GFP_KERNEL);
511 if (!esp->command_block)
512 goto fail_unlink;
513 esp->command_block_dma = (dma_addr_t)esp->command_block;
514
515 esp->scsi_id = 7;
516 host->this_id = esp->scsi_id;
517 esp->scsi_id_mask = 1 << esp->scsi_id;
518
519 mep = kzalloc(sizeof(struct mac_esp_priv), GFP_KERNEL);
520 if (!mep)
521 goto fail_free_command_block;
522 mep->esp = esp;
523 platform_set_drvdata(dev, mep);
524
525 switch (macintosh_config->scsi_type) {
526 case MAC_SCSI_QUADRA:
527 esp->cfreq = 16500000;
528 esp->regs = (void __iomem *)MAC_ESP_REGS_QUADRA;
529 mep->pdma_io = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
530 mep->pdma_regs = NULL;
531 break;
532 case MAC_SCSI_QUADRA2:
533 esp->cfreq = 25000000;
534 esp->regs = (void __iomem *)(MAC_ESP_REGS_QUADRA2 +
535 dev->id * MAC_ESP_REGS_SPACING);
536 mep->pdma_io = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
537 mep->pdma_regs = (void __iomem *)(MAC_ESP_PDMA_REG +
538 dev->id * MAC_ESP_PDMA_REG_SPACING);
539 nubus_writel(0x1d1, mep->pdma_regs);
540 break;
541 case MAC_SCSI_QUADRA3:
542 /* These quadras have a real DMA controller (the PSC) but we
543 * don't know how to drive it so we must use PIO instead.
544 */
545 esp->cfreq = 25000000;
546 esp->regs = (void __iomem *)MAC_ESP_REGS_QUADRA3;
547 mep->pdma_io = NULL;
548 mep->pdma_regs = NULL;
549 break;
550 }
551
552 esp->ops = &mac_esp_ops;
553 if (mep->pdma_io == NULL) {
554 printk(KERN_INFO PFX "using PIO for controller %d\n", dev->id);
555 esp_write8(0, ESP_TCLOW);
556 esp_write8(0, ESP_TCMED);
557 esp->flags = ESP_FLAG_DISABLE_SYNC;
558 mac_esp_ops.send_dma_cmd = mac_esp_send_pio_cmd;
559 } else {
560 printk(KERN_INFO PFX "using PDMA for controller %d\n", dev->id);
561 }
562
563 host->irq = IRQ_MAC_SCSI;
564 esp_chips[dev->id] = esp;
565 mb();
566 if (esp_chips[!dev->id] == NULL) {
567 err = request_irq(host->irq, mac_scsi_esp_intr, 0,
568 "Mac ESP", NULL);
569 if (err < 0) {
570 esp_chips[dev->id] = NULL;
571 goto fail_free_priv;
572 }
573 }
574
575 err = scsi_esp_register(esp, &dev->dev);
576 if (err)
577 goto fail_free_irq;
578
579 return 0;
580
581 fail_free_irq:
582 if (esp_chips[!dev->id] == NULL)
583 free_irq(host->irq, esp);
584 fail_free_priv:
585 kfree(mep);
586 fail_free_command_block:
587 kfree(esp->command_block);
588 fail_unlink:
589 scsi_host_put(host);
590 fail:
591 return err;
592 }
593
594 static int __devexit esp_mac_remove(struct platform_device *dev)
595 {
596 struct mac_esp_priv *mep = platform_get_drvdata(dev);
597 struct esp *esp = mep->esp;
598 unsigned int irq = esp->host->irq;
599
600 scsi_esp_unregister(esp);
601
602 esp_chips[dev->id] = NULL;
603 if (!(esp_chips[0] || esp_chips[1]))
604 free_irq(irq, NULL);
605
606 kfree(mep);
607
608 kfree(esp->command_block);
609
610 scsi_host_put(esp->host);
611
612 return 0;
613 }
614
615 static struct platform_driver esp_mac_driver = {
616 .probe = esp_mac_probe,
617 .remove = __devexit_p(esp_mac_remove),
618 .driver = {
619 .name = DRV_MODULE_NAME,
620 .owner = THIS_MODULE,
621 },
622 };
623
624 static int __init mac_esp_init(void)
625 {
626 return platform_driver_register(&esp_mac_driver);
627 }
628
629 static void __exit mac_esp_exit(void)
630 {
631 platform_driver_unregister(&esp_mac_driver);
632 }
633
634 MODULE_DESCRIPTION("Mac ESP SCSI driver");
635 MODULE_AUTHOR("Finn Thain <fthain@telegraphics.com.au>");
636 MODULE_LICENSE("GPL v2");
637 MODULE_VERSION(DRV_VERSION);
638 MODULE_ALIAS("platform:" DRV_MODULE_NAME);
639
640 module_init(mac_esp_init);
641 module_exit(mac_esp_exit);