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/module.h>
72 #define NDEBUG_ABORT 0x800000
73 #define NDEBUG_TAGS 0x1000000
74 #define NDEBUG_MERGING 0x2000000
77 /* For the Atari version, use only polled IO or REAL_DMA */
79 /* Support tagged queuing? (on devices that are able to... :-) */
83 #include <linux/types.h>
84 #include <linux/stddef.h>
85 #include <linux/ctype.h>
86 #include <linux/delay.h>
88 #include <linux/blkdev.h>
89 #include <linux/sched.h>
90 #include <linux/interrupt.h>
91 #include <linux/init.h>
92 #include <linux/nvram.h>
93 #include <linux/bitops.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>
104 #include <scsi/scsi_host.h>
105 #include "atari_scsi.h"
107 #include <asm/atari_stdma.h>
108 #include <asm/atari_stram.h>
111 #include <linux/stat.h>
113 #define IS_A_TT() ATARIHW_PRESENT(TT_SCSI)
115 #define SCSI_DMA_WRITE_P(elt,val) \
117 unsigned long v = val; \
118 tt_scsi_dma.elt##_lo = v & 0xff; \
120 tt_scsi_dma.elt##_lmd = v & 0xff; \
122 tt_scsi_dma.elt##_hmd = v & 0xff; \
124 tt_scsi_dma.elt##_hi = v & 0xff; \
127 #define SCSI_DMA_READ_P(elt) \
128 (((((((unsigned long)tt_scsi_dma.elt##_hi << 8) | \
129 (unsigned long)tt_scsi_dma.elt##_hmd) << 8) | \
130 (unsigned long)tt_scsi_dma.elt##_lmd) << 8) | \
131 (unsigned long)tt_scsi_dma.elt##_lo)
134 static inline void SCSI_DMA_SETADR(unsigned long adr
)
136 st_dma
.dma_lo
= (unsigned char)adr
;
139 st_dma
.dma_md
= (unsigned char)adr
;
142 st_dma
.dma_hi
= (unsigned char)adr
;
146 static inline unsigned long SCSI_DMA_GETADR(void)
151 adr
|= (st_dma
.dma_md
& 0xff) << 8;
153 adr
|= (st_dma
.dma_hi
& 0xff) << 16;
158 static inline void ENABLE_IRQ(void)
161 atari_enable_irq(IRQ_TT_MFP_SCSI
);
163 atari_enable_irq(IRQ_MFP_FSCSI
);
166 static inline void DISABLE_IRQ(void)
169 atari_disable_irq(IRQ_TT_MFP_SCSI
);
171 atari_disable_irq(IRQ_MFP_FSCSI
);
175 #define HOSTDATA_DMALEN (((struct NCR5380_hostdata *) \
176 (atari_scsi_host->hostdata))->dma_len)
178 /* Time (in jiffies) to wait after a reset; the SCSI standard calls for 250ms,
179 * we usually do 0.5s to be on the safe side. But Toshiba CD-ROMs once more
180 * need ten times the standard value... */
181 #ifndef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
182 #define AFTER_RESET_DELAY (HZ/2)
184 #define AFTER_RESET_DELAY (5*HZ/2)
187 /***************************** Prototypes *****************************/
190 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat
);
191 static void atari_scsi_fetch_restbytes( void );
192 static long atari_scsi_dma_residual( struct Scsi_Host
*instance
);
193 static int falcon_classify_cmd( Scsi_Cmnd
*cmd
);
194 static unsigned long atari_dma_xfer_len( unsigned long wanted_len
,
195 Scsi_Cmnd
*cmd
, int write_flag
);
197 static irqreturn_t
scsi_tt_intr( int irq
, void *dummy
, struct pt_regs
*fp
);
198 static irqreturn_t
scsi_falcon_intr( int irq
, void *dummy
, struct pt_regs
*fp
);
199 static void falcon_release_lock_if_possible( struct NCR5380_hostdata
*
201 static void falcon_get_lock( void );
202 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
203 static void atari_scsi_reset_boot( void );
205 static unsigned char atari_scsi_tt_reg_read( unsigned char reg
);
206 static void atari_scsi_tt_reg_write( unsigned char reg
, unsigned char value
);
207 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg
);
208 static void atari_scsi_falcon_reg_write( unsigned char reg
, unsigned char value
);
210 /************************* End of Prototypes **************************/
213 static struct Scsi_Host
*atari_scsi_host
= NULL
;
214 static unsigned char (*atari_scsi_reg_read
)( unsigned char reg
);
215 static void (*atari_scsi_reg_write
)( unsigned char reg
, unsigned char value
);
218 static unsigned long atari_dma_residual
, atari_dma_startaddr
;
219 static short atari_dma_active
;
220 /* pointer to the dribble buffer */
221 static char *atari_dma_buffer
= NULL
;
222 /* precalculated physical address of the dribble buffer */
223 static unsigned long atari_dma_phys_buffer
;
224 /* != 0 tells the Falcon int handler to copy data from the dribble buffer */
225 static char *atari_dma_orig_addr
;
226 /* size of the dribble buffer; 4k seems enough, since the Falcon cannot use
227 * scatter-gather anyway, so most transfers are 1024 byte only. In the rare
228 * cases where requests to physical contiguous buffers have been merged, this
229 * request is <= 4k (one page). So I don't think we have to split transfers
230 * just due to this buffer size...
232 #define STRAM_BUFFER_SIZE (4096)
233 /* mask for address bits that can't be used with the ST-DMA */
234 static unsigned long atari_dma_stram_mask
;
235 #define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0)
236 /* number of bytes to cut from a transfer to handle NCR overruns */
237 static int atari_read_overruns
= 0;
240 static int setup_can_queue
= -1;
241 module_param(setup_can_queue
, int, 0);
242 static int setup_cmd_per_lun
= -1;
243 module_param(setup_cmd_per_lun
, int, 0);
244 static int setup_sg_tablesize
= -1;
245 module_param(setup_sg_tablesize
, int, 0);
247 static int setup_use_tagged_queuing
= -1;
248 module_param(setup_use_tagged_queuing
, int, 0);
250 static int setup_hostid
= -1;
251 module_param(setup_hostid
, int, 0);
254 #if defined(CONFIG_TT_DMA_EMUL)
255 #include "atari_dma_emul.c"
258 #if defined(REAL_DMA)
260 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat
)
263 unsigned long addr
= SCSI_DMA_READ_P( dma_addr
), end_addr
;
265 if (dma_stat
& 0x01) {
267 /* A bus error happens when DMA-ing from the last page of a
268 * physical memory chunk (DMA prefetch!), but that doesn't hurt.
269 * Check for this case:
272 for( i
= 0; i
< m68k_num_memory
; ++i
) {
273 end_addr
= m68k_memory
[i
].addr
+
275 if (end_addr
<= addr
&& addr
<= end_addr
+ 4)
284 /* Dead code... wasn't called anyway :-) and causes some trouble, because at
285 * end-of-DMA, both SCSI ints are triggered simultaneously, so the NCR int has
286 * to clear the DMA int pending bit before it allows other level 6 interrupts.
288 static void scsi_dma_buserr (int irq
, void *dummy
, struct pt_regs
*fp
)
290 unsigned char dma_stat
= tt_scsi_dma
.dma_ctrl
;
292 /* Don't do anything if a NCR interrupt is pending. Probably it's just
294 if (atari_irq_pending( IRQ_TT_MFP_SCSI
))
297 printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
298 SCSI_DMA_READ_P(dma_addr
), dma_stat
, SCSI_DMA_READ_P(dma_cnt
));
299 if (dma_stat
& 0x80) {
300 if (!scsi_dma_is_ignored_buserr( dma_stat
))
301 printk( "SCSI DMA bus error -- bad DMA programming!\n" );
304 /* Under normal circumstances we never should get to this point,
305 * since both interrupts are triggered simultaneously and the 5380
306 * int has higher priority. When this irq is handled, that DMA
307 * interrupt is cleared. So a warning message is printed here.
309 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
317 static irqreturn_t
scsi_tt_intr (int irq
, void *dummy
, struct pt_regs
*fp
)
322 dma_stat
= tt_scsi_dma
.dma_ctrl
;
324 INT_PRINTK("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
325 atari_scsi_host
->host_no
, dma_stat
& 0xff);
327 /* Look if it was the DMA that has interrupted: First possibility
328 * is that a bus error occurred...
330 if (dma_stat
& 0x80) {
331 if (!scsi_dma_is_ignored_buserr( dma_stat
)) {
332 printk(KERN_ERR
"SCSI DMA caused bus error near 0x%08lx\n",
333 SCSI_DMA_READ_P(dma_addr
));
334 printk(KERN_CRIT
"SCSI DMA bus error -- bad DMA programming!");
338 /* If the DMA is active but not finished, we have the case
339 * that some other 5380 interrupt occurred within the DMA transfer.
340 * This means we have residual bytes, if the desired end address
341 * is not yet reached. Maybe we have to fetch some bytes from the
342 * rest data register, too. The residual must be calculated from
343 * the address pointer, not the counter register, because only the
344 * addr reg counts bytes not yet written and pending in the rest
347 if ((dma_stat
& 0x02) && !(dma_stat
& 0x40)) {
348 atari_dma_residual
= HOSTDATA_DMALEN
- (SCSI_DMA_READ_P( dma_addr
) -
349 atari_dma_startaddr
);
351 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
354 if ((signed int)atari_dma_residual
< 0)
355 atari_dma_residual
= 0;
356 if ((dma_stat
& 1) == 0) {
357 /* After read operations, we maybe have to
358 transport some rest bytes */
359 atari_scsi_fetch_restbytes();
362 /* There seems to be a nasty bug in some SCSI-DMA/NCR
363 combinations: If a target disconnects while a write
364 operation is going on, the address register of the
365 DMA may be a few bytes farer than it actually read.
366 This is probably due to DMA prefetching and a delay
367 between DMA and NCR. Experiments showed that the
368 dma_addr is 9 bytes to high, but this could vary.
369 The problem is, that the residual is thus calculated
370 wrong and the next transfer will start behind where
371 it should. So we round up the residual to the next
372 multiple of a sector size, if it isn't already a
373 multiple and the originally expected transfer size
374 was. The latter condition is there to ensure that
375 the correction is taken only for "real" data
376 transfers and not for, e.g., the parameters of some
377 other command. These shouldn't disconnect anyway.
379 if (atari_dma_residual
& 0x1ff) {
380 DMA_PRINTK("SCSI DMA: DMA bug corrected, "
381 "difference %ld bytes\n",
382 512 - (atari_dma_residual
& 0x1ff));
383 atari_dma_residual
= (atari_dma_residual
+ 511) & ~0x1ff;
386 tt_scsi_dma
.dma_ctrl
= 0;
389 /* If the DMA is finished, fetch the rest bytes and turn it off */
390 if (dma_stat
& 0x40) {
391 atari_dma_residual
= 0;
392 if ((dma_stat
& 1) == 0)
393 atari_scsi_fetch_restbytes();
394 tt_scsi_dma
.dma_ctrl
= 0;
397 #endif /* REAL_DMA */
399 NCR5380_intr (0, 0, 0);
402 /* To be sure the int is not masked */
403 atari_enable_irq( IRQ_TT_MFP_SCSI
);
409 static irqreturn_t
scsi_falcon_intr (int irq
, void *dummy
, struct pt_regs
*fp
)
414 /* Turn off DMA and select sector counter register before
415 * accessing the status register (Atari recommendation!)
417 st_dma
.dma_mode_status
= 0x90;
418 dma_stat
= st_dma
.dma_mode_status
;
420 /* Bit 0 indicates some error in the DMA process... don't know
421 * what happened exactly (no further docu).
423 if (!(dma_stat
& 0x01)) {
425 printk(KERN_CRIT
"SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR());
428 /* If the DMA was active, but now bit 1 is not clear, it is some
429 * other 5380 interrupt that finishes the DMA transfer. We have to
430 * calculate the number of residual bytes and give a warning if
431 * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
433 if (atari_dma_active
&& (dma_stat
& 0x02)) {
434 unsigned long transferred
;
436 transferred
= SCSI_DMA_GETADR() - atari_dma_startaddr
;
437 /* The ST-DMA address is incremented in 2-byte steps, but the
438 * data are written only in 16-byte chunks. If the number of
439 * transferred bytes is not divisible by 16, the remainder is
440 * lost somewhere in outer space.
442 if (transferred
& 15)
443 printk(KERN_ERR
"SCSI DMA error: %ld bytes lost in "
444 "ST-DMA fifo\n", transferred
& 15);
446 atari_dma_residual
= HOSTDATA_DMALEN
- transferred
;
447 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
451 atari_dma_residual
= 0;
452 atari_dma_active
= 0;
454 if (atari_dma_orig_addr
) {
455 /* If the dribble buffer was used on a read operation, copy the DMA-ed
456 * data to the original destination address.
458 memcpy(atari_dma_orig_addr
, phys_to_virt(atari_dma_startaddr
),
459 HOSTDATA_DMALEN
- atari_dma_residual
);
460 atari_dma_orig_addr
= NULL
;
463 #endif /* REAL_DMA */
465 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
)
514 if (IS_A_TT()) return;
516 local_irq_save(flags
);
518 if (falcon_got_lock
&&
519 !hostdata
->disconnected_queue
&&
520 !hostdata
->issue_queue
&&
521 !hostdata
->connected
) {
523 if (falcon_dont_release
) {
525 printk("WARNING: Lock release not allowed. Ignored\n");
527 local_irq_restore(flags
);
532 wake_up( &falcon_fairness_wait
);
535 local_irq_restore(flags
);
538 /* This function manages the locking of the ST-DMA.
539 * If the DMA isn't locked already for SCSI, it tries to lock it by
540 * calling stdma_lock(). But if the DMA is locked by the SCSI code and
541 * there are other drivers waiting for the chip, we do not issue the
542 * command immediately but wait on 'falcon_fairness_queue'. We will be
543 * waked up when the DMA is unlocked by some SCSI interrupt. After that
544 * we try to get the lock again.
545 * But we must be prepared that more than one instance of
546 * falcon_get_lock() is waiting on the fairness queue. They should not
547 * try all at once to call stdma_lock(), one is enough! For that, the
548 * first one sets 'falcon_trying_lock', others that see that variable
549 * set wait on the queue 'falcon_try_wait'.
550 * Complicated, complicated.... Sigh...
553 static void falcon_get_lock( void )
557 if (IS_A_TT()) return;
559 local_irq_save(flags
);
561 while( !in_interrupt() && falcon_got_lock
&& stdma_others_waiting() )
562 sleep_on( &falcon_fairness_wait
);
564 while (!falcon_got_lock
) {
566 panic( "Falcon SCSI hasn't ST-DMA lock in interrupt" );
567 if (!falcon_trying_lock
) {
568 falcon_trying_lock
= 1;
569 stdma_lock(scsi_falcon_intr
, NULL
);
571 falcon_trying_lock
= 0;
572 wake_up( &falcon_try_wait
);
575 sleep_on( &falcon_try_wait
);
579 local_irq_restore(flags
);
580 if (!falcon_got_lock
)
581 panic("Falcon SCSI: someone stole the lock :-(\n");
585 /* This is the wrapper function for NCR5380_queue_command(). It just
586 * tries to get the lock on the ST-DMA (see above) and then calls the
591 int atari_queue_command (Scsi_Cmnd
*cmd
, void (*done
)(Scsi_Cmnd
*))
593 /* falcon_get_lock();
594 * ++guenther: moved to NCR5380_queue_command() to prevent
595 * race condition, see there for an explanation.
597 return( NCR5380_queue_command( cmd
, done
) );
602 int atari_scsi_detect (struct scsi_host_template
*host
)
604 static int called
= 0;
605 struct Scsi_Host
*instance
;
607 if (!MACH_IS_ATARI
||
608 (!ATARIHW_PRESENT(ST_SCSI
) && !ATARIHW_PRESENT(TT_SCSI
)) ||
612 host
->proc_name
= "Atari";
614 atari_scsi_reg_read
= IS_A_TT() ? atari_scsi_tt_reg_read
:
615 atari_scsi_falcon_reg_read
;
616 atari_scsi_reg_write
= IS_A_TT() ? atari_scsi_tt_reg_write
:
617 atari_scsi_falcon_reg_write
;
619 /* setup variables */
621 (setup_can_queue
> 0) ? setup_can_queue
:
622 IS_A_TT() ? ATARI_TT_CAN_QUEUE
: ATARI_FALCON_CAN_QUEUE
;
624 (setup_cmd_per_lun
> 0) ? setup_cmd_per_lun
:
625 IS_A_TT() ? ATARI_TT_CMD_PER_LUN
: ATARI_FALCON_CMD_PER_LUN
;
626 /* Force sg_tablesize to 0 on a Falcon! */
628 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE
:
629 (setup_sg_tablesize
>= 0) ? setup_sg_tablesize
: ATARI_TT_SG_TABLESIZE
;
631 if (setup_hostid
>= 0)
632 host
->this_id
= setup_hostid
;
634 /* use 7 as default */
636 /* Test if a host id is set in the NVRam */
637 if (ATARIHW_PRESENT(TT_CLK
) && nvram_check_checksum()) {
638 unsigned char b
= nvram_read_byte( 14 );
639 /* Arbitration enabled? (for TOS) If yes, use configured host ID */
641 host
->this_id
= b
& 7;
646 if (setup_use_tagged_queuing
< 0)
647 setup_use_tagged_queuing
= DEFAULT_USE_TAGGED_QUEUING
;
650 /* If running on a Falcon and if there's TT-Ram (i.e., more than one
651 * memory block, since there's always ST-Ram in a Falcon), then allocate a
652 * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative
655 if (MACH_IS_ATARI
&& ATARIHW_PRESENT(ST_SCSI
) &&
656 !ATARIHW_PRESENT(EXTD_DMA
) && m68k_num_memory
> 1) {
657 atari_dma_buffer
= atari_stram_alloc(STRAM_BUFFER_SIZE
, "SCSI");
658 if (!atari_dma_buffer
) {
659 printk( KERN_ERR
"atari_scsi_detect: can't allocate ST-RAM "
663 atari_dma_phys_buffer
= virt_to_phys( atari_dma_buffer
);
664 atari_dma_orig_addr
= 0;
667 instance
= scsi_register (host
, sizeof (struct NCR5380_hostdata
));
670 atari_stram_free(atari_dma_buffer
);
671 atari_dma_buffer
= 0;
674 atari_scsi_host
= instance
;
675 /* Set irq to 0, to avoid that the mid-level code disables our interrupt
676 * during queue_command calls. This is completely unnecessary, and even
677 * worse causes bad problems on the Falcon, where the int is shared with
681 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
682 atari_scsi_reset_boot();
684 NCR5380_init (instance
, 0);
688 /* This int is actually "pseudo-slow", i.e. it acts like a slow
689 * interrupt after having cleared the pending flag for the DMA
691 if (request_irq(IRQ_TT_MFP_SCSI
, scsi_tt_intr
, IRQ_TYPE_SLOW
,
692 "SCSI NCR5380", scsi_tt_intr
)) {
693 printk(KERN_ERR
"atari_scsi_detect: cannot allocate irq %d, aborting",IRQ_TT_MFP_SCSI
);
694 scsi_unregister(atari_scsi_host
);
695 atari_stram_free(atari_dma_buffer
);
696 atari_dma_buffer
= 0;
699 tt_mfp
.active_edge
|= 0x80; /* SCSI int on L->H */
701 tt_scsi_dma
.dma_ctrl
= 0;
702 atari_dma_residual
= 0;
703 #ifdef CONFIG_TT_DMA_EMUL
705 if (request_irq(IRQ_AUTO_2
, hades_dma_emulator
,
706 IRQ_TYPE_PRIO
, "Hades DMA emulator",
707 hades_dma_emulator
)) {
708 printk(KERN_ERR
"atari_scsi_detect: cannot allocate irq %d, aborting (MACH_IS_HADES)",IRQ_AUTO_2
);
709 free_irq(IRQ_TT_MFP_SCSI
, scsi_tt_intr
);
710 scsi_unregister(atari_scsi_host
);
711 atari_stram_free(atari_dma_buffer
);
712 atari_dma_buffer
= 0;
717 if (MACH_IS_MEDUSA
|| MACH_IS_HADES
) {
718 /* While the read overruns (described by Drew Eckhardt in
719 * NCR5380.c) never happened on TTs, they do in fact on the Medusa
720 * (This was the cause why SCSI didn't work right for so long
721 * there.) Since handling the overruns slows down a bit, I turned
722 * the #ifdef's into a runtime condition.
724 * In principle it should be sufficient to do max. 1 byte with
725 * PIO, but there is another problem on the Medusa with the DMA
726 * rest data register. So 'atari_read_overruns' is currently set
727 * to 4 to avoid having transfers that aren't a multiple of 4. If
728 * the rest data bug is fixed, this can be lowered to 1.
730 atari_read_overruns
= 4;
734 else { /* ! IS_A_TT */
736 /* Nothing to do for the interrupt: the ST-DMA is initialized
737 * already by atari_init_INTS()
741 atari_dma_residual
= 0;
742 atari_dma_active
= 0;
743 atari_dma_stram_mask
= (ATARIHW_PRESENT(EXTD_DMA
) ? 0x00000000
748 printk(KERN_INFO
"scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
753 instance
->host_no
, instance
->hostt
->can_queue
,
754 instance
->hostt
->cmd_per_lun
,
755 instance
->hostt
->sg_tablesize
,
757 setup_use_tagged_queuing
? "yes" : "no",
759 instance
->hostt
->this_id
);
760 NCR5380_print_options (instance
);
768 int atari_scsi_release (struct Scsi_Host
*sh
)
771 free_irq(IRQ_TT_MFP_SCSI
, scsi_tt_intr
);
772 if (atari_dma_buffer
)
773 atari_stram_free (atari_dma_buffer
);
778 void __init
atari_scsi_setup(char *str
, int *ints
)
780 /* Format of atascsi parameter is:
781 * atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
782 * Defaults depend on TT or Falcon, hostid determined at run time.
783 * Negative values mean don't change.
787 printk( "atari_scsi_setup: no arguments!\n" );
793 /* no limits on this, just > 0 */
794 setup_can_queue
= ints
[1];
798 setup_cmd_per_lun
= ints
[2];
802 setup_sg_tablesize
= ints
[3];
803 /* Must be <= SG_ALL (255) */
804 if (setup_sg_tablesize
> SG_ALL
)
805 setup_sg_tablesize
= SG_ALL
;
809 /* Must be between 0 and 7 */
810 if (ints
[4] >= 0 && ints
[4] <= 7)
811 setup_hostid
= ints
[4];
812 else if (ints
[4] > 7)
813 printk( "atari_scsi_setup: invalid host ID %d !\n", ints
[4] );
818 setup_use_tagged_queuing
= !!ints
[5];
823 int atari_scsi_bus_reset(Scsi_Cmnd
*cmd
)
826 struct NCR5380_hostdata
*hostdata
=
827 (struct NCR5380_hostdata
*)cmd
->device
->host
->hostdata
;
829 /* For doing the reset, SCSI interrupts must be disabled first,
830 * since the 5380 raises its IRQ line while _RST is active and we
831 * can't disable interrupts completely, since we need the timer.
833 /* And abort a maybe active DMA transfer */
835 atari_turnoff_irq( IRQ_TT_MFP_SCSI
);
837 tt_scsi_dma
.dma_ctrl
= 0;
838 #endif /* REAL_DMA */
841 atari_turnoff_irq( IRQ_MFP_FSCSI
);
843 st_dma
.dma_mode_status
= 0x90;
844 atari_dma_active
= 0;
845 atari_dma_orig_addr
= NULL
;
846 #endif /* REAL_DMA */
849 rv
= NCR5380_bus_reset(cmd
);
853 atari_turnon_irq( IRQ_TT_MFP_SCSI
);
856 atari_turnon_irq( IRQ_MFP_FSCSI
);
858 if ((rv
& SCSI_RESET_ACTION
) == SCSI_RESET_SUCCESS
)
859 falcon_release_lock_if_possible(hostdata
);
865 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
866 static void __init
atari_scsi_reset_boot(void)
871 * Do a SCSI reset to clean up the bus during initialization. No messing
872 * with the queues, interrupts, or locks necessary here.
875 printk( "Atari SCSI: resetting the SCSI bus..." );
878 NCR5380_write( TARGET_COMMAND_REG
,
879 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG
) ));
882 NCR5380_write( INITIATOR_COMMAND_REG
, ICR_BASE
| ICR_ASSERT_RST
);
883 /* The min. reset hold time is 25us, so 40us should be enough */
885 /* reset RST and interrupt */
886 NCR5380_write( INITIATOR_COMMAND_REG
, ICR_BASE
);
887 NCR5380_read( RESET_PARITY_INTERRUPT_REG
);
889 end
= jiffies
+ AFTER_RESET_DELAY
;
890 while (time_before(jiffies
, end
))
898 const char * atari_scsi_info (struct Scsi_Host
*host
)
900 /* atari_scsi_detect() is verbose enough... */
901 static const char string
[] = "Atari native SCSI";
906 #if defined(REAL_DMA)
908 unsigned long atari_scsi_dma_setup( struct Scsi_Host
*instance
, void *data
,
909 unsigned long count
, int dir
)
911 unsigned long addr
= virt_to_phys( data
);
913 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
914 "dir = %d\n", instance
->host_no
, data
, addr
, count
, dir
);
916 if (!IS_A_TT() && !STRAM_ADDR(addr
)) {
917 /* If we have a non-DMAable address on a Falcon, use the dribble
918 * buffer; 'orig_addr' != 0 in the read case tells the interrupt
919 * handler to copy data from the dribble buffer to the originally
923 memcpy( atari_dma_buffer
, data
, count
);
925 atari_dma_orig_addr
= data
;
926 addr
= atari_dma_phys_buffer
;
929 atari_dma_startaddr
= addr
; /* Needed for calculating residual later. */
931 /* Cache cleanup stuff: On writes, push any dirty cache out before sending
932 * it to the peripheral. (Must be done before DMA setup, since at least
933 * the ST-DMA begins to fill internal buffers right after setup. For
934 * reads, invalidate any cache, may be altered after DMA without CPU
937 * ++roman: For the Medusa, there's no need at all for that cache stuff,
938 * because the hardware does bus snooping (fine!).
940 dma_cache_maintenance( addr
, count
, dir
);
943 printk(KERN_NOTICE
"SCSI warning: DMA programmed for 0 bytes !\n");
946 tt_scsi_dma
.dma_ctrl
= dir
;
947 SCSI_DMA_WRITE_P( dma_addr
, addr
);
948 SCSI_DMA_WRITE_P( dma_cnt
, count
);
949 tt_scsi_dma
.dma_ctrl
= dir
| 2;
951 else { /* ! IS_A_TT */
954 SCSI_DMA_SETADR( addr
);
956 /* toggle direction bit to clear FIFO and set DMA direction */
958 st_dma
.dma_mode_status
= 0x90 | dir
;
959 st_dma
.dma_mode_status
= 0x90 | (dir
^ 0x100);
960 st_dma
.dma_mode_status
= 0x90 | dir
;
962 /* On writes, round up the transfer length to the next multiple of 512
963 * (see also comment at atari_dma_xfer_len()). */
964 st_dma
.fdc_acces_seccount
= (count
+ (dir
? 511 : 0)) >> 9;
966 st_dma
.dma_mode_status
= 0x10 | dir
;
968 /* need not restore value of dir, only boolean value is tested */
969 atari_dma_active
= 1;
976 static long atari_scsi_dma_residual( struct Scsi_Host
*instance
)
978 return( atari_dma_residual
);
982 #define CMD_SURELY_BLOCK_MODE 0
983 #define CMD_SURELY_BYTE_MODE 1
984 #define CMD_MODE_UNKNOWN 2
986 static int falcon_classify_cmd( Scsi_Cmnd
*cmd
)
988 unsigned char opcode
= cmd
->cmnd
[0];
990 if (opcode
== READ_DEFECT_DATA
|| opcode
== READ_LONG
||
991 opcode
== READ_BUFFER
)
992 return( CMD_SURELY_BYTE_MODE
);
993 else if (opcode
== READ_6
|| opcode
== READ_10
||
994 opcode
== 0xa8 /* READ_12 */ || opcode
== READ_REVERSE
||
995 opcode
== RECOVER_BUFFERED_DATA
) {
996 /* In case of a sequential-access target (tape), special care is
997 * needed here: The transfer is block-mode only if the 'fixed' bit is
999 if (cmd
->device
->type
== TYPE_TAPE
&& !(cmd
->cmnd
[1] & 1))
1000 return( CMD_SURELY_BYTE_MODE
);
1002 return( CMD_SURELY_BLOCK_MODE
);
1005 return( CMD_MODE_UNKNOWN
);
1009 /* This function calculates the number of bytes that can be transferred via
1010 * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
1011 * ST-DMA chip. There are only multiples of 512 bytes possible and max.
1012 * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
1013 * possible on the Falcon, since that would require to program the DMA for
1014 * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1015 * the overrun problem, so this question is academic :-)
1018 static unsigned long atari_dma_xfer_len( unsigned long wanted_len
,
1022 unsigned long possible_len
, limit
;
1023 #ifndef CONFIG_TT_DMA_EMUL
1025 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1029 /* TT SCSI DMA can transfer arbitrary #bytes */
1030 return( wanted_len
);
1032 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1033 * 255*512 bytes, but this should be enough)
1035 * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1036 * that return a number of bytes which cannot be known beforehand. In this
1037 * case, the given transfer length is an "allocation length". Now it
1038 * can happen that this allocation length is a multiple of 512 bytes and
1039 * the DMA is used. But if not n*512 bytes really arrive, some input data
1040 * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1041 * between commands that do block transfers and those that do byte
1042 * transfers. But this isn't easy... there are lots of vendor specific
1043 * commands, and the user can issue any command via the
1044 * SCSI_IOCTL_SEND_COMMAND.
1046 * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1047 * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1048 * and 3), the thing to do is obvious: allow any number of blocks via DMA
1049 * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1050 * the transfer (allocation) length is < 1024, hoping that no cmd. not
1051 * explicitly known as byte mode have such big allocation lengths...
1052 * BTW, all the discussion above applies only to reads. DMA writes are
1053 * unproblematic anyways, since the targets aborts the transfer after
1054 * receiving a sufficient number of bytes.
1056 * Another point: If the transfer is from/to an non-ST-RAM address, we
1057 * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1061 /* Write operation can always use the DMA, but the transfer size must
1062 * be rounded up to the next multiple of 512 (atari_dma_setup() does
1065 possible_len
= wanted_len
;
1068 /* Read operations: if the wanted transfer length is not a multiple of
1069 * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1070 * (no interrupt on DMA finished!)
1072 if (wanted_len
& 0x1ff)
1075 /* Now classify the command (see above) and decide whether it is
1076 * allowed to do DMA at all */
1077 switch( falcon_classify_cmd( cmd
)) {
1078 case CMD_SURELY_BLOCK_MODE
:
1079 possible_len
= wanted_len
;
1081 case CMD_SURELY_BYTE_MODE
:
1082 possible_len
= 0; /* DMA prohibited */
1084 case CMD_MODE_UNKNOWN
:
1086 /* For unknown commands assume block transfers if the transfer
1087 * size/allocation length is >= 1024 */
1088 possible_len
= (wanted_len
< 1024) ? 0 : wanted_len
;
1094 /* Last step: apply the hard limit on DMA transfers */
1095 limit
= (atari_dma_buffer
&& !STRAM_ADDR( virt_to_phys(cmd
->SCp
.ptr
) )) ?
1096 STRAM_BUFFER_SIZE
: 255*512;
1097 if (possible_len
> limit
)
1098 possible_len
= limit
;
1100 if (possible_len
!= wanted_len
)
1101 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1102 "instead of %ld\n", possible_len
, wanted_len
);
1104 return( possible_len
);
1108 #endif /* REAL_DMA */
1111 /* NCR5380 register access functions
1113 * There are separate functions for TT and Falcon, because the access
1114 * methods are quite different. The calling macros NCR5380_read and
1115 * NCR5380_write call these functions via function pointers.
1118 static unsigned char atari_scsi_tt_reg_read( unsigned char reg
)
1120 return( tt_scsi_regp
[reg
* 2] );
1123 static void atari_scsi_tt_reg_write( unsigned char reg
, unsigned char value
)
1125 tt_scsi_regp
[reg
* 2] = value
;
1128 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg
)
1130 dma_wd
.dma_mode_status
= (u_short
)(0x88 + reg
);
1131 return( (u_char
)dma_wd
.fdc_acces_seccount
);
1134 static void atari_scsi_falcon_reg_write( unsigned char reg
, unsigned char value
)
1136 dma_wd
.dma_mode_status
= (u_short
)(0x88 + reg
);
1137 dma_wd
.fdc_acces_seccount
= (u_short
)value
;
1141 #include "atari_NCR5380.c"
1143 static struct scsi_host_template driver_template
= {
1144 .proc_info
= atari_scsi_proc_info
,
1145 .name
= "Atari native SCSI",
1146 .detect
= atari_scsi_detect
,
1147 .release
= atari_scsi_release
,
1148 .info
= atari_scsi_info
,
1149 .queuecommand
= atari_scsi_queue_command
,
1150 .eh_abort_handler
= atari_scsi_abort
,
1151 .eh_bus_reset_handler
= atari_scsi_bus_reset
,
1152 .can_queue
= 0, /* initialized at run-time */
1153 .this_id
= 0, /* initialized at run-time */
1154 .sg_tablesize
= 0, /* initialized at run-time */
1155 .cmd_per_lun
= 0, /* initialized at run-time */
1156 .use_clustering
= DISABLE_CLUSTERING
1160 #include "scsi_module.c"
1162 MODULE_LICENSE("GPL");