blob: dfb1bcfae82ebe834812e3dd8738b227110fc8c9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * atari_scsi.c -- Device dependent functions for the Atari generic SCSI port
3 *
4 * Copyright 1994 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
5 *
6 * Loosely based on the work of Robert De Vries' team and added:
7 * - working real DMA
8 * - Falcon support (untested yet!) ++bjoern fixed and now it works
9 * - lots of extensions and bug fixes.
10 *
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
13 * for more details.
14 *
15 */
16
17
18/**************************************************************************/
19/* */
20/* Notes for Falcon SCSI: */
21/* ---------------------- */
22/* */
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. */
30/* */
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 */
36/* empty. */
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. */
41/* */
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! */
63/* */
64/**************************************************************************/
65
66
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/module.h>
69
70#define NDEBUG (0)
71
72#define NDEBUG_ABORT 0x800000
73#define NDEBUG_TAGS 0x1000000
74#define NDEBUG_MERGING 0x2000000
75
76#define AUTOSENSE
77/* For the Atari version, use only polled IO or REAL_DMA */
78#define REAL_DMA
79/* Support tagged queuing? (on devices that are able to... :-) */
80#define SUPPORT_TAGS
81#define MAX_TAGS 32
82
83#include <linux/types.h>
84#include <linux/stddef.h>
85#include <linux/ctype.h>
86#include <linux/delay.h>
87#include <linux/mm.h>
88#include <linux/blkdev.h>
89#include <linux/sched.h>
90#include <linux/interrupt.h>
91#include <linux/init.h>
92#include <linux/nvram.h>
93#include <linux/bitops.h>
94
95#include <asm/setup.h>
96#include <asm/atarihw.h>
97#include <asm/atariints.h>
98#include <asm/page.h>
99#include <asm/pgtable.h>
100#include <asm/irq.h>
101#include <asm/traps.h>
102
103#include "scsi.h"
104#include <scsi/scsi_host.h>
105#include "atari_scsi.h"
106#include "NCR5380.h"
107#include <asm/atari_stdma.h>
108#include <asm/atari_stram.h>
109#include <asm/io.h>
110
111#include <linux/stat.h>
112
113#define IS_A_TT() ATARIHW_PRESENT(TT_SCSI)
114
115#define SCSI_DMA_WRITE_P(elt,val) \
116 do { \
117 unsigned long v = val; \
118 tt_scsi_dma.elt##_lo = v & 0xff; \
119 v >>= 8; \
120 tt_scsi_dma.elt##_lmd = v & 0xff; \
121 v >>= 8; \
122 tt_scsi_dma.elt##_hmd = v & 0xff; \
123 v >>= 8; \
124 tt_scsi_dma.elt##_hi = v & 0xff; \
125 } while(0)
126
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)
132
133
134static inline void SCSI_DMA_SETADR(unsigned long adr)
135{
136 st_dma.dma_lo = (unsigned char)adr;
137 MFPDELAY();
138 adr >>= 8;
139 st_dma.dma_md = (unsigned char)adr;
140 MFPDELAY();
141 adr >>= 8;
142 st_dma.dma_hi = (unsigned char)adr;
143 MFPDELAY();
144}
145
146static inline unsigned long SCSI_DMA_GETADR(void)
147{
148 unsigned long adr;
149 adr = st_dma.dma_lo;
150 MFPDELAY();
151 adr |= (st_dma.dma_md & 0xff) << 8;
152 MFPDELAY();
153 adr |= (st_dma.dma_hi & 0xff) << 16;
154 MFPDELAY();
155 return adr;
156}
157
158static inline void ENABLE_IRQ(void)
159{
160 if (IS_A_TT())
161 atari_enable_irq(IRQ_TT_MFP_SCSI);
162 else
163 atari_enable_irq(IRQ_MFP_FSCSI);
164}
165
166static inline void DISABLE_IRQ(void)
167{
168 if (IS_A_TT())
169 atari_disable_irq(IRQ_TT_MFP_SCSI);
170 else
171 atari_disable_irq(IRQ_MFP_FSCSI);
172}
173
174
175#define HOSTDATA_DMALEN (((struct NCR5380_hostdata *) \
176 (atari_scsi_host->hostdata))->dma_len)
177
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)
183#else
184#define AFTER_RESET_DELAY (5*HZ/2)
185#endif
186
187/***************************** Prototypes *****************************/
188
189#ifdef REAL_DMA
190static int scsi_dma_is_ignored_buserr( unsigned char dma_stat );
191static void atari_scsi_fetch_restbytes( void );
192static long atari_scsi_dma_residual( struct Scsi_Host *instance );
193static int falcon_classify_cmd( Scsi_Cmnd *cmd );
194static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
195 Scsi_Cmnd *cmd, int write_flag );
196#endif
David Howells7d12e782006-10-05 14:55:46 +0100197static irqreturn_t scsi_tt_intr( int irq, void *dummy);
198static irqreturn_t scsi_falcon_intr( int irq, void *dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199static void falcon_release_lock_if_possible( struct NCR5380_hostdata *
200 hostdata );
201static void falcon_get_lock( void );
202#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
203static void atari_scsi_reset_boot( void );
204#endif
205static unsigned char atari_scsi_tt_reg_read( unsigned char reg );
206static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value);
207static unsigned char atari_scsi_falcon_reg_read( unsigned char reg );
208static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value );
209
210/************************* End of Prototypes **************************/
211
212
213static struct Scsi_Host *atari_scsi_host = NULL;
214static unsigned char (*atari_scsi_reg_read)( unsigned char reg );
215static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value );
216
217#ifdef REAL_DMA
218static unsigned long atari_dma_residual, atari_dma_startaddr;
219static short atari_dma_active;
220/* pointer to the dribble buffer */
221static char *atari_dma_buffer = NULL;
222/* precalculated physical address of the dribble buffer */
223static unsigned long atari_dma_phys_buffer;
224/* != 0 tells the Falcon int handler to copy data from the dribble buffer */
225static 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...
231 */
232#define STRAM_BUFFER_SIZE (4096)
233/* mask for address bits that can't be used with the ST-DMA */
234static 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 */
237static int atari_read_overruns = 0;
238#endif
239
240static int setup_can_queue = -1;
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800241module_param(setup_can_queue, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242static int setup_cmd_per_lun = -1;
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800243module_param(setup_cmd_per_lun, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244static int setup_sg_tablesize = -1;
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800245module_param(setup_sg_tablesize, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246#ifdef SUPPORT_TAGS
247static int setup_use_tagged_queuing = -1;
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800248module_param(setup_use_tagged_queuing, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249#endif
250static int setup_hostid = -1;
Rusty Russell8d3b33f2006-03-25 03:07:05 -0800251module_param(setup_hostid, int, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253
254#if defined(CONFIG_TT_DMA_EMUL)
255#include "atari_dma_emul.c"
256#endif
257
258#if defined(REAL_DMA)
259
260static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
261{
262 int i;
263 unsigned long addr = SCSI_DMA_READ_P( dma_addr ), end_addr;
264
265 if (dma_stat & 0x01) {
266
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:
270 */
271
272 for( i = 0; i < m68k_num_memory; ++i ) {
273 end_addr = m68k_memory[i].addr +
274 m68k_memory[i].size;
275 if (end_addr <= addr && addr <= end_addr + 4)
276 return( 1 );
277 }
278 }
279 return( 0 );
280}
281
282
283#if 0
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.
287 */
David Howells7d12e782006-10-05 14:55:46 +0100288static void scsi_dma_buserr (int irq, void *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
290 unsigned char dma_stat = tt_scsi_dma.dma_ctrl;
291
292 /* Don't do anything if a NCR interrupt is pending. Probably it's just
293 * masked... */
294 if (atari_irq_pending( IRQ_TT_MFP_SCSI ))
295 return;
296
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" );
302 }
303 else {
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.
308 */
309 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
310 }
311}
312#endif
313
314#endif
315
316
David Howells7d12e782006-10-05 14:55:46 +0100317static irqreturn_t scsi_tt_intr (int irq, void *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
319#ifdef REAL_DMA
320 int dma_stat;
321
322 dma_stat = tt_scsi_dma.dma_ctrl;
323
324 INT_PRINTK("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
325 atari_scsi_host->host_no, dma_stat & 0xff);
326
327 /* Look if it was the DMA that has interrupted: First possibility
328 * is that a bus error occurred...
329 */
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!");
335 }
336 }
337
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
345 * data reg!
346 */
347 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
348 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P( dma_addr ) -
349 atari_dma_startaddr);
350
351 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
352 atari_dma_residual);
353
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();
360 }
361 else {
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.
378 */
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;
384 }
385 }
386 tt_scsi_dma.dma_ctrl = 0;
387 }
388
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;
395 }
396
397#endif /* REAL_DMA */
398
399 NCR5380_intr (0, 0, 0);
400
401#if 0
402 /* To be sure the int is not masked */
403 atari_enable_irq( IRQ_TT_MFP_SCSI );
404#endif
405 return IRQ_HANDLED;
406}
407
408
David Howells7d12e782006-10-05 14:55:46 +0100409static irqreturn_t scsi_falcon_intr (int irq, void *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
411#ifdef REAL_DMA
412 int dma_stat;
413
414 /* Turn off DMA and select sector counter register before
415 * accessing the status register (Atari recommendation!)
416 */
417 st_dma.dma_mode_status = 0x90;
418 dma_stat = st_dma.dma_mode_status;
419
420 /* Bit 0 indicates some error in the DMA process... don't know
421 * what happened exactly (no further docu).
422 */
423 if (!(dma_stat & 0x01)) {
424 /* DMA error */
425 printk(KERN_CRIT "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR());
426 }
427
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!)
432 */
433 if (atari_dma_active && (dma_stat & 0x02)) {
434 unsigned long transferred;
435
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.
441 */
442 if (transferred & 15)
443 printk(KERN_ERR "SCSI DMA error: %ld bytes lost in "
444 "ST-DMA fifo\n", transferred & 15);
445
446 atari_dma_residual = HOSTDATA_DMALEN - transferred;
447 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
448 atari_dma_residual);
449 }
450 else
451 atari_dma_residual = 0;
452 atari_dma_active = 0;
453
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.
457 */
458 memcpy(atari_dma_orig_addr, phys_to_virt(atari_dma_startaddr),
459 HOSTDATA_DMALEN - atari_dma_residual);
460 atari_dma_orig_addr = NULL;
461 }
462
463#endif /* REAL_DMA */
464
465 NCR5380_intr (0, 0, 0);
466 return IRQ_HANDLED;
467}
468
469
470#ifdef REAL_DMA
471static void atari_scsi_fetch_restbytes( void )
472{
473 int nr;
474 char *src, *dst;
475 unsigned long phys_dst;
476
477 /* fetch rest bytes in the DMA register */
478 phys_dst = SCSI_DMA_READ_P(dma_addr);
479 nr = phys_dst & 3;
480 if (nr) {
481 /* there are 'nr' bytes left for the last long address
482 before the DMA pointer */
483 phys_dst ^= nr;
484 DMA_PRINTK("SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
485 nr, phys_dst);
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)
490 *dst++ = *src++;
491 }
492}
493#endif /* REAL_DMA */
494
495
496static int falcon_got_lock = 0;
497static DECLARE_WAIT_QUEUE_HEAD(falcon_fairness_wait);
498static int falcon_trying_lock = 0;
499static DECLARE_WAIT_QUEUE_HEAD(falcon_try_wait);
500static int falcon_dont_release = 0;
501
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).
507 */
508
509static void
510falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
511{
512 unsigned long flags;
513
514 if (IS_A_TT()) return;
515
516 local_irq_save(flags);
517
518 if (falcon_got_lock &&
519 !hostdata->disconnected_queue &&
520 !hostdata->issue_queue &&
521 !hostdata->connected) {
522
523 if (falcon_dont_release) {
524#if 0
525 printk("WARNING: Lock release not allowed. Ignored\n");
526#endif
527 local_irq_restore(flags);
528 return;
529 }
530 falcon_got_lock = 0;
531 stdma_release();
532 wake_up( &falcon_fairness_wait );
533 }
534
535 local_irq_restore(flags);
536}
537
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...
551 */
552
553static void falcon_get_lock( void )
554{
555 unsigned long flags;
556
557 if (IS_A_TT()) return;
558
559 local_irq_save(flags);
560
561 while( !in_interrupt() && falcon_got_lock && stdma_others_waiting() )
562 sleep_on( &falcon_fairness_wait );
563
564 while (!falcon_got_lock) {
565 if (in_interrupt())
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);
570 falcon_got_lock = 1;
571 falcon_trying_lock = 0;
572 wake_up( &falcon_try_wait );
573 }
574 else {
575 sleep_on( &falcon_try_wait );
576 }
577 }
578
579 local_irq_restore(flags);
580 if (!falcon_got_lock)
581 panic("Falcon SCSI: someone stole the lock :-(\n");
582}
583
584
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
587 * original function.
588 */
589
590#if 0
591int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
592{
593 /* falcon_get_lock();
594 * ++guenther: moved to NCR5380_queue_command() to prevent
595 * race condition, see there for an explanation.
596 */
597 return( NCR5380_queue_command( cmd, done ) );
598}
599#endif
600
601
Christoph Hellwigd0be4a7d2005-10-31 18:31:40 +0100602int atari_scsi_detect (struct scsi_host_template *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603{
604 static int called = 0;
605 struct Scsi_Host *instance;
606
607 if (!MACH_IS_ATARI ||
608 (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
609 called)
610 return( 0 );
611
612 host->proc_name = "Atari";
613
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;
618
619 /* setup variables */
620 host->can_queue =
621 (setup_can_queue > 0) ? setup_can_queue :
622 IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE;
623 host->cmd_per_lun =
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! */
627 host->sg_tablesize =
628 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE :
629 (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE;
630
631 if (setup_hostid >= 0)
632 host->this_id = setup_hostid;
633 else {
634 /* use 7 as default */
635 host->this_id = 7;
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 */
640 if (b & 0x80)
641 host->this_id = b & 7;
642 }
643 }
644
645#ifdef SUPPORT_TAGS
646 if (setup_use_tagged_queuing < 0)
647 setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
648#endif
649#ifdef REAL_DMA
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
653 * Ram.
654 */
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 "
660 "double buffer\n" );
661 return( 0 );
662 }
663 atari_dma_phys_buffer = virt_to_phys( atari_dma_buffer );
664 atari_dma_orig_addr = 0;
665 }
666#endif
667 instance = scsi_register (host, sizeof (struct NCR5380_hostdata));
668 if(instance == NULL)
669 {
670 atari_stram_free(atari_dma_buffer);
671 atari_dma_buffer = 0;
672 return 0;
673 }
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
678 * IDE and floppy! */
679 instance->irq = 0;
680
681#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
682 atari_scsi_reset_boot();
683#endif
684 NCR5380_init (instance, 0);
685
686 if (IS_A_TT()) {
687
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
690 * interrupt. */
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;
697 return 0;
698 }
699 tt_mfp.active_edge |= 0x80; /* SCSI int on L->H */
700#ifdef REAL_DMA
701 tt_scsi_dma.dma_ctrl = 0;
702 atari_dma_residual = 0;
703#ifdef CONFIG_TT_DMA_EMUL
704 if (MACH_IS_HADES) {
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;
713 return 0;
714 }
715 }
716#endif
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.
723 *
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.
729 */
730 atari_read_overruns = 4;
731 }
732#endif /*REAL_DMA*/
733 }
734 else { /* ! IS_A_TT */
735
736 /* Nothing to do for the interrupt: the ST-DMA is initialized
737 * already by atari_init_INTS()
738 */
739
740#ifdef REAL_DMA
741 atari_dma_residual = 0;
742 atari_dma_active = 0;
743 atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
744 : 0xff000000);
745#endif
746 }
747
748 printk(KERN_INFO "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
749#ifdef SUPPORT_TAGS
750 "TAGGED-QUEUING=%s "
751#endif
752 "HOSTID=%d",
753 instance->host_no, instance->hostt->can_queue,
754 instance->hostt->cmd_per_lun,
755 instance->hostt->sg_tablesize,
756#ifdef SUPPORT_TAGS
757 setup_use_tagged_queuing ? "yes" : "no",
758#endif
759 instance->hostt->this_id );
760 NCR5380_print_options (instance);
761 printk ("\n");
762
763 called = 1;
764 return( 1 );
765}
766
767#ifdef MODULE
768int atari_scsi_release (struct Scsi_Host *sh)
769{
770 if (IS_A_TT())
771 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr);
772 if (atari_dma_buffer)
773 atari_stram_free (atari_dma_buffer);
774 return 1;
775}
776#endif
777
778void __init atari_scsi_setup(char *str, int *ints)
779{
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.
784 */
785
786 if (ints[0] < 1) {
787 printk( "atari_scsi_setup: no arguments!\n" );
788 return;
789 }
790
791 if (ints[0] >= 1) {
792 if (ints[1] > 0)
793 /* no limits on this, just > 0 */
794 setup_can_queue = ints[1];
795 }
796 if (ints[0] >= 2) {
797 if (ints[2] > 0)
798 setup_cmd_per_lun = ints[2];
799 }
800 if (ints[0] >= 3) {
801 if (ints[3] >= 0) {
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;
806 }
807 }
808 if (ints[0] >= 4) {
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] );
814 }
815#ifdef SUPPORT_TAGS
816 if (ints[0] >= 5) {
817 if (ints[5] >= 0)
818 setup_use_tagged_queuing = !!ints[5];
819 }
820#endif
821}
822
823int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
824{
825 int rv;
826 struct NCR5380_hostdata *hostdata =
827 (struct NCR5380_hostdata *)cmd->device->host->hostdata;
828
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.
832 */
833 /* And abort a maybe active DMA transfer */
834 if (IS_A_TT()) {
835 atari_turnoff_irq( IRQ_TT_MFP_SCSI );
836#ifdef REAL_DMA
837 tt_scsi_dma.dma_ctrl = 0;
838#endif /* REAL_DMA */
839 }
840 else {
841 atari_turnoff_irq( IRQ_MFP_FSCSI );
842#ifdef REAL_DMA
843 st_dma.dma_mode_status = 0x90;
844 atari_dma_active = 0;
845 atari_dma_orig_addr = NULL;
846#endif /* REAL_DMA */
847 }
848
849 rv = NCR5380_bus_reset(cmd);
850
851 /* Re-enable ints */
852 if (IS_A_TT()) {
853 atari_turnon_irq( IRQ_TT_MFP_SCSI );
854 }
855 else {
856 atari_turnon_irq( IRQ_MFP_FSCSI );
857 }
858 if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS)
859 falcon_release_lock_if_possible(hostdata);
860
861 return( rv );
862}
863
864
865#ifdef CONFIG_ATARI_SCSI_RESET_BOOT
866static void __init atari_scsi_reset_boot(void)
867{
868 unsigned long end;
869
870 /*
871 * Do a SCSI reset to clean up the bus during initialization. No messing
872 * with the queues, interrupts, or locks necessary here.
873 */
874
875 printk( "Atari SCSI: resetting the SCSI bus..." );
876
877 /* get in phase */
878 NCR5380_write( TARGET_COMMAND_REG,
879 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) ));
880
881 /* assert RST */
882 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST );
883 /* The min. reset hold time is 25us, so 40us should be enough */
884 udelay( 50 );
885 /* reset RST and interrupt */
886 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
887 NCR5380_read( RESET_PARITY_INTERRUPT_REG );
888
889 end = jiffies + AFTER_RESET_DELAY;
890 while (time_before(jiffies, end))
891 barrier();
892
893 printk( " done\n" );
894}
895#endif
896
897
898const char * atari_scsi_info (struct Scsi_Host *host)
899{
900 /* atari_scsi_detect() is verbose enough... */
901 static const char string[] = "Atari native SCSI";
902 return string;
903}
904
905
906#if defined(REAL_DMA)
907
908unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
909 unsigned long count, int dir )
910{
911 unsigned long addr = virt_to_phys( data );
912
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);
915
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
920 * wanted address.
921 */
922 if (dir)
923 memcpy( atari_dma_buffer, data, count );
924 else
925 atari_dma_orig_addr = data;
926 addr = atari_dma_phys_buffer;
927 }
928
929 atari_dma_startaddr = addr; /* Needed for calculating residual later. */
930
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
935 * knowledge.
936 *
937 * ++roman: For the Medusa, there's no need at all for that cache stuff,
938 * because the hardware does bus snooping (fine!).
939 */
940 dma_cache_maintenance( addr, count, dir );
941
942 if (count == 0)
943 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n");
944
945 if (IS_A_TT()) {
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;
950 }
951 else { /* ! IS_A_TT */
952
953 /* set address */
954 SCSI_DMA_SETADR( addr );
955
956 /* toggle direction bit to clear FIFO and set DMA direction */
957 dir <<= 8;
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;
961 udelay(40);
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;
965 udelay(40);
966 st_dma.dma_mode_status = 0x10 | dir;
967 udelay(40);
968 /* need not restore value of dir, only boolean value is tested */
969 atari_dma_active = 1;
970 }
971
972 return( count );
973}
974
975
976static long atari_scsi_dma_residual( struct Scsi_Host *instance )
977{
978 return( atari_dma_residual );
979}
980
981
982#define CMD_SURELY_BLOCK_MODE 0
983#define CMD_SURELY_BYTE_MODE 1
984#define CMD_MODE_UNKNOWN 2
985
986static int falcon_classify_cmd( Scsi_Cmnd *cmd )
987{
988 unsigned char opcode = cmd->cmnd[0];
989
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
998 * set! */
999 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
1000 return( CMD_SURELY_BYTE_MODE );
1001 else
1002 return( CMD_SURELY_BLOCK_MODE );
1003 }
1004 else
1005 return( CMD_MODE_UNKNOWN );
1006}
1007
1008
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 :-)
1016 */
1017
1018static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1019 Scsi_Cmnd *cmd,
1020 int write_flag )
1021{
1022 unsigned long possible_len, limit;
1023#ifndef CONFIG_TT_DMA_EMUL
1024 if (MACH_IS_HADES)
1025 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1026 return( 0 );
1027#endif
1028 if (IS_A_TT())
1029 /* TT SCSI DMA can transfer arbitrary #bytes */
1030 return( wanted_len );
1031
1032 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1033 * 255*512 bytes, but this should be enough)
1034 *
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.
1045 *
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.
1055 *
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.
1058 */
1059
1060 if (write_flag) {
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
1063 * this).
1064 */
1065 possible_len = wanted_len;
1066 }
1067 else {
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!)
1071 */
1072 if (wanted_len & 0x1ff)
1073 possible_len = 0;
1074 else {
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;
1080 break;
1081 case CMD_SURELY_BYTE_MODE:
1082 possible_len = 0; /* DMA prohibited */
1083 break;
1084 case CMD_MODE_UNKNOWN:
1085 default:
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;
1089 break;
1090 }
1091 }
1092 }
1093
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;
1099
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);
1103
1104 return( possible_len );
1105}
1106
1107
1108#endif /* REAL_DMA */
1109
1110
1111/* NCR5380 register access functions
1112 *
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.
1116 */
1117
1118static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
1119{
1120 return( tt_scsi_regp[reg * 2] );
1121}
1122
1123static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
1124{
1125 tt_scsi_regp[reg * 2] = value;
1126}
1127
1128static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
1129{
1130 dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1131 return( (u_char)dma_wd.fdc_acces_seccount );
1132}
1133
1134static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
1135{
1136 dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1137 dma_wd.fdc_acces_seccount = (u_short)value;
1138}
1139
1140
1141#include "atari_NCR5380.c"
1142
Christoph Hellwigd0be4a7d2005-10-31 18:31:40 +01001143static struct scsi_host_template driver_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 .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
1157};
1158
1159
1160#include "scsi_module.c"
1161
1162MODULE_LICENSE("GPL");