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