[SCSI] remove Scsi_Host_Template typedef
[linux-2.6.git] / 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/blkdev.h>
90 #include <linux/sched.h>
91 #include <linux/interrupt.h>
92 #include <linux/init.h>
93 #include <linux/nvram.h>
94 #include <linux/bitops.h>
95
96 #include <asm/setup.h>
97 #include <asm/atarihw.h>
98 #include <asm/atariints.h>
99 #include <asm/page.h>
100 #include <asm/pgtable.h>
101 #include <asm/irq.h>
102 #include <asm/traps.h>
103
104 #include "scsi.h"
105 #include <scsi/scsi_host.h>
106 #include "atari_scsi.h"
107 #include "NCR5380.h"
108 #include <asm/atari_stdma.h>
109 #include <asm/atari_stram.h>
110 #include <asm/io.h>
111
112 #include <linux/stat.h>
113
114 #define IS_A_TT()       ATARIHW_PRESENT(TT_SCSI)
115
116 #define SCSI_DMA_WRITE_P(elt,val)                               \
117         do {                                                    \
118                 unsigned long v = val;                          \
119                 tt_scsi_dma.elt##_lo = v & 0xff;                \
120                 v >>= 8;                                        \
121                 tt_scsi_dma.elt##_lmd = v & 0xff;               \
122                 v >>= 8;                                        \
123                 tt_scsi_dma.elt##_hmd = v & 0xff;               \
124                 v >>= 8;                                        \
125                 tt_scsi_dma.elt##_hi = v & 0xff;                \
126         } while(0)
127
128 #define SCSI_DMA_READ_P(elt)                                    \
129         (((((((unsigned long)tt_scsi_dma.elt##_hi << 8) |       \
130              (unsigned long)tt_scsi_dma.elt##_hmd) << 8) |      \
131            (unsigned long)tt_scsi_dma.elt##_lmd) << 8) |        \
132          (unsigned long)tt_scsi_dma.elt##_lo)
133
134
135 static inline void SCSI_DMA_SETADR(unsigned long adr)
136 {
137         st_dma.dma_lo = (unsigned char)adr;
138         MFPDELAY();
139         adr >>= 8;
140         st_dma.dma_md = (unsigned char)adr;
141         MFPDELAY();
142         adr >>= 8;
143         st_dma.dma_hi = (unsigned char)adr;
144         MFPDELAY();
145 }
146
147 static inline unsigned long SCSI_DMA_GETADR(void)
148 {
149         unsigned long adr;
150         adr = st_dma.dma_lo;
151         MFPDELAY();
152         adr |= (st_dma.dma_md & 0xff) << 8;
153         MFPDELAY();
154         adr |= (st_dma.dma_hi & 0xff) << 16;
155         MFPDELAY();
156         return adr;
157 }
158
159 static inline void ENABLE_IRQ(void)
160 {
161         if (IS_A_TT())
162                 atari_enable_irq(IRQ_TT_MFP_SCSI);
163         else
164                 atari_enable_irq(IRQ_MFP_FSCSI);
165 }
166
167 static inline void DISABLE_IRQ(void)
168 {
169         if (IS_A_TT())
170                 atari_disable_irq(IRQ_TT_MFP_SCSI);
171         else
172                 atari_disable_irq(IRQ_MFP_FSCSI);
173 }
174
175
176 #define HOSTDATA_DMALEN         (((struct NCR5380_hostdata *) \
177                                 (atari_scsi_host->hostdata))->dma_len)
178
179 /* Time (in jiffies) to wait after a reset; the SCSI standard calls for 250ms,
180  * we usually do 0.5s to be on the safe side. But Toshiba CD-ROMs once more
181  * need ten times the standard value... */
182 #ifndef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
183 #define AFTER_RESET_DELAY       (HZ/2)
184 #else
185 #define AFTER_RESET_DELAY       (5*HZ/2)
186 #endif
187
188 /***************************** Prototypes *****************************/
189
190 #ifdef REAL_DMA
191 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat );
192 static void atari_scsi_fetch_restbytes( void );
193 static long atari_scsi_dma_residual( struct Scsi_Host *instance );
194 static int falcon_classify_cmd( Scsi_Cmnd *cmd );
195 static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
196                                          Scsi_Cmnd *cmd, int write_flag );
197 #endif
198 static irqreturn_t scsi_tt_intr( int irq, void *dummy, struct pt_regs *fp);
199 static irqreturn_t scsi_falcon_intr( int irq, void *dummy, struct pt_regs *fp);
200 static void falcon_release_lock_if_possible( struct NCR5380_hostdata *
201                                              hostdata );
202 static void falcon_get_lock( void );
203 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
204 static void atari_scsi_reset_boot( void );
205 #endif
206 static unsigned char atari_scsi_tt_reg_read( unsigned char reg );
207 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value);
208 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg );
209 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value );
210
211 /************************* End of Prototypes **************************/
212
213
214 static struct Scsi_Host *atari_scsi_host = NULL;
215 static unsigned char (*atari_scsi_reg_read)( unsigned char reg );
216 static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value );
217
218 #ifdef REAL_DMA
219 static unsigned long    atari_dma_residual, atari_dma_startaddr;
220 static short            atari_dma_active;
221 /* pointer to the dribble buffer */
222 static char             *atari_dma_buffer = NULL;
223 /* precalculated physical address of the dribble buffer */
224 static unsigned long    atari_dma_phys_buffer;
225 /* != 0 tells the Falcon int handler to copy data from the dribble buffer */
226 static char             *atari_dma_orig_addr;
227 /* size of the dribble buffer; 4k seems enough, since the Falcon cannot use
228  * scatter-gather anyway, so most transfers are 1024 byte only. In the rare
229  * cases where requests to physical contiguous buffers have been merged, this
230  * request is <= 4k (one page). So I don't think we have to split transfers
231  * just due to this buffer size...
232  */
233 #define STRAM_BUFFER_SIZE       (4096)
234 /* mask for address bits that can't be used with the ST-DMA */
235 static unsigned long    atari_dma_stram_mask;
236 #define STRAM_ADDR(a)   (((a) & atari_dma_stram_mask) == 0)
237 /* number of bytes to cut from a transfer to handle NCR overruns */
238 static int atari_read_overruns = 0;
239 #endif
240
241 static int setup_can_queue = -1;
242 MODULE_PARM(setup_can_queue, "i");
243 static int setup_cmd_per_lun = -1;
244 MODULE_PARM(setup_cmd_per_lun, "i");
245 static int setup_sg_tablesize = -1;
246 MODULE_PARM(setup_sg_tablesize, "i");
247 #ifdef SUPPORT_TAGS
248 static int setup_use_tagged_queuing = -1;
249 MODULE_PARM(setup_use_tagged_queuing, "i");
250 #endif
251 static int setup_hostid = -1;
252 MODULE_PARM(setup_hostid, "i");
253
254
255 #if defined(CONFIG_TT_DMA_EMUL)
256 #include "atari_dma_emul.c"
257 #endif
258
259 #if defined(REAL_DMA)
260
261 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
262 {
263         int i;
264         unsigned long   addr = SCSI_DMA_READ_P( dma_addr ), end_addr;
265
266         if (dma_stat & 0x01) {
267
268                 /* A bus error happens when DMA-ing from the last page of a
269                  * physical memory chunk (DMA prefetch!), but that doesn't hurt.
270                  * Check for this case:
271                  */
272                 
273                 for( i = 0; i < m68k_num_memory; ++i ) {
274                         end_addr = m68k_memory[i].addr +
275                                 m68k_memory[i].size;
276                         if (end_addr <= addr && addr <= end_addr + 4)
277                                 return( 1 );
278                 }
279         }
280         return( 0 );
281 }
282
283
284 #if 0
285 /* Dead code... wasn't called anyway :-) and causes some trouble, because at
286  * end-of-DMA, both SCSI ints are triggered simultaneously, so the NCR int has
287  * to clear the DMA int pending bit before it allows other level 6 interrupts.
288  */
289 static void scsi_dma_buserr (int irq, void *dummy, struct pt_regs *fp)
290 {
291         unsigned char   dma_stat = tt_scsi_dma.dma_ctrl;
292
293         /* Don't do anything if a NCR interrupt is pending. Probably it's just
294          * masked... */
295         if (atari_irq_pending( IRQ_TT_MFP_SCSI ))
296                 return;
297         
298         printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
299                SCSI_DMA_READ_P(dma_addr), dma_stat, SCSI_DMA_READ_P(dma_cnt));
300         if (dma_stat & 0x80) {
301                 if (!scsi_dma_is_ignored_buserr( dma_stat ))
302                         printk( "SCSI DMA bus error -- bad DMA programming!\n" );
303         }
304         else {
305                 /* Under normal circumstances we never should get to this point,
306                  * since both interrupts are triggered simultaneously and the 5380
307                  * int has higher priority. When this irq is handled, that DMA
308                  * interrupt is cleared. So a warning message is printed here.
309                  */
310                 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
311         }
312 }
313 #endif
314
315 #endif
316
317
318 static irqreturn_t scsi_tt_intr (int irq, void *dummy, struct pt_regs *fp)
319 {
320 #ifdef REAL_DMA
321         int dma_stat;
322
323         dma_stat = tt_scsi_dma.dma_ctrl;
324
325         INT_PRINTK("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
326                    atari_scsi_host->host_no, dma_stat & 0xff);
327
328         /* Look if it was the DMA that has interrupted: First possibility
329          * is that a bus error occurred...
330          */
331         if (dma_stat & 0x80) {
332                 if (!scsi_dma_is_ignored_buserr( dma_stat )) {
333                         printk(KERN_ERR "SCSI DMA caused bus error near 0x%08lx\n",
334                                SCSI_DMA_READ_P(dma_addr));
335                         printk(KERN_CRIT "SCSI DMA bus error -- bad DMA programming!");
336                 }
337         }
338
339         /* If the DMA is active but not finished, we have the case
340          * that some other 5380 interrupt occurred within the DMA transfer.
341          * This means we have residual bytes, if the desired end address
342          * is not yet reached. Maybe we have to fetch some bytes from the
343          * rest data register, too. The residual must be calculated from
344          * the address pointer, not the counter register, because only the
345          * addr reg counts bytes not yet written and pending in the rest
346          * data reg!
347          */
348         if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
349                 atari_dma_residual = HOSTDATA_DMALEN - (SCSI_DMA_READ_P( dma_addr ) -
350                                                                                                 atari_dma_startaddr);
351
352                 DMA_PRINTK("SCSI DMA: There are %ld residual bytes.\n",
353                            atari_dma_residual);
354
355                 if ((signed int)atari_dma_residual < 0)
356                         atari_dma_residual = 0;
357                 if ((dma_stat & 1) == 0) {
358                         /* After read operations, we maybe have to
359                            transport some rest bytes */
360                         atari_scsi_fetch_restbytes();
361                 }
362                 else {
363                         /* There seems to be a nasty bug in some SCSI-DMA/NCR
364                            combinations: If a target disconnects while a write
365                            operation is going on, the address register of the
366                            DMA may be a few bytes farer than it actually read.
367                            This is probably due to DMA prefetching and a delay
368                            between DMA and NCR.  Experiments showed that the
369                            dma_addr is 9 bytes to high, but this could vary.
370                            The problem is, that the residual is thus calculated
371                            wrong and the next transfer will start behind where
372                            it should.  So we round up the residual to the next
373                            multiple of a sector size, if it isn't already a
374                            multiple and the originally expected transfer size
375                            was.  The latter condition is there to ensure that
376                            the correction is taken only for "real" data
377                            transfers and not for, e.g., the parameters of some
378                            other command.  These shouldn't disconnect anyway.
379                            */
380                         if (atari_dma_residual & 0x1ff) {
381                                 DMA_PRINTK("SCSI DMA: DMA bug corrected, "
382                                            "difference %ld bytes\n",
383                                            512 - (atari_dma_residual & 0x1ff));
384                                 atari_dma_residual = (atari_dma_residual + 511) & ~0x1ff;
385                         }
386                 }
387                 tt_scsi_dma.dma_ctrl = 0;
388         }
389
390         /* If the DMA is finished, fetch the rest bytes and turn it off */
391         if (dma_stat & 0x40) {
392                 atari_dma_residual = 0;
393                 if ((dma_stat & 1) == 0)
394                         atari_scsi_fetch_restbytes();
395                 tt_scsi_dma.dma_ctrl = 0;
396         }
397
398 #endif /* REAL_DMA */
399         
400         NCR5380_intr (0, 0, 0);
401
402 #if 0
403         /* To be sure the int is not masked */
404         atari_enable_irq( IRQ_TT_MFP_SCSI );
405 #endif
406         return IRQ_HANDLED;
407 }
408
409
410 static irqreturn_t 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         return IRQ_HANDLED;
468 }
469
470
471 #ifdef REAL_DMA
472 static void atari_scsi_fetch_restbytes( void )
473 {
474         int nr;
475         char *src, *dst;
476         unsigned long phys_dst;
477
478         /* fetch rest bytes in the DMA register */
479         phys_dst = SCSI_DMA_READ_P(dma_addr);
480         nr = phys_dst & 3;
481         if (nr) {
482                 /* there are 'nr' bytes left for the last long address
483                    before the DMA pointer */
484                 phys_dst ^= nr;
485                 DMA_PRINTK("SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
486                            nr, phys_dst);
487                 /* The content of the DMA pointer is a physical address!  */
488                 dst = phys_to_virt(phys_dst);
489                 DMA_PRINTK(" = virt addr %p\n", dst);
490                 for (src = (char *)&tt_scsi_dma.dma_restdata; nr != 0; --nr)
491                         *dst++ = *src++;
492         }
493 }
494 #endif /* REAL_DMA */
495
496
497 static int falcon_got_lock = 0;
498 static DECLARE_WAIT_QUEUE_HEAD(falcon_fairness_wait);
499 static int falcon_trying_lock = 0;
500 static DECLARE_WAIT_QUEUE_HEAD(falcon_try_wait);
501 static int falcon_dont_release = 0;
502
503 /* This function releases the lock on the DMA chip if there is no
504  * connected command and the disconnected queue is empty. On
505  * releasing, instances of falcon_get_lock are awoken, that put
506  * themselves to sleep for fairness. They can now try to get the lock
507  * again (but others waiting longer more probably will win).
508  */
509
510 static void
511 falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
512 {
513         unsigned long flags;
514                 
515         if (IS_A_TT()) return;
516         
517         local_irq_save(flags);
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                         local_irq_restore(flags);
529                         return;
530                 }
531                 falcon_got_lock = 0;
532                 stdma_release();
533                 wake_up( &falcon_fairness_wait );
534         }
535
536         local_irq_restore(flags);
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 flags;
557
558         if (IS_A_TT()) return;
559
560         local_irq_save(flags);
561
562         while( !in_interrupt() && falcon_got_lock && stdma_others_waiting() )
563                 sleep_on( &falcon_fairness_wait );
564
565         while (!falcon_got_lock) {
566                 if (in_interrupt())
567                         panic( "Falcon SCSI hasn't ST-DMA lock in interrupt" );
568                 if (!falcon_trying_lock) {
569                         falcon_trying_lock = 1;
570                         stdma_lock(scsi_falcon_intr, NULL);
571                         falcon_got_lock = 1;
572                         falcon_trying_lock = 0;
573                         wake_up( &falcon_try_wait );
574                 }
575                 else {
576                         sleep_on( &falcon_try_wait );
577                 }
578         }       
579
580         local_irq_restore(flags);
581         if (!falcon_got_lock)
582                 panic("Falcon SCSI: someone stole the lock :-(\n");
583 }
584
585
586 /* This is the wrapper function for NCR5380_queue_command(). It just
587  * tries to get the lock on the ST-DMA (see above) and then calls the
588  * original function.
589  */
590
591 #if 0
592 int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
593 {
594         /* falcon_get_lock();
595          * ++guenther: moved to NCR5380_queue_command() to prevent
596          * race condition, see there for an explanation.
597          */
598         return( NCR5380_queue_command( cmd, done ) );
599 }
600 #endif
601
602
603 int atari_scsi_detect (struct scsi_host_template *host)
604 {
605         static int called = 0;
606         struct Scsi_Host *instance;
607
608         if (!MACH_IS_ATARI ||
609             (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
610             called)
611                 return( 0 );
612
613         host->proc_name = "Atari";
614
615         atari_scsi_reg_read  = IS_A_TT() ? atari_scsi_tt_reg_read :
616                                            atari_scsi_falcon_reg_read;
617         atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write :
618                                            atari_scsi_falcon_reg_write;
619
620         /* setup variables */
621         host->can_queue =
622                 (setup_can_queue > 0) ? setup_can_queue :
623                 IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE;
624         host->cmd_per_lun =
625                 (setup_cmd_per_lun > 0) ? setup_cmd_per_lun :
626                 IS_A_TT() ? ATARI_TT_CMD_PER_LUN : ATARI_FALCON_CMD_PER_LUN;
627         /* Force sg_tablesize to 0 on a Falcon! */
628         host->sg_tablesize =
629                 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE :
630                 (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE;
631
632         if (setup_hostid >= 0)
633                 host->this_id = setup_hostid;
634         else {
635                 /* use 7 as default */
636                 host->this_id = 7;
637                 /* Test if a host id is set in the NVRam */
638                 if (ATARIHW_PRESENT(TT_CLK) && nvram_check_checksum()) {
639                         unsigned char b = nvram_read_byte( 14 );
640                         /* Arbitration enabled? (for TOS) If yes, use configured host ID */
641                         if (b & 0x80)
642                                 host->this_id = b & 7;
643                 }
644         }
645
646 #ifdef SUPPORT_TAGS
647         if (setup_use_tagged_queuing < 0)
648                 setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
649 #endif
650 #ifdef REAL_DMA
651         /* If running on a Falcon and if there's TT-Ram (i.e., more than one
652          * memory block, since there's always ST-Ram in a Falcon), then allocate a
653          * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative
654          * Ram.
655          */
656         if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) &&
657             !ATARIHW_PRESENT(EXTD_DMA) && m68k_num_memory > 1) {
658                 atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
659                 if (!atari_dma_buffer) {
660                         printk( KERN_ERR "atari_scsi_detect: can't allocate ST-RAM "
661                                         "double buffer\n" );
662                         return( 0 );
663                 }
664                 atari_dma_phys_buffer = virt_to_phys( atari_dma_buffer );
665                 atari_dma_orig_addr = 0;
666         }
667 #endif
668         instance = scsi_register (host, sizeof (struct NCR5380_hostdata));
669         if(instance == NULL)
670         {
671                 atari_stram_free(atari_dma_buffer);
672                 atari_dma_buffer = 0;
673                 return 0;
674         }
675         atari_scsi_host = instance;
676        /* Set irq to 0, to avoid that the mid-level code disables our interrupt
677         * during queue_command calls. This is completely unnecessary, and even
678         * worse causes bad problems on the Falcon, where the int is shared with
679         * IDE and floppy! */
680        instance->irq = 0;
681
682 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
683         atari_scsi_reset_boot();
684 #endif
685         NCR5380_init (instance, 0);
686
687         if (IS_A_TT()) {
688
689                 /* This int is actually "pseudo-slow", i.e. it acts like a slow
690                  * interrupt after having cleared the pending flag for the DMA
691                  * interrupt. */
692                 if (request_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_SLOW,
693                                  "SCSI NCR5380", scsi_tt_intr)) {
694                         printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting",IRQ_TT_MFP_SCSI);
695                         scsi_unregister(atari_scsi_host);
696                         atari_stram_free(atari_dma_buffer);
697                         atari_dma_buffer = 0;
698                         return 0;
699                 }
700                 tt_mfp.active_edge |= 0x80;             /* SCSI int on L->H */
701 #ifdef REAL_DMA
702                 tt_scsi_dma.dma_ctrl = 0;
703                 atari_dma_residual = 0;
704 #ifdef CONFIG_TT_DMA_EMUL
705                 if (MACH_IS_HADES) {
706                         if (request_irq(IRQ_AUTO_2, hades_dma_emulator,
707                                          IRQ_TYPE_PRIO, "Hades DMA emulator",
708                                          hades_dma_emulator)) {
709                                 printk(KERN_ERR "atari_scsi_detect: cannot allocate irq %d, aborting (MACH_IS_HADES)",IRQ_AUTO_2);
710                                 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr);
711                                 scsi_unregister(atari_scsi_host);
712                                 atari_stram_free(atari_dma_buffer);
713                                 atari_dma_buffer = 0;
714                                 return 0;
715                         }
716                 }
717 #endif
718                 if (MACH_IS_MEDUSA || MACH_IS_HADES) {
719                         /* While the read overruns (described by Drew Eckhardt in
720                          * NCR5380.c) never happened on TTs, they do in fact on the Medusa
721                          * (This was the cause why SCSI didn't work right for so long
722                          * there.) Since handling the overruns slows down a bit, I turned
723                          * the #ifdef's into a runtime condition.
724                          *
725                          * In principle it should be sufficient to do max. 1 byte with
726                          * PIO, but there is another problem on the Medusa with the DMA
727                          * rest data register. So 'atari_read_overruns' is currently set
728                          * to 4 to avoid having transfers that aren't a multiple of 4. If
729                          * the rest data bug is fixed, this can be lowered to 1.
730                          */
731                         atari_read_overruns = 4;
732                 }               
733 #endif /*REAL_DMA*/
734         }
735         else { /* ! IS_A_TT */
736                 
737                 /* Nothing to do for the interrupt: the ST-DMA is initialized
738                  * already by atari_init_INTS()
739                  */
740
741 #ifdef REAL_DMA
742                 atari_dma_residual = 0;
743                 atari_dma_active = 0;
744                 atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
745                                         : 0xff000000);
746 #endif
747         }
748
749         printk(KERN_INFO "scsi%d: options CAN_QUEUE=%d CMD_PER_LUN=%d SCAT-GAT=%d "
750 #ifdef SUPPORT_TAGS
751                         "TAGGED-QUEUING=%s "
752 #endif
753                         "HOSTID=%d",
754                         instance->host_no, instance->hostt->can_queue,
755                         instance->hostt->cmd_per_lun,
756                         instance->hostt->sg_tablesize,
757 #ifdef SUPPORT_TAGS
758                         setup_use_tagged_queuing ? "yes" : "no",
759 #endif
760                         instance->hostt->this_id );
761         NCR5380_print_options (instance);
762         printk ("\n");
763
764         called = 1;
765         return( 1 );
766 }
767
768 #ifdef MODULE
769 int atari_scsi_release (struct Scsi_Host *sh)
770 {
771         if (IS_A_TT())
772                 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr);
773         if (atari_dma_buffer)
774                 atari_stram_free (atari_dma_buffer);
775         return 1;
776 }
777 #endif
778
779 void __init atari_scsi_setup(char *str, int *ints)
780 {
781         /* Format of atascsi parameter is:
782          *   atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
783          * Defaults depend on TT or Falcon, hostid determined at run time.
784          * Negative values mean don't change.
785          */
786         
787         if (ints[0] < 1) {
788                 printk( "atari_scsi_setup: no arguments!\n" );
789                 return;
790         }
791
792         if (ints[0] >= 1) {
793                 if (ints[1] > 0)
794                         /* no limits on this, just > 0 */
795                         setup_can_queue = ints[1];
796         }
797         if (ints[0] >= 2) {
798                 if (ints[2] > 0)
799                         setup_cmd_per_lun = ints[2];
800         }
801         if (ints[0] >= 3) {
802                 if (ints[3] >= 0) {
803                         setup_sg_tablesize = ints[3];
804                         /* Must be <= SG_ALL (255) */
805                         if (setup_sg_tablesize > SG_ALL)
806                                 setup_sg_tablesize = SG_ALL;
807                 }
808         }
809         if (ints[0] >= 4) {
810                 /* Must be between 0 and 7 */
811                 if (ints[4] >= 0 && ints[4] <= 7)
812                         setup_hostid = ints[4];
813                 else if (ints[4] > 7)
814                         printk( "atari_scsi_setup: invalid host ID %d !\n", ints[4] );
815         }
816 #ifdef SUPPORT_TAGS
817         if (ints[0] >= 5) {
818                 if (ints[5] >= 0)
819                         setup_use_tagged_queuing = !!ints[5];
820         }
821 #endif
822 }
823
824 int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
825 {
826         int             rv;
827         struct NCR5380_hostdata *hostdata =
828                 (struct NCR5380_hostdata *)cmd->device->host->hostdata;
829
830         /* For doing the reset, SCSI interrupts must be disabled first,
831          * since the 5380 raises its IRQ line while _RST is active and we
832          * can't disable interrupts completely, since we need the timer.
833          */
834         /* And abort a maybe active DMA transfer */
835         if (IS_A_TT()) {
836                 atari_turnoff_irq( IRQ_TT_MFP_SCSI );
837 #ifdef REAL_DMA
838                 tt_scsi_dma.dma_ctrl = 0;
839 #endif /* REAL_DMA */
840         }
841         else {
842                 atari_turnoff_irq( IRQ_MFP_FSCSI );
843 #ifdef REAL_DMA
844                 st_dma.dma_mode_status = 0x90;
845                 atari_dma_active = 0;
846                 atari_dma_orig_addr = NULL;
847 #endif /* REAL_DMA */
848         }
849
850         rv = NCR5380_bus_reset(cmd);
851
852         /* Re-enable ints */
853         if (IS_A_TT()) {
854                 atari_turnon_irq( IRQ_TT_MFP_SCSI );
855         }
856         else {
857                 atari_turnon_irq( IRQ_MFP_FSCSI );
858         }
859         if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS)
860                 falcon_release_lock_if_possible(hostdata);
861
862         return( rv );
863 }
864
865         
866 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
867 static void __init atari_scsi_reset_boot(void)
868 {
869         unsigned long end;
870         
871         /*
872          * Do a SCSI reset to clean up the bus during initialization. No messing
873          * with the queues, interrupts, or locks necessary here.
874          */
875
876         printk( "Atari SCSI: resetting the SCSI bus..." );
877
878         /* get in phase */
879         NCR5380_write( TARGET_COMMAND_REG,
880                       PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) ));
881
882         /* assert RST */
883         NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST );
884         /* The min. reset hold time is 25us, so 40us should be enough */
885         udelay( 50 );
886         /* reset RST and interrupt */
887         NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
888         NCR5380_read( RESET_PARITY_INTERRUPT_REG );
889
890         end = jiffies + AFTER_RESET_DELAY;
891         while (time_before(jiffies, end))
892                 barrier();
893
894         printk( " done\n" );
895 }
896 #endif
897
898
899 const char * atari_scsi_info (struct Scsi_Host *host)
900 {
901         /* atari_scsi_detect() is verbose enough... */
902         static const char string[] = "Atari native SCSI";
903         return string;
904 }
905
906
907 #if defined(REAL_DMA)
908
909 unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
910                                    unsigned long count, int dir )
911 {
912         unsigned long addr = virt_to_phys( data );
913
914         DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
915                    "dir = %d\n", instance->host_no, data, addr, count, dir);
916
917         if (!IS_A_TT() && !STRAM_ADDR(addr)) {
918                 /* If we have a non-DMAable address on a Falcon, use the dribble
919                  * buffer; 'orig_addr' != 0 in the read case tells the interrupt
920                  * handler to copy data from the dribble buffer to the originally
921                  * wanted address.
922                  */
923                 if (dir)
924                         memcpy( atari_dma_buffer, data, count );
925                 else
926                         atari_dma_orig_addr = data;
927                 addr = atari_dma_phys_buffer;
928         }
929         
930         atari_dma_startaddr = addr;     /* Needed for calculating residual later. */
931   
932         /* Cache cleanup stuff: On writes, push any dirty cache out before sending
933          * it to the peripheral. (Must be done before DMA setup, since at least
934          * the ST-DMA begins to fill internal buffers right after setup. For
935          * reads, invalidate any cache, may be altered after DMA without CPU
936          * knowledge.
937          * 
938          * ++roman: For the Medusa, there's no need at all for that cache stuff,
939          * because the hardware does bus snooping (fine!).
940          */
941         dma_cache_maintenance( addr, count, dir );
942
943         if (count == 0)
944                 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n");
945
946         if (IS_A_TT()) {
947                 tt_scsi_dma.dma_ctrl = dir;
948                 SCSI_DMA_WRITE_P( dma_addr, addr );
949                 SCSI_DMA_WRITE_P( dma_cnt, count );
950                 tt_scsi_dma.dma_ctrl = dir | 2;
951         }
952         else { /* ! IS_A_TT */
953   
954                 /* set address */
955                 SCSI_DMA_SETADR( addr );
956
957                 /* toggle direction bit to clear FIFO and set DMA direction */
958                 dir <<= 8;
959                 st_dma.dma_mode_status = 0x90 | dir;
960                 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
961                 st_dma.dma_mode_status = 0x90 | dir;
962                 udelay(40);
963                 /* On writes, round up the transfer length to the next multiple of 512
964                  * (see also comment at atari_dma_xfer_len()). */
965                 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
966                 udelay(40);
967                 st_dma.dma_mode_status = 0x10 | dir;
968                 udelay(40);
969                 /* need not restore value of dir, only boolean value is tested */
970                 atari_dma_active = 1;
971         }
972
973         return( count );
974 }
975
976
977 static long atari_scsi_dma_residual( struct Scsi_Host *instance )
978 {
979         return( atari_dma_residual );
980 }
981
982
983 #define CMD_SURELY_BLOCK_MODE   0
984 #define CMD_SURELY_BYTE_MODE    1
985 #define CMD_MODE_UNKNOWN                2
986
987 static int falcon_classify_cmd( Scsi_Cmnd *cmd )
988 {
989         unsigned char opcode = cmd->cmnd[0];
990         
991         if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
992                 opcode == READ_BUFFER)
993                 return( CMD_SURELY_BYTE_MODE );
994         else if (opcode == READ_6 || opcode == READ_10 ||
995                  opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE ||
996                  opcode == RECOVER_BUFFERED_DATA) {
997                 /* In case of a sequential-access target (tape), special care is
998                  * needed here: The transfer is block-mode only if the 'fixed' bit is
999                  * set! */
1000                 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
1001                         return( CMD_SURELY_BYTE_MODE );
1002                 else
1003                         return( CMD_SURELY_BLOCK_MODE );
1004         }
1005         else
1006                 return( CMD_MODE_UNKNOWN );
1007 }
1008
1009
1010 /* This function calculates the number of bytes that can be transferred via
1011  * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
1012  * ST-DMA chip. There are only multiples of 512 bytes possible and max.
1013  * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
1014  * possible on the Falcon, since that would require to program the DMA for
1015  * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1016  * the overrun problem, so this question is academic :-)
1017  */
1018
1019 static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1020                                         Scsi_Cmnd *cmd,
1021                                         int write_flag )
1022 {
1023         unsigned long   possible_len, limit;
1024 #ifndef CONFIG_TT_DMA_EMUL
1025         if (MACH_IS_HADES)
1026                 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1027                 return( 0 );
1028 #endif  
1029         if (IS_A_TT())
1030                 /* TT SCSI DMA can transfer arbitrary #bytes */
1031                 return( wanted_len );
1032
1033         /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1034          * 255*512 bytes, but this should be enough)
1035          *
1036          * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1037          * that return a number of bytes which cannot be known beforehand. In this
1038          * case, the given transfer length is an "allocation length". Now it
1039          * can happen that this allocation length is a multiple of 512 bytes and
1040          * the DMA is used. But if not n*512 bytes really arrive, some input data
1041          * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1042          * between commands that do block transfers and those that do byte
1043          * transfers. But this isn't easy... there are lots of vendor specific
1044          * commands, and the user can issue any command via the
1045          * SCSI_IOCTL_SEND_COMMAND.
1046          *
1047          * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1048          * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1049          * and 3), the thing to do is obvious: allow any number of blocks via DMA
1050          * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1051          * the transfer (allocation) length is < 1024, hoping that no cmd. not
1052          * explicitly known as byte mode have such big allocation lengths...
1053          * BTW, all the discussion above applies only to reads. DMA writes are
1054          * unproblematic anyways, since the targets aborts the transfer after
1055          * receiving a sufficient number of bytes.
1056          *
1057          * Another point: If the transfer is from/to an non-ST-RAM address, we
1058          * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1059          */
1060
1061         if (write_flag) {
1062                 /* Write operation can always use the DMA, but the transfer size must
1063                  * be rounded up to the next multiple of 512 (atari_dma_setup() does
1064                  * this).
1065                  */
1066                 possible_len = wanted_len;
1067         }
1068         else {
1069                 /* Read operations: if the wanted transfer length is not a multiple of
1070                  * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1071                  * (no interrupt on DMA finished!)
1072                  */
1073                 if (wanted_len & 0x1ff)
1074                         possible_len = 0;
1075                 else {
1076                         /* Now classify the command (see above) and decide whether it is
1077                          * allowed to do DMA at all */
1078                         switch( falcon_classify_cmd( cmd )) {
1079                           case CMD_SURELY_BLOCK_MODE:
1080                                 possible_len = wanted_len;
1081                                 break;
1082                           case CMD_SURELY_BYTE_MODE:
1083                                 possible_len = 0; /* DMA prohibited */
1084                                 break;
1085                           case CMD_MODE_UNKNOWN:
1086                           default:
1087                                 /* For unknown commands assume block transfers if the transfer
1088                                  * size/allocation length is >= 1024 */
1089                                 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
1090                                 break;
1091                         }
1092                 }
1093         }
1094         
1095         /* Last step: apply the hard limit on DMA transfers */
1096         limit = (atari_dma_buffer && !STRAM_ADDR( virt_to_phys(cmd->SCp.ptr) )) ?
1097                     STRAM_BUFFER_SIZE : 255*512;
1098         if (possible_len > limit)
1099                 possible_len = limit;
1100
1101         if (possible_len != wanted_len)
1102                 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1103                            "instead of %ld\n", possible_len, wanted_len);
1104
1105         return( possible_len );
1106 }
1107
1108
1109 #endif  /* REAL_DMA */
1110
1111
1112 /* NCR5380 register access functions
1113  *
1114  * There are separate functions for TT and Falcon, because the access
1115  * methods are quite different. The calling macros NCR5380_read and
1116  * NCR5380_write call these functions via function pointers.
1117  */
1118
1119 static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
1120 {
1121         return( tt_scsi_regp[reg * 2] );
1122 }
1123
1124 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
1125 {
1126         tt_scsi_regp[reg * 2] = value;
1127 }
1128
1129 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
1130 {
1131         dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1132         return( (u_char)dma_wd.fdc_acces_seccount );
1133 }
1134
1135 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
1136 {
1137         dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1138         dma_wd.fdc_acces_seccount = (u_short)value;
1139 }
1140
1141
1142 #include "atari_NCR5380.c"
1143
1144 static struct scsi_host_template driver_template = {
1145         .proc_info              = atari_scsi_proc_info,
1146         .name                   = "Atari native SCSI",
1147         .detect                 = atari_scsi_detect,
1148         .release                = atari_scsi_release,
1149         .info                   = atari_scsi_info,
1150         .queuecommand           = atari_scsi_queue_command,
1151         .eh_abort_handler       = atari_scsi_abort,
1152         .eh_bus_reset_handler   = atari_scsi_bus_reset,
1153         .can_queue              = 0, /* initialized at run-time */
1154         .this_id                = 0, /* initialized at run-time */
1155         .sg_tablesize           = 0, /* initialized at run-time */
1156         .cmd_per_lun            = 0, /* initialized at run-time */
1157         .use_clustering         = DISABLE_CLUSTERING
1158 };
1159
1160
1161 #include "scsi_module.c"
1162
1163 MODULE_LICENSE("GPL");