1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#include <linux/module.h>
36#include <linux/types.h>
37#include <linux/blkdev.h>
38#include <linux/interrupt.h>
39#include <linux/init.h>
40#include <linux/nvram.h>
41#include <linux/bitops.h>
42#include <linux/wait.h>
43#include <linux/platform_device.h>
44
45#include <asm/setup.h>
46#include <asm/atarihw.h>
47#include <asm/atariints.h>
48#include <asm/atari_stdma.h>
49#include <asm/atari_stram.h>
50#include <asm/io.h>
51
52#include <scsi/scsi_host.h>
53
54#define DMA_MIN_SIZE 32
55
56
57
58#define NCR5380_implementation_fields
59
60static u8 (*atari_scsi_reg_read)(unsigned int);
61static void (*atari_scsi_reg_write)(unsigned int, u8);
62
63#define NCR5380_read(reg) atari_scsi_reg_read(reg)
64#define NCR5380_write(reg, value) atari_scsi_reg_write(reg, value)
65
66#define NCR5380_queue_command atari_scsi_queue_command
67#define NCR5380_abort atari_scsi_abort
68#define NCR5380_info atari_scsi_info
69
70#define NCR5380_dma_xfer_len atari_scsi_dma_xfer_len
71#define NCR5380_dma_recv_setup atari_scsi_dma_recv_setup
72#define NCR5380_dma_send_setup atari_scsi_dma_send_setup
73#define NCR5380_dma_residual atari_scsi_dma_residual
74
75#define NCR5380_acquire_dma_irq(instance) falcon_get_lock(instance)
76#define NCR5380_release_dma_irq(instance) falcon_release_lock()
77
78#include "NCR5380.h"
79
80
81#define IS_A_TT() ATARIHW_PRESENT(TT_SCSI)
82
83#define SCSI_DMA_WRITE_P(elt,val) \
84 do { \
85 unsigned long v = val; \
86 tt_scsi_dma.elt##_lo = v & 0xff; \
87 v >>= 8; \
88 tt_scsi_dma.elt##_lmd = v & 0xff; \
89 v >>= 8; \
90 tt_scsi_dma.elt##_hmd = v & 0xff; \
91 v >>= 8; \
92 tt_scsi_dma.elt##_hi = v & 0xff; \
93 } while(0)
94
95#define SCSI_DMA_READ_P(elt) \
96 (((((((unsigned long)tt_scsi_dma.elt##_hi << 8) | \
97 (unsigned long)tt_scsi_dma.elt##_hmd) << 8) | \
98 (unsigned long)tt_scsi_dma.elt##_lmd) << 8) | \
99 (unsigned long)tt_scsi_dma.elt##_lo)
100
101
102static inline void SCSI_DMA_SETADR(unsigned long adr)
103{
104 st_dma.dma_lo = (unsigned char)adr;
105 MFPDELAY();
106 adr >>= 8;
107 st_dma.dma_md = (unsigned char)adr;
108 MFPDELAY();
109 adr >>= 8;
110 st_dma.dma_hi = (unsigned char)adr;
111 MFPDELAY();
112}
113
114static inline unsigned long SCSI_DMA_GETADR(void)
115{
116 unsigned long adr;
117 adr = st_dma.dma_lo;
118 MFPDELAY();
119 adr |= (st_dma.dma_md & 0xff) << 8;
120 MFPDELAY();
121 adr |= (st_dma.dma_hi & 0xff) << 16;
122 MFPDELAY();
123 return adr;
124}
125
126static void atari_scsi_fetch_restbytes(void);
127
128static unsigned long atari_dma_residual, atari_dma_startaddr;
129static short atari_dma_active;
130
131static char *atari_dma_buffer;
132
133static unsigned long atari_dma_phys_buffer;
134
135static char *atari_dma_orig_addr;
136
137
138
139
140
141
142#define STRAM_BUFFER_SIZE (4096)
143
144static unsigned long atari_dma_stram_mask;
145#define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0)
146
147static int setup_can_queue = -1;
148module_param(setup_can_queue, int, 0);
149static int setup_cmd_per_lun = -1;
150module_param(setup_cmd_per_lun, int, 0);
151static int setup_sg_tablesize = -1;
152module_param(setup_sg_tablesize, int, 0);
153static int setup_hostid = -1;
154module_param(setup_hostid, int, 0);
155static int setup_toshiba_delay = -1;
156module_param(setup_toshiba_delay, int, 0);
157
158
159static int scsi_dma_is_ignored_buserr(unsigned char dma_stat)
160{
161 int i;
162 unsigned long addr = SCSI_DMA_READ_P(dma_addr), end_addr;
163
164 if (dma_stat & 0x01) {
165
166
167
168
169
170
171 for (i = 0; i < m68k_num_memory; ++i) {
172 end_addr = m68k_memory[i].addr + m68k_memory[i].size;
173 if (end_addr <= addr && addr <= end_addr + 4)
174 return 1;
175 }
176 }
177 return 0;
178}
179
180
181static irqreturn_t scsi_tt_intr(int irq, void *dev)
182{
183 struct Scsi_Host *instance = dev;
184 struct NCR5380_hostdata *hostdata = shost_priv(instance);
185 int dma_stat;
186
187 dma_stat = tt_scsi_dma.dma_ctrl;
188
189 dsprintk(NDEBUG_INTR, instance, "NCR5380 interrupt, DMA status = %02x\n",
190 dma_stat & 0xff);
191
192
193
194
195 if (dma_stat & 0x80) {
196 if (!scsi_dma_is_ignored_buserr(dma_stat)) {
197 printk(KERN_ERR "SCSI DMA caused bus error near 0x%08lx\n",
198 SCSI_DMA_READ_P(dma_addr));
199 printk(KERN_CRIT "SCSI DMA bus error -- bad DMA programming!");
200 }
201 }
202
203
204
205
206
207
208
209
210
211
212 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
213 atari_dma_residual = hostdata->dma_len -
214 (SCSI_DMA_READ_P(dma_addr) - atari_dma_startaddr);
215
216 dprintk(NDEBUG_DMA, "SCSI DMA: There are %ld residual bytes.\n",
217 atari_dma_residual);
218
219 if ((signed int)atari_dma_residual < 0)
220 atari_dma_residual = 0;
221 if ((dma_stat & 1) == 0) {
222
223
224
225
226 atari_scsi_fetch_restbytes();
227 } else {
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246 if (atari_dma_residual & 0x1ff) {
247 dprintk(NDEBUG_DMA, "SCSI DMA: DMA bug corrected, "
248 "difference %ld bytes\n",
249 512 - (atari_dma_residual & 0x1ff));
250 atari_dma_residual = (atari_dma_residual + 511) & ~0x1ff;
251 }
252 }
253 tt_scsi_dma.dma_ctrl = 0;
254 }
255
256
257 if (dma_stat & 0x40) {
258 atari_dma_residual = 0;
259 if ((dma_stat & 1) == 0)
260 atari_scsi_fetch_restbytes();
261 tt_scsi_dma.dma_ctrl = 0;
262 }
263
264 NCR5380_intr(irq, dev);
265
266 return IRQ_HANDLED;
267}
268
269
270static irqreturn_t scsi_falcon_intr(int irq, void *dev)
271{
272 struct Scsi_Host *instance = dev;
273 struct NCR5380_hostdata *hostdata = shost_priv(instance);
274 int dma_stat;
275
276
277
278
279 st_dma.dma_mode_status = 0x90;
280 dma_stat = st_dma.dma_mode_status;
281
282
283
284
285 if (!(dma_stat & 0x01)) {
286
287 printk(KERN_CRIT "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR());
288 }
289
290
291
292
293
294
295 if (atari_dma_active && (dma_stat & 0x02)) {
296 unsigned long transferred;
297
298 transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
299
300
301
302
303
304 if (transferred & 15)
305 printk(KERN_ERR "SCSI DMA error: %ld bytes lost in "
306 "ST-DMA fifo\n", transferred & 15);
307
308 atari_dma_residual = hostdata->dma_len - transferred;
309 dprintk(NDEBUG_DMA, "SCSI DMA: There are %ld residual bytes.\n",
310 atari_dma_residual);
311 } else
312 atari_dma_residual = 0;
313 atari_dma_active = 0;
314
315 if (atari_dma_orig_addr) {
316
317
318
319 memcpy(atari_dma_orig_addr, phys_to_virt(atari_dma_startaddr),
320 hostdata->dma_len - atari_dma_residual);
321 atari_dma_orig_addr = NULL;
322 }
323
324 NCR5380_intr(irq, dev);
325
326 return IRQ_HANDLED;
327}
328
329
330static void atari_scsi_fetch_restbytes(void)
331{
332 int nr;
333 char *src, *dst;
334 unsigned long phys_dst;
335
336
337 phys_dst = SCSI_DMA_READ_P(dma_addr);
338 nr = phys_dst & 3;
339 if (nr) {
340
341
342 phys_dst ^= nr;
343 dprintk(NDEBUG_DMA, "SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
344 nr, phys_dst);
345
346 dst = phys_to_virt(phys_dst);
347 dprintk(NDEBUG_DMA, " = virt addr %p\n", dst);
348 for (src = (char *)&tt_scsi_dma.dma_restdata; nr != 0; --nr)
349 *dst++ = *src++;
350 }
351}
352
353
354
355
356
357
358static void falcon_release_lock(void)
359{
360 if (IS_A_TT())
361 return;
362
363 if (stdma_is_locked_by(scsi_falcon_intr))
364 stdma_release();
365}
366
367
368
369
370
371
372
373
374static int falcon_get_lock(struct Scsi_Host *instance)
375{
376 if (IS_A_TT())
377 return 1;
378
379 if (stdma_is_locked_by(scsi_falcon_intr))
380 return 1;
381
382
383 return stdma_try_lock(scsi_falcon_intr, instance);
384}
385
386#ifndef MODULE
387static int __init atari_scsi_setup(char *str)
388{
389
390
391
392
393
394 int ints[8];
395
396 get_options(str, ARRAY_SIZE(ints), ints);
397
398 if (ints[0] < 1) {
399 printk("atari_scsi_setup: no arguments!\n");
400 return 0;
401 }
402 if (ints[0] >= 1)
403 setup_can_queue = ints[1];
404 if (ints[0] >= 2)
405 setup_cmd_per_lun = ints[2];
406 if (ints[0] >= 3)
407 setup_sg_tablesize = ints[3];
408 if (ints[0] >= 4)
409 setup_hostid = ints[4];
410
411
412 if (ints[0] >= 7)
413 setup_toshiba_delay = ints[7];
414
415 return 1;
416}
417
418__setup("atascsi=", atari_scsi_setup);
419#endif
420
421static unsigned long atari_scsi_dma_setup(struct NCR5380_hostdata *hostdata,
422 void *data, unsigned long count,
423 int dir)
424{
425 unsigned long addr = virt_to_phys(data);
426
427 dprintk(NDEBUG_DMA, "scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, dir = %d\n",
428 hostdata->host->host_no, data, addr, count, dir);
429
430 if (!IS_A_TT() && !STRAM_ADDR(addr)) {
431
432
433
434
435
436 if (dir)
437 memcpy(atari_dma_buffer, data, count);
438 else
439 atari_dma_orig_addr = data;
440 addr = atari_dma_phys_buffer;
441 }
442
443 atari_dma_startaddr = addr;
444
445
446
447
448
449
450
451
452
453
454 dma_cache_maintenance(addr, count, dir);
455
456 if (IS_A_TT()) {
457 tt_scsi_dma.dma_ctrl = dir;
458 SCSI_DMA_WRITE_P(dma_addr, addr);
459 SCSI_DMA_WRITE_P(dma_cnt, count);
460 tt_scsi_dma.dma_ctrl = dir | 2;
461 } else {
462
463
464 SCSI_DMA_SETADR(addr);
465
466
467 dir <<= 8;
468 st_dma.dma_mode_status = 0x90 | dir;
469 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
470 st_dma.dma_mode_status = 0x90 | dir;
471 udelay(40);
472
473
474 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
475 udelay(40);
476 st_dma.dma_mode_status = 0x10 | dir;
477 udelay(40);
478
479 atari_dma_active = 1;
480 }
481
482 return count;
483}
484
485static inline int atari_scsi_dma_recv_setup(struct NCR5380_hostdata *hostdata,
486 unsigned char *data, int count)
487{
488 return atari_scsi_dma_setup(hostdata, data, count, 0);
489}
490
491static inline int atari_scsi_dma_send_setup(struct NCR5380_hostdata *hostdata,
492 unsigned char *data, int count)
493{
494 return atari_scsi_dma_setup(hostdata, data, count, 1);
495}
496
497static int atari_scsi_dma_residual(struct NCR5380_hostdata *hostdata)
498{
499 return atari_dma_residual;
500}
501
502
503#define CMD_SURELY_BLOCK_MODE 0
504#define CMD_SURELY_BYTE_MODE 1
505#define CMD_MODE_UNKNOWN 2
506
507static int falcon_classify_cmd(struct scsi_cmnd *cmd)
508{
509 unsigned char opcode = cmd->cmnd[0];
510
511 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
512 opcode == READ_BUFFER)
513 return CMD_SURELY_BYTE_MODE;
514 else if (opcode == READ_6 || opcode == READ_10 ||
515 opcode == 0xa8 || opcode == READ_REVERSE ||
516 opcode == RECOVER_BUFFERED_DATA) {
517
518
519
520 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
521 return CMD_SURELY_BYTE_MODE;
522 else
523 return CMD_SURELY_BLOCK_MODE;
524 } else
525 return CMD_MODE_UNKNOWN;
526}
527
528
529
530
531
532
533
534
535
536
537
538static int atari_scsi_dma_xfer_len(struct NCR5380_hostdata *hostdata,
539 struct scsi_cmnd *cmd)
540{
541 int wanted_len = cmd->SCp.this_residual;
542 int possible_len, limit;
543
544 if (wanted_len < DMA_MIN_SIZE)
545 return 0;
546
547 if (IS_A_TT())
548
549 return wanted_len;
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
580
581
582
583
584 possible_len = wanted_len;
585 } else {
586
587
588
589
590 if (wanted_len & 0x1ff)
591 possible_len = 0;
592 else {
593
594
595 switch (falcon_classify_cmd(cmd)) {
596 case CMD_SURELY_BLOCK_MODE:
597 possible_len = wanted_len;
598 break;
599 case CMD_SURELY_BYTE_MODE:
600 possible_len = 0;
601 break;
602 case CMD_MODE_UNKNOWN:
603 default:
604
605
606 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
607 break;
608 }
609 }
610 }
611
612
613 limit = (atari_dma_buffer && !STRAM_ADDR(virt_to_phys(cmd->SCp.ptr))) ?
614 STRAM_BUFFER_SIZE : 255*512;
615 if (possible_len > limit)
616 possible_len = limit;
617
618 if (possible_len != wanted_len)
619 dprintk(NDEBUG_DMA, "DMA transfer now %d bytes instead of %d\n",
620 possible_len, wanted_len);
621
622 return possible_len;
623}
624
625
626
627
628
629
630
631
632
633static u8 atari_scsi_tt_reg_read(unsigned int reg)
634{
635 return tt_scsi_regp[reg * 2];
636}
637
638static void atari_scsi_tt_reg_write(unsigned int reg, u8 value)
639{
640 tt_scsi_regp[reg * 2] = value;
641}
642
643static u8 atari_scsi_falcon_reg_read(unsigned int reg)
644{
645 unsigned long flags;
646 u8 result;
647
648 reg += 0x88;
649 local_irq_save(flags);
650 dma_wd.dma_mode_status = (u_short)reg;
651 result = (u8)dma_wd.fdc_acces_seccount;
652 local_irq_restore(flags);
653 return result;
654}
655
656static void atari_scsi_falcon_reg_write(unsigned int reg, u8 value)
657{
658 unsigned long flags;
659
660 reg += 0x88;
661 local_irq_save(flags);
662 dma_wd.dma_mode_status = (u_short)reg;
663 dma_wd.fdc_acces_seccount = (u_short)value;
664 local_irq_restore(flags);
665}
666
667
668#include "NCR5380.c"
669
670static int atari_scsi_host_reset(struct scsi_cmnd *cmd)
671{
672 int rv;
673 unsigned long flags;
674
675 local_irq_save(flags);
676
677
678 if (IS_A_TT()) {
679 tt_scsi_dma.dma_ctrl = 0;
680 } else {
681 if (stdma_is_locked_by(scsi_falcon_intr))
682 st_dma.dma_mode_status = 0x90;
683 atari_dma_active = 0;
684 atari_dma_orig_addr = NULL;
685 }
686
687 rv = NCR5380_host_reset(cmd);
688
689
690
691
692
693
694
695 local_irq_restore(flags);
696
697 return rv;
698}
699
700#define DRV_MODULE_NAME "atari_scsi"
701#define PFX DRV_MODULE_NAME ": "
702
703static struct scsi_host_template atari_scsi_template = {
704 .module = THIS_MODULE,
705 .proc_name = DRV_MODULE_NAME,
706 .name = "Atari native SCSI",
707 .info = atari_scsi_info,
708 .queuecommand = atari_scsi_queue_command,
709 .eh_abort_handler = atari_scsi_abort,
710 .eh_host_reset_handler = atari_scsi_host_reset,
711 .this_id = 7,
712 .cmd_per_lun = 2,
713 .dma_boundary = PAGE_SIZE - 1,
714 .cmd_size = NCR5380_CMD_SIZE,
715};
716
717static int __init atari_scsi_probe(struct platform_device *pdev)
718{
719 struct Scsi_Host *instance;
720 int error;
721 struct resource *irq;
722 int host_flags = 0;
723
724 irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
725 if (!irq)
726 return -ENODEV;
727
728 if (ATARIHW_PRESENT(TT_SCSI)) {
729 atari_scsi_reg_read = atari_scsi_tt_reg_read;
730 atari_scsi_reg_write = atari_scsi_tt_reg_write;
731 } else {
732 atari_scsi_reg_read = atari_scsi_falcon_reg_read;
733 atari_scsi_reg_write = atari_scsi_falcon_reg_write;
734 }
735
736 if (ATARIHW_PRESENT(TT_SCSI)) {
737 atari_scsi_template.can_queue = 16;
738 atari_scsi_template.sg_tablesize = SG_ALL;
739 } else {
740 atari_scsi_template.can_queue = 1;
741 atari_scsi_template.sg_tablesize = 1;
742 }
743
744 if (setup_can_queue > 0)
745 atari_scsi_template.can_queue = setup_can_queue;
746
747 if (setup_cmd_per_lun > 0)
748 atari_scsi_template.cmd_per_lun = setup_cmd_per_lun;
749
750
751 if (ATARIHW_PRESENT(TT_SCSI) && setup_sg_tablesize > 0)
752 atari_scsi_template.sg_tablesize = setup_sg_tablesize;
753
754 if (setup_hostid >= 0) {
755 atari_scsi_template.this_id = setup_hostid & 7;
756 } else if (IS_REACHABLE(CONFIG_NVRAM)) {
757
758 if (ATARIHW_PRESENT(TT_CLK)) {
759 unsigned char b;
760 loff_t offset = 16;
761 ssize_t count = nvram_read(&b, 1, &offset);
762
763
764
765
766 if ((count == 1) && (b & 0x80))
767 atari_scsi_template.this_id = b & 7;
768 }
769 }
770
771
772
773
774
775
776 if (ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(EXTD_DMA) &&
777 m68k_realnum_memory > 1) {
778 atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
779 if (!atari_dma_buffer) {
780 pr_err(PFX "can't allocate ST-RAM double buffer\n");
781 return -ENOMEM;
782 }
783 atari_dma_phys_buffer = atari_stram_to_phys(atari_dma_buffer);
784 atari_dma_orig_addr = NULL;
785 }
786
787 instance = scsi_host_alloc(&atari_scsi_template,
788 sizeof(struct NCR5380_hostdata));
789 if (!instance) {
790 error = -ENOMEM;
791 goto fail_alloc;
792 }
793
794 instance->irq = irq->start;
795
796 host_flags |= IS_A_TT() ? 0 : FLAG_LATE_DMA_SETUP;
797 host_flags |= setup_toshiba_delay > 0 ? FLAG_TOSHIBA_DELAY : 0;
798
799 error = NCR5380_init(instance, host_flags);
800 if (error)
801 goto fail_init;
802
803 if (IS_A_TT()) {
804 error = request_irq(instance->irq, scsi_tt_intr, 0,
805 "NCR5380", instance);
806 if (error) {
807 pr_err(PFX "request irq %d failed, aborting\n",
808 instance->irq);
809 goto fail_irq;
810 }
811 tt_mfp.active_edge |= 0x80;
812
813 tt_scsi_dma.dma_ctrl = 0;
814 atari_dma_residual = 0;
815
816
817
818
819
820
821
822
823
824
825
826
827
828 if (MACH_IS_MEDUSA) {
829 struct NCR5380_hostdata *hostdata =
830 shost_priv(instance);
831
832 hostdata->read_overruns = 4;
833 }
834 } else {
835
836
837
838 atari_dma_residual = 0;
839 atari_dma_active = 0;
840 atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
841 : 0xff000000);
842 }
843
844 NCR5380_maybe_reset_bus(instance);
845
846 error = scsi_add_host(instance, NULL);
847 if (error)
848 goto fail_host;
849
850 platform_set_drvdata(pdev, instance);
851
852 scsi_scan_host(instance);
853 return 0;
854
855fail_host:
856 if (IS_A_TT())
857 free_irq(instance->irq, instance);
858fail_irq:
859 NCR5380_exit(instance);
860fail_init:
861 scsi_host_put(instance);
862fail_alloc:
863 if (atari_dma_buffer)
864 atari_stram_free(atari_dma_buffer);
865 return error;
866}
867
868static int __exit atari_scsi_remove(struct platform_device *pdev)
869{
870 struct Scsi_Host *instance = platform_get_drvdata(pdev);
871
872 scsi_remove_host(instance);
873 if (IS_A_TT())
874 free_irq(instance->irq, instance);
875 NCR5380_exit(instance);
876 scsi_host_put(instance);
877 if (atari_dma_buffer)
878 atari_stram_free(atari_dma_buffer);
879 return 0;
880}
881
882static struct platform_driver atari_scsi_driver = {
883 .remove = __exit_p(atari_scsi_remove),
884 .driver = {
885 .name = DRV_MODULE_NAME,
886 },
887};
888
889module_platform_driver_probe(atari_scsi_driver, atari_scsi_probe);
890
891MODULE_ALIAS("platform:" DRV_MODULE_NAME);
892MODULE_LICENSE("GPL");
893