642de7b2b7a2596bdeac54bc1ea05105ad6c08ae
[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, 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, 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_interrupt() && falcon_got_lock && stdma_others_waiting() )
561                 sleep_on( &falcon_fairness_wait );
562
563         while (!falcon_got_lock) {
564                 if (in_interrupt())
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 #ifdef MODULE
767 int atari_scsi_release (struct Scsi_Host *sh)
768 {
769         if (IS_A_TT())
770                 free_irq(IRQ_TT_MFP_SCSI, scsi_tt_intr);
771         if (atari_dma_buffer)
772                 atari_stram_free (atari_dma_buffer);
773         return 1;
774 }
775 #endif
776
777 void __init atari_scsi_setup(char *str, int *ints)
778 {
779         /* Format of atascsi parameter is:
780          *   atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
781          * Defaults depend on TT or Falcon, hostid determined at run time.
782          * Negative values mean don't change.
783          */
784         
785         if (ints[0] < 1) {
786                 printk( "atari_scsi_setup: no arguments!\n" );
787                 return;
788         }
789
790         if (ints[0] >= 1) {
791                 if (ints[1] > 0)
792                         /* no limits on this, just > 0 */
793                         setup_can_queue = ints[1];
794         }
795         if (ints[0] >= 2) {
796                 if (ints[2] > 0)
797                         setup_cmd_per_lun = ints[2];
798         }
799         if (ints[0] >= 3) {
800                 if (ints[3] >= 0) {
801                         setup_sg_tablesize = ints[3];
802                         /* Must be <= SG_ALL (255) */
803                         if (setup_sg_tablesize > SG_ALL)
804                                 setup_sg_tablesize = SG_ALL;
805                 }
806         }
807         if (ints[0] >= 4) {
808                 /* Must be between 0 and 7 */
809                 if (ints[4] >= 0 && ints[4] <= 7)
810                         setup_hostid = ints[4];
811                 else if (ints[4] > 7)
812                         printk( "atari_scsi_setup: invalid host ID %d !\n", ints[4] );
813         }
814 #ifdef SUPPORT_TAGS
815         if (ints[0] >= 5) {
816                 if (ints[5] >= 0)
817                         setup_use_tagged_queuing = !!ints[5];
818         }
819 #endif
820 }
821
822 int atari_scsi_bus_reset(Scsi_Cmnd *cmd)
823 {
824         int             rv;
825         struct NCR5380_hostdata *hostdata =
826                 (struct NCR5380_hostdata *)cmd->device->host->hostdata;
827
828         /* For doing the reset, SCSI interrupts must be disabled first,
829          * since the 5380 raises its IRQ line while _RST is active and we
830          * can't disable interrupts completely, since we need the timer.
831          */
832         /* And abort a maybe active DMA transfer */
833         if (IS_A_TT()) {
834                 atari_turnoff_irq( IRQ_TT_MFP_SCSI );
835 #ifdef REAL_DMA
836                 tt_scsi_dma.dma_ctrl = 0;
837 #endif /* REAL_DMA */
838         }
839         else {
840                 atari_turnoff_irq( IRQ_MFP_FSCSI );
841 #ifdef REAL_DMA
842                 st_dma.dma_mode_status = 0x90;
843                 atari_dma_active = 0;
844                 atari_dma_orig_addr = NULL;
845 #endif /* REAL_DMA */
846         }
847
848         rv = NCR5380_bus_reset(cmd);
849
850         /* Re-enable ints */
851         if (IS_A_TT()) {
852                 atari_turnon_irq( IRQ_TT_MFP_SCSI );
853         }
854         else {
855                 atari_turnon_irq( IRQ_MFP_FSCSI );
856         }
857         if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS)
858                 falcon_release_lock_if_possible(hostdata);
859
860         return( rv );
861 }
862
863         
864 #ifdef CONFIG_ATARI_SCSI_RESET_BOOT
865 static void __init atari_scsi_reset_boot(void)
866 {
867         unsigned long end;
868         
869         /*
870          * Do a SCSI reset to clean up the bus during initialization. No messing
871          * with the queues, interrupts, or locks necessary here.
872          */
873
874         printk( "Atari SCSI: resetting the SCSI bus..." );
875
876         /* get in phase */
877         NCR5380_write( TARGET_COMMAND_REG,
878                       PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) ));
879
880         /* assert RST */
881         NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST );
882         /* The min. reset hold time is 25us, so 40us should be enough */
883         udelay( 50 );
884         /* reset RST and interrupt */
885         NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
886         NCR5380_read( RESET_PARITY_INTERRUPT_REG );
887
888         end = jiffies + AFTER_RESET_DELAY;
889         while (time_before(jiffies, end))
890                 barrier();
891
892         printk( " done\n" );
893 }
894 #endif
895
896
897 const char * atari_scsi_info (struct Scsi_Host *host)
898 {
899         /* atari_scsi_detect() is verbose enough... */
900         static const char string[] = "Atari native SCSI";
901         return string;
902 }
903
904
905 #if defined(REAL_DMA)
906
907 unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
908                                    unsigned long count, int dir )
909 {
910         unsigned long addr = virt_to_phys( data );
911
912         DMA_PRINTK("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, "
913                    "dir = %d\n", instance->host_no, data, addr, count, dir);
914
915         if (!IS_A_TT() && !STRAM_ADDR(addr)) {
916                 /* If we have a non-DMAable address on a Falcon, use the dribble
917                  * buffer; 'orig_addr' != 0 in the read case tells the interrupt
918                  * handler to copy data from the dribble buffer to the originally
919                  * wanted address.
920                  */
921                 if (dir)
922                         memcpy( atari_dma_buffer, data, count );
923                 else
924                         atari_dma_orig_addr = data;
925                 addr = atari_dma_phys_buffer;
926         }
927         
928         atari_dma_startaddr = addr;     /* Needed for calculating residual later. */
929   
930         /* Cache cleanup stuff: On writes, push any dirty cache out before sending
931          * it to the peripheral. (Must be done before DMA setup, since at least
932          * the ST-DMA begins to fill internal buffers right after setup. For
933          * reads, invalidate any cache, may be altered after DMA without CPU
934          * knowledge.
935          * 
936          * ++roman: For the Medusa, there's no need at all for that cache stuff,
937          * because the hardware does bus snooping (fine!).
938          */
939         dma_cache_maintenance( addr, count, dir );
940
941         if (count == 0)
942                 printk(KERN_NOTICE "SCSI warning: DMA programmed for 0 bytes !\n");
943
944         if (IS_A_TT()) {
945                 tt_scsi_dma.dma_ctrl = dir;
946                 SCSI_DMA_WRITE_P( dma_addr, addr );
947                 SCSI_DMA_WRITE_P( dma_cnt, count );
948                 tt_scsi_dma.dma_ctrl = dir | 2;
949         }
950         else { /* ! IS_A_TT */
951   
952                 /* set address */
953                 SCSI_DMA_SETADR( addr );
954
955                 /* toggle direction bit to clear FIFO and set DMA direction */
956                 dir <<= 8;
957                 st_dma.dma_mode_status = 0x90 | dir;
958                 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
959                 st_dma.dma_mode_status = 0x90 | dir;
960                 udelay(40);
961                 /* On writes, round up the transfer length to the next multiple of 512
962                  * (see also comment at atari_dma_xfer_len()). */
963                 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
964                 udelay(40);
965                 st_dma.dma_mode_status = 0x10 | dir;
966                 udelay(40);
967                 /* need not restore value of dir, only boolean value is tested */
968                 atari_dma_active = 1;
969         }
970
971         return( count );
972 }
973
974
975 static long atari_scsi_dma_residual( struct Scsi_Host *instance )
976 {
977         return( atari_dma_residual );
978 }
979
980
981 #define CMD_SURELY_BLOCK_MODE   0
982 #define CMD_SURELY_BYTE_MODE    1
983 #define CMD_MODE_UNKNOWN                2
984
985 static int falcon_classify_cmd( Scsi_Cmnd *cmd )
986 {
987         unsigned char opcode = cmd->cmnd[0];
988         
989         if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
990                 opcode == READ_BUFFER)
991                 return( CMD_SURELY_BYTE_MODE );
992         else if (opcode == READ_6 || opcode == READ_10 ||
993                  opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE ||
994                  opcode == RECOVER_BUFFERED_DATA) {
995                 /* In case of a sequential-access target (tape), special care is
996                  * needed here: The transfer is block-mode only if the 'fixed' bit is
997                  * set! */
998                 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
999                         return( CMD_SURELY_BYTE_MODE );
1000                 else
1001                         return( CMD_SURELY_BLOCK_MODE );
1002         }
1003         else
1004                 return( CMD_MODE_UNKNOWN );
1005 }
1006
1007
1008 /* This function calculates the number of bytes that can be transferred via
1009  * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
1010  * ST-DMA chip. There are only multiples of 512 bytes possible and max.
1011  * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
1012  * possible on the Falcon, since that would require to program the DMA for
1013  * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1014  * the overrun problem, so this question is academic :-)
1015  */
1016
1017 static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
1018                                         Scsi_Cmnd *cmd,
1019                                         int write_flag )
1020 {
1021         unsigned long   possible_len, limit;
1022 #ifndef CONFIG_TT_DMA_EMUL
1023         if (MACH_IS_HADES)
1024                 /* Hades has no SCSI DMA at all :-( Always force use of PIO */
1025                 return( 0 );
1026 #endif  
1027         if (IS_A_TT())
1028                 /* TT SCSI DMA can transfer arbitrary #bytes */
1029                 return( wanted_len );
1030
1031         /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1032          * 255*512 bytes, but this should be enough)
1033          *
1034          * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1035          * that return a number of bytes which cannot be known beforehand. In this
1036          * case, the given transfer length is an "allocation length". Now it
1037          * can happen that this allocation length is a multiple of 512 bytes and
1038          * the DMA is used. But if not n*512 bytes really arrive, some input data
1039          * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1040          * between commands that do block transfers and those that do byte
1041          * transfers. But this isn't easy... there are lots of vendor specific
1042          * commands, and the user can issue any command via the
1043          * SCSI_IOCTL_SEND_COMMAND.
1044          *
1045          * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1046          * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1047          * and 3), the thing to do is obvious: allow any number of blocks via DMA
1048          * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1049          * the transfer (allocation) length is < 1024, hoping that no cmd. not
1050          * explicitly known as byte mode have such big allocation lengths...
1051          * BTW, all the discussion above applies only to reads. DMA writes are
1052          * unproblematic anyways, since the targets aborts the transfer after
1053          * receiving a sufficient number of bytes.
1054          *
1055          * Another point: If the transfer is from/to an non-ST-RAM address, we
1056          * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1057          */
1058
1059         if (write_flag) {
1060                 /* Write operation can always use the DMA, but the transfer size must
1061                  * be rounded up to the next multiple of 512 (atari_dma_setup() does
1062                  * this).
1063                  */
1064                 possible_len = wanted_len;
1065         }
1066         else {
1067                 /* Read operations: if the wanted transfer length is not a multiple of
1068                  * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1069                  * (no interrupt on DMA finished!)
1070                  */
1071                 if (wanted_len & 0x1ff)
1072                         possible_len = 0;
1073                 else {
1074                         /* Now classify the command (see above) and decide whether it is
1075                          * allowed to do DMA at all */
1076                         switch( falcon_classify_cmd( cmd )) {
1077                           case CMD_SURELY_BLOCK_MODE:
1078                                 possible_len = wanted_len;
1079                                 break;
1080                           case CMD_SURELY_BYTE_MODE:
1081                                 possible_len = 0; /* DMA prohibited */
1082                                 break;
1083                           case CMD_MODE_UNKNOWN:
1084                           default:
1085                                 /* For unknown commands assume block transfers if the transfer
1086                                  * size/allocation length is >= 1024 */
1087                                 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
1088                                 break;
1089                         }
1090                 }
1091         }
1092         
1093         /* Last step: apply the hard limit on DMA transfers */
1094         limit = (atari_dma_buffer && !STRAM_ADDR( virt_to_phys(cmd->SCp.ptr) )) ?
1095                     STRAM_BUFFER_SIZE : 255*512;
1096         if (possible_len > limit)
1097                 possible_len = limit;
1098
1099         if (possible_len != wanted_len)
1100                 DMA_PRINTK("Sorry, must cut DMA transfer size to %ld bytes "
1101                            "instead of %ld\n", possible_len, wanted_len);
1102
1103         return( possible_len );
1104 }
1105
1106
1107 #endif  /* REAL_DMA */
1108
1109
1110 /* NCR5380 register access functions
1111  *
1112  * There are separate functions for TT and Falcon, because the access
1113  * methods are quite different. The calling macros NCR5380_read and
1114  * NCR5380_write call these functions via function pointers.
1115  */
1116
1117 static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
1118 {
1119         return( tt_scsi_regp[reg * 2] );
1120 }
1121
1122 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
1123 {
1124         tt_scsi_regp[reg * 2] = value;
1125 }
1126
1127 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
1128 {
1129         dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1130         return( (u_char)dma_wd.fdc_acces_seccount );
1131 }
1132
1133 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
1134 {
1135         dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1136         dma_wd.fdc_acces_seccount = (u_short)value;
1137 }
1138
1139
1140 #include "atari_NCR5380.c"
1141
1142 static struct scsi_host_template driver_template = {
1143         .proc_info              = atari_scsi_proc_info,
1144         .name                   = "Atari native SCSI",
1145         .detect                 = atari_scsi_detect,
1146         .release                = atari_scsi_release,
1147         .info                   = atari_scsi_info,
1148         .queuecommand           = atari_scsi_queue_command,
1149         .eh_abort_handler       = atari_scsi_abort,
1150         .eh_bus_reset_handler   = atari_scsi_bus_reset,
1151         .can_queue              = 0, /* initialized at run-time */
1152         .this_id                = 0, /* initialized at run-time */
1153         .sg_tablesize           = 0, /* initialized at run-time */
1154         .cmd_per_lun            = 0, /* initialized at run-time */
1155         .use_clustering         = DISABLE_CLUSTERING
1156 };
1157
1158
1159 #include "scsi_module.c"
1160
1161 MODULE_LICENSE("GPL");