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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68#include <linux/module.h>
69
70#define NDEBUG (0)
71
72#define NDEBUG_ABORT 0x00100000
73#define NDEBUG_TAGS 0x00200000
74#define NDEBUG_MERGING 0x00400000
75
76#define AUTOSENSE
77
78#define REAL_DMA
79
80#define SUPPORT_TAGS
81#define MAX_TAGS 32
82
83#include <linux/types.h>
84#include <linux/stddef.h>
85#include <linux/ctype.h>
86#include <linux/delay.h>
87#include <linux/mm.h>
88#include <linux/blkdev.h>
89#include <linux/interrupt.h>
90#include <linux/init.h>
91#include <linux/nvram.h>
92#include <linux/bitops.h>
93
94#include <asm/setup.h>
95#include <asm/atarihw.h>
96#include <asm/atariints.h>
97#include <asm/page.h>
98#include <asm/pgtable.h>
99#include <asm/irq.h>
100#include <asm/traps.h>
101
102#include "scsi.h"
103#include <scsi/scsi_host.h>
104#include "atari_scsi.h"
105#include "NCR5380.h"
106#include <asm/atari_stdma.h>
107#include <asm/atari_stram.h>
108#include <asm/io.h>
109
110#include <linux/stat.h>
111
112#define IS_A_TT() ATARIHW_PRESENT(TT_SCSI)
113
114#define SCSI_DMA_WRITE_P(elt,val) \
115 do { \
116 unsigned long v = val; \
117 tt_scsi_dma.elt##_lo = v & 0xff; \
118 v >>= 8; \
119 tt_scsi_dma.elt##_lmd = v & 0xff; \
120 v >>= 8; \
121 tt_scsi_dma.elt##_hmd = v & 0xff; \
122 v >>= 8; \
123 tt_scsi_dma.elt##_hi = v & 0xff; \
124 } while(0)
125
126#define SCSI_DMA_READ_P(elt) \
127 (((((((unsigned long)tt_scsi_dma.elt##_hi << 8) | \
128 (unsigned long)tt_scsi_dma.elt##_hmd) << 8) | \
129 (unsigned long)tt_scsi_dma.elt##_lmd) << 8) | \
130 (unsigned long)tt_scsi_dma.elt##_lo)
131
132
133static inline void SCSI_DMA_SETADR(unsigned long adr)
134{
135 st_dma.dma_lo = (unsigned char)adr;
136 MFPDELAY();
137 adr >>= 8;
138 st_dma.dma_md = (unsigned char)adr;
139 MFPDELAY();
140 adr >>= 8;
141 st_dma.dma_hi = (unsigned char)adr;
142 MFPDELAY();
143}
144
145static inline unsigned long SCSI_DMA_GETADR(void)
146{
147 unsigned long adr;
148 adr = st_dma.dma_lo;
149 MFPDELAY();
150 adr |= (st_dma.dma_md & 0xff) << 8;
151 MFPDELAY();
152 adr |= (st_dma.dma_hi & 0xff) << 16;
153 MFPDELAY();
154 return adr;
155}
156
157static inline void ENABLE_IRQ(void)
158{
159 if (IS_A_TT())
160 atari_enable_irq(IRQ_TT_MFP_SCSI);
161 else
162 atari_enable_irq(IRQ_MFP_FSCSI);
163}
164
165static inline void DISABLE_IRQ(void)
166{
167 if (IS_A_TT())
168 atari_disable_irq(IRQ_TT_MFP_SCSI);
169 else
170 atari_disable_irq(IRQ_MFP_FSCSI);
171}
172
173
174#define HOSTDATA_DMALEN (((struct NCR5380_hostdata *) \
175 (atari_scsi_host->hostdata))->dma_len)
176
177
178
179
180#ifndef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
181#define AFTER_RESET_DELAY (HZ/2)
182#else
183#define AFTER_RESET_DELAY (5*HZ/2)
184#endif
185
186
187
188#ifdef REAL_DMA
189static int scsi_dma_is_ignored_buserr(unsigned char dma_stat);
190static void atari_scsi_fetch_restbytes(void);
191static long atari_scsi_dma_residual(struct Scsi_Host *instance);
192static int falcon_classify_cmd(Scsi_Cmnd *cmd);
193static unsigned long atari_dma_xfer_len(unsigned long wanted_len,
194 Scsi_Cmnd *cmd, int write_flag);
195#endif
196static irqreturn_t scsi_tt_intr(int irq, void *dummy);
197static irqreturn_t scsi_falcon_intr(int irq, void *dummy);
198static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata);
199static void falcon_get_lock(void);
200#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
201static void atari_scsi_reset_boot(void);
202#endif
203static unsigned char atari_scsi_tt_reg_read(unsigned char reg);
204static void atari_scsi_tt_reg_write(unsigned char reg, unsigned char value);
205static unsigned char atari_scsi_falcon_reg_read(unsigned char reg);
206static void atari_scsi_falcon_reg_write(unsigned char reg, unsigned char value);
207
208
209
210
211static struct Scsi_Host *atari_scsi_host;
212static unsigned char (*atari_scsi_reg_read)(unsigned char reg);
213static void (*atari_scsi_reg_write)(unsigned char reg, unsigned char value);
214
215#ifdef REAL_DMA
216static unsigned long atari_dma_residual, atari_dma_startaddr;
217static short atari_dma_active;
218
219static char *atari_dma_buffer;
220
221static unsigned long atari_dma_phys_buffer;
222
223static char *atari_dma_orig_addr;
224
225
226
227
228
229
230#define STRAM_BUFFER_SIZE (4096)
231
232static unsigned long atari_dma_stram_mask;
233#define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0)
234
235static int atari_read_overruns;
236#endif
237
238static int setup_can_queue = -1;
239module_param(setup_can_queue, int, 0);
240static int setup_cmd_per_lun = -1;
241module_param(setup_cmd_per_lun, int, 0);
242static int setup_sg_tablesize = -1;
243module_param(setup_sg_tablesize, int, 0);
244#ifdef SUPPORT_TAGS
245static int setup_use_tagged_queuing = -1;
246module_param(setup_use_tagged_queuing, int, 0);
247#endif
248static int setup_hostid = -1;
249module_param(setup_hostid, int, 0);
250
251
252#if defined(REAL_DMA)
253
254static int scsi_dma_is_ignored_buserr(unsigned char dma_stat)
255{
256 int i;
257 unsigned long addr = SCSI_DMA_READ_P(dma_addr), end_addr;
258
259 if (dma_stat & 0x01) {
260
261
262
263
264
265
266 for (i = 0; i < m68k_num_memory; ++i) {
267 end_addr = m68k_memory[i].addr + m68k_memory[i].size;
268 if (end_addr <= addr && addr <= end_addr + 4)
269 return 1;
270 }
271 }
272 return 0;
273}
274
275
276#if 0
277
278
279
280
281static void scsi_dma_buserr(int irq, void *dummy)
282{
283 unsigned char dma_stat = tt_scsi_dma.dma_ctrl;
284
285
286
287 if (atari_irq_pending(IRQ_TT_MFP_SCSI))
288 return;
289
290 printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
291 SCSI_DMA_READ_P(dma_addr), dma_stat, SCSI_DMA_READ_P(dma_cnt));
292 if (dma_stat & 0x80) {
293 if (!scsi_dma_is_ignored_buserr(dma_stat))
294 printk("SCSI DMA bus error -- bad DMA programming!\n");
295 } else {
296
297
298
299
300
301 printk("SCSI DMA intr ?? -- this shouldn't happen!\n");
302 }
303}
304#endif
305
306#endif
307
308
309static irqreturn_t scsi_tt_intr(int irq, void *dummy)
310{
311#ifdef REAL_DMA
312 int dma_stat;
313
314 dma_stat = tt_scsi_dma.dma_ctrl;
315
316 INT_PRINTK("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
317 atari_scsi_host->host_no, dma_stat & 0xff);
318
319
320
321
322 if (dma_stat & 0x80) {
323 if (!scsi_dma_is_ignored_buserr(dma_stat)) {
324 printk(KERN_ERR "SCSI DMA caused bus error near 0x%08lx\n",
325 SCSI_DMA_READ_P(dma_addr));
326 printk(KERN_CRIT "SCSI DMA bus error -- bad DMA programming!");
327 }
328 }
329
330
331
332
333
334
335
336
337
338
339 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
340 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P(dma_addr) - atari_dma_startaddr);
341
342 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
343 atari_dma_residual);
344
345 if ((signed int)atari_dma_residual < 0)
346 atari_dma_residual = 0;
347 if ((dma_stat & 1) == 0) {
348
349
350
351
352 atari_scsi_fetch_restbytes();
353 } else {
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372 if (atari_dma_residual & 0x1ff) {
373 DMA_PRINTK("SCSI DMA: DMA bug corrected, "
374 "difference %ld bytes\n",
375 512 - (atari_dma_residual & 0x1ff));
376 atari_dma_residual = (atari_dma_residual + 511) & ~0x1ff;
377 }
378 }
379 tt_scsi_dma.dma_ctrl = 0;
380 }
381
382
383 if (dma_stat & 0x40) {
384 atari_dma_residual = 0;
385 if ((dma_stat & 1) == 0)
386 atari_scsi_fetch_restbytes();
387 tt_scsi_dma.dma_ctrl = 0;
388 }
389
390#endif
391
392 NCR5380_intr(irq, dummy);
393
394#if 0
395
396 atari_enable_irq(IRQ_TT_MFP_SCSI);
397#endif
398 return IRQ_HANDLED;
399}
400
401
402static irqreturn_t scsi_falcon_intr(int irq, void *dummy)
403{
404#ifdef REAL_DMA
405 int dma_stat;
406
407
408
409
410 st_dma.dma_mode_status = 0x90;
411 dma_stat = st_dma.dma_mode_status;
412
413
414
415
416 if (!(dma_stat & 0x01)) {
417
418 printk(KERN_CRIT "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR());
419 }
420
421
422
423
424
425
426 if (atari_dma_active && (dma_stat & 0x02)) {
427 unsigned long transferred;
428
429 transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
430
431
432
433
434
435 if (transferred & 15)
436 printk(KERN_ERR "SCSI DMA error: %ld bytes lost in "
437 "ST-DMA fifo\n", transferred & 15);
438
439 atari_dma_residual = HOSTDATA_DMALEN - transferred;
440 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
441 atari_dma_residual);
442 } else
443 atari_dma_residual = 0;
444 atari_dma_active = 0;
445
446 if (atari_dma_orig_addr) {
447
448
449
450 memcpy(atari_dma_orig_addr, phys_to_virt(atari_dma_startaddr),
451 HOSTDATA_DMALEN - atari_dma_residual);
452 atari_dma_orig_addr = NULL;
453 }
454
455#endif
456
457 NCR5380_intr(irq, dummy);
458 return IRQ_HANDLED;
459}
460
461
462#ifdef REAL_DMA
463static void atari_scsi_fetch_restbytes(void)
464{
465 int nr;
466 char *src, *dst;
467 unsigned long phys_dst;
468
469
470 phys_dst = SCSI_DMA_READ_P(dma_addr);
471 nr = phys_dst & 3;
472 if (nr) {
473
474
475 phys_dst ^= nr;
476 DMA_PRINTK("SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
477 nr, phys_dst);
478
479 dst = phys_to_virt(phys_dst);
480 DMA_PRINTK(" = virt addr %p\n", dst);
481 for (src = (char *)&tt_scsi_dma.dma_restdata; nr != 0; --nr)
482 *dst++ = *src++;
483 }
484}
485#endif
486
487
488static int falcon_got_lock = 0;
489static DECLARE_WAIT_QUEUE_HEAD(falcon_fairness_wait);
490static int falcon_trying_lock = 0;
491static DECLARE_WAIT_QUEUE_HEAD(falcon_try_wait);
492static int falcon_dont_release = 0;
493
494
495
496
497
498
499
500
501static void falcon_release_lock_if_possible(struct NCR5380_hostdata *hostdata)
502{
503 unsigned long flags;
504
505 if (IS_A_TT())
506 return;
507
508 local_irq_save(flags);
509
510 if (falcon_got_lock && !hostdata->disconnected_queue &&
511 !hostdata->issue_queue && !hostdata->connected) {
512
513 if (falcon_dont_release) {
514#if 0
515 printk("WARNING: Lock release not allowed. Ignored\n");
516#endif
517 local_irq_restore(flags);
518 return;
519 }
520 falcon_got_lock = 0;
521 stdma_release();
522 wake_up(&falcon_fairness_wait);
523 }
524
525 local_irq_restore(flags);
526}
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543static void falcon_get_lock(void)
544{
545 unsigned long flags;
546
547 if (IS_A_TT())
548 return;
549
550 local_irq_save(flags);
551
552 while (!in_irq() && falcon_got_lock && stdma_others_waiting())
553 sleep_on(&falcon_fairness_wait);
554
555 while (!falcon_got_lock) {
556 if (in_irq())
557 panic("Falcon SCSI hasn't ST-DMA lock in interrupt");
558 if (!falcon_trying_lock) {
559 falcon_trying_lock = 1;
560 stdma_lock(scsi_falcon_intr, NULL);
561 falcon_got_lock = 1;
562 falcon_trying_lock = 0;
563 wake_up(&falcon_try_wait);
564 } else {
565 sleep_on(&falcon_try_wait);
566 }
567 }
568
569 local_irq_restore(flags);
570 if (!falcon_got_lock)
571 panic("Falcon SCSI: someone stole the lock :-(\n");
572}
573
574
575int __init atari_scsi_detect(struct scsi_host_template *host)
576{
577 static int called = 0;
578 struct Scsi_Host *instance;
579
580 if (!MACH_IS_ATARI ||
581 (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
582 called)
583 return 0;
584
585 host->proc_name = "Atari";
586
587 atari_scsi_reg_read = IS_A_TT() ? atari_scsi_tt_reg_read :
588 atari_scsi_falcon_reg_read;
589 atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write :
590 atari_scsi_falcon_reg_write;
591
592
593 host->can_queue =
594 (setup_can_queue > 0) ? setup_can_queue :
595 IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE;
596 host->cmd_per_lun =
597 (setup_cmd_per_lun > 0) ? setup_cmd_per_lun :
598 IS_A_TT() ? ATARI_TT_CMD_PER_LUN : ATARI_FALCON_CMD_PER_LUN;
599
600 host->sg_tablesize =
601 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE :
602 (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE;
603
604 if (setup_hostid >= 0)
605 host->this_id = setup_hostid;
606 else {
607
608 host->this_id = 7;
609
610 if (ATARIHW_PRESENT(TT_CLK) && nvram_check_checksum()) {
611 unsigned char b = nvram_read_byte( 14 );
612
613 if (b & 0x80)
614 host->this_id = b & 7;
615 }
616 }
617
618#ifdef SUPPORT_TAGS
619 if (setup_use_tagged_queuing < 0)
620 setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
621#endif
622#ifdef REAL_DMA
623
624
625
626
627
628 if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) &&
629 !ATARIHW_PRESENT(EXTD_DMA) && m68k_num_memory > 1) {
630 atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
631 if (!atari_dma_buffer) {
632 printk(KERN_ERR "atari_scsi_detect: can't allocate ST-RAM "
633 "double buffer\n");
634 return 0;
635 }
636 atari_dma_phys_buffer = virt_to_phys(atari_dma_buffer);
637 atari_dma_orig_addr = 0;
638 }
639#endif
640 instance = scsi_register(host, sizeof(struct NCR5380_hostdata));
641 if (instance == NULL) {
642 atari_stram_free(atari_dma_buffer);
643 atari_dma_buffer = 0;
644 return 0;
645 }
646 atari_scsi_host = instance;
647
648
649
650
651
652
653 instance->irq = 0;
654
655#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
656 atari_scsi_reset_boot();
657#endif
658 NCR5380_init(instance, 0);
659
660 if (IS_A_TT()) {
661
662
663
664
665 if (request_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_SLOW,
666 "SCSI NCR5380", instance)) {
667 printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting",IRQ_TT_MFP_SCSI);
668 scsi_unregister(atari_scsi_host);
669 atari_stram_free(atari_dma_buffer);
670 atari_dma_buffer = 0;
671 return 0;
672 }
673 tt_mfp.active_edge |= 0x80;
674#ifdef REAL_DMA
675 tt_scsi_dma.dma_ctrl = 0;
676 atari_dma_residual = 0;
677
678 if (MACH_IS_MEDUSA) {
679
680
681
682
683
684
685
686
687
688
689
690
691 atari_read_overruns = 4;
692 }
693#endif
694 } else {
695
696
697
698
699
700#ifdef REAL_DMA
701 atari_dma_residual = 0;
702 atari_dma_active = 0;
703 atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
704 : 0xff000000);
705#endif
706 }
707
708 printk(KERN_INFO "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
709#ifdef SUPPORT_TAGS
710 "TAGGED-QUEUING=%s "
711#endif
712 "HOSTID=%d",
713 instance->host_no, instance->hostt->can_queue,
714 instance->hostt->cmd_per_lun,
715 instance->hostt->sg_tablesize,
716#ifdef SUPPORT_TAGS
717 setup_use_tagged_queuing ? "yes" : "no",
718#endif
719 instance->hostt->this_id );
720 NCR5380_print_options(instance);
721 printk("\n");
722
723 called = 1;
724 return 1;
725}
726
727int atari_scsi_release(struct Scsi_Host *sh)
728{
729 if (IS_A_TT())
730 free_irq(IRQ_TT_MFP_SCSI, sh);
731 if (atari_dma_buffer)
732 atari_stram_free(atari_dma_buffer);
733 NCR5380_exit(sh);
734 return 1;
735}
736
737void __init atari_scsi_setup(char *str, int *ints)
738{
739
740
741
742
743
744
745 if (ints[0] < 1) {
746 printk("atari_scsi_setup: no arguments!\n");
747 return;
748 }
749
750 if (ints[0] >= 1) {
751 if (ints[1] > 0)
752
753 setup_can_queue = ints[1];
754 }
755 if (ints[0] >= 2) {
756 if (ints[2] > 0)
757 setup_cmd_per_lun = ints[2];
758 }
759 if (ints[0] >= 3) {
760 if (ints[3] >= 0) {
761 setup_sg_tablesize = ints[3];
762
763 if (setup_sg_tablesize > SG_ALL)
764 setup_sg_tablesize = SG_ALL;
765 }
766 }
767 if (ints[0] >= 4) {
768
769 if (ints[4] >= 0 && ints[4] <= 7)
770 setup_hostid = ints[4];
771 else if (ints[4] > 7)
772 printk("atari_scsi_setup: invalid host ID %d !\n", ints[4]);
773 }
774#ifdef SUPPORT_TAGS
775 if (ints[0] >= 5) {
776 if (ints[5] >= 0)
777 setup_use_tagged_queuing = !!ints[5];
778 }
779#endif
780}
781
782int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
783{
784 int rv;
785 struct NCR5380_hostdata *hostdata =
786 (struct NCR5380_hostdata *)cmd->device->host->hostdata;
787
788
789
790
791
792
793 if (IS_A_TT()) {
794 atari_turnoff_irq(IRQ_TT_MFP_SCSI);
795#ifdef REAL_DMA
796 tt_scsi_dma.dma_ctrl = 0;
797#endif
798 } else {
799 atari_turnoff_irq(IRQ_MFP_FSCSI);
800#ifdef REAL_DMA
801 st_dma.dma_mode_status = 0x90;
802 atari_dma_active = 0;
803 atari_dma_orig_addr = NULL;
804#endif
805 }
806
807 rv = NCR5380_bus_reset(cmd);
808
809
810 if (IS_A_TT()) {
811 atari_turnon_irq(IRQ_TT_MFP_SCSI);
812 } else {
813 atari_turnon_irq(IRQ_MFP_FSCSI);
814 }
815 if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS)
816 falcon_release_lock_if_possible(hostdata);
817
818 return rv;
819}
820
821
822#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
823static void __init atari_scsi_reset_boot(void)
824{
825 unsigned long end;
826
827
828
829
830
831
832 printk("Atari SCSI: resetting the SCSI bus...");
833
834
835 NCR5380_write(TARGET_COMMAND_REG,
836 PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG)));
837
838
839 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
840
841 udelay(50);
842
843 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
844 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
845
846 end = jiffies + AFTER_RESET_DELAY;
847 while (time_before(jiffies, end))
848 barrier();
849
850 printk(" done\n");
851}
852#endif
853
854
855const char *atari_scsi_info(struct Scsi_Host *host)
856{
857
858 static const char string[] = "Atari native SCSI";
859 return string;
860}
861
862
863#if defined(REAL_DMA)
864
865unsigned long atari_scsi_dma_setup(struct Scsi_Host *instance, void *data,
866 unsigned long count, int dir)
867{
868 unsigned long addr = virt_to_phys(data);
869
870 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
871 "dir = %d\n", instance->host_no, data, addr, count, dir);
872
873 if (!IS_A_TT() && !STRAM_ADDR(addr)) {
874
875
876
877
878
879 if (dir)
880 memcpy(atari_dma_buffer, data, count);
881 else
882 atari_dma_orig_addr = data;
883 addr = atari_dma_phys_buffer;
884 }
885
886 atari_dma_startaddr = addr;
887
888
889
890
891
892
893
894
895
896
897 dma_cache_maintenance(addr, count, dir);
898
899 if (count == 0)
900 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n");
901
902 if (IS_A_TT()) {
903 tt_scsi_dma.dma_ctrl = dir;
904 SCSI_DMA_WRITE_P(dma_addr, addr);
905 SCSI_DMA_WRITE_P(dma_cnt, count);
906 tt_scsi_dma.dma_ctrl = dir | 2;
907 } else {
908
909
910 SCSI_DMA_SETADR(addr);
911
912
913 dir <<= 8;
914 st_dma.dma_mode_status = 0x90 | dir;
915 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
916 st_dma.dma_mode_status = 0x90 | dir;
917 udelay(40);
918
919
920 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
921 udelay(40);
922 st_dma.dma_mode_status = 0x10 | dir;
923 udelay(40);
924
925 atari_dma_active = 1;
926 }
927
928 return count;
929}
930
931
932static long atari_scsi_dma_residual(struct Scsi_Host *instance)
933{
934 return atari_dma_residual;
935}
936
937
938#define CMD_SURELY_BLOCK_MODE 0
939#define CMD_SURELY_BYTE_MODE 1
940#define CMD_MODE_UNKNOWN 2
941
942static int falcon_classify_cmd(Scsi_Cmnd *cmd)
943{
944 unsigned char opcode = cmd->cmnd[0];
945
946 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
947 opcode == READ_BUFFER)
948 return CMD_SURELY_BYTE_MODE;
949 else if (opcode == READ_6 || opcode == READ_10 ||
950 opcode == 0xa8 || opcode == READ_REVERSE ||
951 opcode == RECOVER_BUFFERED_DATA) {
952
953
954
955 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
956 return CMD_SURELY_BYTE_MODE;
957 else
958 return CMD_SURELY_BLOCK_MODE;
959 } else
960 return CMD_MODE_UNKNOWN;
961}
962
963
964
965
966
967
968
969
970
971
972
973static unsigned long atari_dma_xfer_len(unsigned long wanted_len,
974 Scsi_Cmnd *cmd, int write_flag)
975{
976 unsigned long possible_len, limit;
977
978 if (IS_A_TT())
979
980 return wanted_len;
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010 if (write_flag) {
1011
1012
1013
1014
1015 possible_len = wanted_len;
1016 } else {
1017
1018
1019
1020
1021 if (wanted_len & 0x1ff)
1022 possible_len = 0;
1023 else {
1024
1025
1026 switch (falcon_classify_cmd(cmd)) {
1027 case CMD_SURELY_BLOCK_MODE:
1028 possible_len = wanted_len;
1029 break;
1030 case CMD_SURELY_BYTE_MODE:
1031 possible_len = 0;
1032 break;
1033 case CMD_MODE_UNKNOWN:
1034 default:
1035
1036
1037 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
1038 break;
1039 }
1040 }
1041 }
1042
1043
1044 limit = (atari_dma_buffer && !STRAM_ADDR(virt_to_phys(cmd->SCp.ptr))) ?
1045 STRAM_BUFFER_SIZE : 255*512;
1046 if (possible_len > limit)
1047 possible_len = limit;
1048
1049 if (possible_len != wanted_len)
1050 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1051 "instead of %ld\n", possible_len, wanted_len);
1052
1053 return possible_len;
1054}
1055
1056
1057#endif
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067static unsigned char atari_scsi_tt_reg_read(unsigned char reg)
1068{
1069 return tt_scsi_regp[reg * 2];
1070}
1071
1072static void atari_scsi_tt_reg_write(unsigned char reg, unsigned char value)
1073{
1074 tt_scsi_regp[reg * 2] = value;
1075}
1076
1077static unsigned char atari_scsi_falcon_reg_read(unsigned char reg)
1078{
1079 dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1080 return (u_char)dma_wd.fdc_acces_seccount;
1081}
1082
1083static void atari_scsi_falcon_reg_write(unsigned char reg, unsigned char value)
1084{
1085 dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1086 dma_wd.fdc_acces_seccount = (u_short)value;
1087}
1088
1089
1090#include "atari_NCR5380.c"
1091
1092static struct scsi_host_template driver_template = {
1093 .proc_info = atari_scsi_proc_info,
1094 .name = "Atari native SCSI",
1095 .detect = atari_scsi_detect,
1096 .release = atari_scsi_release,
1097 .info = atari_scsi_info,
1098 .queuecommand = atari_scsi_queue_command,
1099 .eh_abort_handler = atari_scsi_abort,
1100 .eh_bus_reset_handler = atari_scsi_bus_reset,
1101 .can_queue = 0,
1102 .this_id = 0,
1103 .sg_tablesize = 0,
1104 .cmd_per_lun = 0,
1105 .use_clustering = DISABLE_CLUSTERING
1106};
1107
1108
1109#include "scsi_module.c"
1110
1111MODULE_LICENSE("GPL");
1112