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");