File: /usr/src/linux/drivers/scsi/atari_scsi.c
1 /*
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
68 #include <linux/config.h>
69 #include <linux/module.h>
70
71 #define NDEBUG (0)
72
73 #define NDEBUG_ABORT 0x800000
74 #define NDEBUG_TAGS 0x1000000
75 #define NDEBUG_MERGING 0x2000000
76
77 #define AUTOSENSE
78 /* For the Atari version, use only polled IO or REAL_DMA */
79 #define REAL_DMA
80 /* Support tagged queuing? (on devices that are able to... :-) */
81 #define SUPPORT_TAGS
82 #define MAX_TAGS 32
83
84 #include <linux/types.h>
85 #include <linux/stddef.h>
86 #include <linux/ctype.h>
87 #include <linux/delay.h>
88 #include <linux/mm.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>
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 #include <asm/bitops.h>
103
104 #include "scsi.h"
105 #include "hosts.h"
106 #include "atari_scsi.h"
107 #include "NCR5380.h"
108 #include "constants.h"
109 #include <asm/atari_stdma.h>
110 #include <asm/atari_stram.h>
111 #include <asm/io.h>
112
113 #include <linux/stat.h>
114
115 #define IS_A_TT() ATARIHW_PRESENT(TT_SCSI)
116
117 #define SCSI_DMA_WRITE_P(elt,val) \
118 do { \
119 unsigned long v = val; \
120 tt_scsi_dma.elt##_lo = v & 0xff; \
121 v >>= 8; \
122 tt_scsi_dma.elt##_lmd = v & 0xff; \
123 v >>= 8; \
124 tt_scsi_dma.elt##_hmd = v & 0xff; \
125 v >>= 8; \
126 tt_scsi_dma.elt##_hi = v & 0xff; \
127 } while(0)
128
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)
134
135
136 static inline void SCSI_DMA_SETADR(unsigned long adr)
137 {
138 st_dma.dma_lo = (unsigned char)adr;
139 MFPDELAY();
140 adr >>= 8;
141 st_dma.dma_md = (unsigned char)adr;
142 MFPDELAY();
143 adr >>= 8;
144 st_dma.dma_hi = (unsigned char)adr;
145 MFPDELAY();
146 }
147
148 static inline unsigned long SCSI_DMA_GETADR(void)
149 {
150 unsigned long adr;
151 adr = st_dma.dma_lo;
152 MFPDELAY();
153 adr |= (st_dma.dma_md & 0xff) << 8;
154 MFPDELAY();
155 adr |= (st_dma.dma_hi & 0xff) << 16;
156 MFPDELAY();
157 return adr;
158 }
159
160 static inline void ENABLE_IRQ(void)
161 {
162 if (IS_A_TT())
163 atari_enable_irq(IRQ_TT_MFP_SCSI);
164 else
165 atari_enable_irq(IRQ_MFP_FSCSI);
166 }
167
168 static inline void DISABLE_IRQ(void)
169 {
170 if (IS_A_TT())
171 atari_disable_irq(IRQ_TT_MFP_SCSI);
172 else
173 atari_disable_irq(IRQ_MFP_FSCSI);
174 }
175
176
177 #define HOSTDATA_DMALEN (((struct NCR5380_hostdata *) \
178 (atari_scsi_host->hostdata))->dma_len)
179
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)
185 #else
186 #define AFTER_RESET_DELAY (5*HZ/2)
187 #endif
188
189 /***************************** Prototypes *****************************/
190
191 #ifdef REAL_DMA
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 );
198 #endif
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 *
202 hostdata );
203 static void falcon_get_lock( void );
204 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
205 static void atari_scsi_reset_boot( void );
206 #endif
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 );
211
212 /************************* End of Prototypes **************************/
213
214
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 );
218
219 #ifdef REAL_DMA
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...
233 */
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;
240 #endif
241
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");
248 #ifdef SUPPORT_TAGS
249 static int setup_use_tagged_queuing = -1;
250 MODULE_PARM(setup_use_tagged_queuing, "i");
251 #endif
252 static int setup_hostid = -1;
253 MODULE_PARM(setup_hostid, "i");
254
255
256 #if defined(CONFIG_TT_DMA_EMUL)
257 #include "atari_dma_emul.c"
258 #endif
259
260 #if defined(REAL_DMA)
261
262 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
263 {
264 int i;
265 unsigned long addr = SCSI_DMA_READ_P( dma_addr ), end_addr;
266
267 if (dma_stat & 0x01) {
268
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:
272 */
273
274 for( i = 0; i < m68k_num_memory; ++i ) {
275 end_addr = m68k_memory[i].addr +
276 m68k_memory[i].size;
277 if (end_addr <= addr && addr <= end_addr + 4)
278 return( 1 );
279 }
280 }
281 return( 0 );
282 }
283
284
285 #if 0
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.
289 */
290 static void scsi_dma_buserr (int irq, void *dummy, struct pt_regs *fp)
291 {
292 unsigned char dma_stat = tt_scsi_dma.dma_ctrl;
293
294 /* Don't do anything if a NCR interrupt is pending. Probably it's just
295 * masked... */
296 if (atari_irq_pending( IRQ_TT_MFP_SCSI ))
297 return;
298
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" );
304 }
305 else {
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.
310 */
311 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
312 }
313 }
314 #endif
315
316 #endif
317
318
319 static void scsi_tt_intr (int irq, void *dummy, struct pt_regs *fp)
320 {
321 #ifdef REAL_DMA
322 int dma_stat;
323
324 dma_stat = tt_scsi_dma.dma_ctrl;
325
326 INT_PRINTK("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
327 atari_scsi_host->host_no, dma_stat & 0xff);
328
329 /* Look if it was the DMA that has interrupted: First possibility
330 * is that a bus error occurred...
331 */
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!");
337 }
338 }
339
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
347 * data reg!
348 */
349 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
350 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P( dma_addr ) -
351 atari_dma_startaddr);
352
353 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
354 atari_dma_residual);
355
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();
362 }
363 else {
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.
380 */
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;
386 }
387 }
388 tt_scsi_dma.dma_ctrl = 0;
389 }
390
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;
397 }
398
399 #endif /* REAL_DMA */
400
401 NCR5380_intr (0, 0, 0);
402
403 #if 0
404 /* To be sure the int is not masked */
405 atari_enable_irq( IRQ_TT_MFP_SCSI );
406 #endif
407 }
408
409
410 static void scsi_falcon_intr (int irq, void *dummy, struct pt_regs *fp)
411 {
412 #ifdef REAL_DMA
413 int dma_stat;
414
415 /* Turn off DMA and select sector counter register before
416 * accessing the status register (Atari recommendation!)
417 */
418 st_dma.dma_mode_status = 0x90;
419 dma_stat = st_dma.dma_mode_status;
420
421 /* Bit 0 indicates some error in the DMA process... don't know
422 * what happened exactly (no further docu).
423 */
424 if (!(dma_stat & 0x01)) {
425 /* DMA error */
426 printk(KERN_CRIT "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR());
427 }
428
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!)
433 */
434 if (atari_dma_active && (dma_stat & 0x02)) {
435 unsigned long transferred;
436
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.
442 */
443 if (transferred & 15)
444 printk(KERN_ERR "SCSI DMA error: %ld bytes lost in "
445 "ST-DMA fifo\n", transferred & 15);
446
447 atari_dma_residual = HOSTDATA_DMALEN - transferred;
448 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
449 atari_dma_residual);
450 }
451 else
452 atari_dma_residual = 0;
453 atari_dma_active = 0;
454
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.
458 */
459 memcpy(atari_dma_orig_addr, phys_to_virt(atari_dma_startaddr),
460 HOSTDATA_DMALEN - atari_dma_residual);
461 atari_dma_orig_addr = NULL;
462 }
463
464 #endif /* REAL_DMA */
465
466 NCR5380_intr (0, 0, 0);
467 }
468
469
470 #ifdef REAL_DMA
471 static 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
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;
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
509 static void
510 falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
511 {
512 unsigned long oldflags;
513
514 if (IS_A_TT()) return;
515
516 save_flags(oldflags);
517 cli();
518
519 if (falcon_got_lock &&
520 !hostdata->disconnected_queue &&
521 !hostdata->issue_queue &&
522 !hostdata->connected) {
523
524 if (falcon_dont_release) {
525 #if 0
526 printk("WARNING: Lock release not allowed. Ignored\n");
527 #endif
528 restore_flags(oldflags);
529 return;
530 }
531 falcon_got_lock = 0;
532 stdma_release();
533 wake_up( &falcon_fairness_wait );
534 }
535
536 restore_flags(oldflags);
537 }
538
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...
552 */
553
554 static void falcon_get_lock( void )
555 {
556 unsigned long oldflags;
557
558 if (IS_A_TT()) return;
559
560 save_flags(oldflags);
561 cli();
562
563 while( !in_interrupt() && falcon_got_lock && stdma_others_waiting() )
564 sleep_on( &falcon_fairness_wait );
565
566 while (!falcon_got_lock) {
567 if (in_interrupt())
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);
572 falcon_got_lock = 1;
573 falcon_trying_lock = 0;
574 wake_up( &falcon_try_wait );
575 }
576 else {
577 sleep_on( &falcon_try_wait );
578 }
579 }
580
581 restore_flags(oldflags);
582 if (!falcon_got_lock)
583 panic("Falcon SCSI: someone stole the lock :-(\n");
584 }
585
586
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
589 * original function.
590 */
591
592 #if 0
593 int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
594 {
595 /* falcon_get_lock();
596 * ++guenther: moved to NCR5380_queue_command() to prevent
597 * race condition, see there for an explanation.
598 */
599 return( NCR5380_queue_command( cmd, done ) );
600 }
601 #endif
602
603
604 int atari_scsi_detect (Scsi_Host_Template *host)
605 {
606 static int called = 0;
607 struct Scsi_Host *instance;
608
609 if (!MACH_IS_ATARI ||
610 (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
611 called)
612 return( 0 );
613
614 host->proc_name = "Atari";
615
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;
620
621 /* setup variables */
622 host->can_queue =
623 (setup_can_queue > 0) ? setup_can_queue :
624 IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE;
625 host->cmd_per_lun =
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! */
629 host->sg_tablesize =
630 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE :
631 (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE;
632
633 if (setup_hostid >= 0)
634 host->this_id = setup_hostid;
635 else {
636 /* use 7 as default */
637 host->this_id = 7;
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 */
642 if (b & 0x80)
643 host->this_id = b & 7;
644 }
645 }
646
647 #ifdef SUPPORT_TAGS
648 if (setup_use_tagged_queuing < 0)
649 setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
650 #endif
651 #ifdef REAL_DMA
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
655 * Ram.
656 */
657 if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) &&
658 !ATARIHW_PRESENT(EXTD_DMA) && m68k_num_memory > 1) {
659 atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
660 if (!atari_dma_buffer) {
661 printk( KERN_ERR "atari_scsi_detect: can't allocate ST-RAM "
662 "double buffer\n" );
663 return( 0 );
664 }
665 atari_dma_phys_buffer = virt_to_phys( atari_dma_buffer );
666 atari_dma_orig_addr = 0;
667 }
668 #endif
669 instance = scsi_register (host, sizeof (struct NCR5380_hostdata));
670 if(instance == NULL)
671 {
672 atari_stram_free(atari_dma_buffer);
673 atari_dma_buffer = 0;
674 return 0;
675 }
676 atari_scsi_host = instance;
677 /* Set irq to 0, to avoid that the mid-level code disables our interrupt
678 * during queue_command calls. This is completely unnecessary, and even
679 * worse causes bad problems on the Falcon, where the int is shared with
680 * IDE and floppy! */
681 instance->irq = 0;
682
683 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
684 atari_scsi_reset_boot();
685 #endif
686 NCR5380_init (instance, 0);
687
688 if (IS_A_TT()) {
689
690 /* This int is actually "pseudo-slow", i.e. it acts like a slow
691 * interrupt after having cleared the pending flag for the DMA
692 * interrupt. */
693 if (request_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_SLOW,
694 "SCSI NCR5380", scsi_tt_intr)) {
695 printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting",IRQ_TT_MFP_SCSI);
696 scsi_unregister(atari_scsi_host);
697 atari_stram_free(atari_dma_buffer);
698 atari_dma_buffer = 0;
699 return 0;
700 }
701 tt_mfp.active_edge |= 0x80; /* SCSI int on L->H */
702 #ifdef REAL_DMA
703 tt_scsi_dma.dma_ctrl = 0;
704 atari_dma_residual = 0;
705 #ifdef CONFIG_TT_DMA_EMUL
706 if (MACH_IS_HADES) {
707 if (request_irq(IRQ_AUTO_2, hades_dma_emulator,
708 IRQ_TYPE_PRIO, "Hades DMA emulator",
709 hades_dma_emulator)) {
710 printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting (MACH_IS_HADES)",IRQ_AUTO_2);
711 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr);
712 scsi_unregister(atari_scsi_host);
713 atari_stram_free(atari_dma_buffer);
714 atari_dma_buffer = 0;
715 return 0;
716 }
717 }
718 #endif
719 if (MACH_IS_MEDUSA || MACH_IS_HADES) {
720 /* While the read overruns (described by Drew Eckhardt in
721 * NCR5380.c) never happened on TTs, they do in fact on the Medusa
722 * (This was the cause why SCSI didn't work right for so long
723 * there.) Since handling the overruns slows down a bit, I turned
724 * the #ifdef's into a runtime condition.
725 *
726 * In principle it should be sufficient to do max. 1 byte with
727 * PIO, but there is another problem on the Medusa with the DMA
728 * rest data register. So 'atari_read_overruns' is currently set
729 * to 4 to avoid having transfers that aren't a multiple of 4. If
730 * the rest data bug is fixed, this can be lowered to 1.
731 */
732 atari_read_overruns = 4;
733 }
734 #endif /*REAL_DMA*/
735 }
736 else { /* ! IS_A_TT */
737
738 /* Nothing to do for the interrupt: the ST-DMA is initialized
739 * already by atari_init_INTS()
740 */
741
742 #ifdef REAL_DMA
743 atari_dma_residual = 0;
744 atari_dma_active = 0;
745 atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
746 : 0xff000000);
747 #endif
748 }
749
750 printk(KERN_INFO "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
751 #ifdef SUPPORT_TAGS
752 "TAGGED-QUEUING=%s "
753 #endif
754 "HOSTID=%d",
755 instance->host_no, instance->hostt->can_queue,
756 instance->hostt->cmd_per_lun,
757 instance->hostt->sg_tablesize,
758 #ifdef SUPPORT_TAGS
759 setup_use_tagged_queuing ? "yes" : "no",
760 #endif
761 instance->hostt->this_id );
762 NCR5380_print_options (instance);
763 printk ("\n");
764
765 called = 1;
766 return( 1 );
767 }
768
769 #ifdef MODULE
770 int atari_scsi_release (struct Scsi_Host *sh)
771 {
772 if (IS_A_TT())
773 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr);
774 if (atari_dma_buffer)
775 atari_stram_free (atari_dma_buffer);
776 return 1;
777 }
778 #endif
779
780 void __init atari_scsi_setup(char *str, int *ints)
781 {
782 /* Format of atascsi parameter is:
783 * atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
784 * Defaults depend on TT or Falcon, hostid determined at run time.
785 * Negative values mean don't change.
786 */
787
788 if (ints[0] < 1) {
789 printk( "atari_scsi_setup: no arguments!\n" );
790 return;
791 }
792
793 if (ints[0] >= 1) {
794 if (ints[1] > 0)
795 /* no limits on this, just > 0 */
796 setup_can_queue = ints[1];
797 }
798 if (ints[0] >= 2) {
799 if (ints[2] > 0)
800 setup_cmd_per_lun = ints[2];
801 }
802 if (ints[0] >= 3) {
803 if (ints[3] >= 0) {
804 setup_sg_tablesize = ints[3];
805 /* Must be <= SG_ALL (255) */
806 if (setup_sg_tablesize > SG_ALL)
807 setup_sg_tablesize = SG_ALL;
808 }
809 }
810 if (ints[0] >= 4) {
811 /* Must be between 0 and 7 */
812 if (ints[4] >= 0 && ints[4] <= 7)
813 setup_hostid = ints[4];
814 else if (ints[4] > 7)
815 printk( "atari_scsi_setup: invalid host ID %d !\n", ints[4] );
816 }
817 #ifdef SUPPORT_TAGS
818 if (ints[0] >= 5) {
819 if (ints[5] >= 0)
820 setup_use_tagged_queuing = !!ints[5];
821 }
822 #endif
823 }
824
825 int atari_scsi_reset( Scsi_Cmnd *cmd, unsigned int reset_flags)
826 {
827 int rv;
828 struct NCR5380_hostdata *hostdata =
829 (struct NCR5380_hostdata *)cmd->host->hostdata;
830
831 /* For doing the reset, SCSI interrupts must be disabled first,
832 * since the 5380 raises its IRQ line while _RST is active and we
833 * can't disable interrupts completely, since we need the timer.
834 */
835 /* And abort a maybe active DMA transfer */
836 if (IS_A_TT()) {
837 atari_turnoff_irq( IRQ_TT_MFP_SCSI );
838 #ifdef REAL_DMA
839 tt_scsi_dma.dma_ctrl = 0;
840 #endif /* REAL_DMA */
841 }
842 else {
843 atari_turnoff_irq( IRQ_MFP_FSCSI );
844 #ifdef REAL_DMA
845 st_dma.dma_mode_status = 0x90;
846 atari_dma_active = 0;
847 atari_dma_orig_addr = NULL;
848 #endif /* REAL_DMA */
849 }
850
851 rv = NCR5380_reset(cmd, reset_flags);
852
853 /* Re-enable ints */
854 if (IS_A_TT()) {
855 atari_turnon_irq( IRQ_TT_MFP_SCSI );
856 }
857 else {
858 atari_turnon_irq( IRQ_MFP_FSCSI );
859 }
860 if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS)
861 falcon_release_lock_if_possible(hostdata);
862
863 return( rv );
864 }
865
866
867 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
868 static void __init atari_scsi_reset_boot(void)
869 {
870 unsigned long end;
871
872 /*
873 * Do a SCSI reset to clean up the bus during initialization. No messing
874 * with the queues, interrupts, or locks necessary here.
875 */
876
877 printk( "Atari SCSI: resetting the SCSI bus..." );
878
879 /* get in phase */
880 NCR5380_write( TARGET_COMMAND_REG,
881 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) ));
882
883 /* assert RST */
884 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST );
885 /* The min. reset hold time is 25us, so 40us should be enough */
886 udelay( 50 );
887 /* reset RST and interrupt */
888 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
889 NCR5380_read( RESET_PARITY_INTERRUPT_REG );
890
891 end = jiffies + AFTER_RESET_DELAY;
892 while (time_before(jiffies, end))
893 barrier();
894
895 printk( " done\n" );
896 }
897 #endif
898
899
900 const char * atari_scsi_info (struct Scsi_Host *host)
901 {
902 /* atari_scsi_detect() is verbose enough... */
903 static const char string[] = "Atari native SCSI";
904 return string;
905 }
906
907
908 #if defined(REAL_DMA)
909
910 unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
911 unsigned long count, int dir )
912 {
913 unsigned long addr = virt_to_phys( data );
914
915 DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
916 "dir = %d\n", instance->host_no, data, addr, count, dir);
917
918 if (!IS_A_TT() && !STRAM_ADDR(addr)) {
919 /* If we have a non-DMAable address on a Falcon, use the dribble
920 * buffer; 'orig_addr' != 0 in the read case tells the interrupt
921 * handler to copy data from the dribble buffer to the originally
922 * wanted address.
923 */
924 if (dir)
925 memcpy( atari_dma_buffer, data, count );
926 else
927 atari_dma_orig_addr = data;
928 addr = atari_dma_phys_buffer;
929 }
930
931 atari_dma_startaddr = addr; /* Needed for calculating residual later. */
932
933 /* Cache cleanup stuff: On writes, push any dirty cache out before sending
934 * it to the peripheral. (Must be done before DMA setup, since at least
935 * the ST-DMA begins to fill internal buffers right after setup. For
936 * reads, invalidate any cache, may be altered after DMA without CPU
937 * knowledge.
938 *
939 * ++roman: For the Medusa, there's no need at all for that cache stuff,
940 * because the hardware does bus snooping (fine!).
941 */
942 dma_cache_maintenance( addr, count, dir );
943
944 if (count == 0)
945 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n");
946
947 if (IS_A_TT()) {
948 tt_scsi_dma.dma_ctrl = dir;
949 SCSI_DMA_WRITE_P( dma_addr, addr );
950 SCSI_DMA_WRITE_P( dma_cnt, count );
951 tt_scsi_dma.dma_ctrl = dir | 2;
952 }
953 else { /* ! IS_A_TT */
954
955 /* set address */
956 SCSI_DMA_SETADR( addr );
957
958 /* toggle direction bit to clear FIFO and set DMA direction */
959 dir <<= 8;
960 st_dma.dma_mode_status = 0x90 | dir;
961 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
962 st_dma.dma_mode_status = 0x90 | dir;
963 udelay(40);
964 /* On writes, round up the transfer length to the next multiple of 512
965 * (see also comment at atari_dma_xfer_len()). */
966 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
967 udelay(40);
968 st_dma.dma_mode_status = 0x10 | dir;
969 udelay(40);
970 /* need not restore value of dir, only boolean value is tested */
971 atari_dma_active = 1;
972 }
973
974 return( count );
975 }
976
977
978 static long atari_scsi_dma_residual( struct Scsi_Host *instance )
979 {
980 return( atari_dma_residual );
981 }
982
983
984 #define CMD_SURELY_BLOCK_MODE 0
985 #define CMD_SURELY_BYTE_MODE 1
986 #define CMD_MODE_UNKNOWN 2
987
988 static int falcon_classify_cmd( Scsi_Cmnd *cmd )
989 {
990 unsigned char opcode = cmd->cmnd[0];
991
992 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
993 opcode == READ_BUFFER)
994 return( CMD_SURELY_BYTE_MODE );
995 else if (opcode == READ_6 || opcode == READ_10 ||
996 opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE ||
997 opcode == RECOVER_BUFFERED_DATA) {
998 /* In case of a sequential-access target (tape), special care is
999 * needed here: The transfer is block-mode only if the 'fixed' bit is
1000 * set! */
1001 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
1002 return( CMD_SURELY_BYTE_MODE );
1003 else
1004 return( CMD_SURELY_BLOCK_MODE );
1005 }
1006 else
1007 return( CMD_MODE_UNKNOWN );
1008 }
1009
1010
1011 /* This function calculates the number of bytes that can be transferred via
1012 * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
1013 * ST-DMA chip. There are only multiples of 512 bytes possible and max.
1014 * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
1015 * possible on the Falcon, since that would require to program the DMA for
1016 * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1017 * the overrun problem, so this question is academic :-)
1018 */
1019
1020 static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1021 Scsi_Cmnd *cmd,
1022 int write_flag )
1023 {
1024 unsigned long possible_len, limit;
1025 #ifndef CONFIG_TT_DMA_EMUL
1026 if (MACH_IS_HADES)
1027 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1028 return( 0 );
1029 #endif
1030 if (IS_A_TT())
1031 /* TT SCSI DMA can transfer arbitrary #bytes */
1032 return( wanted_len );
1033
1034 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1035 * 255*512 bytes, but this should be enough)
1036 *
1037 * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1038 * that return a number of bytes which cannot be known beforehand. In this
1039 * case, the given transfer length is an "allocation length". Now it
1040 * can happen that this allocation length is a multiple of 512 bytes and
1041 * the DMA is used. But if not n*512 bytes really arrive, some input data
1042 * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1043 * between commands that do block transfers and those that do byte
1044 * transfers. But this isn't easy... there are lots of vendor specific
1045 * commands, and the user can issue any command via the
1046 * SCSI_IOCTL_SEND_COMMAND.
1047 *
1048 * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1049 * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1050 * and 3), the thing to do is obvious: allow any number of blocks via DMA
1051 * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1052 * the transfer (allocation) length is < 1024, hoping that no cmd. not
1053 * explicitly known as byte mode have such big allocation lengths...
1054 * BTW, all the discussion above applies only to reads. DMA writes are
1055 * unproblematic anyways, since the targets aborts the transfer after
1056 * receiving a sufficient number of bytes.
1057 *
1058 * Another point: If the transfer is from/to an non-ST-RAM address, we
1059 * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1060 */
1061
1062 if (write_flag) {
1063 /* Write operation can always use the DMA, but the transfer size must
1064 * be rounded up to the next multiple of 512 (atari_dma_setup() does
1065 * this).
1066 */
1067 possible_len = wanted_len;
1068 }
1069 else {
1070 /* Read operations: if the wanted transfer length is not a multiple of
1071 * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1072 * (no interrupt on DMA finished!)
1073 */
1074 if (wanted_len & 0x1ff)
1075 possible_len = 0;
1076 else {
1077 /* Now classify the command (see above) and decide whether it is
1078 * allowed to do DMA at all */
1079 switch( falcon_classify_cmd( cmd )) {
1080 case CMD_SURELY_BLOCK_MODE:
1081 possible_len = wanted_len;
1082 break;
1083 case CMD_SURELY_BYTE_MODE:
1084 possible_len = 0; /* DMA prohibited */
1085 break;
1086 case CMD_MODE_UNKNOWN:
1087 default:
1088 /* For unknown commands assume block transfers if the transfer
1089 * size/allocation length is >= 1024 */
1090 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
1091 break;
1092 }
1093 }
1094 }
1095
1096 /* Last step: apply the hard limit on DMA transfers */
1097 limit = (atari_dma_buffer && !STRAM_ADDR( virt_to_phys(cmd->SCp.ptr) )) ?
1098 STRAM_BUFFER_SIZE : 255*512;
1099 if (possible_len > limit)
1100 possible_len = limit;
1101
1102 if (possible_len != wanted_len)
1103 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1104 "instead of %ld\n", possible_len, wanted_len);
1105
1106 return( possible_len );
1107 }
1108
1109
1110 #endif /* REAL_DMA */
1111
1112
1113 /* NCR5380 register access functions
1114 *
1115 * There are separate functions for TT and Falcon, because the access
1116 * methods are quite different. The calling macros NCR5380_read and
1117 * NCR5380_write call these functions via function pointers.
1118 */
1119
1120 static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
1121 {
1122 return( tt_scsi_regp[reg * 2] );
1123 }
1124
1125 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
1126 {
1127 tt_scsi_regp[reg * 2] = value;
1128 }
1129
1130 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
1131 {
1132 dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1133 return( (u_char)dma_wd.fdc_acces_seccount );
1134 }
1135
1136 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
1137 {
1138 dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1139 dma_wd.fdc_acces_seccount = (u_short)value;
1140 }
1141
1142
1143 #include "atari_NCR5380.c"
1144
1145 static Scsi_Host_Template driver_template = ATARI_SCSI;
1146 #include "scsi_module.c"
1147