2 * atari_scsi.c -- Device dependent functions for the Atari generic SCSI port
4 * Copyright 1994 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
6 * Loosely based on the work of Robert De Vries' team and added:
8 * - Falcon support (untested yet!) ++bjoern fixed and now it works
9 * - lots of extensions and bug fixes.
11 * This file is subject to the terms and conditions of the GNU General Public
12 * License. See the file COPYING in the main directory of this archive
18 /**************************************************************************/
20 /* Notes for Falcon SCSI: */
21 /* ---------------------- */
23 /* Since the Falcon SCSI uses the ST-DMA chip, that is shared among */
24 /* several device drivers, locking and unlocking the access to this */
25 /* chip is required. But locking is not possible from an interrupt, */
26 /* since it puts the process to sleep if the lock is not available. */
27 /* This prevents "late" locking of the DMA chip, i.e. locking it just */
28 /* before using it, since in case of disconnection-reconnection */
29 /* commands, the DMA is started from the reselection interrupt. */
31 /* Two possible schemes for ST-DMA-locking would be: */
32 /* 1) The lock is taken for each command separately and disconnecting */
33 /* is forbidden (i.e. can_queue = 1). */
34 /* 2) The DMA chip is locked when the first command comes in and */
35 /* released when the last command is finished and all queues are */
37 /* The first alternative would result in bad performance, since the */
38 /* interleaving of commands would not be used. The second is unfair to */
39 /* other drivers using the ST-DMA, because the queues will seldom be */
40 /* totally empty if there is a lot of disk traffic. */
42 /* For this reasons I decided to employ a more elaborate scheme: */
43 /* - First, we give up the lock every time we can (for fairness), this */
44 /* means every time a command finishes and there are no other commands */
45 /* on the disconnected queue. */
46 /* - If there are others waiting to lock the DMA chip, we stop */
47 /* issuing commands, i.e. moving them onto the issue queue. */
48 /* Because of that, the disconnected queue will run empty in a */
49 /* while. Instead we go to sleep on a 'fairness_queue'. */
50 /* - If the lock is released, all processes waiting on the fairness */
51 /* queue will be woken. The first of them tries to re-lock the DMA, */
52 /* the others wait for the first to finish this task. After that, */
53 /* they can all run on and do their commands... */
54 /* This sounds complicated (and it is it :-(), but it seems to be a */
55 /* good compromise between fairness and performance: As long as no one */
56 /* else wants to work with the ST-DMA chip, SCSI can go along as */
57 /* usual. If now someone else comes, this behaviour is changed to a */
58 /* "fairness mode": just already initiated commands are finished and */
59 /* then the lock is released. The other one waiting will probably win */
60 /* the race for locking the DMA, since it was waiting for longer. And */
61 /* after it has finished, SCSI can go ahead again. Finally: I hope I */
62 /* have not produced any deadlock possibilities! */
64 /**************************************************************************/
68 #include <linux/config.h>
69 #include <linux/module.h>
73 #define NDEBUG_ABORT 0x800000
74 #define NDEBUG_TAGS 0x1000000
75 #define NDEBUG_MERGING 0x2000000
78 /* For the Atari version, use only polled IO or REAL_DMA */
80 /* Support tagged queuing? (on devices that are able to... :-) */
84 #include <linux/types.h>
85 #include <linux/stddef.h>
86 #include <linux/ctype.h>
87 #include <linux/delay.h>
89 #include <linux/blk.h>
90 #include <linux/sched.h>
91 #include <linux/interrupt.h>
92 #include <linux/init.h>
93 #include <linux/nvram.h>
95 #include <asm/setup.h>
96 #include <asm/atarihw.h>
97 #include <asm/atariints.h>
99 #include <asm/pgtable.h>
101 #include <asm/traps.h>
102 #include <asm/bitops.h>
106 #include "atari_scsi.h"
108 #include "constants.h"
109 #include <asm/atari_stdma.h>
110 #include <asm/atari_stram.h>
113 #include <linux/stat.h>
115 #define IS_A_TT() ATARIHW_PRESENT(TT_SCSI)
117 #define SCSI_DMA_WRITE_P(elt,val) \
119 unsigned long v = val; \
120 tt_scsi_dma.elt##_lo = v & 0xff; \
122 tt_scsi_dma.elt##_lmd = v & 0xff; \
124 tt_scsi_dma.elt##_hmd = v & 0xff; \
126 tt_scsi_dma.elt##_hi = v & 0xff; \
129 #define SCSI_DMA_READ_P(elt) \
130 (((((((unsigned long)tt_scsi_dma.elt##_hi << 8) | \
131 (unsigned long)tt_scsi_dma.elt##_hmd) << 8) | \
132 (unsigned long)tt_scsi_dma.elt##_lmd) << 8) | \
133 (unsigned long)tt_scsi_dma.elt##_lo)
136 static inline void SCSI_DMA_SETADR(unsigned long adr
)
138 st_dma
.dma_lo
= (unsigned char)adr
;
141 st_dma
.dma_md
= (unsigned char)adr
;
144 st_dma
.dma_hi
= (unsigned char)adr
;
148 static inline unsigned long SCSI_DMA_GETADR(void)
153 adr
|= (st_dma
.dma_md
& 0xff) << 8;
155 adr
|= (st_dma
.dma_hi
& 0xff) << 16;
160 static inline void ENABLE_IRQ(void)
163 atari_enable_irq(IRQ_TT_MFP_SCSI
);
165 atari_enable_irq(IRQ_MFP_FSCSI
);
168 static inline void DISABLE_IRQ(void)
171 atari_disable_irq(IRQ_TT_MFP_SCSI
);
173 atari_disable_irq(IRQ_MFP_FSCSI
);
177 #define HOSTDATA_DMALEN (((struct NCR5380_hostdata *) \
178 (atari_scsi_host->hostdata))->dma_len)
180 /* Time (in jiffies) to wait after a reset; the SCSI standard calls for 250ms,
181 * we usually do 0.5s to be on the safe side. But Toshiba CD-ROMs once more
182 * need ten times the standard value... */
183 #ifndef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
184 #define AFTER_RESET_DELAY (HZ/2)
186 #define AFTER_RESET_DELAY (5*HZ/2)
189 /***************************** Prototypes *****************************/
192 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat
);
193 static void atari_scsi_fetch_restbytes( void );
194 static long atari_scsi_dma_residual( struct Scsi_Host
*instance
);
195 static int falcon_classify_cmd( Scsi_Cmnd
*cmd
);
196 static unsigned long atari_dma_xfer_len( unsigned long wanted_len
,
197 Scsi_Cmnd
*cmd
, int write_flag
);
199 static void scsi_tt_intr( int irq
, void *dummy
, struct pt_regs
*fp
);
200 static void scsi_falcon_intr( int irq
, void *dummy
, struct pt_regs
*fp
);
201 static void falcon_release_lock_if_possible( struct NCR5380_hostdata
*
203 static void falcon_get_lock( void );
204 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
205 static void atari_scsi_reset_boot( void );
207 static unsigned char atari_scsi_tt_reg_read( unsigned char reg
);
208 static void atari_scsi_tt_reg_write( unsigned char reg
, unsigned char value
);
209 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg
);
210 static void atari_scsi_falcon_reg_write( unsigned char reg
, unsigned char value
);
212 /************************* End of Prototypes **************************/
215 static struct Scsi_Host
*atari_scsi_host
= NULL
;
216 static unsigned char (*atari_scsi_reg_read
)( unsigned char reg
);
217 static void (*atari_scsi_reg_write
)( unsigned char reg
, unsigned char value
);
220 static unsigned long atari_dma_residual
, atari_dma_startaddr
;
221 static short atari_dma_active
;
222 /* pointer to the dribble buffer */
223 static char *atari_dma_buffer
= NULL
;
224 /* precalculated physical address of the dribble buffer */
225 static unsigned long atari_dma_phys_buffer
;
226 /* != 0 tells the Falcon int handler to copy data from the dribble buffer */
227 static char *atari_dma_orig_addr
;
228 /* size of the dribble buffer; 4k seems enough, since the Falcon cannot use
229 * scatter-gather anyway, so most transfers are 1024 byte only. In the rare
230 * cases where requests to physical contiguous buffers have been merged, this
231 * request is <= 4k (one page). So I don't think we have to split transfers
232 * just due to this buffer size...
234 #define STRAM_BUFFER_SIZE (4096)
235 /* mask for address bits that can't be used with the ST-DMA */
236 static unsigned long atari_dma_stram_mask
;
237 #define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0)
238 /* number of bytes to cut from a transfer to handle NCR overruns */
239 static int atari_read_overruns
= 0;
242 static int setup_can_queue
= -1;
243 MODULE_PARM(setup_can_queue
, "i");
244 static int setup_cmd_per_lun
= -1;
245 MODULE_PARM(setup_cmd_per_lun
, "i");
246 static int setup_sg_tablesize
= -1;
247 MODULE_PARM(setup_sg_tablesize
, "i");
249 static int setup_use_tagged_queuing
= -1;
250 MODULE_PARM(setup_use_tagged_queuing
, "i");
252 static int setup_hostid
= -1;
253 MODULE_PARM(setup_hostid
, "i");
256 #if defined(CONFIG_TT_DMA_EMUL)
257 #include "atari_dma_emul.c"
260 #if defined(REAL_DMA)
262 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat
)
265 unsigned long addr
= SCSI_DMA_READ_P( dma_addr
), end_addr
;
267 if (dma_stat
& 0x01) {
269 /* A bus error happens when DMA-ing from the last page of a
270 * physical memory chunk (DMA prefetch!), but that doesn't hurt.
271 * Check for this case:
274 for( i
= 0; i
< m68k_num_memory
; ++i
) {
275 end_addr
= m68k_memory
[i
].addr
+
277 if (end_addr
<= addr
&& addr
<= end_addr
+ 4)
286 /* Dead code... wasn't called anyway :-) and causes some trouble, because at
287 * end-of-DMA, both SCSI ints are triggered simultaneously, so the NCR int has
288 * to clear the DMA int pending bit before it allows other level 6 interrupts.
290 static void scsi_dma_buserr (int irq
, void *dummy
, struct pt_regs
*fp
)
292 unsigned char dma_stat
= tt_scsi_dma
.dma_ctrl
;
294 /* Don't do anything if a NCR interrupt is pending. Probably it's just
296 if (atari_irq_pending( IRQ_TT_MFP_SCSI
))
299 printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
300 SCSI_DMA_READ_P(dma_addr
), dma_stat
, SCSI_DMA_READ_P(dma_cnt
));
301 if (dma_stat
& 0x80) {
302 if (!scsi_dma_is_ignored_buserr( dma_stat
))
303 printk( "SCSI DMA bus error -- bad DMA programming!\n" );
306 /* Under normal circumstances we never should get to this point,
307 * since both interrupts are triggered simultaneously and the 5380
308 * int has higher priority. When this irq is handled, that DMA
309 * interrupt is cleared. So a warning message is printed here.
311 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
319 static void scsi_tt_intr (int irq
, void *dummy
, struct pt_regs
*fp
)
324 dma_stat
= tt_scsi_dma
.dma_ctrl
;
326 INT_PRINTK("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
327 atari_scsi_host
->host_no
, dma_stat
& 0xff);
329 /* Look if it was the DMA that has interrupted: First possibility
330 * is that a bus error occurred...
332 if (dma_stat
& 0x80) {
333 if (!scsi_dma_is_ignored_buserr( dma_stat
)) {
334 printk(KERN_ERR
"SCSI DMA caused bus error near 0x%08lx\n",
335 SCSI_DMA_READ_P(dma_addr
));
336 printk(KERN_CRIT
"SCSI DMA bus error -- bad DMA programming!");
340 /* If the DMA is active but not finished, we have the case
341 * that some other 5380 interrupt occurred within the DMA transfer.
342 * This means we have residual bytes, if the desired end address
343 * is not yet reached. Maybe we have to fetch some bytes from the
344 * rest data register, too. The residual must be calculated from
345 * the address pointer, not the counter register, because only the
346 * addr reg counts bytes not yet written and pending in the rest
349 if ((dma_stat
& 0x02) && !(dma_stat
& 0x40)) {
350 atari_dma_residual
= HOSTDATA_DMALEN
- (SCSI_DMA_READ_P( dma_addr
) -
351 atari_dma_startaddr
);
353 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
356 if ((signed int)atari_dma_residual
< 0)
357 atari_dma_residual
= 0;
358 if ((dma_stat
& 1) == 0) {
359 /* After read operations, we maybe have to
360 transport some rest bytes */
361 atari_scsi_fetch_restbytes();
364 /* There seems to be a nasty bug in some SCSI-DMA/NCR
365 combinations: If a target disconnects while a write
366 operation is going on, the address register of the
367 DMA may be a few bytes farer than it actually read.
368 This is probably due to DMA prefetching and a delay
369 between DMA and NCR. Experiments showed that the
370 dma_addr is 9 bytes to high, but this could vary.
371 The problem is, that the residual is thus calculated
372 wrong and the next transfer will start behind where
373 it should. So we round up the residual to the next
374 multiple of a sector size, if it isn't already a
375 multiple and the originally expected transfer size
376 was. The latter condition is there to ensure that
377 the correction is taken only for "real" data
378 transfers and not for, e.g., the parameters of some
379 other command. These shouldn't disconnect anyway.
381 if (atari_dma_residual
& 0x1ff) {
382 DMA_PRINTK("SCSI DMA: DMA bug corrected, "
383 "difference %ld bytes\n",
384 512 - (atari_dma_residual
& 0x1ff));
385 atari_dma_residual
= (atari_dma_residual
+ 511) & ~0x1ff;
388 tt_scsi_dma
.dma_ctrl
= 0;
391 /* If the DMA is finished, fetch the rest bytes and turn it off */
392 if (dma_stat
& 0x40) {
393 atari_dma_residual
= 0;
394 if ((dma_stat
& 1) == 0)
395 atari_scsi_fetch_restbytes();
396 tt_scsi_dma
.dma_ctrl
= 0;
399 #endif /* REAL_DMA */
401 NCR5380_intr (0, 0, 0);
404 /* To be sure the int is not masked */
405 atari_enable_irq( IRQ_TT_MFP_SCSI
);
410 static void scsi_falcon_intr (int irq
, void *dummy
, struct pt_regs
*fp
)
415 /* Turn off DMA and select sector counter register before
416 * accessing the status register (Atari recommendation!)
418 st_dma
.dma_mode_status
= 0x90;
419 dma_stat
= st_dma
.dma_mode_status
;
421 /* Bit 0 indicates some error in the DMA process... don't know
422 * what happened exactly (no further docu).
424 if (!(dma_stat
& 0x01)) {
426 printk(KERN_CRIT
"SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR());
429 /* If the DMA was active, but now bit 1 is not clear, it is some
430 * other 5380 interrupt that finishes the DMA transfer. We have to
431 * calculate the number of residual bytes and give a warning if
432 * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
434 if (atari_dma_active
&& (dma_stat
& 0x02)) {
435 unsigned long transferred
;
437 transferred
= SCSI_DMA_GETADR() - atari_dma_startaddr
;
438 /* The ST-DMA address is incremented in 2-byte steps, but the
439 * data are written only in 16-byte chunks. If the number of
440 * transferred bytes is not divisible by 16, the remainder is
441 * lost somewhere in outer space.
443 if (transferred
& 15)
444 printk(KERN_ERR
"SCSI DMA error: %ld bytes lost in "
445 "ST-DMA fifo\n", transferred
& 15);
447 atari_dma_residual
= HOSTDATA_DMALEN
- transferred
;
448 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
452 atari_dma_residual
= 0;
453 atari_dma_active
= 0;
455 if (atari_dma_orig_addr
) {
456 /* If the dribble buffer was used on a read operation, copy the DMA-ed
457 * data to the original destination address.
459 memcpy(atari_dma_orig_addr
, phys_to_virt(atari_dma_startaddr
),
460 HOSTDATA_DMALEN
- atari_dma_residual
);
461 atari_dma_orig_addr
= NULL
;
464 #endif /* REAL_DMA */
466 NCR5380_intr (0, 0, 0);
471 static void atari_scsi_fetch_restbytes( void )
475 unsigned long phys_dst
;
477 /* fetch rest bytes in the DMA register */
478 phys_dst
= SCSI_DMA_READ_P(dma_addr
);
481 /* there are 'nr' bytes left for the last long address
482 before the DMA pointer */
484 DMA_PRINTK("SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
486 /* The content of the DMA pointer is a physical address! */
487 dst
= phys_to_virt(phys_dst
);
488 DMA_PRINTK(" = virt addr %p\n", dst
);
489 for (src
= (char *)&tt_scsi_dma
.dma_restdata
; nr
!= 0; --nr
)
493 #endif /* REAL_DMA */
496 static int falcon_got_lock
= 0;
497 static DECLARE_WAIT_QUEUE_HEAD(falcon_fairness_wait
);
498 static int falcon_trying_lock
= 0;
499 static DECLARE_WAIT_QUEUE_HEAD(falcon_try_wait
);
500 static int falcon_dont_release
= 0;
502 /* This function releases the lock on the DMA chip if there is no
503 * connected command and the disconnected queue is empty. On
504 * releasing, instances of falcon_get_lock are awoken, that put
505 * themselves to sleep for fairness. They can now try to get the lock
506 * again (but others waiting longer more probably will win).
510 falcon_release_lock_if_possible( struct NCR5380_hostdata
* hostdata
)
512 unsigned long oldflags
;
514 if (IS_A_TT()) return;
516 save_flags(oldflags
);
519 if (falcon_got_lock
&&
520 !hostdata
->disconnected_queue
&&
521 !hostdata
->issue_queue
&&
522 !hostdata
->connected
) {
524 if (falcon_dont_release
) {
526 printk("WARNING: Lock release not allowed. Ignored\n");
528 restore_flags(oldflags
);
533 wake_up( &falcon_fairness_wait
);
536 restore_flags(oldflags
);
539 /* This function manages the locking of the ST-DMA.
540 * If the DMA isn't locked already for SCSI, it tries to lock it by
541 * calling stdma_lock(). But if the DMA is locked by the SCSI code and
542 * there are other drivers waiting for the chip, we do not issue the
543 * command immediately but wait on 'falcon_fairness_queue'. We will be
544 * waked up when the DMA is unlocked by some SCSI interrupt. After that
545 * we try to get the lock again.
546 * But we must be prepared that more than one instance of
547 * falcon_get_lock() is waiting on the fairness queue. They should not
548 * try all at once to call stdma_lock(), one is enough! For that, the
549 * first one sets 'falcon_trying_lock', others that see that variable
550 * set wait on the queue 'falcon_try_wait'.
551 * Complicated, complicated.... Sigh...
554 static void falcon_get_lock( void )
556 unsigned long oldflags
;
558 if (IS_A_TT()) return;
560 save_flags(oldflags
);
563 while( !in_interrupt() && falcon_got_lock
&& stdma_others_waiting() )
564 sleep_on( &falcon_fairness_wait
);
566 while (!falcon_got_lock
) {
568 panic( "Falcon SCSI hasn't ST-DMA lock in interrupt" );
569 if (!falcon_trying_lock
) {
570 falcon_trying_lock
= 1;
571 stdma_lock(scsi_falcon_intr
, NULL
);
573 falcon_trying_lock
= 0;
574 wake_up( &falcon_try_wait
);
577 sleep_on( &falcon_try_wait
);
581 restore_flags(oldflags
);
582 if (!falcon_got_lock
)
583 panic("Falcon SCSI: someone stole the lock :-(\n");
587 /* This is the wrapper function for NCR5380_queue_command(). It just
588 * tries to get the lock on the ST-DMA (see above) and then calls the
593 int atari_queue_command (Scsi_Cmnd
*cmd
, void (*done
)(Scsi_Cmnd
*))
595 /* falcon_get_lock();
596 * ++guenther: moved to NCR5380_queue_command() to prevent
597 * race condition, see there for an explanation.
599 return( NCR5380_queue_command( cmd
, done
) );
604 int atari_scsi_detect (Scsi_Host_Template
*host
)
606 static int called
= 0;
607 struct Scsi_Host
*instance
;
609 if (!MACH_IS_ATARI
||
610 (!ATARIHW_PRESENT(ST_SCSI
) && !ATARIHW_PRESENT(TT_SCSI
)) ||
614 host
->proc_name
= "Atari";
616 atari_scsi_reg_read
= IS_A_TT() ? atari_scsi_tt_reg_read
:
617 atari_scsi_falcon_reg_read
;
618 atari_scsi_reg_write
= IS_A_TT() ? atari_scsi_tt_reg_write
:
619 atari_scsi_falcon_reg_write
;
621 /* setup variables */
623 (setup_can_queue
> 0) ? setup_can_queue
:
624 IS_A_TT() ? ATARI_TT_CAN_QUEUE
: ATARI_FALCON_CAN_QUEUE
;
626 (setup_cmd_per_lun
> 0) ? setup_cmd_per_lun
:
627 IS_A_TT() ? ATARI_TT_CMD_PER_LUN
: ATARI_FALCON_CMD_PER_LUN
;
628 /* Force sg_tablesize to 0 on a Falcon! */
630 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE
:
631 (setup_sg_tablesize
>= 0) ? setup_sg_tablesize
: ATARI_TT_SG_TABLESIZE
;
633 if (setup_hostid
>= 0)
634 host
->this_id
= setup_hostid
;
636 /* use 7 as default */
638 /* Test if a host id is set in the NVRam */
639 if (ATARIHW_PRESENT(TT_CLK
) && nvram_check_checksum()) {
640 unsigned char b
= nvram_read_byte( 14 );
641 /* Arbitration enabled? (for TOS) If yes, use configured host ID */
643 host
->this_id
= b
& 7;
648 if (setup_use_tagged_queuing
< 0)
649 setup_use_tagged_queuing
= DEFAULT_USE_TAGGED_QUEUING
;
652 /* If running on a Falcon and if there's TT-Ram (i.e., more than one
653 * memory block, since there's always ST-Ram in a Falcon), then allocate a
654 * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative
657 if (MACH_IS_ATARI
&& ATARIHW_PRESENT(ST_SCSI
) &&
658 !ATARIHW_PRESENT(EXTD_DMA
) && m68k_num_memory
> 1) {
659 atari_dma_buffer
= atari_stram_alloc(STRAM_BUFFER_SIZE
, "SCSI");
660 if (!atari_dma_buffer
) {
661 printk( KERN_ERR
"atari_scsi_detect: can't allocate ST-RAM "
665 atari_dma_phys_buffer
= virt_to_phys( atari_dma_buffer
);
666 atari_dma_orig_addr
= 0;
669 instance
= scsi_register (host
, sizeof (struct NCR5380_hostdata
));
672 atari_stram_free(atari_dma_buffer
);
673 atari_dma_buffer
= 0;
676 atari_scsi_host
= instance
;
677 /* Set irq to 0, to avoid that the mid-level code disables our interrupt
678 * during queue_command calls. This is completely unnecessary, and even
679 * worse causes bad problems on the Falcon, where the int is shared with
683 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
684 atari_scsi_reset_boot();
686 NCR5380_init (instance
, 0);
690 /* This int is actually "pseudo-slow", i.e. it acts like a slow
691 * interrupt after having cleared the pending flag for the DMA
693 request_irq(IRQ_TT_MFP_SCSI
, scsi_tt_intr
, IRQ_TYPE_SLOW
,
694 "SCSI NCR5380", scsi_tt_intr
);
695 tt_mfp
.active_edge
|= 0x80; /* SCSI int on L->H */
697 tt_scsi_dma
.dma_ctrl
= 0;
698 atari_dma_residual
= 0;
699 #endif /* REAL_DMA */
701 #ifdef CONFIG_TT_DMA_EMUL
703 request_irq(IRQ_AUTO_2
, hades_dma_emulator
,
704 IRQ_TYPE_PRIO
, "Hades DMA emulator",
708 if (MACH_IS_MEDUSA
|| MACH_IS_HADES
) {
709 /* While the read overruns (described by Drew Eckhardt in
710 * NCR5380.c) never happened on TTs, they do in fact on the Medusa
711 * (This was the cause why SCSI didn't work right for so long
712 * there.) Since handling the overruns slows down a bit, I turned
713 * the #ifdef's into a runtime condition.
715 * In principle it should be sufficient to do max. 1 byte with
716 * PIO, but there is another problem on the Medusa with the DMA
717 * rest data register. So 'atari_read_overruns' is currently set
718 * to 4 to avoid having transfers that aren't a multiple of 4. If
719 * the rest data bug is fixed, this can be lowered to 1.
721 atari_read_overruns
= 4;
726 else { /* ! IS_A_TT */
728 /* Nothing to do for the interrupt: the ST-DMA is initialized
729 * already by atari_init_INTS()
733 atari_dma_residual
= 0;
734 atari_dma_active
= 0;
735 atari_dma_stram_mask
= (ATARIHW_PRESENT(EXTD_DMA
) ? 0x00000000
740 printk(KERN_INFO
"scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
745 instance
->host_no
, instance
->hostt
->can_queue
,
746 instance
->hostt
->cmd_per_lun
,
747 instance
->hostt
->sg_tablesize
,
749 setup_use_tagged_queuing
? "yes" : "no",
751 instance
->hostt
->this_id
);
752 NCR5380_print_options (instance
);
760 int atari_scsi_release (struct Scsi_Host
*sh
)
763 free_irq(IRQ_TT_MFP_SCSI
, scsi_tt_intr
);
764 if (atari_dma_buffer
)
765 atari_stram_free (atari_dma_buffer
);
770 void __init
atari_scsi_setup(char *str
, int *ints
)
772 /* Format of atascsi parameter is:
773 * atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
774 * Defaults depend on TT or Falcon, hostid determined at run time.
775 * Negative values mean don't change.
779 printk( "atari_scsi_setup: no arguments!\n" );
785 /* no limits on this, just > 0 */
786 setup_can_queue
= ints
[1];
790 setup_cmd_per_lun
= ints
[2];
794 setup_sg_tablesize
= ints
[3];
795 /* Must be <= SG_ALL (255) */
796 if (setup_sg_tablesize
> SG_ALL
)
797 setup_sg_tablesize
= SG_ALL
;
801 /* Must be between 0 and 7 */
802 if (ints
[4] >= 0 && ints
[4] <= 7)
803 setup_hostid
= ints
[4];
804 else if (ints
[4] > 7)
805 printk( "atari_scsi_setup: invalid host ID %d !\n", ints
[4] );
810 setup_use_tagged_queuing
= !!ints
[5];
815 int atari_scsi_reset( Scsi_Cmnd
*cmd
, unsigned int reset_flags
)
818 struct NCR5380_hostdata
*hostdata
=
819 (struct NCR5380_hostdata
*)cmd
->host
->hostdata
;
821 /* For doing the reset, SCSI interrupts must be disabled first,
822 * since the 5380 raises its IRQ line while _RST is active and we
823 * can't disable interrupts completely, since we need the timer.
825 /* And abort a maybe active DMA transfer */
827 atari_turnoff_irq( IRQ_TT_MFP_SCSI
);
829 tt_scsi_dma
.dma_ctrl
= 0;
830 #endif /* REAL_DMA */
833 atari_turnoff_irq( IRQ_MFP_FSCSI
);
835 st_dma
.dma_mode_status
= 0x90;
836 atari_dma_active
= 0;
837 atari_dma_orig_addr
= NULL
;
838 #endif /* REAL_DMA */
841 rv
= NCR5380_reset(cmd
, reset_flags
);
845 atari_turnon_irq( IRQ_TT_MFP_SCSI
);
848 atari_turnon_irq( IRQ_MFP_FSCSI
);
850 if ((rv
& SCSI_RESET_ACTION
) == SCSI_RESET_SUCCESS
)
851 falcon_release_lock_if_possible(hostdata
);
857 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
858 static void __init
atari_scsi_reset_boot(void)
863 * Do a SCSI reset to clean up the bus during initialization. No messing
864 * with the queues, interrupts, or locks necessary here.
867 printk( "Atari SCSI: resetting the SCSI bus..." );
870 NCR5380_write( TARGET_COMMAND_REG
,
871 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG
) ));
874 NCR5380_write( INITIATOR_COMMAND_REG
, ICR_BASE
| ICR_ASSERT_RST
);
875 /* The min. reset hold time is 25us, so 40us should be enough */
877 /* reset RST and interrupt */
878 NCR5380_write( INITIATOR_COMMAND_REG
, ICR_BASE
);
879 NCR5380_read( RESET_PARITY_INTERRUPT_REG
);
881 end
= jiffies
+ AFTER_RESET_DELAY
;
882 while (time_before(jiffies
, end
))
890 const char * atari_scsi_info (struct Scsi_Host
*host
)
892 /* atari_scsi_detect() is verbose enough... */
893 static const char string
[] = "Atari native SCSI";
898 #if defined(REAL_DMA)
900 unsigned long atari_scsi_dma_setup( struct Scsi_Host
*instance
, void *data
,
901 unsigned long count
, int dir
)
903 unsigned long addr
= virt_to_phys( data
);
905 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
906 "dir = %d\n", instance
->host_no
, data
, addr
, count
, dir
);
908 if (!IS_A_TT() && !STRAM_ADDR(addr
)) {
909 /* If we have a non-DMAable address on a Falcon, use the dribble
910 * buffer; 'orig_addr' != 0 in the read case tells the interrupt
911 * handler to copy data from the dribble buffer to the originally
915 memcpy( atari_dma_buffer
, data
, count
);
917 atari_dma_orig_addr
= data
;
918 addr
= atari_dma_phys_buffer
;
921 atari_dma_startaddr
= addr
; /* Needed for calculating residual later. */
923 /* Cache cleanup stuff: On writes, push any dirty cache out before sending
924 * it to the peripheral. (Must be done before DMA setup, since at least
925 * the ST-DMA begins to fill internal buffers right after setup. For
926 * reads, invalidate any cache, may be altered after DMA without CPU
929 * ++roman: For the Medusa, there's no need at all for that cache stuff,
930 * because the hardware does bus snooping (fine!).
932 dma_cache_maintenance( addr
, count
, dir
);
935 printk(KERN_NOTICE
"SCSI warning: DMA programmed for 0 bytes !\n");
938 tt_scsi_dma
.dma_ctrl
= dir
;
939 SCSI_DMA_WRITE_P( dma_addr
, addr
);
940 SCSI_DMA_WRITE_P( dma_cnt
, count
);
941 tt_scsi_dma
.dma_ctrl
= dir
| 2;
943 else { /* ! IS_A_TT */
946 SCSI_DMA_SETADR( addr
);
948 /* toggle direction bit to clear FIFO and set DMA direction */
950 st_dma
.dma_mode_status
= 0x90 | dir
;
951 st_dma
.dma_mode_status
= 0x90 | (dir
^ 0x100);
952 st_dma
.dma_mode_status
= 0x90 | dir
;
954 /* On writes, round up the transfer length to the next multiple of 512
955 * (see also comment at atari_dma_xfer_len()). */
956 st_dma
.fdc_acces_seccount
= (count
+ (dir
? 511 : 0)) >> 9;
958 st_dma
.dma_mode_status
= 0x10 | dir
;
960 /* need not restore value of dir, only boolean value is tested */
961 atari_dma_active
= 1;
968 static long atari_scsi_dma_residual( struct Scsi_Host
*instance
)
970 return( atari_dma_residual
);
974 #define CMD_SURELY_BLOCK_MODE 0
975 #define CMD_SURELY_BYTE_MODE 1
976 #define CMD_MODE_UNKNOWN 2
978 static int falcon_classify_cmd( Scsi_Cmnd
*cmd
)
980 unsigned char opcode
= cmd
->cmnd
[0];
982 if (opcode
== READ_DEFECT_DATA
|| opcode
== READ_LONG
||
983 opcode
== READ_BUFFER
)
984 return( CMD_SURELY_BYTE_MODE
);
985 else if (opcode
== READ_6
|| opcode
== READ_10
||
986 opcode
== 0xa8 /* READ_12 */ || opcode
== READ_REVERSE
||
987 opcode
== RECOVER_BUFFERED_DATA
) {
988 /* In case of a sequential-access target (tape), special care is
989 * needed here: The transfer is block-mode only if the 'fixed' bit is
991 if (cmd
->device
->type
== TYPE_TAPE
&& !(cmd
->cmnd
[1] & 1))
992 return( CMD_SURELY_BYTE_MODE
);
994 return( CMD_SURELY_BLOCK_MODE
);
997 return( CMD_MODE_UNKNOWN
);
1001 /* This function calculates the number of bytes that can be transferred via
1002 * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
1003 * ST-DMA chip. There are only multiples of 512 bytes possible and max.
1004 * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
1005 * possible on the Falcon, since that would require to program the DMA for
1006 * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1007 * the overrun problem, so this question is academic :-)
1010 static unsigned long atari_dma_xfer_len( unsigned long wanted_len
,
1014 unsigned long possible_len
, limit
;
1015 #ifndef CONFIG_TT_DMA_EMUL
1017 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1021 /* TT SCSI DMA can transfer arbitrary #bytes */
1022 return( wanted_len
);
1024 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1025 * 255*512 bytes, but this should be enough)
1027 * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1028 * that return a number of bytes which cannot be known beforehand. In this
1029 * case, the given transfer length is an "allocation length". Now it
1030 * can happen that this allocation length is a multiple of 512 bytes and
1031 * the DMA is used. But if not n*512 bytes really arrive, some input data
1032 * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1033 * between commands that do block transfers and those that do byte
1034 * transfers. But this isn't easy... there are lots of vendor specific
1035 * commands, and the user can issue any command via the
1036 * SCSI_IOCTL_SEND_COMMAND.
1038 * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1039 * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1040 * and 3), the thing to do is obvious: allow any number of blocks via DMA
1041 * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1042 * the transfer (allocation) length is < 1024, hoping that no cmd. not
1043 * explicitly known as byte mode have such big allocation lengths...
1044 * BTW, all the discussion above applies only to reads. DMA writes are
1045 * unproblematic anyways, since the targets aborts the transfer after
1046 * receiving a sufficient number of bytes.
1048 * Another point: If the transfer is from/to an non-ST-RAM address, we
1049 * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1053 /* Write operation can always use the DMA, but the transfer size must
1054 * be rounded up to the next multiple of 512 (atari_dma_setup() does
1057 possible_len
= wanted_len
;
1060 /* Read operations: if the wanted transfer length is not a multiple of
1061 * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1062 * (no interrupt on DMA finished!)
1064 if (wanted_len
& 0x1ff)
1067 /* Now classify the command (see above) and decide whether it is
1068 * allowed to do DMA at all */
1069 switch( falcon_classify_cmd( cmd
)) {
1070 case CMD_SURELY_BLOCK_MODE
:
1071 possible_len
= wanted_len
;
1073 case CMD_SURELY_BYTE_MODE
:
1074 possible_len
= 0; /* DMA prohibited */
1076 case CMD_MODE_UNKNOWN
:
1078 /* For unknown commands assume block transfers if the transfer
1079 * size/allocation length is >= 1024 */
1080 possible_len
= (wanted_len
< 1024) ? 0 : wanted_len
;
1086 /* Last step: apply the hard limit on DMA transfers */
1087 limit
= (atari_dma_buffer
&& !STRAM_ADDR( virt_to_phys(cmd
->SCp
.ptr
) )) ?
1088 STRAM_BUFFER_SIZE
: 255*512;
1089 if (possible_len
> limit
)
1090 possible_len
= limit
;
1092 if (possible_len
!= wanted_len
)
1093 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1094 "instead of %ld\n", possible_len
, wanted_len
);
1096 return( possible_len
);
1100 #endif /* REAL_DMA */
1103 /* NCR5380 register access functions
1105 * There are separate functions for TT and Falcon, because the access
1106 * methods are quite different. The calling macros NCR5380_read and
1107 * NCR5380_write call these functions via function pointers.
1110 static unsigned char atari_scsi_tt_reg_read( unsigned char reg
)
1112 return( tt_scsi_regp
[reg
* 2] );
1115 static void atari_scsi_tt_reg_write( unsigned char reg
, unsigned char value
)
1117 tt_scsi_regp
[reg
* 2] = value
;
1120 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg
)
1122 dma_wd
.dma_mode_status
= (u_short
)(0x88 + reg
);
1123 return( (u_char
)dma_wd
.fdc_acces_seccount
);
1126 static void atari_scsi_falcon_reg_write( unsigned char reg
, unsigned char value
)
1128 dma_wd
.dma_mode_status
= (u_short
)(0x88 + reg
);
1129 dma_wd
.fdc_acces_seccount
= (u_short
)value
;
1133 #include "atari_NCR5380.c"
1135 static Scsi_Host_Template driver_template
= ATARI_SCSI
;
1136 #include "scsi_module.c"