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
, NULL
, "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
));
670 atari_scsi_host
= instance
;
671 /* Set irq to 0, to avoid that the mid-level code disables our interrupt
672 * during queue_command calls. This is completely unnecessary, and even
673 * worse causes bad problems on the Falcon, where the int is shared with
677 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
678 atari_scsi_reset_boot();
680 NCR5380_init (instance
, 0);
684 /* This int is actually "pseudo-slow", i.e. it acts like a slow
685 * interrupt after having cleared the pending flag for the DMA
687 request_irq(IRQ_TT_MFP_SCSI
, scsi_tt_intr
, IRQ_TYPE_SLOW
,
688 "SCSI NCR5380", scsi_tt_intr
);
689 tt_mfp
.active_edge
|= 0x80; /* SCSI int on L->H */
691 tt_scsi_dma
.dma_ctrl
= 0;
692 atari_dma_residual
= 0;
693 #endif /* REAL_DMA */
695 #ifdef CONFIG_TT_DMA_EMUL
697 request_irq(IRQ_AUTO_2
, hades_dma_emulator
,
698 IRQ_TYPE_PRIO
, "Hades DMA emulator",
702 if (MACH_IS_MEDUSA
|| MACH_IS_HADES
) {
703 /* While the read overruns (described by Drew Eckhardt in
704 * NCR5380.c) never happened on TTs, they do in fact on the Medusa
705 * (This was the cause why SCSI didn't work right for so long
706 * there.) Since handling the overruns slows down a bit, I turned
707 * the #ifdef's into a runtime condition.
709 * In principle it should be sufficient to do max. 1 byte with
710 * PIO, but there is another problem on the Medusa with the DMA
711 * rest data register. So 'atari_read_overruns' is currently set
712 * to 4 to avoid having transfers that aren't a multiple of 4. If
713 * the rest data bug is fixed, this can be lowered to 1.
715 atari_read_overruns
= 4;
720 else { /* ! IS_A_TT */
722 /* Nothing to do for the interrupt: the ST-DMA is initialized
723 * already by atari_init_INTS()
727 atari_dma_residual
= 0;
728 atari_dma_active
= 0;
729 atari_dma_stram_mask
= (ATARIHW_PRESENT(EXTD_DMA
) ? 0x00000000
734 printk(KERN_INFO
"scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
739 instance
->host_no
, instance
->hostt
->can_queue
,
740 instance
->hostt
->cmd_per_lun
,
741 instance
->hostt
->sg_tablesize
,
743 setup_use_tagged_queuing
? "yes" : "no",
745 instance
->hostt
->this_id
);
746 NCR5380_print_options (instance
);
754 int atari_scsi_release (struct Scsi_Host
*sh
)
757 free_irq(IRQ_TT_MFP_SCSI
, scsi_tt_intr
);
758 if (atari_dma_buffer
)
759 atari_stram_free (atari_dma_buffer
);
764 void __init
atari_scsi_setup(char *str
, int *ints
)
766 /* Format of atascsi parameter is:
767 * atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
768 * Defaults depend on TT or Falcon, hostid determined at run time.
769 * Negative values mean don't change.
773 printk( "atari_scsi_setup: no arguments!\n" );
779 /* no limits on this, just > 0 */
780 setup_can_queue
= ints
[1];
784 setup_cmd_per_lun
= ints
[2];
788 setup_sg_tablesize
= ints
[3];
789 /* Must be <= SG_ALL (255) */
790 if (setup_sg_tablesize
> SG_ALL
)
791 setup_sg_tablesize
= SG_ALL
;
795 /* Must be between 0 and 7 */
796 if (ints
[4] >= 0 && ints
[4] <= 7)
797 setup_hostid
= ints
[4];
798 else if (ints
[4] > 7)
799 printk( "atari_scsi_setup: invalid host ID %d !\n", ints
[4] );
804 setup_use_tagged_queuing
= !!ints
[5];
809 int atari_scsi_reset( Scsi_Cmnd
*cmd
, unsigned int reset_flags
)
812 struct NCR5380_hostdata
*hostdata
=
813 (struct NCR5380_hostdata
*)cmd
->host
->hostdata
;
815 /* For doing the reset, SCSI interrupts must be disabled first,
816 * since the 5380 raises its IRQ line while _RST is active and we
817 * can't disable interrupts completely, since we need the timer.
819 /* And abort a maybe active DMA transfer */
821 atari_turnoff_irq( IRQ_TT_MFP_SCSI
);
823 tt_scsi_dma
.dma_ctrl
= 0;
824 #endif /* REAL_DMA */
827 atari_turnoff_irq( IRQ_MFP_FSCSI
);
829 st_dma
.dma_mode_status
= 0x90;
830 atari_dma_active
= 0;
831 atari_dma_orig_addr
= NULL
;
832 #endif /* REAL_DMA */
835 rv
= NCR5380_reset(cmd
, reset_flags
);
839 atari_turnon_irq( IRQ_TT_MFP_SCSI
);
842 atari_turnon_irq( IRQ_MFP_FSCSI
);
844 if ((rv
& SCSI_RESET_ACTION
) == SCSI_RESET_SUCCESS
)
845 falcon_release_lock_if_possible(hostdata
);
851 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
852 static void __init
atari_scsi_reset_boot(void)
857 * Do a SCSI reset to clean up the bus during initialization. No messing
858 * with the queues, interrupts, or locks necessary here.
861 printk( "Atari SCSI: resetting the SCSI bus..." );
864 NCR5380_write( TARGET_COMMAND_REG
,
865 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG
) ));
868 NCR5380_write( INITIATOR_COMMAND_REG
, ICR_BASE
| ICR_ASSERT_RST
);
869 /* The min. reset hold time is 25us, so 40us should be enough */
871 /* reset RST and interrupt */
872 NCR5380_write( INITIATOR_COMMAND_REG
, ICR_BASE
);
873 NCR5380_read( RESET_PARITY_INTERRUPT_REG
);
875 end
= jiffies
+ AFTER_RESET_DELAY
;
876 while (time_before(jiffies
, end
))
884 const char * atari_scsi_info (struct Scsi_Host
*host
)
886 /* atari_scsi_detect() is verbose enough... */
887 static const char string
[] = "Atari native SCSI";
892 #if defined(REAL_DMA)
894 unsigned long atari_scsi_dma_setup( struct Scsi_Host
*instance
, void *data
,
895 unsigned long count
, int dir
)
897 unsigned long addr
= virt_to_phys( data
);
899 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
900 "dir = %d\n", instance
->host_no
, data
, addr
, count
, dir
);
902 if (!IS_A_TT() && !STRAM_ADDR(addr
)) {
903 /* If we have a non-DMAable address on a Falcon, use the dribble
904 * buffer; 'orig_addr' != 0 in the read case tells the interrupt
905 * handler to copy data from the dribble buffer to the originally
909 memcpy( atari_dma_buffer
, data
, count
);
911 atari_dma_orig_addr
= data
;
912 addr
= atari_dma_phys_buffer
;
915 atari_dma_startaddr
= addr
; /* Needed for calculating residual later. */
917 /* Cache cleanup stuff: On writes, push any dirty cache out before sending
918 * it to the peripheral. (Must be done before DMA setup, since at least
919 * the ST-DMA begins to fill internal buffers right after setup. For
920 * reads, invalidate any cache, may be altered after DMA without CPU
923 * ++roman: For the Medusa, there's no need at all for that cache stuff,
924 * because the hardware does bus snooping (fine!).
926 dma_cache_maintenance( addr
, count
, dir
);
929 printk(KERN_NOTICE
"SCSI warning: DMA programmed for 0 bytes !\n");
932 tt_scsi_dma
.dma_ctrl
= dir
;
933 SCSI_DMA_WRITE_P( dma_addr
, addr
);
934 SCSI_DMA_WRITE_P( dma_cnt
, count
);
935 tt_scsi_dma
.dma_ctrl
= dir
| 2;
937 else { /* ! IS_A_TT */
940 SCSI_DMA_SETADR( addr
);
942 /* toggle direction bit to clear FIFO and set DMA direction */
944 st_dma
.dma_mode_status
= 0x90 | dir
;
945 st_dma
.dma_mode_status
= 0x90 | (dir
^ 0x100);
946 st_dma
.dma_mode_status
= 0x90 | dir
;
948 /* On writes, round up the transfer length to the next multiple of 512
949 * (see also comment at atari_dma_xfer_len()). */
950 st_dma
.fdc_acces_seccount
= (count
+ (dir
? 511 : 0)) >> 9;
952 st_dma
.dma_mode_status
= 0x10 | dir
;
954 /* need not restore value of dir, only boolean value is tested */
955 atari_dma_active
= 1;
962 static long atari_scsi_dma_residual( struct Scsi_Host
*instance
)
964 return( atari_dma_residual
);
968 #define CMD_SURELY_BLOCK_MODE 0
969 #define CMD_SURELY_BYTE_MODE 1
970 #define CMD_MODE_UNKNOWN 2
972 static int falcon_classify_cmd( Scsi_Cmnd
*cmd
)
974 unsigned char opcode
= cmd
->cmnd
[0];
976 if (opcode
== READ_DEFECT_DATA
|| opcode
== READ_LONG
||
977 opcode
== READ_BUFFER
)
978 return( CMD_SURELY_BYTE_MODE
);
979 else if (opcode
== READ_6
|| opcode
== READ_10
||
980 opcode
== 0xa8 /* READ_12 */ || opcode
== READ_REVERSE
||
981 opcode
== RECOVER_BUFFERED_DATA
) {
982 /* In case of a sequential-access target (tape), special care is
983 * needed here: The transfer is block-mode only if the 'fixed' bit is
985 if (cmd
->device
->type
== TYPE_TAPE
&& !(cmd
->cmnd
[1] & 1))
986 return( CMD_SURELY_BYTE_MODE
);
988 return( CMD_SURELY_BLOCK_MODE
);
991 return( CMD_MODE_UNKNOWN
);
995 /* This function calculates the number of bytes that can be transferred via
996 * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
997 * ST-DMA chip. There are only multiples of 512 bytes possible and max.
998 * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
999 * possible on the Falcon, since that would require to program the DMA for
1000 * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1001 * the overrun problem, so this question is academic :-)
1004 static unsigned long atari_dma_xfer_len( unsigned long wanted_len
,
1008 unsigned long possible_len
, limit
;
1009 #ifndef CONFIG_TT_DMA_EMUL
1011 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1015 /* TT SCSI DMA can transfer arbitrary #bytes */
1016 return( wanted_len
);
1018 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1019 * 255*512 bytes, but this should be enough)
1021 * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1022 * that return a number of bytes which cannot be known beforehand. In this
1023 * case, the given transfer length is an "allocation length". Now it
1024 * can happen that this allocation length is a multiple of 512 bytes and
1025 * the DMA is used. But if not n*512 bytes really arrive, some input data
1026 * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1027 * between commands that do block transfers and those that do byte
1028 * transfers. But this isn't easy... there are lots of vendor specific
1029 * commands, and the user can issue any command via the
1030 * SCSI_IOCTL_SEND_COMMAND.
1032 * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1033 * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1034 * and 3), the thing to do is obvious: allow any number of blocks via DMA
1035 * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1036 * the transfer (allocation) length is < 1024, hoping that no cmd. not
1037 * explicitly known as byte mode have such big allocation lengths...
1038 * BTW, all the discussion above applies only to reads. DMA writes are
1039 * unproblematic anyways, since the targets aborts the transfer after
1040 * receiving a sufficient number of bytes.
1042 * Another point: If the transfer is from/to an non-ST-RAM address, we
1043 * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1047 /* Write operation can always use the DMA, but the transfer size must
1048 * be rounded up to the next multiple of 512 (atari_dma_setup() does
1051 possible_len
= wanted_len
;
1054 /* Read operations: if the wanted transfer length is not a multiple of
1055 * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1056 * (no interrupt on DMA finished!)
1058 if (wanted_len
& 0x1ff)
1061 /* Now classify the command (see above) and decide whether it is
1062 * allowed to do DMA at all */
1063 switch( falcon_classify_cmd( cmd
)) {
1064 case CMD_SURELY_BLOCK_MODE
:
1065 possible_len
= wanted_len
;
1067 case CMD_SURELY_BYTE_MODE
:
1068 possible_len
= 0; /* DMA prohibited */
1070 case CMD_MODE_UNKNOWN
:
1072 /* For unknown commands assume block transfers if the transfer
1073 * size/allocation length is >= 1024 */
1074 possible_len
= (wanted_len
< 1024) ? 0 : wanted_len
;
1080 /* Last step: apply the hard limit on DMA transfers */
1081 limit
= (atari_dma_buffer
&& !STRAM_ADDR( virt_to_phys(cmd
->SCp
.ptr
) )) ?
1082 STRAM_BUFFER_SIZE
: 255*512;
1083 if (possible_len
> limit
)
1084 possible_len
= limit
;
1086 if (possible_len
!= wanted_len
)
1087 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1088 "instead of %ld\n", possible_len
, wanted_len
);
1090 return( possible_len
);
1094 #endif /* REAL_DMA */
1097 /* NCR5380 register access functions
1099 * There are separate functions for TT and Falcon, because the access
1100 * methods are quite different. The calling macros NCR5380_read and
1101 * NCR5380_write call these functions via function pointers.
1104 static unsigned char atari_scsi_tt_reg_read( unsigned char reg
)
1106 return( tt_scsi_regp
[reg
* 2] );
1109 static void atari_scsi_tt_reg_write( unsigned char reg
, unsigned char value
)
1111 tt_scsi_regp
[reg
* 2] = value
;
1114 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg
)
1116 dma_wd
.dma_mode_status
= (u_short
)(0x88 + reg
);
1117 return( (u_char
)dma_wd
.fdc_acces_seccount
);
1120 static void atari_scsi_falcon_reg_write( unsigned char reg
, unsigned char value
)
1122 dma_wd
.dma_mode_status
= (u_short
)(0x88 + reg
);
1123 dma_wd
.fdc_acces_seccount
= (u_short
)value
;
1127 #include "atari_NCR5380.c"
1130 Scsi_Host_Template driver_template
= ATARI_SCSI
;
1132 #include "scsi_module.c"