root/drivers/scsi/atari_scsi.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. scsi_dma_is_ignored_buserr
  2. scsi_dma_buserr
  3. scsi_tt_intr
  4. scsi_falcon_intr
  5. atari_scsi_fetch_restbytes
  6. falcon_release_lock_if_possible
  7. falcon_get_lock
  8. atari_queue_command
  9. atari_scsi_detect
  10. atari_scsi_release
  11. atari_scsi_setup
  12. atari_scsi_reset
  13. atari_scsi_reset_boot
  14. atari_scsi_info
  15. atari_scsi_dma_setup
  16. atari_scsi_dma_residual
  17. falcon_classify_cmd
  18. atari_dma_xfer_len
  19. atari_scsi_tt_reg_read
  20. atari_scsi_tt_reg_write
  21. atari_scsi_falcon_reg_read
  22. atari_scsi_falcon_reg_write

   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 README.legal 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 (NDEBUG_DMA) */
  72 
  73 #define AUTOSENSE
  74 /* For the Atari version, use only polled IO or REAL_DMA */
  75 #define REAL_DMA
  76 /* Support tagged queuing? (on devices that are able to... :-) */
  77 #define SUPPORT_TAGS
  78 #define MAX_TAGS 32
  79 
  80 #include <linux/types.h>
  81 #include <linux/stddef.h>
  82 #include <linux/ctype.h>
  83 #include <linux/delay.h>
  84 #include <linux/mm.h>
  85 #include <linux/blk.h>
  86 
  87 #include <asm/bootinfo.h>
  88 #include <asm/atarihw.h>
  89 #include <asm/atariints.h>
  90 #include <asm/page.h>
  91 #include <asm/pgtable.h>
  92 #include <asm/irq.h>
  93 #include <asm/traps.h>
  94 #include <asm/bitops.h>
  95 
  96 #include "scsi.h"
  97 #include "hosts.h"
  98 #include "atari_scsi.h"
  99 #include "NCR5380.h"
 100 #include "constants.h"
 101 #include <asm/atari_stdma.h>
 102 #include <asm/io.h>
 103 
 104 #include<linux/stat.h>
 105 
 106 struct proc_dir_entry proc_scsi_atari = {
 107     PROC_SCSI_ATARI, 5, "Atari",
 108     S_IFDIR | S_IRUGO | S_IXUGO, 2
 109 };
 110 
 111 #define IS_A_TT()       ATARIHW_PRESENT(TT_SCSI)
 112 
 113 #define SCSI_DMA_WRITE_P(elt,val)                               \
 114         do {                                                    \
 115                 unsigned long v = val;                          \
 116                 tt_scsi_dma.elt##_lo = v & 0xff;                \
 117                 v >>= 8;                                        \
 118                 tt_scsi_dma.elt##_lmd = v & 0xff;               \
 119                 v >>= 8;                                        \
 120                 tt_scsi_dma.elt##_hmd = v & 0xff;               \
 121                 v >>= 8;                                        \
 122                 tt_scsi_dma.elt##_hi = v & 0xff;                \
 123         } while(0)
 124 
 125 #define SCSI_DMA_READ_P(elt)                                    \
 126         (((unsigned long)tt_scsi_dma.elt##_hi  << 24) |         \
 127          ((unsigned long)tt_scsi_dma.elt##_hmd << 16) |         \
 128          ((unsigned long)tt_scsi_dma.elt##_lmd << 8) |          \
 129           (unsigned long)tt_scsi_dma.elt##_lo)
 130 
 131 
 132 #define SCSI_DMA_SETADR(adr)                            \
 133     do {                                                \
 134         unsigned long __adr = (adr);                    \
 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     } while(0)
 144 
 145 #define SCSI_DMA_GETADR() ({                            \
 146     unsigned long       __adr;                          \
 147     __adr = st_dma.dma_lo;                              \
 148     MFPDELAY();                                         \
 149     __adr |= (st_dma.dma_md & 0xff) << 8;               \
 150     MFPDELAY();                                         \
 151     __adr |= (st_dma.dma_hi & 0xff) << 16;              \
 152     MFPDELAY();                                         \
 153     __adr;                                              \
 154 })
 155 
 156 #define ENABLE_IRQ()                                    \
 157         do {                                            \
 158                 if (IS_A_TT())                          \
 159                         atari_enable_irq( IRQ_TT_MFP_SCSI );    \
 160                 else                                    \
 161                         atari_enable_irq( IRQ_MFP_FSCSI );      \
 162         } while(0)
 163 
 164 #define DISABLE_IRQ()                                   \
 165         do {                                            \
 166                 if (IS_A_TT())                          \
 167                         atari_disable_irq( IRQ_TT_MFP_SCSI );   \
 168                 else                                    \
 169                         atari_disable_irq( IRQ_MFP_FSCSI );     \
 170         } while(0)
 171 
 172 
 173 #define HOSTDATA_DMALEN         (((struct NCR5380_hostdata *) \
 174                                 (atari_scsi_host->hostdata))->dma_len)
 175 
 176 /* Time (in jiffies) to wait after a reset; the SCSI standard calls for 250ms,
 177  * we usually do 0.5s to be on the safe side. But Toshiba CD-ROMs once more
 178  * need ten times the standard value... */
 179 #ifndef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
 180 #define AFTER_RESET_DELAY       (HZ/2)
 181 #else
 182 #define AFTER_RESET_DELAY       (5*HZ/2)
 183 #endif
 184 
 185 /***************************** Prototypes *****************************/
 186 
 187 #ifdef REAL_DMA
 188 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat );
 189 static void scsi_dma_buserr( int irq, struct pt_regs *fp, void *dummy);
 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 void scsi_tt_intr( int irq, struct pt_regs *fp, void *dummy);
 197 static void scsi_falcon_intr( int irq, struct pt_regs *fp, void *dummy);
 198 static void falcon_release_lock_if_possible( struct NCR5380_hostdata *
 199                                              hostdata );
 200 static void falcon_get_lock( void );
 201 static void atari_scsi_reset_boot( void );
 202 static unsigned char atari_scsi_tt_reg_read( unsigned char reg );
 203 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value);
 204 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg );
 205 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value );
 206 
 207 /************************* End of Prototypes **************************/
 208 
 209 
 210 static struct Scsi_Host *atari_scsi_host = NULL;
 211 static unsigned char (*atari_scsi_reg_read)( unsigned char reg );
 212 static void (*atari_scsi_reg_write)( unsigned char reg, unsigned char value );
 213 
 214 #ifdef REAL_DMA
 215 static unsigned long    atari_dma_residual, atari_dma_startaddr;
 216 static short            atari_dma_active;
 217 /* pointer to the dribble buffer */
 218 static char             *atari_dma_buffer = NULL;
 219 /* precalculated physical address of the dribble buffer */
 220 static unsigned long    atari_dma_phys_buffer;
 221 /* != 0 tells the Falcon int handler to copy data from the dribble buffer */
 222 static char             *atari_dma_orig_addr;
 223 /* size of the dribble buffer; 4k seems enough, since the Falcon cannot use
 224  * scatter-gather anyway, so most transfers are 1024 byte only. In the rare
 225  * cases where requests to physical contiguous buffers have been merged, this
 226  * request is <= 4k (one page). So I don't think we have to split transfers
 227  * just due to this buffer size...
 228  */
 229 #define STRAM_BUFFER_SIZE       (4096)
 230 /* mask for address bits that can't be used with the ST-DMA */
 231 static unsigned long    atari_dma_stram_mask;
 232 #define STRAM_ADDR(a)   (((a) & atari_dma_stram_mask) == 0)
 233 /* number of bytes to cut from a transfer to handle NCR overruns */
 234 static int atari_read_overruns = 0;
 235 #endif
 236 
 237 int setup_can_queue = -1;
 238 int setup_cmd_per_lun = -1;
 239 int setup_sg_tablesize = -1;
 240 #ifdef SUPPORT_TAGS
 241 int setup_use_tagged_queuing = -1;
 242 #endif
 243 int setup_hostid = -1;
 244 
 245 
 246 #if defined(REAL_DMA)
 247 
 248 static int scsi_dma_is_ignored_buserr( unsigned char dma_stat )
     /* [previous][next][first][last][top][bottom][index][help] */
 249 {
 250         int i;
 251         unsigned long   addr = SCSI_DMA_READ_P( dma_addr ), end_addr;
 252 
 253         if (dma_stat & 0x01) {
 254 
 255                 /* A bus error happens when DMA-ing from the last page of a
 256                  * physical memory chunk (DMA prefetch!), but that doesn't hurt.
 257                  * Check for this case:
 258                  */
 259                 
 260                 for( i = 0; i < boot_info.num_memory; ++i ) {
 261                         end_addr = boot_info.memory[i].addr +
 262                                 boot_info.memory[i].size;
 263                         if (end_addr <= addr && addr <= end_addr + 4)
 264                                 return( 1 );
 265                 }
 266         }
 267         return( 0 );
 268 }
 269 
 270 
 271 static void scsi_dma_buserr (int irq, struct pt_regs *fp, void *dummy)
     /* [previous][next][first][last][top][bottom][index][help] */
 272 {
 273         unsigned char   dma_stat = tt_scsi_dma.dma_ctrl;
 274 
 275         /* Don't do anything if a NCR interrupt is pending. Probably it's just
 276          * masked... */
 277         if (atari_irq_pending( IRQ_TT_MFP_SCSI ))
 278                 return;
 279         
 280         printk("Bad SCSI DMA interrupt! dma_addr=0x%08lx dma_stat=%02x dma_cnt=%08lx\n",
 281                SCSI_DMA_READ_P(dma_addr), dma_stat, SCSI_DMA_READ_P(dma_cnt));
 282         if (dma_stat & 0x80) {
 283                 if (!scsi_dma_is_ignored_buserr( dma_stat ))
 284                         printk( "SCSI DMA bus error -- bad DMA programming!\n" );
 285         }
 286         else {
 287                 /* Under normal circumstances we never should get to this point,
 288                  * since both interrupts are triggered simultaneously and the 5380
 289                  * int has higher priority. When this irq is handled, that DMA
 290                  * interrupt is cleared. So a warning message is printed here.
 291                  */
 292                 printk( "SCSI DMA intr ?? -- this shouldn't happen!\n" );
 293         }
 294 }
 295 
 296 #endif
 297 
 298 
 299 static void scsi_tt_intr (int irq, struct pt_regs *fp, void *dummy)
     /* [previous][next][first][last][top][bottom][index][help] */
 300 {
 301         unsigned long   flags;
 302 #ifdef REAL_DMA
 303         int dma_stat;
 304 #endif
 305 
 306         /* If we got this interrupt, we don't need the other one from the DMA any
 307          * more. So clear it. */
 308         atari_clear_pending_irq( IRQ_TT_MFP_SCSIDMA );
 309         /* After this has been done, we can make this int handler "slow", i.e.
 310          * mask the NCR int and lower the IPL, as a slow int would do (see
 311          * arch/m68k/atari/ataints.c) */
 312         atari_disable_irq( IRQ_TT_MFP_SCSI );
 313         save_flags(flags);
 314         flags &= 0xf8ff;
 315         flags |= fp->sr & 0x0700;
 316         restore_flags(flags);
 317         
 318 #ifdef REAL_DMA
 319         dma_stat = tt_scsi_dma.dma_ctrl;
 320 
 321 #if (NDEBUG & NDEBUG_INTR)
 322         printk("scsi%d: NCR5380 interrupt, DMA status = %02x\n",
 323                atari_scsi_host->host_no, dma_stat & 0xff);
 324 #endif
 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( "SCSI DMA caused bus error near 0x%08lx\n",
 332                                         SCSI_DMA_READ_P( dma_addr ));
 333                         panic( "SCSI DMA bus error -- bad DMA programming!" );
 334                 }
 335         }
 336 
 337         /* If the DMA is active but not finished, we have the 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 #if (NDEBUG & NDEBUG_DMA)
 350                 printk( "SCSI DMA: There are %ld residual bytes.\n",
 351                                 atari_dma_residual );
 352 #endif
 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 #if (NDEBUG & NDEBUG_DMA)
 380                                 printk("SCSI DMA: DMA bug corrected, difference %ld bytes\n",
 381                                        512 - (atari_dma_residual & 0x1ff));
 382 #endif
 383                                 atari_dma_residual = (atari_dma_residual + 511) & ~0x1ff;
 384                         }
 385                 }
 386                 tt_scsi_dma.dma_ctrl = 0;
 387         }
 388 
 389         /* If the DMA is finished, fetch the rest bytes and turn it off */
 390         if (dma_stat & 0x40) {
 391                 atari_dma_residual = 0;
 392                 if ((dma_stat & 1) == 0)
 393                         atari_scsi_fetch_restbytes();
 394                 tt_scsi_dma.dma_ctrl = 0;
 395         }
 396 
 397 #endif /* REAL_DMA */
 398         
 399         NCR5380_intr (0, 0, 0);
 400 
 401         /* To be sure the int is not masked */
 402         atari_enable_irq( IRQ_TT_MFP_SCSI );
 403 }
 404 
 405 
 406 static void scsi_falcon_intr (int irq, struct pt_regs *fp, void *dummy)
     /* [previous][next][first][last][top][bottom][index][help] */
 407 {
 408 #ifdef REAL_DMA
 409         int dma_stat;
 410 
 411         /* Turn off DMA and select sector counter register before
 412          * accessing the status register (Atari recommendation!)
 413          */
 414         st_dma.dma_mode_status = 0x90;
 415         dma_stat = st_dma.dma_mode_status;
 416 
 417         /* Bit 0 indicates some error in the DMA process... don't know
 418          * what happened exactly (no further docu).
 419          */
 420         if (!(dma_stat & 0x01)) {
 421                 /* DMA error */
 422                 printk( "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR() );
 423         }
 424 
 425         /* If the DMA was active, but now bit 1 is not clear, it is some
 426          * other 5380 interrupt that finishes the DMA transfer. We have to
 427          * calculate the number of residual bytes and give a warning if
 428          * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
 429          */
 430         if (atari_dma_active && (dma_stat & 0x02)) {
 431                 unsigned long   transferred;
 432 
 433                 transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
 434                 /* The ST-DMA address is incremented in 2-byte steps, but the
 435                  * data are written only in 16-byte chunks. If the number of
 436                  * transferred bytes is not divisible by 16, the remainder is
 437                  * lost somewhere in outer space.
 438                  */
 439                 if (transferred & 15)
 440                         printk( "SCSI DMA error: %ld bytes lost in ST-DMA fifo :-((\n",
 441                                transferred & 15 );
 442 
 443                 atari_dma_residual = HOSTDATA_DMALEN - transferred;
 444 #if (NDEBUG & NDEBUG_DMA)
 445                 printk( "SCSI DMA: There are %ld residual bytes.\n",
 446                        atari_dma_residual );
 447 #endif
 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, (void *)PTOV(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 }
 466 
 467 
 468 #ifdef REAL_DMA
 469 static void atari_scsi_fetch_restbytes( void )
     /* [previous][next][first][last][top][bottom][index][help] */
 470 {
 471         int nr;
 472         char    *src, *dst;
 473 
 474         /* fetch rest bytes in the DMA register */
 475         dst = (char *)SCSI_DMA_READ_P( dma_addr );
 476         if ((nr = ((long)dst & 3))) {
 477                 /* there are 'nr' bytes left for the last long address before the
 478                    DMA pointer */
 479                 dst = (char *)( (unsigned long)dst & ~3 );
 480 #if (NDEBUG & NDEBUG_DMA)
 481                 printk( "SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
 482                        nr, (long)dst );
 483 #endif
 484                 dst = (char *)PTOV(dst);  /* The content of the DMA pointer
 485                                            * is a physical address! */
 486 #if (NDEBUG & NDEBUG_DMA)
 487                 printk( " = virt addr 0x%08lx\n", (long)dst );
 488 #endif
 489                 for( src = (char *)&tt_scsi_dma.dma_restdata; nr > 0; --nr )
 490                         *dst++ = *src++;
 491         }
 492 }
 493 #endif /* REAL_DMA */
 494 
 495 
 496 static int falcon_got_lock = 0;
 497 static struct wait_queue        *falcon_fairness_wait = NULL;
 498 static int falcon_trying_lock = 0;
 499 static struct wait_queue        *falcon_try_wait = NULL;
 500 static int falcon_dont_release = 0;
 501 
 502 /* This function releases the lock on the DMA chip if there is no
 503  * connected command and the disconnected queue is empty. On
 504  * releasing, instances of falcon_get_lock are awoken, that put
 505  * themselves to sleep for fairness. They can now try to get the lock
 506  * again (but others waiting longer more probably will win).
 507  */
 508 
 509 static void
 510 falcon_release_lock_if_possible( struct NCR5380_hostdata * hostdata )
     /* [previous][next][first][last][top][bottom][index][help] */
 511 {
 512         unsigned long   oldflags;
 513                 
 514         if (IS_A_TT()) return;
 515         
 516         save_flags(oldflags);
 517         cli();
 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                         restore_flags(oldflags);
 529                         return;
 530                 }
 531                 falcon_got_lock = 0;
 532                 stdma_release();
 533                 wake_up( &falcon_fairness_wait );
 534         }
 535 
 536         restore_flags(oldflags);
 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 )
     /* [previous][next][first][last][top][bottom][index][help] */
 555 {
 556         unsigned long   oldflags;
 557 
 558         if (IS_A_TT()) return;
 559 
 560         save_flags(oldflags);
 561         cli();
 562 
 563         while( intr_count == 0 && falcon_got_lock && stdma_others_waiting() )
 564                 sleep_on( &falcon_fairness_wait );
 565 
 566         while (!falcon_got_lock) {
 567                 if (intr_count > 0)
 568                         panic( "Falcon SCSI hasn't ST-DMA lock in interrupt" );
 569                 if (!falcon_trying_lock) {
 570                         falcon_trying_lock = 1;
 571                         stdma_lock(scsi_falcon_intr, NULL);
 572                         falcon_got_lock = 1;
 573                         falcon_trying_lock = 0;
 574                         wake_up( &falcon_try_wait );
 575                 }
 576                 else {
 577                         sleep_on( &falcon_try_wait );
 578                 }
 579         }       
 580 
 581         restore_flags(oldflags);
 582         if (!falcon_got_lock)
 583                 panic("Falcon SCSI: someone stole the lock :-(\n");
 584 }
 585 
 586 
 587 /* This is the wrapper function for NCR5380_queue_command(). It just
 588  * tries to get the lock on the ST-DMA (see above) and then calls the
 589  * original function.
 590  */
 591 
 592 #if 0
 593 int atari_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
     /* [previous][next][first][last][top][bottom][index][help] */
 594 {
 595         /* falcon_get_lock();
 596          * ++guenther: moved to NCR5380_queue_command() to prevent
 597          * race condition, see there for an explanation.
 598          */
 599         return( NCR5380_queue_command( cmd, done ) );
 600 }
 601 #endif
 602 
 603 
 604 #define RTC_READ(reg)                           \
 605     ({  unsigned char   __val;                  \
 606                 outb(reg,&tt_rtc.regsel);       \
 607                 __val = tt_rtc.data;            \
 608                 __val;                          \
 609         })
 610 
 611 #define RTC_WRITE(reg,val)                      \
 612     do {                                        \
 613                 outb(reg,&tt_rtc.regsel);       \
 614                 tt_rtc.data = (val);            \
 615         } while(0)
 616     
 617                                    
 618 int atari_scsi_detect (Scsi_Host_Template *host)
     /* [previous][next][first][last][top][bottom][index][help] */
 619 {
 620         static int called = 0;
 621         struct Scsi_Host *instance;
 622 
 623         if (!MACH_IS_ATARI ||
 624             (!ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(TT_SCSI)) ||
 625             called)
 626                 return( 0 );
 627 
 628         host->proc_dir = &proc_scsi_atari;
 629 
 630         atari_scsi_reg_read  = IS_A_TT() ? atari_scsi_tt_reg_read :
 631                                            atari_scsi_falcon_reg_read;
 632         atari_scsi_reg_write = IS_A_TT() ? atari_scsi_tt_reg_write :
 633                                            atari_scsi_falcon_reg_write;
 634 
 635         /* setup variables */
 636         host->can_queue =
 637                 (setup_can_queue > 0) ? setup_can_queue :
 638                 IS_A_TT() ? ATARI_TT_CAN_QUEUE : ATARI_FALCON_CAN_QUEUE;
 639         host->cmd_per_lun =
 640                 (setup_cmd_per_lun > 0) ? setup_cmd_per_lun :
 641                 IS_A_TT() ? ATARI_TT_CMD_PER_LUN : ATARI_FALCON_CMD_PER_LUN;
 642         /* Force sg_tablesize to 0 on a Falcon! */
 643         host->sg_tablesize =
 644                 !IS_A_TT() ? ATARI_FALCON_SG_TABLESIZE :
 645                 (setup_sg_tablesize >= 0) ? setup_sg_tablesize : ATARI_TT_SG_TABLESIZE;
 646 
 647         if (setup_hostid >= 0)
 648                 host->this_id = setup_hostid;
 649         else {
 650                 /* use 7 as default */
 651                 host->this_id = 7;
 652                 /* Test if a host id is set in the NVRam */
 653                 if (ATARIHW_PRESENT(TT_CLK)) {
 654                         unsigned char sum = 0, b;
 655                         int i;
 656                         
 657                         /* Make checksum */
 658                         for( i = 14; i < 62; ++i )
 659                                 sum += RTC_READ(i);
 660                         
 661                         if (/* NV-Ram checksum valid? */
 662                                 RTC_READ(62) == sum && RTC_READ(63) == ~sum &&
 663                                 /* Arbitration enabled? (for TOS) */
 664                                 (b = RTC_READ( 30 )) & 0x80) {
 665                                 host->this_id = b & 7;
 666                         }
 667                 }
 668         }
 669 
 670 #ifdef SUPPORT_TAGS
 671         if (setup_use_tagged_queuing < 0)
 672                 setup_use_tagged_queuing = DEFAULT_USE_TAGGED_QUEUING;
 673 #endif
 674 
 675         /* If running on a Falcon and if there's TT-Ram (i.e., more than one
 676          * memory block, since there's always ST-Ram in a Falcon), then allocate a
 677          * STRAM_BUFFER_SIZE byte dribble buffer for transfers from/to alternative
 678          * Ram.
 679          */
 680         if (MACH_IS_ATARI && ATARIHW_PRESENT(ST_SCSI) &&
 681             !ATARIHW_PRESENT(EXTD_DMA) && boot_info.num_memory > 1) {
 682                 atari_dma_buffer = scsi_init_malloc(STRAM_BUFFER_SIZE,
 683                                                     GFP_ATOMIC | GFP_DMA);
 684                 atari_dma_phys_buffer = VTOP( atari_dma_buffer );
 685                 atari_dma_orig_addr = 0;
 686         }
 687 
 688         instance = scsi_register (host, sizeof (struct NCR5380_hostdata));
 689         atari_scsi_host = instance;
 690         instance->irq = IS_A_TT() ? IRQ_TT_MFP_SCSI : IRQ_MFP_FSCSI;
 691 
 692         atari_scsi_reset_boot();
 693         NCR5380_init (instance, 0);
 694 
 695         if (IS_A_TT()) {
 696 
 697                 /* This int is actually "pseudo-slow", i.e. it acts like a slow
 698                  * interrupt after having cleared the pending flag for the DMA
 699                  * interrupt. */
 700                 add_isr(IRQ_TT_MFP_SCSI, scsi_tt_intr, IRQ_TYPE_PRIO,
 701                         NULL, "SCSI NCR5380");
 702                 tt_mfp.active_edge |= 0x80;             /* SCSI int on L->H */
 703 #ifdef REAL_DMA
 704                 /* On the TT, we got a second interrupt for DMA ready and DMA buserror.
 705                  * Since on DMA ready we get a "normal" interrupt, too, the service
 706                  * routine for the second int just checks for buserrs.
 707                  */
 708                 add_isr(IRQ_TT_MFP_SCSIDMA, scsi_dma_buserr, IRQ_TYPE_SLOW,
 709                         NULL, "SCSI DMA");
 710                 tt_mfp.active_edge &= ~0x20;    /* DMA int on H->L */
 711 
 712                 tt_scsi_dma.dma_ctrl = 0;
 713                 atari_dma_residual = 0;
 714 #endif /* REAL_DMA */
 715 
 716                 if (is_medusa) {
 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                 
 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( "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)
     /* [previous][next][first][last][top][bottom][index][help] */
 768 {
 769         if (IS_A_TT()) {
 770                 remove_isr (IRQ_TT_MFP_SCSI, scsi_tt_intr);
 771 #ifdef REAL_DMA
 772                 remove_isr (IRQ_TT_MFP_SCSIDMA, scsi_dma_buserr);
 773 #endif
 774         }
 775         if (atari_dma_buffer)
 776                 scsi_init_free (atari_dma_buffer, STRAM_BUFFER_SIZE);
 777         return 1;
 778 }
 779 #endif
 780 
 781 void atari_scsi_setup( char *str, int *ints )
     /* [previous][next][first][last][top][bottom][index][help] */
 782 {
 783         /* Format of atascsi parameter is:
 784          *   atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
 785          * Defaults depend on TT or Falcon, hostid determined at run time.
 786          * Negative values mean don't change.
 787          */
 788         
 789         /* Grmbl... the standard parameter parsing can't handle negative numbers
 790          * :-( So let's do it ourselves!
 791          */
 792 
 793         int i = ints[0]+1, fact;
 794 
 795         while( str && (isdigit(*str) || *str == '-') && i <= 10) {
 796                 if (*str == '-')
 797                         fact = -1, ++str;
 798                 else
 799                         fact = 1;
 800                 ints[i++] = simple_strtoul( str, NULL, 0 ) * fact;
 801                 if ((str = strchr( str, ',' )) != NULL)
 802                         ++str;
 803         }
 804         ints[0] = i-1;
 805         
 806         if (ints[0] < 1) {
 807                 printk( "atari_scsi_setup: no arguments!\n" );
 808                 return;
 809         }
 810 
 811         if (ints[0] >= 1) {
 812                 if (ints[1] > 0)
 813                         /* no limits on this, just > 0 */
 814                         setup_can_queue = ints[1];
 815         }
 816         if (ints[0] >= 2) {
 817                 if (ints[2] > 0)
 818                         setup_cmd_per_lun = ints[2];
 819         }
 820         if (ints[0] >= 3) {
 821                 if (ints[3] >= 0) {
 822                         setup_sg_tablesize = ints[3];
 823                         /* Must be <= SG_ALL (255) */
 824                         if (setup_sg_tablesize > SG_ALL)
 825                                 setup_sg_tablesize = SG_ALL;
 826                 }
 827         }
 828         if (ints[0] >= 4) {
 829                 /* Must be between 0 and 7 */
 830                 if (ints[4] >= 0 && ints[4] <= 7)
 831                         setup_hostid = ints[4];
 832                 else if (ints[4] > 7)
 833                         printk( "atari_scsi_setup: invalid host ID %d !\n", ints[4] );
 834         }
 835 #ifdef SUPPORT_TAGS
 836         if (ints[0] >= 5) {
 837                 if (ints[5] >= 0)
 838                         setup_use_tagged_queuing = !!ints[5];
 839         }
 840 #endif
 841 }
 842 
 843 int atari_scsi_reset( Scsi_Cmnd *cmd, unsigned int reset_flags)
     /* [previous][next][first][last][top][bottom][index][help] */
 844 {
 845         int             rv;
 846         struct NCR5380_hostdata *hostdata =
 847                 (struct NCR5380_hostdata *)cmd->host->hostdata;
 848 
 849         /* For doing the reset, SCSI interrupts must be disabled first,
 850          * since the 5380 raises its IRQ line while _RST is active and we
 851          * can't disable interrupts completely, since we need the timer.
 852          */
 853         /* And abort a maybe active DMA transfer */
 854         if (IS_A_TT()) {
 855                 atari_turnoff_irq( IRQ_TT_MFP_SCSI );
 856 #ifdef REAL_DMA
 857                 tt_scsi_dma.dma_ctrl = 0;
 858 #endif /* REAL_DMA */
 859         }
 860         else {
 861                 atari_turnoff_irq( IRQ_MFP_FSCSI );
 862 #ifdef REAL_DMA
 863                 st_dma.dma_mode_status = 0x90;
 864                 atari_dma_active = 0;
 865                 atari_dma_orig_addr = NULL;
 866 #endif /* REAL_DMA */
 867         }
 868 
 869         rv = NCR5380_reset(cmd, reset_flags);
 870 
 871         /* Re-enable ints */
 872         if (IS_A_TT()) {
 873                 atari_turnon_irq( IRQ_TT_MFP_SCSI );
 874         }
 875         else {
 876                 atari_turnon_irq( IRQ_MFP_FSCSI );
 877         }
 878         falcon_release_lock_if_possible(hostdata);
 879 
 880         return( rv );
 881 }
 882 
 883         
 884 static void atari_scsi_reset_boot( void )
     /* [previous][next][first][last][top][bottom][index][help] */
 885 {
 886         unsigned long end;
 887         
 888         /*
 889          * Do a SCSI reset to clean up the bus during initialization. No messing
 890          * with the queues, interrupts, or locks necessary here.
 891          */
 892 
 893         printk( "Atari SCSI: resetting the SCSI bus..." );
 894 
 895         /* get in phase */
 896         NCR5380_write( TARGET_COMMAND_REG,
 897                       PHASE_SR_TO_TCR( NCR5380_read(STATUS_REG) ));
 898 
 899         /* assert RST */
 900         NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST );
 901         /* The min. reset hold time is 25us, so 40us should be enough */
 902         udelay( 50 );
 903         /* reset RST and interrupt */
 904         NCR5380_write( INITIATOR_COMMAND_REG, ICR_BASE );
 905         NCR5380_read( RESET_PARITY_INTERRUPT_REG );
 906 
 907         for( end = jiffies + AFTER_RESET_DELAY; jiffies < end; )
 908                 barrier();
 909 
 910         printk( " done\n" );
 911 }
 912 
 913 
 914 const char * atari_scsi_info (struct Scsi_Host *host)
     /* [previous][next][first][last][top][bottom][index][help] */
 915 {
 916         /* atari_scsi_detect() is verbose enough... */
 917         static const char string[] = "Atari native SCSI";
 918         return string;
 919 }
 920 
 921 
 922 #if defined(REAL_DMA)
 923 
 924 unsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
     /* [previous][next][first][last][top][bottom][index][help] */
 925                                    unsigned long count, int dir )
 926 {
 927         unsigned long addr = VTOP( data );
 928 
 929 #if (NDEBUG & NDEBUG_DMA)
 930         printk ("scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, dir = %d\n",
 931                 instance->host_no, data, addr, count, dir);
 932 #endif
 933 
 934         if (!IS_A_TT() && !STRAM_ADDR(addr)) {
 935                 /* If we have a non-DMAable address on a Falcon, use the dribble
 936                  * buffer; 'orig_addr' != 0 in the read case tells the interrupt
 937                  * handler to copy data from the dribble buffer to the originally
 938                  * wanted address.
 939                  */
 940                 if (dir)
 941                         memcpy( atari_dma_buffer, data, count );
 942                 else
 943                         atari_dma_orig_addr = data;
 944                 addr = atari_dma_phys_buffer;
 945         }
 946         
 947         atari_dma_startaddr = addr;     /* Needed for calculating residual later. */
 948   
 949         /* Cache cleanup stuff: On writes, push any dirty cache out before sending
 950          * it to the peripheral. (Must be done before DMA setup, since at least
 951          * the ST-DMA begins to fill internal buffers right after setup. For
 952          * reads, invalidate any cache, may be altered after DMA without CPU
 953          * knowledge.
 954          * 
 955          * ++roman: For the Medusa, there's no need at all for that cache stuff,
 956          * because the hardware does bus snooping (fine!).
 957          */
 958         dma_cache_maintenance( addr, count, dir );
 959 
 960         if (count == 0)
 961                 printk("SCSI warning: DMA programmed for 0 bytes !\n");
 962 
 963         if (IS_A_TT()) {
 964                 tt_scsi_dma.dma_ctrl = dir;
 965                 SCSI_DMA_WRITE_P( dma_addr, addr );
 966                 SCSI_DMA_WRITE_P( dma_cnt, count );
 967                 tt_scsi_dma.dma_ctrl = dir | 2;
 968         }
 969         else { /* ! IS_A_TT */
 970   
 971                 /* set address */
 972                 SCSI_DMA_SETADR( addr );
 973 
 974                 /* toggle direction bit to clear FIFO and set DMA direction */
 975                 dir <<= 8;
 976                 st_dma.dma_mode_status = 0x90 | dir;
 977                 st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
 978                 st_dma.dma_mode_status = 0x90 | dir;
 979                 udelay(40);
 980                 /* On writes, round up the transfer length to the next multiple of 512
 981                  * (see also comment at atari_dma_xfer_len()). */
 982                 st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
 983                 udelay(40);
 984                 st_dma.dma_mode_status = 0x10 | dir;
 985                 udelay(40);
 986                 /* need not restore value of dir, only boolean value is tested */
 987                 atari_dma_active = 1;
 988         }
 989 
 990         return( count );
 991 }
 992 
 993 
 994 static long atari_scsi_dma_residual( struct Scsi_Host *instance )
     /* [previous][next][first][last][top][bottom][index][help] */
 995 {
 996         return( atari_dma_residual );
 997 }
 998 
 999 
1000 #define CMD_SURELY_BLOCK_MODE   0
1001 #define CMD_SURELY_BYTE_MODE    1
1002 #define CMD_MODE_UNKNOWN                2
1003 
1004 static int falcon_classify_cmd( Scsi_Cmnd *cmd )
     /* [previous][next][first][last][top][bottom][index][help] */
1005 {
1006         unsigned char opcode = cmd->cmnd[0];
1007         
1008         if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
1009                 opcode == READ_BUFFER)
1010                 return( CMD_SURELY_BYTE_MODE );
1011         else if (opcode == READ_6 || opcode == READ_10 ||
1012                  opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE ||
1013                  opcode == RECOVER_BUFFERED_DATA) {
1014                 /* In case of a sequential-access target (tape), special care is
1015                  * needed here: The transfer is block-mode only if the 'fixed' bit is
1016                  * set! */
1017                 if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
1018                         return( CMD_SURELY_BYTE_MODE );
1019                 else
1020                         return( CMD_SURELY_BLOCK_MODE );
1021         }
1022         else
1023                 return( CMD_MODE_UNKNOWN );
1024 }
1025 
1026 
1027 /* This function calculates the number of bytes that can be transferred via
1028  * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
1029  * ST-DMA chip. There are only multiples of 512 bytes possible and max.
1030  * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
1031  * possible on the Falcon, since that would require to program the DMA for
1032  * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
1033  * the overrun problem, so this question is academic :-)
1034  */
1035 
1036 static unsigned long atari_dma_xfer_len( unsigned long wanted_len,
     /* [previous][next][first][last][top][bottom][index][help] */
1037                                         Scsi_Cmnd *cmd,
1038                                         int write_flag )
1039 {
1040         unsigned long   possible_len, limit;
1041 
1042         if (IS_A_TT())
1043                 /* TT SCSI DMA can transfer arbitrary #bytes */
1044                 return( wanted_len );
1045 
1046         /* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
1047          * 255*512 bytes, but this should be enough)
1048          *
1049          * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
1050          * that return a number of bytes which cannot be known beforehand. In this
1051          * case, the given transfer length is an "allocation length". Now it
1052          * can happen that this allocation length is a multiple of 512 bytes and
1053          * the DMA is used. But if not n*512 bytes really arrive, some input data
1054          * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
1055          * between commands that do block transfers and those that do byte
1056          * transfers. But this isn't easy... there are lots of vendor specific
1057          * commands, and the user can issue any command via the
1058          * SCSI_IOCTL_SEND_COMMAND.
1059          *
1060          * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
1061          * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
1062          * and 3), the thing to do is obvious: allow any number of blocks via DMA
1063          * or none. In case 2), we apply some heuristic: Byte mode is assumed if
1064          * the transfer (allocation) length is < 1024, hoping that no cmd. not
1065          * explicitly known as byte mode have such big allocation lengths...
1066          * BTW, all the discussion above applies only to reads. DMA writes are
1067          * unproblematic anyways, since the targets aborts the transfer after
1068          * receiving a sufficient number of bytes.
1069          *
1070          * Another point: If the transfer is from/to an non-ST-RAM address, we
1071          * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
1072          */
1073 
1074         if (write_flag) {
1075                 /* Write operation can always use the DMA, but the transfer size must
1076                  * be rounded up to the next multiple of 512 (atari_dma_setup() does
1077                  * this).
1078                  */
1079                 possible_len = wanted_len;
1080         }
1081         else {
1082                 /* Read operations: if the wanted transfer length is not a multiple of
1083                  * 512, we cannot use DMA, since the ST-DMA cannot split transfers
1084                  * (no interrupt on DMA finished!)
1085                  */
1086                 if (wanted_len & 0x1ff)
1087                         possible_len = 0;
1088                 else {
1089                         /* Now classify the command (see above) and decide whether it is
1090                          * allowed to do DMA at all */
1091                         switch( falcon_classify_cmd( cmd )) {
1092                           case CMD_SURELY_BLOCK_MODE:
1093                                 possible_len = wanted_len;
1094                                 break;
1095                           case CMD_SURELY_BYTE_MODE:
1096                                 possible_len = 0; /* DMA prohibited */
1097                                 break;
1098                           case CMD_MODE_UNKNOWN:
1099                           default:
1100                                 /* For unknown commands assume block transfers if the transfer
1101                                  * size/allocation length is >= 1024 */
1102                                 possible_len = (wanted_len < 1024) ? 0 : wanted_len;
1103                                 break;
1104                         }
1105                 }
1106         }
1107         
1108         /* Last step: apply the hard limit on DMA transfers */
1109         limit = (atari_dma_buffer && !STRAM_ADDR( VTOP(cmd->SCp.ptr) )) ?
1110                     STRAM_BUFFER_SIZE : 255*512;
1111         if (possible_len > limit)
1112                 possible_len = limit;
1113 
1114 #if (NDEBUG & NDEBUG_DMA)
1115         if (possible_len != wanted_len)
1116                 printk( "Sorry, must cut DMA transfer size to %ld bytes instead of %ld\n",
1117                                 possible_len, wanted_len );
1118 #endif
1119 
1120         return( possible_len );
1121 }
1122 
1123 
1124 #endif  /* REAL_DMA */
1125 
1126 
1127 /* NCR5380 register access functions
1128  *
1129  * There are separate functions for TT and Falcon, because the access
1130  * methods are quite different. The calling macros NCR5380_read and
1131  * NCR5380_write call these functions via function pointers.
1132  */
1133 
1134 static unsigned char atari_scsi_tt_reg_read( unsigned char reg )
     /* [previous][next][first][last][top][bottom][index][help] */
1135 {
1136         return( tt_scsi_regp[reg * 2] );
1137 }
1138 
1139 static void atari_scsi_tt_reg_write( unsigned char reg, unsigned char value )
     /* [previous][next][first][last][top][bottom][index][help] */
1140 {
1141         tt_scsi_regp[reg * 2] = value;
1142 }
1143 
1144 static unsigned char atari_scsi_falcon_reg_read( unsigned char reg )
     /* [previous][next][first][last][top][bottom][index][help] */
1145 {
1146         dma_wd.dma_mode_status= (u_short)(0x88 + reg);
1147         return( (u_char)dma_wd.fdc_acces_seccount );
1148 }
1149 
1150 static void atari_scsi_falcon_reg_write( unsigned char reg, unsigned char value )
     /* [previous][next][first][last][top][bottom][index][help] */
1151 {
1152         dma_wd.dma_mode_status = (u_short)(0x88 + reg);
1153         dma_wd.fdc_acces_seccount = (u_short)value;
1154 }
1155 
1156 
1157 #include "atari_NCR5380.c"
1158 
1159 #ifdef MODULE
1160 Scsi_Host_Template driver_template = ATARI_SCSI;
1161 
1162 #include "scsi_module.c"
1163 #endif

/* [previous][next][first][last][top][bottom][index][help] */