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
575static int __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
727static int 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
737#ifndef MODULE
738static int __init atari_scsi_setup(char *str)
739{
740
741
742
743
744
745 int ints[6];
746
747 get_options(str, ARRAY_SIZE(ints), ints);
748
749 if (ints[0] < 1) {
750 printk("atari_scsi_setup: no arguments!\n");
751 return 0;
752 }
753
754 if (ints[0] >= 1) {
755 if (ints[1] > 0)
756
757 setup_can_queue = ints[1];
758 }
759 if (ints[0] >= 2) {
760 if (ints[2] > 0)
761 setup_cmd_per_lun = ints[2];
762 }
763 if (ints[0] >= 3) {
764 if (ints[3] >= 0) {
765 setup_sg_tablesize = ints[3];
766
767 if (setup_sg_tablesize > SG_ALL)
768 setup_sg_tablesize = SG_ALL;
769 }
770 }
771 if (ints[0] >= 4) {
772
773 if (ints[4] >= 0 && ints[4] <= 7)
774 setup_hostid = ints[4];
775 else if (ints[4] > 7)
776 printk("atari_scsi_setup: invalid host ID %d !\n", ints[4]);
777 }
778#ifdef SUPPORT_TAGS
779 if (ints[0] >= 5) {
780 if (ints[5] >= 0)
781 setup_use_tagged_queuing = !!ints[5];
782 }
783#endif
784
785 return 1;
786}
787
788__setup("atascsi=", atari_scsi_setup);
789#endif
790
791static int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
792{
793 int rv;
794 struct NCR5380_hostdata *hostdata =
795 (struct NCR5380_hostdata *)cmd->device->host->hostdata;
796
797
798
799
800
801
802 if (IS_A_TT()) {
803 atari_turnoff_irq(IRQ_TT_MFP_SCSI);
804#ifdef REAL_DMA
805 tt_scsi_dma.dma_ctrl = 0;
806#endif
807 } else {
808 atari_turnoff_irq(IRQ_MFP_FSCSI);
809#ifdef REAL_DMA
810 st_dma.dma_mode_status = 0x90;
811 atari_dma_active = 0;
812 atari_dma_orig_addr = NULL;
813#endif
814 }
815
816 rv = NCR5380_bus_reset(cmd);
817
818
819 if (IS_A_TT()) {
820 atari_turnon_irq(IRQ_TT_MFP_SCSI);
821 } else {
822 atari_turnon_irq(IRQ_MFP_FSCSI);
823 }
824 if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS)
825 falcon_release_lock_if_possible(hostdata);
826
827 return rv;
828}
829
830
831#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
832static void __init atari_scsi_reset_boot(void)
833{
834 unsigned long end;
835
836
837
838
839
840
841 printk("Atari SCSI: resetting the SCSI bus...");
842
843
844 NCR5380_write(TARGET_COMMAND_REG,
845 PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG)));
846
847
848 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
849
850 udelay(50);
851
852 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
853 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
854
855 end = jiffies + AFTER_RESET_DELAY;
856 while (time_before(jiffies, end))
857 barrier();
858
859 printk(" done\n");
860}
861#endif
862
863
864static const char *atari_scsi_info(struct Scsi_Host *host)
865{
866
867 static const char string[] = "Atari native SCSI";
868 return string;
869}
870
871
872#if defined(REAL_DMA)
873
874static unsigned long atari_scsi_dma_setup(struct Scsi_Host *instance,
875 void *data, unsigned long count,
876 int dir)
877{
878 unsigned long addr = virt_to_phys(data);
879
880 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
881 "dir = %d\n", instance->host_no, data, addr, count, dir);
882
883 if (!IS_A_TT() && !STRAM_ADDR(addr)) {
884
885
886
887
888
889 if (dir)
890 memcpy(atari_dma_buffer, data, count);
891 else
892 atari_dma_orig_addr = data;
893 addr = atari_dma_phys_buffer;
894 }
895
896 atari_dma_startaddr = addr;
897
898
899
900
901
902
903
904
905
906
907 dma_cache_maintenance(addr, count, dir);
908
909 if (count == 0)
910 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n");
911
912 if (IS_A_TT()) {
913 tt_scsi_dma.dma_ctrl = dir;
914 SCSI_DMA_WRITE_P(dma_addr, addr);
915 SCSI_DMA_WRITE_P(dma_cnt, count);
916 tt_scsi_dma.dma_ctrl = dir | 2;
917 } else {
918
919
920 SCSI_DMA_SETADR(addr);
921
922
923 dir <<= 8;
924 st_dma.dma_mode_status = 0x90 | dir;
925 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
926 st_dma.dma_mode_status = 0x90 | dir;
927 udelay(40);
928
929
930 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
931 udelay(40);
932 st_dma.dma_mode_status = 0x10 | dir;
933 udelay(40);
934
935 atari_dma_active = 1;
936 }
937
938 return count;
939}
940
941
942static long atari_scsi_dma_residual(struct Scsi_Host *instance)
943{
944 return atari_dma_residual;
945}
946
947
948#define CMD_SURELY_BLOCK_MODE 0
949#define CMD_SURELY_BYTE_MODE 1
950#define CMD_MODE_UNKNOWN 2
951
952static int falcon_classify_cmd(Scsi_Cmnd *cmd)
953{
954 unsigned char opcode = cmd->cmnd[0];
955
956 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
957 opcode == READ_BUFFER)
958 return CMD_SURELY_BYTE_MODE;
959 else if (opcode == READ_6 || opcode == READ_10 ||
960 opcode == 0xa8 || opcode == READ_REVERSE ||
961 opcode == RECOVER_BUFFERED_DATA) {
962
963
964
965 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
966 return CMD_SURELY_BYTE_MODE;
967 else
968 return CMD_SURELY_BLOCK_MODE;
969 } else
970 return CMD_MODE_UNKNOWN;
971}
972
973
974
975
976
977
978
979
980
981
982
983static unsigned long atari_dma_xfer_len(unsigned long wanted_len,
984 Scsi_Cmnd *cmd, int write_flag)
985{
986 unsigned long possible_len, limit;
987
988 if (IS_A_TT())
989
990 return wanted_len;
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020 if (write_flag) {
1021
1022
1023
1024
1025 possible_len = wanted_len;
1026 } else {
1027
1028
1029
1030
1031 if (wanted_len & 0x1ff)
1032 possible_len = 0;
1033 else {
1034
1035
1036 switch (falcon_classify_cmd(cmd)) {
1037 case CMD_SURELY_BLOCK_MODE:
1038 possible_len = wanted_len;
1039 break;
1040 case CMD_SURELY_BYTE_MODE:
1041 possible_len = 0;
1042 break;
1043 case CMD_MODE_UNKNOWN:
1044 default:
1045
1046
1047 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
1048 break;
1049 }
1050 }
1051 }
1052
1053
1054 limit = (atari_dma_buffer && !STRAM_ADDR(virt_to_phys(cmd->SCp.ptr))) ?
1055 STRAM_BUFFER_SIZE : 255*512;
1056 if (possible_len > limit)
1057 possible_len = limit;
1058
1059 if (possible_len != wanted_len)
1060 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1061 "instead of %ld\n", possible_len, wanted_len);
1062
1063 return possible_len;
1064}
1065
1066
1067#endif
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077static unsigned char atari_scsi_tt_reg_read(unsigned char reg)
1078{
1079 return tt_scsi_regp[reg * 2];
1080}
1081
1082static void atari_scsi_tt_reg_write(unsigned char reg, unsigned char value)
1083{
1084 tt_scsi_regp[reg * 2] = value;
1085}
1086
1087static unsigned char atari_scsi_falcon_reg_read(unsigned char reg)
1088{
1089 dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1090 return (u_char)dma_wd.fdc_acces_seccount;
1091}
1092
1093static void atari_scsi_falcon_reg_write(unsigned char reg, unsigned char value)
1094{
1095 dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1096 dma_wd.fdc_acces_seccount = (u_short)value;
1097}
1098
1099
1100#include "atari_NCR5380.c"
1101
1102static struct scsi_host_template driver_template = {
1103 .show_info = atari_scsi_show_info,
1104 .name = "Atari native SCSI",
1105 .detect = atari_scsi_detect,
1106 .release = atari_scsi_release,
1107 .info = atari_scsi_info,
1108 .queuecommand = atari_scsi_queue_command,
1109 .eh_abort_handler = atari_scsi_abort,
1110 .eh_bus_reset_handler = atari_scsi_bus_reset,
1111 .can_queue = 0,
1112 .this_id = 0,
1113 .sg_tablesize = 0,
1114 .cmd_per_lun = 0,
1115 .use_clustering = DISABLE_CLUSTERING
1116};
1117
1118
1119#include "scsi_module.c"
1120
1121MODULE_LICENSE("GPL");
1122