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