drivers/scsi/atari_scsi.c

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