![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
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 README.legal 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 (NDEBUG_DMA) */
72
73 #define AUTOSENSE
74 /* For the Atari version, use only polled IO or REAL_DMA */
75 #define REAL_DMA
76 /* Support tagged queuing? (on devices that are able to... :-) */
77 #define SUPPORT_TAGS
78 #define MAX_TAGS 32
79
80 #include <linux/types.h>
81 #include <linux/stddef.h>
82 #include <linux/ctype.h>
83 #include <linux/delay.h>
84 #include <linux/mm.h>
85 #include <linux/blk.h>
86
87 #include <asm/bootinfo.h>
88 #include <asm/atarihw.h>
89 #include <asm/atariints.h>
90 #include <asm/page.h>
91 #include <asm/pgtable.h>
92 #include <asm/irq.h>
93 #include <asm/traps.h>
94 #include <asm/bitops.h>
95
96 #include "scsi.h"
97 #include "hosts.h"
98 #include "atari_scsi.h"
99 #include "NCR5380.h"
100 #include "constants.h"
101 #include <asm/atari_stdma.h>
102 #include <asm/io.h>
103
104 #include<linux/stat.h>
105
106 struct proc_dir_entry proc_scsi_atari = {
107 PROC_SCSI_ATARI, 5, "Atari",
108 S_IFDIR | S_IRUGO | S_IXUGO, 2
109 };
110
111 #define IS_A_TT() ATARIHW_PRESENT(TT_SCSI)
112
113 #define SCSI_DMA_WRITE_P(elt,val) \
114 do { \
115 unsigned long v = val; \
116 tt_scsi_dma.elt##_lo = v & 0xff; \
117 v >>= 8; \
118 tt_scsi_dma.elt##_lmd = v & 0xff; \
119 v >>= 8; \
120 tt_scsi_dma.elt##_hmd = v & 0xff; \
121 v >>= 8; \
122 tt_scsi_dma.elt##_hi = v & 0xff; \
123 } while(0)
124
125 #define SCSI_DMA_READ_P(elt) \
126 (((unsigned long)tt_scsi_dma.elt##_hi << 24) | \
127 ((unsigned long)tt_scsi_dma.elt##_hmd << 16) | \
128 ((unsigned long)tt_scsi_dma.elt##_lmd << 8) | \
129 (unsigned long)tt_scsi_dma.elt##_lo)
130
131
132 #define SCSI_DMA_SETADR(adr) \
133 do { \
134 unsigned long __adr = (adr); \
135 st_dma.dma_lo = (unsigned char)__adr; \
136 MFPDELAY(); \
137 __adr >>= 8; \
138 st_dma.dma_md = (unsigned char)__adr; \
139 MFPDELAY(); \
140 __adr >>= 8; \
141 st_dma.dma_hi = (unsigned char)__adr; \
142 MFPDELAY(); \
143 } while(0)
144
145 #define SCSI_DMA_GETADR() ({ \
146 unsigned long __adr; \
147 __adr = st_dma.dma_lo; \
148 MFPDELAY(); \
149 __adr |= (st_dma.dma_md & 0xff) << 8; \
150 MFPDELAY(); \
151 __adr |= (st_dma.dma_hi & 0xff) << 16; \
152 MFPDELAY(); \
153 __adr; \
154 })
155
156 #define ENABLE_IRQ() \
157 do { \
158 if (IS_A_TT()) \
159 atari_enable_irq( IRQ_TT_MFP_SCSI ); \
160 else \
161 atari_enable_irq( IRQ_MFP_FSCSI ); \
162 } while(0)
163
164 #define DISABLE_IRQ() \
165 do { \
166 if (IS_A_TT()) \
167 atari_disable_irq( IRQ_TT_MFP_SCSI ); \
168 else \
169 atari_disable_irq( IRQ_MFP_FSCSI ); \
170 } while(0)
171
172
173 #define HOSTDATA_DMALEN (((struct NCR5380_hostdata *) \
174 (atari_scsi_host->hostdata))->dma_len)
175
176 /* Time (in jiffies) to wait after a reset; the SCSI standard calls for 250ms,
177 * we usually do 0.5s to be on the safe side. But Toshiba CD-ROMs once more
178 * need ten times the standard value... */
179 #ifndef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
180 #define AFTER_RESET_DELAY (HZ/2)
181 #else
182 #define AFTER_RESET_DELAY (5*HZ/2)
183 #endif
184
185 /***************************** Prototypes *****************************/
186
187 #ifdef REAL_DMA
188 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat );
189 static void scsi_dma_buserr( int irq, struct pt_regs *fp, void *dummy);
190 static void atari_scsi_fetch_restbytes( void );
191 static long atari_scsi_dma_residual( struct Scsi_Host *instance );
192 static int falcon_classify_cmd( Scsi_Cmnd *cmd );
193 static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
194 Scsi_Cmnd *cmd, int write_flag );
195 #endif
196 static void scsi_tt_intr( int irq, struct pt_regs *fp, void *dummy);
197 static void scsi_falcon_intr( int irq, struct pt_regs *fp, void *dummy);
198 static void falcon_release_lock_if_possible( struct NCR5380_hostdata *
199 hostdata );
200 static void falcon_get_lock( void );
201 static void atari_scsi_reset_boot( void );
202 static unsigned char atari_scsi_tt_reg_read( unsigned char reg );
203 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value);
204 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg );
205 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value );
206
207 /************************* End of Prototypes **************************/
208
209
210 static struct Scsi_Host *atari_scsi_host = NULL;
211 static unsigned char (*atari_scsi_reg_read)( unsigned char reg );
212 static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value );
213
214 #ifdef REAL_DMA
215 static unsigned long atari_dma_residual, atari_dma_startaddr;
216 static short atari_dma_active;
217 /* pointer to the dribble buffer */
218 static char *atari_dma_buffer = NULL;
219 /* precalculated physical address of the dribble buffer */
220 static unsigned long atari_dma_phys_buffer;
221 /* != 0 tells the Falcon int handler to copy data from the dribble buffer */
222 static char *atari_dma_orig_addr;
223 /* size of the dribble buffer; 4k seems enough, since the Falcon cannot use
224 * scatter-gather anyway, so most transfers are 1024 byte only. In the rare
225 * cases where requests to physical contiguous buffers have been merged, this
226 * request is <= 4k (one page). So I don't think we have to split transfers
227 * just due to this buffer size...
228 */
229 #define STRAM_BUFFER_SIZE (4096)
230 /* mask for address bits that can't be used with the ST-DMA */
231 static unsigned long atari_dma_stram_mask;
232 #define STRAM_ADDR(a) (((a) & atari_dma_stram_mask) == 0)
233 /* number of bytes to cut from a transfer to handle NCR overruns */
234 static int atari_read_overruns = 0;
235 #endif
236
237 int setup_can_queue = -1;
238 int setup_cmd_per_lun = -1;
239 int setup_sg_tablesize = -1;
240 #ifdef SUPPORT_TAGS
241 int setup_use_tagged_queuing = -1;
242 #endif
243 int setup_hostid = -1;
244
245
246 #if defined(REAL_DMA)
247
248 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
249 {
250 int i;
251 unsigned long addr = SCSI_DMA_READ_P( dma_addr ), end_addr;
252
253 if (dma_stat & 0x01) {
254
255 /* A bus error happens when DMA-ing from the last page of a
256 * physical memory chunk (DMA prefetch!), but that doesn't hurt.
257 * Check for this case:
258 */
259
260 for( i = 0; i < boot_info.num_memory; ++i ) {
261 end_addr = boot_info.memory[i].addr +
262 boot_info.memory[i].size;
263 if (end_addr <= addr && addr <= end_addr + 4)
264 return( 1 );
265 }
266 }
267 return( 0 );
268 }
269
270
271 static void scsi_dma_buserr (int irq, struct pt_regs *fp, void *dummy)
/* ![[previous]](../icons/left.png)
*/
272 {
273 unsigned char dma_stat = tt_scsi_dma.dma_ctrl;
274
275 /* Don't do anything if a NCR interrupt is pending. Probably it's just
276 * masked... */
277 if (atari_irq_pending( IRQ_TT_MFP_SCSI ))
278 return;
279
280 printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
281 SCSI_DMA_READ_P(dma_addr), dma_stat, SCSI_DMA_READ_P(dma_cnt));
282 if (dma_stat & 0x80) {
283 if (!scsi_dma_is_ignored_buserr( dma_stat ))
284 printk( "SCSI DMA bus error -- bad DMA programming!\n" );
285 }
286 else {
287 /* Under normal circumstances we never should get to this point,
288 * since both interrupts are triggered simultaneously and the 5380
289 * int has higher priority. When this irq is handled, that DMA
290 * interrupt is cleared. So a warning message is printed here.
291 */
292 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
293 }
294 }
295
296 #endif
297
298
299 static void scsi_tt_intr (int irq, struct pt_regs *fp, void *dummy)
/* */
300 {
301 unsigned long flags;
302 #ifdef REAL_DMA
303 int dma_stat;
304 #endif
305
306 /* If we got this interrupt, we don't need the other one from the DMA any
307 * more. So clear it. */
308 atari_clear_pending_irq( IRQ_TT_MFP_SCSIDMA );
309 /* After this has been done, we can make this int handler "slow", i.e.
310 * mask the NCR int and lower the IPL, as a slow int would do (see
311 * arch/m68k/atari/ataints.c) */
312 atari_disable_irq( IRQ_TT_MFP_SCSI );
313 save_flags(flags);
314 flags &= 0xf8ff;
315 flags |= fp->sr & 0x0700;
316 restore_flags(flags);
317
318 #ifdef REAL_DMA
319 dma_stat = tt_scsi_dma.dma_ctrl;
320
321 #if (NDEBUG & NDEBUG_INTR)
322 printk("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
323 atari_scsi_host->host_no, dma_stat & 0xff);
324 #endif
325
326 /* Look if it was the DMA that has interrupted: First possibility
327 * is that a bus error occurred...
328 */
329 if (dma_stat & 0x80) {
330 if (!scsi_dma_is_ignored_buserr( dma_stat )) {
331 printk( "SCSI DMA caused bus error near 0x%08lx\n",
332 SCSI_DMA_READ_P( dma_addr ));
333 panic( "SCSI DMA bus error -- bad DMA programming!" );
334 }
335 }
336
337 /* If the DMA is active but not finished, we have the the case
338 * that some other 5380 interrupt occurred within the DMA transfer.
339 * This means we have residual bytes, if the desired end address
340 * is not yet reached. Maybe we have to fetch some bytes from the
341 * rest data register, too. The residual must be calculated from
342 * the address pointer, not the counter register, because only the
343 * addr reg counts bytes not yet written and pending in the rest
344 * data reg!
345 */
346 if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
347 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P( dma_addr ) -
348 atari_dma_startaddr);
349 #if (NDEBUG & NDEBUG_DMA)
350 printk( "SCSI DMA: There are %ld residual bytes.\n",
351 atari_dma_residual );
352 #endif
353 if ((signed int)atari_dma_residual < 0)
354 atari_dma_residual = 0;
355 if ((dma_stat & 1) == 0) {
356 /* After read operations, we maybe have to
357 transport some rest bytes */
358 atari_scsi_fetch_restbytes();
359 }
360 else {
361 /* There seems to be a nasty bug in some SCSI-DMA/NCR
362 combinations: If a target disconnects while a write
363 operation is going on, the address register of the
364 DMA may be a few bytes farer than it actually read.
365 This is probably due to DMA prefetching and a delay
366 between DMA and NCR. Experiments showed that the
367 dma_addr is 9 bytes to high, but this could vary.
368 The problem is, that the residual is thus calculated
369 wrong and the next transfer will start behind where
370 it should. So we round up the residual to the next
371 multiple of a sector size, if it isn't already a
372 multiple and the originally expected transfer size
373 was. The latter condition is there to ensure that
374 the correction is taken only for "real" data
375 transfers and not for, e.g., the parameters of some
376 other command. These shouldn't disconnect anyway.
377 */
378 if (atari_dma_residual & 0x1ff) {
379 #if (NDEBUG & NDEBUG_DMA)
380 printk("SCSI DMA: DMA bug corrected, difference %ld bytes\n",
381 512 - (atari_dma_residual & 0x1ff));
382 #endif
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 /* To be sure the int is not masked */
402 atari_enable_irq( IRQ_TT_MFP_SCSI );
403 }
404
405
406 static void scsi_falcon_intr (int irq, struct pt_regs *fp, void *dummy)
/* */
407 {
408 #ifdef REAL_DMA
409 int dma_stat;
410
411 /* Turn off DMA and select sector counter register before
412 * accessing the status register (Atari recommendation!)
413 */
414 st_dma.dma_mode_status = 0x90;
415 dma_stat = st_dma.dma_mode_status;
416
417 /* Bit 0 indicates some error in the DMA process... don't know
418 * what happened exactly (no further docu).
419 */
420 if (!(dma_stat & 0x01)) {
421 /* DMA error */
422 printk( "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR() );
423 }
424
425 /* If the DMA was active, but now bit 1 is not clear, it is some
426 * other 5380 interrupt that finishes the DMA transfer. We have to
427 * calculate the number of residual bytes and give a warning if
428 * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
429 */
430 if (atari_dma_active && (dma_stat & 0x02)) {
431 unsigned long transferred;
432
433 transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
434 /* The ST-DMA address is incremented in 2-byte steps, but the
435 * data are written only in 16-byte chunks. If the number of
436 * transferred bytes is not divisible by 16, the remainder is
437 * lost somewhere in outer space.
438 */
439 if (transferred & 15)
440 printk( "SCSI DMA error: %ld bytes lost in ST-DMA fifo :-((\n",
441 transferred & 15 );
442
443 atari_dma_residual = HOSTDATA_DMALEN - transferred;
444 #if (NDEBUG & NDEBUG_DMA)
445 printk( "SCSI DMA: There are %ld residual bytes.\n",
446 atari_dma_residual );
447 #endif
448 }
449 else
450 atari_dma_residual = 0;
451 atari_dma_active = 0;
452
453 if (atari_dma_orig_addr) {
454 /* If the dribble buffer was used on a read operation, copy the DMA-ed
455 * data to the original destination address.
456 */
457 memcpy( atari_dma_orig_addr, (void *)PTOV(atari_dma_startaddr),
458 HOSTDATA_DMALEN - atari_dma_residual );
459 atari_dma_orig_addr = NULL;
460 }
461
462 #endif /* REAL_DMA */
463
464 NCR5380_intr (0, 0, 0);
465 }
466
467
468 #ifdef REAL_DMA
469 static void atari_scsi_fetch_restbytes( void )
/* */
470 {
471 int nr;
472 char *src, *dst;
473
474 /* fetch rest bytes in the DMA register */
475 dst = (char *)SCSI_DMA_READ_P( dma_addr );
476 if ((nr = ((long)dst & 3))) {
477 /* there are 'nr' bytes left for the last long address before the
478 DMA pointer */
479 dst = (char *)( (unsigned long)dst & ~3 );
480 #if (NDEBUG & NDEBUG_DMA)
481 printk( "SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
482 nr, (long)dst );
483 #endif
484 dst = (char *)PTOV(dst); /* The content of the DMA pointer
485 * is a physical address! */
486 #if (NDEBUG & NDEBUG_DMA)
487 printk( " = virt addr 0x%08lx\n", (long)dst );
488 #endif
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 struct wait_queue *falcon_fairness_wait = NULL;
498 static int falcon_trying_lock = 0;
499 static struct wait_queue *falcon_try_wait = NULL;
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( intr_count == 0 && falcon_got_lock && stdma_others_waiting() )
564 sleep_on( &falcon_fairness_wait );
565
566 while (!falcon_got_lock) {
567 if (intr_count > 0)
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 #define RTC_READ(reg) \
605 ({ unsigned char __val; \
606 outb(reg,&tt_rtc.regsel); \
607 __val = tt_rtc.data; \
608 __val; \
609 })
610
611 #define RTC_WRITE(reg,val) \
612 do { \
613 outb(reg,&tt_rtc.regsel); \
614 tt_rtc.data = (val); \
615 } while(0)
616
617
618 int atari_scsi_detect (Scsi_Host_Template *host)
/* */
619 {
620 static int called = 0;
621 struct Scsi_Host *instance;
622
623 if (!MACH_IS_ATARI ||
624 (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
625 called)
626 return( 0 );
627
628 host->proc_dir = &proc_scsi_atari;
629
630 atari_scsi_reg_read = IS_A_TT() ? atari_scsi_tt_reg_read :
631 atari_scsi_falcon_reg_read;
632 atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write :
633 atari_scsi_falcon_reg_write;
634
635 /* setup variables */
636 host->can_queue =
637 (setup_can_queue > 0) ? setup_can_queue :
638 IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE;
639 host->cmd_per_lun =
640 (setup_cmd_per_lun > 0) ? setup_cmd_per_lun :
641 IS_A_TT() ? ATARI_TT_CMD_PER_LUN : ATARI_FALCON_CMD_PER_LUN;
642 /* Force sg_tablesize to 0 on a Falcon! */
643 host->sg_tablesize =
644 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE :
645 (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE;
646
647 if (setup_hostid >= 0)
648 host->this_id = setup_hostid;
649 else {
650 /* use 7 as default */
651 host->this_id = 7;
652 /* Test if a host id is set in the NVRam */
653 if (ATARIHW_PRESENT(TT_CLK)) {
654 unsigned char sum = 0, b;
655 int i;
656
657 /* Make checksum */
658 for( i = 14; i < 62; ++i )
659 sum += RTC_READ(i);
660
661 if (/* NV-Ram checksum valid? */
662 RTC_READ(62) == sum && RTC_READ(63) == ~sum &&
663 /* Arbitration enabled? (for TOS) */
664 (b = RTC_READ( 30 )) & 0x80) {
665 host->this_id = b & 7;
666 }
667 }
668 }
669
670 #ifdef SUPPORT_TAGS
671 if (setup_use_tagged_queuing < 0)
672 setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
673 #endif
674
675 /* If running on a Falcon and if there's TT-Ram (i.e., more than one
676 * memory block, since there's always ST-Ram in a Falcon), then allocate a
677 * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative
678 * Ram.
679 */
680 if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) &&
681 !ATARIHW_PRESENT(EXTD_DMA) && boot_info.num_memory > 1) {
682 atari_dma_buffer = scsi_init_malloc(STRAM_BUFFER_SIZE,
683 GFP_ATOMIC | GFP_DMA);
684 atari_dma_phys_buffer = VTOP( atari_dma_buffer );
685 atari_dma_orig_addr = 0;
686 }
687
688 instance = scsi_register (host, sizeof (struct NCR5380_hostdata));
689 atari_scsi_host = instance;
690 instance->irq = IS_A_TT() ? IRQ_TT_MFP_SCSI : IRQ_MFP_FSCSI;
691
692 atari_scsi_reset_boot();
693 NCR5380_init (instance, 0);
694
695 if (IS_A_TT()) {
696
697 /* This int is actually "pseudo-slow", i.e. it acts like a slow
698 * interrupt after having cleared the pending flag for the DMA
699 * interrupt. */
700 add_isr(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_PRIO,
701 NULL, "SCSI NCR5380");
702 tt_mfp.active_edge |= 0x80; /* SCSI int on L->H */
703 #ifdef REAL_DMA
704 /* On the TT, we got a second interrupt for DMA ready and DMA buserror.
705 * Since on DMA ready we get a "normal" interrupt, too, the service
706 * routine for the second int just checks for buserrs.
707 */
708 add_isr(IRQ_TT_MFP_SCSIDMA, scsi_dma_buserr, IRQ_TYPE_SLOW,
709 NULL, "SCSI DMA");
710 tt_mfp.active_edge &= ~0x20; /* DMA int on H->L */
711
712 tt_scsi_dma.dma_ctrl = 0;
713 atari_dma_residual = 0;
714 #endif /* REAL_DMA */
715
716 if (is_medusa) {
717 /* While the read overruns (described by Drew Eckhardt in
718 * NCR5380.c) never happened on TTs, they do in fact on the Medusa
719 * (This was the cause why SCSI didn't work right for so long
720 * there.) Since handling the overruns slows down a bit, I turned
721 * the #ifdef's into a runtime condition.
722 *
723 * In principle it should be sufficient to do max. 1 byte with
724 * PIO, but there is another problem on the Medusa with the DMA
725 * rest data register. So 'atari_read_overruns' is currently set
726 * to 4 to avoid having transfers that aren't a multiple of 4. If
727 * the rest data bug is fixed, this can be lowered to 1.
728 */
729 atari_read_overruns = 4;
730 }
731
732 }
733 else { /* ! IS_A_TT */
734
735 /* Nothing to do for the interrupt: the ST-DMA is initialized
736 * already by atari_init_INTS()
737 */
738
739 #ifdef REAL_DMA
740 atari_dma_residual = 0;
741 atari_dma_active = 0;
742 atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
743 : 0xff000000);
744 #endif
745 }
746
747 printk( "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
748 #ifdef SUPPORT_TAGS
749 "TAGGED-QUEUING=%s "
750 #endif
751 "HOSTID=%d",
752 instance->host_no, instance->hostt->can_queue,
753 instance->hostt->cmd_per_lun,
754 instance->hostt->sg_tablesize,
755 #ifdef SUPPORT_TAGS
756 setup_use_tagged_queuing ? "yes" : "no",
757 #endif
758 instance->hostt->this_id );
759 NCR5380_print_options (instance);
760 printk ("\n");
761
762 called = 1;
763 return( 1 );
764 }
765
766 #ifdef MODULE
767 int atari_scsi_release (struct Scsi_Host *sh)
/* */
768 {
769 if (IS_A_TT()) {
770 remove_isr (IRQ_TT_MFP_SCSI, scsi_tt_intr);
771 #ifdef REAL_DMA
772 remove_isr (IRQ_TT_MFP_SCSIDMA, scsi_dma_buserr);
773 #endif
774 }
775 if (atari_dma_buffer)
776 scsi_init_free (atari_dma_buffer, STRAM_BUFFER_SIZE);
777 return 1;
778 }
779 #endif
780
781 void atari_scsi_setup( char *str, int *ints )
/* */
782 {
783 /* Format of atascsi parameter is:
784 * atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
785 * Defaults depend on TT or Falcon, hostid determined at run time.
786 * Negative values mean don't change.
787 */
788
789 /* Grmbl... the standard parameter parsing can't handle negative numbers
790 * :-( So let's do it ourselves!
791 */
792
793 int i = ints[0]+1, fact;
794
795 while( str && (isdigit(*str) || *str == '-') && i <= 10) {
796 if (*str == '-')
797 fact = -1, ++str;
798 else
799 fact = 1;
800 ints[i++] = simple_strtoul( str, NULL, 0 ) * fact;
801 if ((str = strchr( str, ',' )) != NULL)
802 ++str;
803 }
804 ints[0] = i-1;
805
806 if (ints[0] < 1) {
807 printk( "atari_scsi_setup: no arguments!\n" );
808 return;
809 }
810
811 if (ints[0] >= 1) {
812 if (ints[1] > 0)
813 /* no limits on this, just > 0 */
814 setup_can_queue = ints[1];
815 }
816 if (ints[0] >= 2) {
817 if (ints[2] > 0)
818 setup_cmd_per_lun = ints[2];
819 }
820 if (ints[0] >= 3) {
821 if (ints[3] >= 0) {
822 setup_sg_tablesize = ints[3];
823 /* Must be <= SG_ALL (255) */
824 if (setup_sg_tablesize > SG_ALL)
825 setup_sg_tablesize = SG_ALL;
826 }
827 }
828 if (ints[0] >= 4) {
829 /* Must be between 0 and 7 */
830 if (ints[4] >= 0 && ints[4] <= 7)
831 setup_hostid = ints[4];
832 else if (ints[4] > 7)
833 printk( "atari_scsi_setup: invalid host ID %d !\n", ints[4] );
834 }
835 #ifdef SUPPORT_TAGS
836 if (ints[0] >= 5) {
837 if (ints[5] >= 0)
838 setup_use_tagged_queuing = !!ints[5];
839 }
840 #endif
841 }
842
843 int atari_scsi_reset( Scsi_Cmnd *cmd, unsigned int reset_flags)
/* */
844 {
845 int rv;
846 struct NCR5380_hostdata *hostdata =
847 (struct NCR5380_hostdata *)cmd->host->hostdata;
848
849 /* For doing the reset, SCSI interrupts must be disabled first,
850 * since the 5380 raises its IRQ line while _RST is active and we
851 * can't disable interrupts completely, since we need the timer.
852 */
853 /* And abort a maybe active DMA transfer */
854 if (IS_A_TT()) {
855 atari_turnoff_irq( IRQ_TT_MFP_SCSI );
856 #ifdef REAL_DMA
857 tt_scsi_dma.dma_ctrl = 0;
858 #endif /* REAL_DMA */
859 }
860 else {
861 atari_turnoff_irq( IRQ_MFP_FSCSI );
862 #ifdef REAL_DMA
863 st_dma.dma_mode_status = 0x90;
864 atari_dma_active = 0;
865 atari_dma_orig_addr = NULL;
866 #endif /* REAL_DMA */
867 }
868
869 rv = NCR5380_reset(cmd, reset_flags);
870
871 /* Re-enable ints */
872 if (IS_A_TT()) {
873 atari_turnon_irq( IRQ_TT_MFP_SCSI );
874 }
875 else {
876 atari_turnon_irq( IRQ_MFP_FSCSI );
877 }
878 falcon_release_lock_if_possible(hostdata);
879
880 return( rv );
881 }
882
883
884 static void atari_scsi_reset_boot( void )
/* */
885 {
886 unsigned long end;
887
888 /*
889 * Do a SCSI reset to clean up the bus during initialization. No messing
890 * with the queues, interrupts, or locks necessary here.
891 */
892
893 printk( "Atari SCSI: resetting the SCSI bus..." );
894
895 /* get in phase */
896 NCR5380_write( TARGET_COMMAND_REG,
897 PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) ));
898
899 /* assert RST */
900 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST );
901 /* The min. reset hold time is 25us, so 40us should be enough */
902 udelay( 50 );
903 /* reset RST and interrupt */
904 NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
905 NCR5380_read( RESET_PARITY_INTERRUPT_REG );
906
907 for( end = jiffies + AFTER_RESET_DELAY; jiffies < end; )
908 barrier();
909
910 printk( " done\n" );
911 }
912
913
914 const char * atari_scsi_info (struct Scsi_Host *host)
/* */
915 {
916 /* atari_scsi_detect() is verbose enough... */
917 static const char string[] = "Atari native SCSI";
918 return string;
919 }
920
921
922 #if defined(REAL_DMA)
923
924 unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
/* */
925 unsigned long count, int dir )
926 {
927 unsigned long addr = VTOP( data );
928
929 #if (NDEBUG & NDEBUG_DMA)
930 printk ("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, dir = %d\n",
931 instance->host_no, data, addr, count, dir);
932 #endif
933
934 if (!IS_A_TT() && !STRAM_ADDR(addr)) {
935 /* If we have a non-DMAable address on a Falcon, use the dribble
936 * buffer; 'orig_addr' != 0 in the read case tells the interrupt
937 * handler to copy data from the dribble buffer to the originally
938 * wanted address.
939 */
940 if (dir)
941 memcpy( atari_dma_buffer, data, count );
942 else
943 atari_dma_orig_addr = data;
944 addr = atari_dma_phys_buffer;
945 }
946
947 atari_dma_startaddr = addr; /* Needed for calculating residual later. */
948
949 /* Cache cleanup stuff: On writes, push any dirty cache out before sending
950 * it to the peripheral. (Must be done before DMA setup, since at least
951 * the ST-DMA begins to fill internal buffers right after setup. For
952 * reads, invalidate any cache, may be altered after DMA without CPU
953 * knowledge.
954 *
955 * ++roman: For the Medusa, there's no need at all for that cache stuff,
956 * because the hardware does bus snooping (fine!).
957 */
958 dma_cache_maintenance( addr, count, dir );
959
960 if (count == 0)
961 printk("SCSI warning: DMA programmed for 0 bytes !\n");
962
963 if (IS_A_TT()) {
964 tt_scsi_dma.dma_ctrl = dir;
965 SCSI_DMA_WRITE_P( dma_addr, addr );
966 SCSI_DMA_WRITE_P( dma_cnt, count );
967 tt_scsi_dma.dma_ctrl = dir | 2;
968 }
969 else { /* ! IS_A_TT */
970
971 /* set address */
972 SCSI_DMA_SETADR( addr );
973
974 /* toggle direction bit to clear FIFO and set DMA direction */
975 dir <<= 8;
976 st_dma.dma_mode_status = 0x90 | dir;
977 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
978 st_dma.dma_mode_status = 0x90 | dir;
979 udelay(40);
980 /* On writes, round up the transfer length to the next multiple of 512
981 * (see also comment at atari_dma_xfer_len()). */
982 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
983 udelay(40);
984 st_dma.dma_mode_status = 0x10 | dir;
985 udelay(40);
986 /* need not restore value of dir, only boolean value is tested */
987 atari_dma_active = 1;
988 }
989
990 return( count );
991 }
992
993
994 static long atari_scsi_dma_residual( struct Scsi_Host *instance )
/* */
995 {
996 return( atari_dma_residual );
997 }
998
999
1000 #define CMD_SURELY_BLOCK_MODE 0
1001 #define CMD_SURELY_BYTE_MODE 1
1002 #define CMD_MODE_UNKNOWN 2
1003
1004 static int falcon_classify_cmd( Scsi_Cmnd *cmd )
/* */
1005 {
1006 unsigned char opcode = cmd->cmnd[0];
1007
1008 if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
1009 opcode == READ_BUFFER)
1010 return( CMD_SURELY_BYTE_MODE );
1011 else if (opcode == READ_6 || opcode == READ_10 ||
1012 opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE ||
1013 opcode == RECOVER_BUFFERED_DATA) {
1014 /* In case of a sequential-access target (tape), special care is
1015 * needed here: The transfer is block-mode only if the 'fixed' bit is
1016 * set! */
1017 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
1018 return( CMD_SURELY_BYTE_MODE );
1019 else
1020 return( CMD_SURELY_BLOCK_MODE );
1021 }
1022 else
1023 return( CMD_MODE_UNKNOWN );
1024 }
1025
1026
1027 /* This function calculates the number of bytes that can be transferred via
1028 * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
1029 * ST-DMA chip. There are only multiples of 512 bytes possible and max.
1030 * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
1031 * possible on the Falcon, since that would require to program the DMA for
1032 * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1033 * the overrun problem, so this question is academic :-)
1034 */
1035
1036 static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
/* */
1037 Scsi_Cmnd *cmd,
1038 int write_flag )
1039 {
1040 unsigned long possible_len, limit;
1041
1042 if (IS_A_TT())
1043 /* TT SCSI DMA can transfer arbitrary #bytes */
1044 return( wanted_len );
1045
1046 /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1047 * 255*512 bytes, but this should be enough)
1048 *
1049 * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1050 * that return a number of bytes which cannot be known beforehand. In this
1051 * case, the given transfer length is an "allocation length". Now it
1052 * can happen that this allocation length is a multiple of 512 bytes and
1053 * the DMA is used. But if not n*512 bytes really arrive, some input data
1054 * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1055 * between commands that do block transfers and those that do byte
1056 * transfers. But this isn't easy... there are lots of vendor specific
1057 * commands, and the user can issue any command via the
1058 * SCSI_IOCTL_SEND_COMMAND.
1059 *
1060 * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1061 * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1062 * and 3), the thing to do is obvious: allow any number of blocks via DMA
1063 * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1064 * the transfer (allocation) length is < 1024, hoping that no cmd. not
1065 * explicitly known as byte mode have such big allocation lengths...
1066 * BTW, all the discussion above applies only to reads. DMA writes are
1067 * unproblematic anyways, since the targets aborts the transfer after
1068 * receiving a sufficient number of bytes.
1069 *
1070 * Another point: If the transfer is from/to an non-ST-RAM address, we
1071 * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1072 */
1073
1074 if (write_flag) {
1075 /* Write operation can always use the DMA, but the transfer size must
1076 * be rounded up to the next multiple of 512 (atari_dma_setup() does
1077 * this).
1078 */
1079 possible_len = wanted_len;
1080 }
1081 else {
1082 /* Read operations: if the wanted transfer length is not a multiple of
1083 * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1084 * (no interrupt on DMA finished!)
1085 */
1086 if (wanted_len & 0x1ff)
1087 possible_len = 0;
1088 else {
1089 /* Now classify the command (see above) and decide whether it is
1090 * allowed to do DMA at all */
1091 switch( falcon_classify_cmd( cmd )) {
1092 case CMD_SURELY_BLOCK_MODE:
1093 possible_len = wanted_len;
1094 break;
1095 case CMD_SURELY_BYTE_MODE:
1096 possible_len = 0; /* DMA prohibited */
1097 break;
1098 case CMD_MODE_UNKNOWN:
1099 default:
1100 /* For unknown commands assume block transfers if the transfer
1101 * size/allocation length is >= 1024 */
1102 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
1103 break;
1104 }
1105 }
1106 }
1107
1108 /* Last step: apply the hard limit on DMA transfers */
1109 limit = (atari_dma_buffer && !STRAM_ADDR( VTOP(cmd->SCp.ptr) )) ?
1110 STRAM_BUFFER_SIZE : 255*512;
1111 if (possible_len > limit)
1112 possible_len = limit;
1113
1114 #if (NDEBUG & NDEBUG_DMA)
1115 if (possible_len != wanted_len)
1116 printk( "Sorry, must cut DMA transfer size to %ld bytes instead of %ld\n",
1117 possible_len, wanted_len );
1118 #endif
1119
1120 return( possible_len );
1121 }
1122
1123
1124 #endif /* REAL_DMA */
1125
1126
1127 /* NCR5380 register access functions
1128 *
1129 * There are separate functions for TT and Falcon, because the access
1130 * methods are quite different. The calling macros NCR5380_read and
1131 * NCR5380_write call these functions via function pointers.
1132 */
1133
1134 static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
/* */
1135 {
1136 return( tt_scsi_regp[reg * 2] );
1137 }
1138
1139 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
/* */
1140 {
1141 tt_scsi_regp[reg * 2] = value;
1142 }
1143
1144 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
/* */
1145 {
1146 dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1147 return( (u_char)dma_wd.fdc_acces_seccount );
1148 }
1149
1150 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
/* ![[last]](../icons/n_last.png)
*/
1151 {
1152 dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1153 dma_wd.fdc_acces_seccount = (u_short)value;
1154 }
1155
1156
1157 #include "atari_NCR5380.c"
1158
1159 #ifdef MODULE
1160 Scsi_Host_Template driver_template = ATARI_SCSI;
1161
1162 #include "scsi_module.c"
1163 #endif
![[bottom]](../icons/n_bottom.png){kind=icon}
*/