root/drivers/scsi/NCR5380.c

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

DEFINITIONS

This source file includes following definitions.
  1. initialize_SCp
  2. NCR5380_print
  3. NCR5380_print_phase
  4. run_main
  5. should_disconnect
  6. NCR5380_set_timer
  7. NCR5380_timer_fn
  8. NCR5380_all_init
  9. probe_intr
  10. NCR5380_probe_irq
  11. NCR5380_print_options
  12. NCR5380_print_status
  13. NCR5380_init
  14. NCR5380_queue_command
  15. NCR5380_main
  16. NCR5380_intr
  17. NCR5380_select
  18. NCR5380_transfer_pio
  19. NCR5380_transfer_dma
  20. NCR5380_information_transfer
  21. NCR5380_reselect
  22. NCR5380_dma_complete
  23. NCR5380_abort
  24. NCR5380_reset

   1 #define NDEBUG (NDEBUG_RESTART_SELECT)
   2 /* 
   3  * NCR 5380 generic driver routines.  These should make it *trivial*
   4  *      to implement 5380 SCSI drivers under Linux with a non-trantor
   5  *      architecture.
   6  *
   7  *      Note that these routines also work with NR53c400 family chips.
   8  *
   9  * Copyright 1993, Drew Eckhardt
  10  *      Visionary Computing 
  11  *      (Unix and Linux consulting and custom programming)
  12  *      drew@colorado.edu
  13  *      +1 (303) 666-5836
  14  *
  15  * DISTRIBUTION RELEASE 6. 
  16  *
  17  * For more information, please consult 
  18  *
  19  * NCR 5380 Family
  20  * SCSI Protocol Controller
  21  * Databook
  22  *
  23  * NCR Microelectronics
  24  * 1635 Aeroplaza Drive
  25  * Colorado Springs, CO 80916
  26  * 1+ (719) 578-3400
  27  * 1+ (800) 334-5454
  28  */
  29 
  30 /*
  31  * $Log: NCR5380.c,v $
  32  * Revision 1.5  1994/01/19  09:14:57  drew
  33  * Fixed udelay() hack that was being used on DATAOUT phases
  34  * instead of a proper wait for the final handshake.
  35  *
  36  * Revision 1.4  1994/01/19  06:44:25  drew
  37  * *** empty log message ***
  38  *
  39  * Revision 1.3  1994/01/19  05:24:40  drew
  40  * Added support for TCR LAST_BYTE_SENT bit.
  41  *
  42  * Revision 1.2  1994/01/15  06:14:11  drew
  43  * REAL DMA support, bug fixes.
  44  *
  45  * Revision 1.1  1994/01/15  06:00:54  drew
  46  * Initial revision
  47  *
  48  */
  49 
  50 /*
  51  * Further development / testing that should be done : 
  52  * 1.  Cleanup the NCR5380_transfer_dma function and DMA operation complete
  53  *     code so that everything does the same thing that's done at the 
  54  *     end of a pseudo-DMA read operation.
  55  *
  56  * 2.  Fix REAL_DMA (interrupt driven, polled works fine) -
  57  *     basically, transfer size needs to be reduced by one 
  58  *     and the last byte read as is done with PSEUDO_DMA.
  59  * 
  60  * 3.  Test USLEEP code 
  61  *
  62  * 4.  Test SCSI-II tagged queueing (I have no devices which support 
  63  *      tagged queueing)
  64  *
  65  * 5.  Test linked command handling code after Eric is ready with 
  66  *      the high level code.
  67  */
  68 
  69 #ifndef notyet
  70 #undef LINKED
  71 #undef USLEEP
  72 #undef REAL_DMA
  73 #endif
  74 
  75 #ifdef REAL_DMA_POLL
  76 #undef READ_OVERRUNS
  77 #define READ_OVERRUNS
  78 #endif
  79 
  80 /*
  81  * Design
  82  * Issues :
  83  *
  84  * The other Linux SCSI drivers were written when Linux was Intel PC-only,
  85  * and specifically for each board rather than each chip.  This makes their
  86  * adaptation to platforms like the Mac (Some of which use NCR5380's)
  87  * more difficult than it has to be.
  88  *
  89  * Also, many of the SCSI drivers were written before the command queuing
  90  * routines were implemented, meaning their implementations of queued 
  91  * commands were hacked on rather than designed in from the start.
  92  *
  93  * When I designed the Linux SCSI drivers I figured that 
  94  * while having two different SCSI boards in a system might be useful
  95  * for debugging things, two of the same type wouldn't be used.
  96  * Well, I was wrong and a number of users have mailed me about running
  97  * multiple high-performance SCSI boards in a server.
  98  *
  99  * Finally, when I get questions from users, I have no idea what 
 100  * revision of my driver they are running.
 101  *
 102  * This driver attempts to address these problems :
 103  * This is a generic 5380 driver.  To use it on a different platform, 
 104  * one simply writes appropriate system specific macros (ie, data
 105  * transfer - some PC's will use the I/O bus, 68K's must use 
 106  * memory mapped) and drops this file in their 'C' wrapper.
 107  *
 108  * As far as command queueing, two queues are maintained for 
 109  * each 5380 in the system - commands that haven't been issued yet,
 110  * and commands that are currently executing.  This means that an 
 111  * unlimited number of commands may be queued, letting 
 112  * more commands propagate from the higher driver levels giving higher 
 113  * throughput.  Note that both I_T_L and I_T_L_Q nexuses are supported, 
 114  * allowing multiple commands to propagate all the way to a SCSI-II device 
 115  * while a command is already executing.
 116  *
 117  * To solve the multiple-boards-in-the-same-system problem, 
 118  * there is a separate instance structure for each instance
 119  * of a 5380 in the system.  So, multiple NCR5380 drivers will
 120  * be able to coexist with appropriate changes to the high level
 121  * SCSI code.  
 122  *
 123  * A NCR5380_PUBLIC_REVISION macro is provided, with the release
 124  * number (updated for each public release) printed by the 
 125  * NCR5380_print_options command, which should be called from the 
 126  * wrapper detect function, so that I know what release of the driver
 127  * users are using.
 128  *
 129  * Issues specific to the NCR5380 : 
 130  *
 131  * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead 
 132  * piece of hardware that requires you to sit in a loop polling for 
 133  * the REQ signal as long as you are connected.  Some devices are 
 134  * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect 
 135  * while doing long seek operations.
 136  * 
 137  * The workaround for this is to keep track of devices that have
 138  * disconnected.  If the device hasn't disconnected, for commands that
 139  * should disconnect, we do something like 
 140  *
 141  * while (!REQ is asserted) { sleep for N usecs; poll for M usecs }
 142  * 
 143  * Some tweaking of N and M needs to be done.  An algorithm based 
 144  * on "time to data" would give the best results as long as short time
 145  * to datas (ie, on the same track) were considered, however these 
 146  * broken devices are the exception rather than the rule and I'd rather
 147  * spend my time optimizing for the normal case.
 148  *
 149  * Architecture :
 150  *
 151  * At the heart of the design is a coroutine, NCR5380_main,
 152  * which is started when not running by the interrupt handler,
 153  * timer, and queue command function.  It attempts to establish
 154  * I_T_L or I_T_L_Q nexuses by removing the commands from the 
 155  * issue queue and calling NCR5380_select() if a nexus 
 156  * is not established. 
 157  *
 158  * Once a nexus is established, the NCR5380_information_transfer()
 159  * phase goes through the various phases as instructed by the target.
 160  * if the target goes into MSG IN and sends a DISCONNECT message,
 161  * the command structure is placed into the per instance disconnected
 162  * queue, and NCR5380_main tries to find more work.  If USLEEP
 163  * was defined, and the target is idle for too long, the system
 164  * will try to sleep.
 165  *
 166  * If a command has disconnected, eventually an interrupt will trigger,
 167  * calling NCR5380_intr()  which will in turn call NCR5380_reselect
 168  * to reestablish a nexus.  This will run main if necessary.
 169  *
 170  * On command termination, the done function will be called as 
 171  * appropriate.
 172  *
 173  * SCSI pointers are maintained in the SCp field of SCSI command 
 174  * structures, being initialized after the command is connected
 175  * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
 176  * Note that in violation of the standard, an implicit SAVE POINTERS operation
 177  * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
 178  */
 179 
 180 /*
 181  * Using this file :
 182  * This file a skeleton Linux SCSI driver for the NCR 5380 series
 183  * of chips.  To use it, you write a architecture specific functions 
 184  * and macros and include this file in your driver.
 185  *
 186  * These macros control options : 
 187  * AUTOPROBE_IRQ - if defined, the NCR5380_probe_irq() function will be 
 188  *      defined.
 189  * 
 190  * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
 191  *      for commands that return with a CHECK CONDITION status. 
 192  *
 193  * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
 194  *      transceivers. 
 195  *
 196  * LIMIT_TRANSFERSIZE - if defined, limit the pseudo-dma transfers to 512
 197  *      bytes at a time.  Since interrupts are disabled by default during
 198  *      these transfers, we might need this to give reasonable interrupt
 199  *      service time if the transfer size gets too large.
 200  *
 201  * LINKED - if defined, linked commands are supported.
 202  *
 203  * PSEUDO_DMA - if defined, PSEUDO DMA is used during the data transfer phases.
 204  *
 205  * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
 206  *
 207  * REAL_DMA_POLL - if defined, REAL DMA is used but the driver doesn't
 208  *      rely on phase mismatch and EOP interrupts to determine end 
 209  *      of phase.
 210  *
 211  * SCSI2 - if defined, SCSI-2 tagged queuing is used where possible
 212  *
 213  * UNSAFE - leave interrupts enabled during pseudo-DMA transfers.  You
 214  *          only really want to use this if you're having a problem with
 215  *          dropped characters during high speed communications, and even
 216  *          then, you're going to be better off twiddling with transfersize
 217  *          in the high level code.
 218  *
 219  * USLEEP - if defined, on devices that aren't disconnecting from the 
 220  *      bus, we will go to sleep so that the CPU can get real work done 
 221  *      when we run a command that won't complete immediately.
 222  *
 223  * Note that if USLEEP is defined, NCR5380_TIMER *must* also be
 224  * defined.
 225  *
 226  * Defaults for these will be provided if USLEEP is defined, although
 227  * the user may want to adjust these to allocate CPU resources to 
 228  * the SCSI driver or "real" code.
 229  * 
 230  * USLEEP_SLEEP - amount of time, in jiffies, to sleep
 231  *
 232  * USLEEP_POLL - amount of time, in jiffies, to poll
 233  *
 234  * These macros MUST be defined :
 235  * NCR5380_local_declare() - declare any local variables needed for your transfer
 236  *      routines.
 237  *
 238  * NCR5380_setup(instance) - initialize any local variables needed from a given
 239  *      instance of the host adapter for NCR5380_{read,write,pread,pwrite}
 240  * 
 241  * NCR5380_read(register)  - read from the specified register
 242  *
 243  * NCR5380_write(register, value) - write to the specific register 
 244  *
 245  * NCR5380_implementation_fields  - additional fields needed for this 
 246  *      specific implementation of the NCR5380
 247  *
 248  * Either real DMA *or* pseudo DMA may be implemented
 249  * REAL functions : 
 250  * NCR5380_REAL_DMA should be defined if real DMA is to be used.
 251  * Note that the DMA setup functions should return the number of bytes 
 252  *      that they were able to program the controller for.
 253  *
 254  * Also note that generic i386/PC versions of these macros are 
 255  *      available as NCR5380_i386_dma_write_setup,
 256  *      NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
 257  *
 258  * NCR5380_dma_write_setup(instance, src, count) - initialize
 259  * NCR5380_dma_read_setup(instance, dst, count) - initialize
 260  * NCR5380_dma_residual(instance); - residual count
 261  *
 262  * PSEUDO functions :
 263  * NCR5380_pwrite(instance, src, count)
 264  * NCR5380_pread(instance, dst, count);
 265  *
 266  * If nothing specific to this implementation needs doing (ie, with external
 267  * hardware), you must also define 
 268  *  
 269  * NCR5380_queue_command
 270  * NCR5380_reset
 271  * NCR5380_abort
 272  *
 273  * to be the global entry points into the specific driver, ie 
 274  * #define NCR5380_queue_command t128_queue_command.
 275  *
 276  * If this is not done, the routines will be defined as static functions
 277  * with the NCR5380* names and the user must provide a globally
 278  * accessible wrapper function.
 279  *
 280  * The generic driver is initialized by calling NCR5380_init(instance),
 281  * after setting the appropriate host specific fields and ID.  If the 
 282  * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
 283  * possible) function may be used.  Before the specific driver initialization
 284  * code finishes, NCR5380_print_options should be called.
 285  */
 286 
 287 static struct Scsi_Host *first_instance = NULL;
 288 static Scsi_Host_Template *the_template = NULL;
 289 
 290 /*
 291  * Function : void initialize_SCp(Scsi_Cmnd *cmd)
 292  *
 293  * Purpose : initialize the saved data pointers for cmd to point to the 
 294  *      start of the buffer.
 295  *
 296  * Inputs : cmd - Scsi_Cmnd structure to have pointers reset.
 297  */
 298 
 299 static __inline__ void initialize_SCp(Scsi_Cmnd *cmd) {
     /* [previous][next][first][last][top][bottom][index][help] */
 300     /* 
 301      * Initialize the Scsi Pointer field so that all of the commands in the 
 302      * various queues are valid.
 303      */
 304 
 305     if (cmd->use_sg) {
 306         cmd->SCp.buffer = (struct scatterlist *) cmd->buffer;
 307         cmd->SCp.buffers_residual = cmd->use_sg - 1;
 308         cmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
 309         cmd->SCp.this_residual = cmd->SCp.buffer->length;
 310     } else {
 311         cmd->SCp.buffer = NULL;
 312         cmd->SCp.buffers_residual = 0;
 313         cmd->SCp.ptr = (char *) cmd->request_buffer;
 314         cmd->SCp.this_residual = cmd->request_bufflen;
 315     }
 316 }
 317 
 318 #include <linux/delay.h>
 319 
 320 #ifdef NDEBUG
 321 static struct {
 322     unsigned char mask;
 323     char * name;} 
 324 signals[] = {{ SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" }, 
 325     { SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD,  "CD" }, { SR_IO, "IO" }, 
 326     { SR_SEL, "SEL" }, {0, NULL}}, 
 327 basrs[] = {{BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}},
 328 icrs[] = {{ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
 329     {ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"}, 
 330     {ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"}, 
 331     {0, NULL}},
 332 mrs[] = {{MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"}, 
 333     {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR, 
 334     "MODE PARITY INTR"}, {MR_MONITOR_BSY, "MODE MONITOR BSY"},
 335     {MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"}, 
 336     {0, NULL}};
 337 
 338 /*
 339  * Function : void NCR5380_print(struct Scsi_Host *instance)
 340  *
 341  * Purpose : print the SCSI bus signals for debugging purposes
 342  *
 343  * Input : instance - which NCR5380
 344  */
 345 
 346 static void NCR5380_print(struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
 347     NCR5380_local_declare();
 348     unsigned char status, data, basr, mr, icr, i;
 349     NCR5380_setup(instance);
 350     cli();
 351     data = NCR5380_read(CURRENT_SCSI_DATA_REG);
 352     status = NCR5380_read(STATUS_REG);
 353     mr = NCR5380_read(MODE_REG);
 354     icr = NCR5380_read(INITIATOR_COMMAND_REG);
 355     basr = NCR5380_read(BUS_AND_STATUS_REG);
 356     sti();
 357     for (i = 0; signals[i].mask ; ++i) 
 358         if (status & signals[i].mask)
 359             printk(" %s", signals[i].name);
 360     for (i = 0; basrs[i].mask ; ++i) 
 361         if (basr & basrs[i].mask)
 362             printk(" %s", basrs[i].name);
 363     for (i = 0; icrs[i].mask; ++i) 
 364         if (icr & icrs[i].mask)
 365             printk(" %s", icrs[i].name);
 366     for (i = 0; mrs[i].mask; ++i) 
 367         if (mr & mrs[i].mask)
 368             printk(" %s", mrs[i].name);
 369     printk("\n");
 370 }
 371 
 372 static struct {
 373     unsigned char value;
 374     char *name;
 375 } phases[] = {
 376 {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
 377 {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
 378 {PHASE_UNKNOWN, "UNKNOWN"}};
 379 
 380 /* 
 381  * Function : void NCR5380_print_phase(struct Scsi_Host *instance)
 382  *
 383  * Purpose : print the current SCSI phase for debugging purposes
 384  *
 385  * Input : instance - which NCR5380
 386  */
 387 
 388 static void NCR5380_print_phase(struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
 389     NCR5380_local_declare();
 390     unsigned char status;
 391     int i;
 392     NCR5380_setup(instance);
 393 
 394     status = NCR5380_read(STATUS_REG);
 395     if (!(status & SR_REQ)) 
 396         printk("scsi%d : REQ not asserted, phase unknown.\n", 
 397             instance->host_no);
 398     else {
 399         for (i = 0; (phases[i].value != PHASE_UNKNOWN) && 
 400             (phases[i].value != (status & PHASE_MASK)); ++i); 
 401         printk("scsi%d : phase %s\n", instance->host_no, phases[i].name);
 402     }
 403 }
 404 #endif
 405 
 406 /*
 407  * We need to have our coroutine active given these constraints : 
 408  * 1.  The mutex flag, main_running, can only be set when the main 
 409  *     routine can actually process data, otherwise SCSI commands
 410  *     will never get issued.
 411  *
 412  * 2.  NCR5380_main() shouldn't be called before it has exited, because
 413  *     other drivers have had kernel stack overflows in similar
 414  *     situations.
 415  *
 416  * 3.  We don't want to inline NCR5380_main() because of space concerns,
 417  *     even though it is only called in two places.
 418  *
 419  * So, the solution is to set the mutex in an inline wrapper for the 
 420  * main coroutine, and have the main coroutine exit with interrupts 
 421  * disabled after the final search through the queues so that no race 
 422  * conditions are possible.
 423  */
 424 
 425 static volatile int main_running = 0;
 426 
 427 /* 
 428  * Function : run_main(void)
 429  * 
 430  * Purpose : insure that the coroutine is running and will process our 
 431  *      request.  main_running is checked/set here (in an inline function)
 432  *      rather than in NCR5380_main itself to reduce the chances of stack
 433  *      overflow.
 434  *
 435  */
 436 
 437 static __inline__ void run_main(void) {
     /* [previous][next][first][last][top][bottom][index][help] */
 438     cli();
 439     if (!main_running) {
 440         main_running = 1;
 441         NCR5380_main();
 442         /* 
 443          * main_running is cleared in NCR5380_main once it can't do 
 444          * more work, and NCR5380_main exits with interrupts disabled.
 445          */
 446         sti();
 447     } else 
 448         sti();
 449 }
 450 
 451 #ifdef USLEEP
 452 #ifndef NCR5380_TIMER
 453 #error "NCR5380_TIMER must be defined so that this type of NCR5380 driver gets a unique timer."
 454 #endif
 455 
 456 /*
 457  * These need tweaking, and would probably work best as per-device 
 458  * flags initialized differently for disk, tape, cd, etc devices.
 459  * People with broken devices are free to experiment as to what gives
 460  * the best results for them.
 461  *
 462  * USLEEP_SLEEP should be a minimum seek time.
 463  *
 464  * USLEEP_POLL should be a maximum rotational latency.
 465  */
 466 #ifndef USLEEP_SLEEP
 467 /* 20 ms (reasonable hard disk speed) */
 468 #define USLEEP_SLEEP 2
 469 #endif
 470 /* 300 RPM (floppy speed) */
 471 #ifndef USLEEP_POLL
 472 #define USLEEP_POLL 20
 473 #endif
 474 
 475 static struct Scsi_Host * expires_first = NULL;
 476 
 477 /* 
 478  * Function : int should_disconnect (unsigned char cmd)
 479  *
 480  * Purpose : decide weather a command would normally disconnect or 
 481  *      not, since if it won't disconnect we should go to sleep.
 482  *
 483  * Input : cmd - opcode of SCSI command
 484  *
 485  * Returns : DISCONNECT_LONG if we should disconnect for a really long 
 486  *      time (ie always, sleep, look for REQ active, sleep), 
 487  *      DISCONNECT_TIME_TO_DATA if we would only disconnect for a normal
 488  *      time-to-data delay, DISCONNECT_NONE if this command would return
 489  *      immediately.
 490  *
 491  *      Future sleep algorithms based on time to data can exploit 
 492  *      something like this so they can differentiate between "normal" 
 493  *      (ie, read, write, seek) and unusual commands (ie, * format).
 494  *
 495  * Note : We don't deal with commands that handle an immediate disconnect,
 496  *        
 497  */
 498 
 499 static int should_disconnect (unsigned char cmd) {
     /* [previous][next][first][last][top][bottom][index][help] */
 500     switch (cmd) {
 501     case READ_6:
 502     case WRITE_6:
 503     case SEEK_6:
 504     case READ_10:
 505     case WRITE_10:
 506     case SEEK_10:
 507         return DISCONNECT_TIME_TO_DATA;
 508     case FORMAT_UNIT:
 509     case SEARCH_HIGH:
 510     case SEARCH_LOW:
 511     case SEARCH_EQUAL:
 512         return DISCONNECT_LONG;
 513     default:
 514         return DISCONNECT_NONE;
 515     }
 516 }
 517 
 518 /*
 519  * Assumes instance->time_expires has been set in higher level code.
 520  */
 521 
 522 static int NCR5380_set_timer (struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
 523     struct Scsi_Host *tmp, **prev;
 524     
 525     cli();
 526     if (((struct NCR5380_hostdata *) (instance->host_data))->next_timer) {
 527         sti();
 528         return -1;
 529     }
 530 
 531     for (prev = &expires_first, tmp = expires_first; tmp; 
 532         prev = &(((struct NCR5380_hostdata *) tmp->host_data)->next_timer), 
 533         tmp = ((struct NCR5380_hostdata *) tmp->host_data)->next_timer)
 534         if (instance->time_expires < tmp->time_expires) 
 535             break;
 536            
 537     instance->next_timer = tmp;
 538     *prev = instance;
 539     timer_table[NCR5380_TIMER].expires = expires_first->time_expires;
 540     timer_active |= 1 << NCR5380_TIMER;
 541     sti;
 542     return 0;
 543 }    
 544 
 545 /* Doing something about unwanted reentrancy here might be useful */
 546 void NCR5380_timer_fn(void) {
     /* [previous][next][first][last][top][bottom][index][help] */
 547     struct Scsi_Host *instance;
 548     cli();
 549     for (; expires_first && expires_first->time_expires >= jiffies; ) {
 550         instance = ((NCR5380_hostdata *) expires_first->host_data)->
 551             expires_next;
 552         ((NCR5380_hostdata *) expires_first->host_data)->expires_next = 
 553             NULL;
 554         ((NCR5380_hostdata *) expires_first->host_data)->time_expires = 
 555             0;
 556         expires_first = instance;
 557     }
 558 
 559     if (expires_first) {
 560         timer_table[NCR5380_TIMER].expires = ((NCR5380_hostdata *) 
 561             expires_first->host_data)->time_expires;
 562         timer_active |= (1 << NCR5380_TIMER);
 563     } else {
 564         timer_table[NCR5380_TIMER].expires = 0;
 565         timer_active &= ~(1 << MCR5380_TIMER);
 566     }
 567     sti();
 568 
 569     run_main();
 570 }
 571 #endif /* def USLEEP */
 572 
 573 static void NCR5380_all_init (void) {
     /* [previous][next][first][last][top][bottom][index][help] */
 574     static int done = 0;
 575     if (!done) {
 576 #if (NDEBUG & NDEBUG_INIT)
 577         printk("scsi : NCR5380_all_init()\n");
 578 #endif
 579         done = 1;
 580 #ifdef USLEEP
 581         timer_table[NCR5380_TIMER].expires = 0;
 582         timer_table[NCR5380_TIMER].fn = NCR5380_timer_fn;
 583 #endif
 584     }
 585 }
 586 
 587 #ifdef AUTOPROBE_IRQ
 588 /*
 589  * Function : int NCR5380_probe_irq (struct Scsi_Host *instance, int possible)
 590  * 
 591  * Purpose : autoprobe for the IRQ line used by the NCR5380.  
 592  *
 593  * Inputs : instance - pointer to this instance of the NCR5380 driver,
 594  *          possible - bitmask of permissible interrupts.
 595  *
 596  * Returns : number of the IRQ selected, IRQ_NONE if no interrupt fired.
 597  * 
 598  * XXX no effort is made to deal with spurious interrupts. 
 599  */
 600 
 601 
 602 static int probe_irq;
 603 static void probe_intr (int sig) {
     /* [previous][next][first][last][top][bottom][index][help] */
 604     probe_irq = sig;
 605 };
 606 
 607 static int NCR5380_probe_irq (struct Scsi_Host *instance, int possible) {
     /* [previous][next][first][last][top][bottom][index][help] */
 608     NCR5380_local_declare();
 609     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
 610          instance->hostdata;
 611     unsigned long timeout;
 612     int trying_irqs, i, mask;
 613     NCR5380_setup(instance);
 614 
 615     for (trying_irqs = i = 0, mask = 1; i < 16; ++i, mask <<= 1) 
 616         if ((mask & possible) &&  (request_irq(i, &probe_intr, SA_INTERRUPT, "NCR-probe") 
 617             == 0)) 
 618             trying_irqs |= mask;
 619 
 620     timeout = jiffies + 25;
 621     probe_irq = IRQ_NONE;
 622 
 623 /*
 624  * A interrupt is triggered whenever BSY = false, SEL = true
 625  * and a bit set in the SELECT_ENABLE_REG is asserted on the 
 626  * SCSI bus.
 627  *
 628  * Note that the bus is only driven when the phase control signals
 629  * (I/O, C/D, and MSG) match those in the TCR, so we must reset that
 630  * to zero.
 631  */
 632 
 633     NCR5380_write(TARGET_COMMAND_REG, 0);
 634     NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
 635     NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
 636     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | 
 637         ICR_ASSERT_SEL);
 638 
 639     while (probe_irq == IRQ_NONE && jiffies < timeout);
 640 
 641     NCR5380_write(SELECT_ENABLE_REG, 0);
 642     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
 643 
 644     for (i = 0, mask = 1; i < 16; ++i, mask <<= 1)
 645         if (trying_irqs & mask) 
 646             free_irq(i);
 647 
 648     return probe_irq;
 649 }
 650 #endif /* AUTOPROBE_IRQ */
 651  
 652 /*
 653  * Function : void NCR58380_print_options (struct Scsi_Host *instance)
 654  *
 655  * Purpose : called by probe code indicating the NCR5380 driver
 656  *           options that were selected.
 657  *
 658  * Inputs : instance, pointer to this instance.  Unused.
 659  */
 660 
 661 static void NCR5380_print_options (struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
 662     printk(" generic options"
 663 #ifdef AUTOPROBE_IRQ
 664     " AUTOPROBE_IRQ"
 665 #endif
 666 #ifdef AUTOSENSE 
 667     " AUTOSENSE"
 668 #endif
 669 #ifdef DIFFERENTIAL
 670     " DIFFERENTIAL"
 671 #endif
 672 #ifdef REAL_DMA
 673     " REAL DMA"
 674 #endif
 675 #ifdef REAL_DMA_POLL
 676     " REAL DMA POLL"
 677 #endif
 678 #ifdef PARITY
 679     " PARITY"
 680 #endif
 681 #ifdef PSEUDO_DMA
 682     " PSEUDO DMA"
 683 #endif
 684 #ifdef SCSI2
 685     " SCSI-2"
 686 #endif
 687 #ifdef UNSAFE
 688     " UNSAFE "
 689 #endif
 690     );
 691 #ifdef USLEEP
 692     printk(" USLEEP, USLEEP_POLL=%d USLEEP_SLEEP=%d", USLEEP_POLL, USLEEP_SLEEP);
 693 #endif
 694     printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
 695 #ifdef NCR53C400
 696     if (hostdata->flags & FLAG_NCR53C400) {
 697         printk(" ncr53c400 release=%d", NCR53C400_PUBLIC_RELEASE);
 698     }
 699 #endif
 700 }
 701 
 702 /*
 703  * Function : void NCR5380_print_status (struct Scsi_Host *instance)
 704  *
 705  * Purpose : print commands in the various queues, called from
 706  *      NCR5380_abort and NCR5380_debug to aid debugging.
 707  *
 708  * Inputs : instance, pointer to this instance.  
 709  */
 710 
 711 static void NCR5380_print_status (struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
 712     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) 
 713         instance->hostdata;
 714     Scsi_Cmnd *ptr;
 715 
 716 
 717     printk("NCR5380 : coroutine is%s running.\n",
 718         main_running ? "" : "n't");
 719     
 720 #ifdef NDEBUG
 721     NCR5380_print (instance);
 722     NCR5380_print_phase (instance);
 723 #endif
 724 
 725     cli();
 726     if (!hostdata->connected) {
 727         printk ("scsi%d: no currently connected command\n",
 728             instance->host_no);
 729     } else {
 730         print_Scsi_Cmnd ((Scsi_Cmnd *) hostdata->connected);
 731     }
 732 
 733     printk ("scsi%d: issue_queue\n", instance->host_no);
 734 
 735     for (ptr = (Scsi_Cmnd *) hostdata->issue_queue; ptr; 
 736         ptr = (Scsi_Cmnd *) ptr->host_scribble) 
 737         print_Scsi_Cmnd (ptr);
 738 
 739     printk ("scsi%d: disconnected_queue\n", instance->host_no);
 740 
 741     for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr; 
 742         ptr = (Scsi_Cmnd *) ptr->host_scribble) 
 743         print_Scsi_Cmnd (ptr);
 744     
 745     sti();
 746 }
 747 
 748 
 749 /* 
 750  * Function : void NCR5380_init (struct Scsi_Host *instance, flags)
 751  *
 752  * Purpose : initializes *instance and corresponding 5380 chip,
 753  *      with flags OR'd into the initial flags value.
 754  *
 755  * Inputs : instance - instantiation of the 5380 driver.  
 756  *
 757  * Notes : I assume that the host, hostno, and id bits have been
 758  *      set correctly.  I don't care about the irq and other fields. 
 759  * 
 760  */
 761 
 762 static void NCR5380_init (struct Scsi_Host *instance, int flags) {
     /* [previous][next][first][last][top][bottom][index][help] */
 763     NCR5380_local_declare();
 764     int i;
 765     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) 
 766         instance->hostdata;
 767 
 768     /* 
 769      * On NCR53C400 boards, NCR5380 registers are mapped 8 past 
 770      * the base address.
 771      */
 772 
 773     if (flags & FLAG_NCR53C400)
 774         instance->io_port += 8;
 775 
 776     NCR5380_setup(instance);
 777 
 778     NCR5380_all_init();
 779 
 780     hostdata->aborted = 0;
 781     hostdata->id_mask = 1 << instance->this_id;
 782     for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
 783         if (i > hostdata->id_mask)
 784             hostdata->id_higher_mask |= i;
 785     for (i = 0; i < 8; ++i)
 786         hostdata->busy[i] = 0;
 787 #ifdef REAL_DMA
 788     hostdata->dmalen = 0;
 789 #endif
 790     hostdata->targets_present = 0;
 791     hostdata->connected = NULL;
 792     hostdata->issue_queue = NULL;
 793     hostdata->disconnected_queue = NULL;
 794     hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT | flags;
 795 
 796     if (!the_template) {
 797         the_template = instance->hostt;
 798         first_instance = instance;
 799     }
 800         
 801 
 802 #ifdef USLEEP
 803     hostdata->time_expires = 0;
 804     hostdata->next_timer = NULL;
 805 #endif
 806 
 807 #ifndef AUTOSENSE
 808     if ((instance->cmd_per_lun > 1) || instance->can_queue > 1)) 
 809          printk("scsi%d : WARNING : support for multiple outstanding commands enabled\n"
 810                 "         without AUTOSENSE option, contingent allegiance conditions may\n"
 811                 "         be incorrectly cleared.\n", instance->host_no);
 812 #endif /* def AUTOSENSE */
 813 
 814     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
 815     NCR5380_write(MODE_REG, MR_BASE);
 816     NCR5380_write(TARGET_COMMAND_REG, 0);
 817     NCR5380_write(SELECT_ENABLE_REG, 0);
 818 #ifdef NCR53C400
 819     if (hostdata->flags & FLAG_NCR53C400) {
 820         NCR5380_write(C400_CONTROL_STATUS_REG, CSR_BASE);
 821     }
 822 #endif
 823 }
 824 
 825 /* 
 826  * Function : int NCR5380_queue_command (Scsi_Cmnd *cmd, 
 827  *      void (*done)(Scsi_Cmnd *)) 
 828  *
 829  * Purpose :  enqueues a SCSI command
 830  *
 831  * Inputs : cmd - SCSI command, done - function called on completion, with
 832  *      a pointer to the command descriptor.
 833  * 
 834  * Returns : 0
 835  *
 836  * Side effects : 
 837  *      cmd is added to the per instance issue_queue, with minor 
 838  *      twiddling done to the host specific fields of cmd.  If the 
 839  *      main coroutine is not running, it is restarted.
 840  *
 841  */
 842 
 843 /* Only make static if a wrapper function is used */
 844 #ifndef NCR5380_queue_command
 845 static
 846 #endif
 847 int NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) {
     /* [previous][next][first][last][top][bottom][index][help] */
 848     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
 849         cmd->host->hostdata;
 850     Scsi_Cmnd *tmp;
 851 
 852 #if (NDEBUG & NDEBUG_NO_WRITE)
 853     switch (cmd->cmnd[0]) {
 854     case WRITE:
 855     case WRITE_10:
 856         printk("scsi%d : WRITE attempted with NO_WRITE debugging flag set\n",
 857             instance->host_no);
 858         cmd->result = (DID_ERROR << 16);
 859         done(cmd);
 860         return 0;
 861     }
 862 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
 863 
 864 
 865     /* 
 866      * We use the host_scribble field as a pointer to the next command  
 867      * in a queue 
 868      */
 869 
 870     cmd->host_scribble = NULL;
 871     cmd->scsi_done = done;
 872 
 873     cmd->result = 0;
 874 
 875 
 876     /* 
 877      * Insert the cmd into the issue queue. Note that REQUEST SENSE 
 878      * commands are added to the head of the queue since any command will
 879      * clear the contingent allegiance condition that exists and the 
 880      * sense data is only guaranteed to be valid while the condition exists.
 881      */
 882 
 883     cli();
 884     if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
 885         cmd->host_scribble = (unsigned char *) hostdata->issue_queue;
 886         hostdata->issue_queue = cmd;
 887     } else {
 888         for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp->host_scribble; 
 889                 tmp = (Scsi_Cmnd *) tmp->host_scribble);
 890         tmp->host_scribble = (unsigned char *) cmd;
 891     }
 892 #if (NDEBUG & NDEBUG_QUEUES)
 893     printk("scsi%d : command added to %s of queue\n", instance->host_no,
 894         (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
 895 #endif
 896 
 897 /* Run the coroutine if it isn't already running. */
 898     run_main();
 899     return 0;
 900 }
 901 
 902 /*
 903  * Function : NCR5380_main (void) 
 904  *
 905  * Purpose : NCR5380_main is a coroutine that runs as long as more work can 
 906  *      be done on the NCR5380 host adapters in a system.  Both 
 907  *      NCR5380_queue_command() and NCR5380_intr() will try to start it 
 908  *      in case it is not running.
 909  * 
 910  * NOTE : NCR5380_main exits with interrupts *disabled*, the caller should 
 911  *  reenable them.  This prevents reentrancy and kernel stack overflow.
 912  */     
 913     
 914 static void NCR5380_main (void) {
     /* [previous][next][first][last][top][bottom][index][help] */
 915     Scsi_Cmnd *tmp, *prev;
 916     struct Scsi_Host *instance;
 917     struct NCR5380_hostdata *hostdata;
 918     int done;
 919 
 920     /*
 921      * We run (with interrupts disabled) until we're sure that none of 
 922      * the host adapters have anything that can be done, at which point 
 923      * we set main_running to 0 and exit.
 924      *
 925      * Interrupts are enabled before doing various other internal 
 926      * instructions, after we've decided that we need to run through
 927      * the loop again.
 928      *
 929      * this should prevent any race conditions.
 930      */
 931 
 932     do {
 933         cli(); /* Freeze request queues */
 934         done = 1;
 935         for (instance = first_instance; instance && 
 936             instance->hostt == the_template; instance=instance->next) {
 937             hostdata = (struct NCR5380_hostdata *) instance->hostdata;
 938             cli();
 939             if (!hostdata->connected) {
 940 #if (NDEBUG & NDEBUG_MAIN)
 941                 printk("scsi%d : not connected\n", instance->host_no);
 942 #endif
 943                 /*
 944                  * Search through the issue_queue for a command destined
 945                  * for a target that's not busy.
 946                  */
 947                 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, 
 948                     prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) 
 949                     tmp->host_scribble) 
 950 
 951                     /*  When we find one, remove it from the issue queue. */
 952                     if (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
 953                             if (prev)
 954                                 prev->host_scribble = tmp->host_scribble;
 955                             else
 956                                 hostdata->issue_queue = (Scsi_Cmnd *) tmp->host_scribble;
 957                         tmp->host_scribble = NULL;
 958 
 959                         /* reenable interrupts after finding one */
 960                         sti();
 961 
 962                         /* 
 963                          * Attempt to establish an I_T_L nexus here. 
 964                          * On success, instance->hostdata->connected is set.
 965                          * On failure, we must add the command back to the
 966                          *   issue queue so we can keep trying. 
 967                          */
 968 #if (NDEBUG & (NDEBUG_MAIN | NDEBUG_QUEUES))
 969                         printk("scsi%d : main() : command for target %d lun %d removed from issue_queue\n",
 970                             instance->host_no, tmp->target, tmp->lun);
 971 #endif
 972                         /* 
 973                          * REQUEST SENSE commands are issued without tagged
 974                          * queueing, even on SCSI-II devices because the 
 975                          * contingent allegiance condition exists for the 
 976                          * entire unit.
 977                          */
 978                         
 979                         if (!NCR5380_select(instance, tmp, 
 980                             (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : 
 981                             TAG_NEXT)) {
 982                             break;
 983                         } else {
 984                             cli();
 985                             tmp->host_scribble = (unsigned char *) 
 986                                 hostdata->issue_queue;
 987                             hostdata->issue_queue = tmp;
 988                             sti();
 989 #if (NDEBUG & (NDEBUG_MAIN | NDEBUG_QUEUES))
 990                         printk("scsi%d : main(): select() failed, returned to issue_queue\n",
 991                             instance->host_no);
 992 #endif
 993                         }
 994                     } /* if target/lun is not busy */
 995             } /* if (!hostdata->connected) */
 996                 
 997             if (hostdata->connected 
 998 #ifdef REAL_DMA
 999                 && !hostdata->dmalen
1000 #endif
1001 #ifdef USLEEP
1002                 && (!hostdata->time_expires || hostdata->time_expires >= jiffies)
1003 #endif
1004                 ) {
1005                 sti();
1006 #if (NDEBUG & NDEBUG_MAIN)
1007                 printk("scsi%d : main() : performing information transfer\n",
1008                         instance->host_no);
1009 #endif
1010                 NCR5380_information_transfer(instance);
1011 #if (NDEBUG & NDEBUG_MAIN)
1012                 printk("scsi%d : main() : done set false\n", instance->host_no);
1013 #endif
1014                 done = 0;
1015             } else 
1016                 break;
1017         } /* for instance */
1018     } while (!done);
1019     main_running = 0;
1020 }
1021 
1022 /*
1023  * Function : void NCR5380_intr (int irq)
1024  * 
1025  * Purpose : handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
1026  *      from the disconnected queue, and restarting NCR5380_main() 
1027  *      as required.
1028  *
1029  * Inputs : int irq, irq that caused this interrupt.
1030  *
1031  */
1032 
1033 static void NCR5380_intr (int irq) {
     /* [previous][next][first][last][top][bottom][index][help] */
1034     NCR5380_local_declare(); 
1035     struct Scsi_Host *instance;
1036     int done;
1037     unsigned char basr;
1038 #if (NDEBUG & NDEBUG_INTR)
1039     printk("scsi : NCR5380 irq %d triggered\n", irq);
1040 #endif
1041     do {
1042         done = 1;
1043         for (instance = first_instance; instance && (instance->hostt == 
1044             the_template); instance = instance->next)
1045             if (instance->irq == irq) {
1046                 
1047                 /* Look for pending interrupts */
1048                 NCR5380_setup(instance);
1049                 basr = NCR5380_read(BUS_AND_STATUS_REG);
1050                 /* XXX dispatch to appropriate routine if found and done=0 */
1051                 if (basr & BASR_IRQ) {
1052 #if (NDEBUG & NDEBUG_INTR)
1053                     NCR5380_print(instance);
1054 #endif
1055                     if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == 
1056                         (SR_SEL | SR_IO)) {
1057                         done = 0;
1058                         sti();
1059 #if (NDEBUG & NDEBUG_INTR)
1060                         printk("scsi%d : SEL interrupt\n", instance->host_no);
1061 #endif
1062                         NCR5380_reselect(instance);
1063                         (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1064                     } else if (basr & BASR_PARITY_ERROR) {
1065 #if (NDEBUG & NDEBUG_INTR)
1066                         printk("scsi%d : PARITY interrupt\n", instance->host_no);
1067 #endif
1068                         (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1069                     } else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) {
1070 #if (NDEBUG & NDEBUG_INTR)
1071                         printk("scsi%d : RESET interrupt\n", instance->host_no);
1072 #endif
1073                         (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1074                     } else {
1075 /*  
1076  * XXX the rest of the interrupt conditions should *only* occur during a 
1077  * DMA transfer, which I haven't gotten around to fixing yet.
1078  */
1079 
1080 #if defined(REAL_DMA)
1081                     /*
1082                      * We should only get PHASE MISMATCH and EOP interrupts
1083                      * if we have DMA enabled, so do a sanity check based on
1084                      * the current setting of the MODE register.
1085                      */
1086 
1087                         if ((NCR5380_read(MODE_REG) & MR_DMA) && ((basr & 
1088                             BASR_END_DMA_TRANSFER) || 
1089                             !(basr & BASR_PHASE_MATCH))) {
1090                             int transfered;
1091 
1092                             if (!hostdata->connected) 
1093                                 panic("scsi%d : received end of DMA interrupt with no connected cmd\n",
1094                                     instance->hostno);
1095 
1096                             transfered = (hostdata->dmalen - NCR5380_dma_residual(instance));
1097                             hostdata->connected->SCp.this_residual -= transferred;
1098                             hostdata->connected->SCp.ptr += transferred;
1099                             hostdata->dmalen = 0;
1100 
1101                             (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1102 #if NCR_TIMEOUT
1103                             {
1104                               unsigned long timeout = jiffies + NCR_TIMEOUT;
1105 
1106                               while (NCR5380_read(BUS_AND_STATUS_REG) & BASR_ACK
1107                                      && jiffies < timeout)
1108                                 ;
1109                               if (jiffies >= timeout)
1110                                 printk("scsi: timeout at %d\n", __LINE__);
1111                             }
1112 #else /* NCR_TIMEOUT */
1113                             while (NCR5380_read(BUS_AND_STATUS_REG) & BASR_ACK);
1114 #endif
1115 
1116                             NCR5380_write(MODE_REG, MR_BASE);
1117                             NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1118                         }
1119 #else
1120 #if (NDEBUG & NDEBUG_INTR)
1121                     printk("scsi : unknown interrupt, BASR 0x%X, MR 0x%X, SR 0x%x\n", basr, NCR5380_read(MODE_REG), NCR5380_read(STATUS_REG));
1122 #endif
1123                     (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1124 #endif
1125                     } 
1126                 } /* if BASR_IRQ */
1127                 if (!done) 
1128                     run_main();
1129             } /* if (instance->irq == irq) */
1130     } while (!done);
1131 }
1132 
1133 /* 
1134  * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, 
1135  *      int tag);
1136  *
1137  * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
1138  *      including ARBITRATION, SELECTION, and initial message out for 
1139  *      IDENTIFY and queue messages. 
1140  *
1141  * Inputs : instance - instantiation of the 5380 driver on which this 
1142  *      target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for 
1143  *      new tag, TAG_NONE for untagged queueing, otherwise set to the tag for 
1144  *      the command that is presently connected.
1145  * 
1146  * Returns : -1 if selection could not execute for some reason,
1147  *      0 if selection succeeded or failed because the target 
1148  *      did not respond.
1149  *
1150  * Side effects : 
1151  *      If bus busy, arbitration failed, etc, NCR5380_select() will exit 
1152  *              with registers as they should have been on entry - ie
1153  *              SELECT_ENABLE will be set appropriately, the NCR5380
1154  *              will cease to drive any SCSI bus signals.
1155  *
1156  *      If successful : I_T_L or I_T_L_Q nexus will be established, 
1157  *              instance->connected will be set to cmd.  
1158  *              SELECT interrupt will be disabled.
1159  *
1160  *      If failed (no target) : cmd->scsi_done() will be called, and the 
1161  *              cmd->result host byte set to DID_BAD_TARGET.
1162  */
1163 
1164 static int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
     /* [previous][next][first][last][top][bottom][index][help] */
1165     int tag) {
1166     NCR5380_local_declare();
1167     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata*) 
1168         instance->hostdata;
1169     unsigned char tmp[3], phase;
1170     unsigned char *data;
1171     int len;
1172     unsigned long timeout;
1173     NCR5380_setup(instance);
1174 
1175     hostdata->restart_select = 0;
1176 #if defined (NDEBUG) && (NDEBUG & NDEBUG_ARBITRATION) 
1177     NCR5380_print(instance);
1178     printk("scsi%d : starting arbitration, id = %d\n", instance->host_no,
1179         instance->this_id);
1180 #endif
1181     cli(); 
1182 
1183     /* 
1184      * Set the phase bits to 0, otherwise the NCR5380 won't drive the 
1185      * data bus during SELECTION.
1186      */
1187 
1188     NCR5380_write(TARGET_COMMAND_REG, 0);
1189 
1190 
1191     /* 
1192      * Start arbitration.
1193      */
1194     
1195     NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1196     NCR5380_write(MODE_REG, MR_ARBITRATE);
1197 
1198     sti();
1199 
1200     /* Wait for arbitration logic to complete */
1201 #if NCR_TIMEOUT
1202     {
1203       unsigned long timeout = jiffies + 2*NCR_TIMEOUT;
1204 
1205       while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS)
1206            && jiffies < timeout)
1207         ;
1208       if (jiffies >= timeout)
1209       {
1210         printk("scsi: arbitration timeout at %d\n", __LINE__);
1211         NCR5380_write(MODE_REG, MR_BASE);
1212         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1213         return -1;
1214       }
1215     }
1216 #else /* NCR_TIMEOUT */
1217     while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS));
1218 #endif
1219 
1220 #if (NDEBUG & NDEBUG_ARBITRATION) 
1221     printk("scsi%d : arbitration complete\n", instance->host_no);
1222 /* Avoid GCC 2.4.5 asm needs to many reloads error */
1223     __asm__("nop");
1224 #endif
1225 
1226     /* 
1227      * The arbitration delay is 2.2us, but this is a minimum and there is 
1228      * no maximum so we can safely sleep for ceil(2.2) usecs to accommodate
1229      * the integral nature of udelay().
1230      *
1231      */
1232 
1233     udelay(3);
1234 
1235     /* Check for lost arbitration */
1236     if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1237         (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
1238         (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1239         NCR5380_write(MODE_REG, MR_BASE); 
1240 #if (NDEBUG & NDEBUG_ARBITRATION)
1241     printk("scsi%d : lost arbitration, deasserting MR_ARBITRATE\n", 
1242         instance->host_no);
1243 #endif
1244         return -1;
1245     }
1246 
1247 
1248 
1249     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_SEL);
1250     
1251     if (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) {
1252         NCR5380_write(MODE_REG, MR_BASE);
1253         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1254 #if (NDEBUG & NDEBUG_ARBITRATION)
1255     printk("scsi%d : lost arbitration, deasserting ICR_ASSERT_SEL\n", 
1256         instance->host_no);
1257 #endif
1258         return -1;
1259     }
1260 
1261     /* 
1262      * Again, bus clear + bus settle time is 1.2us, however, this is 
1263      * a minimum so we'll udelay ceil(1.2)
1264      */
1265 
1266     udelay(2);  
1267 
1268 #if (NDEBUG & NDEBUG_ARBITRATION)
1269     printk("scsi%d : won arbitration\n", instance->host_no);
1270 #endif
1271 
1272 
1273     /* 
1274      * Now that we have won arbitration, start Selection process, asserting 
1275      * the host and target ID's on the SCSI bus.
1276      */
1277 
1278     NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->target)));
1279 
1280     /* 
1281      * Raise ATN while SEL is true before BSY goes false from arbitration,
1282      * since this is the only way to guarantee that we'll get a MESSAGE OUT
1283      * phase immediately after selection.
1284      */
1285 
1286     NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY | 
1287         ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL ));
1288     NCR5380_write(MODE_REG, MR_BASE);
1289 
1290     /* 
1291      * Reselect interrupts must be turned off prior to the dropping of BSY,
1292      * otherwise we will trigger an interrupt.
1293      */
1294     NCR5380_write(SELECT_ENABLE_REG, 0);
1295 
1296     /* Reset BSY */
1297     NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA | 
1298         ICR_ASSERT_ATN | ICR_ASSERT_SEL));
1299 
1300     /* 
1301      * Something weird happens when we cease to drive BSY - looks
1302      * like the board/chip is letting us do another read before the 
1303      * appropriate propagation delay has expired, and we're confusing
1304      * a BSY signal from ourselves as the target's response to SELECTION.
1305      *
1306      * A small delay (the 'C++' frontend breaks the pipeline with an
1307      * unnecessary jump, making it work on my 386-33/Trantor T128, the
1308      * tighter 'C' code breaks and requires this) solves the problem - 
1309      * the 1 us delay is arbitrary, and only used because this delay will 
1310      * be the same on other platforms and since it works here, it should 
1311      * work there.
1312      */
1313 
1314     udelay(1);
1315 
1316 #if (NDEBUG & NDEBUG_SELECTION)
1317     printk("scsi%d : selecting target %d\n", instance->host_no, cmd->target);
1318 #endif
1319 
1320     /* 
1321      * The SCSI specification calls for a 250 ms timeout for the actual 
1322      * selection.
1323      */
1324 
1325     timeout = jiffies + 25; 
1326 
1327     /* 
1328      * XXX very interesting - we're seeing a bounce where the BSY we 
1329      * asserted is being reflected / still asserted (propagation delay?)
1330      * and it's detecting as true.  Sigh.
1331      */
1332 
1333     while ((jiffies < timeout) && !(NCR5380_read(STATUS_REG) & 
1334         (SR_BSY | SR_IO)));
1335 
1336     if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == 
1337             (SR_SEL | SR_IO)) {
1338             NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1339             NCR5380_reselect(instance);
1340             printk ("scsi%d : reselection after won arbitration?\n",
1341                 instance->host_no);
1342             NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1343             return -1;
1344     }
1345 
1346     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1347 
1348     if (!(NCR5380_read(STATUS_REG) & SR_BSY)) {
1349         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1350         if (hostdata->targets_present & (1 << cmd->target)) {
1351             printk("scsi%d : weirdness\n", instance->host_no);
1352             if (hostdata->restart_select)
1353                 printk("\trestart select\n");
1354 #ifdef NDEBUG
1355             NCR5380_print (instance);
1356 #endif
1357             NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1358             return -1;
1359         }
1360         cmd->result = DID_BAD_TARGET << 16;
1361         cmd->scsi_done(cmd);
1362         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1363 #if (NDEBUG & NDEBUG_SELECTION)
1364         printk("scsi%d : target did not respond within 250ms\n", 
1365             instance->host_no);
1366 #endif
1367         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1368         return 0;
1369     } 
1370 
1371     hostdata->targets_present |= (1 << cmd->target);
1372 
1373     /*
1374      * Since we followed the SCSI spec, and raised ATN while SEL 
1375      * was true but before BSY was false during selection, the information
1376      * transfer phase should be a MESSAGE OUT phase so that we can send the
1377      * IDENTIFY message.
1378      * 
1379      * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
1380      * message (2 bytes) with a tag ID that we increment with every command
1381      * until it wraps back to 0.
1382      *
1383      * XXX - it turns out that there are some broken SCSI-II devices,
1384      *       which claim to support tagged queuing but fail when more than
1385      *       some number of commands are issued at once.
1386      */
1387 
1388     /* Wait for start of REQ/ACK handshake */
1389     while (!(NCR5380_read(STATUS_REG) & SR_REQ));
1390 
1391 #if (NDEBUG & NDEBUG_SELECTION)
1392     printk("scsi%d : target %d selected, going into MESSAGE OUT phase.\n",
1393         instance->host_no, cmd->target);
1394 #endif
1395     tmp[0] = IDENTIFY(((instance->irq == IRQ_NONE) ? 0 : 1), cmd->lun);
1396 #ifdef SCSI2
1397     if (cmd->device->tagged_queue && (tag != TAG_NONE)) {
1398         tmp[1] = SIMPLE_QUEUE_TAG;
1399         if (tag == TAG_NEXT) {
1400             /* 0 is TAG_NONE, used to imply no tag for this command */
1401             if (cmd->device->current_tag == 0)
1402                 cmd->device->current_tag = 1;
1403 
1404             cmd->tag = cmd->device->current_tag;
1405             cmd->device->current_tag++;
1406         } else  
1407             cmd->tag = (unsigned char) tag;
1408 
1409         tmp[2] = cmd->tag;
1410         hostdata->last_message = SIMPLE_QUEUE_TAG;
1411         len = 3;
1412     } else 
1413 #endif /* def SCSI2 */
1414     {
1415         len = 1;
1416         cmd->tag=0;
1417     }
1418 
1419     /* Send message(s) */
1420     data = tmp;
1421     phase = PHASE_MSGOUT;
1422     NCR5380_transfer_pio(instance, &phase, &len, &data);
1423 #if (NDEBUG & NDEBUG_SELECTION)
1424     printk("scsi%d : nexus established.\n", instance->host_no);
1425 #endif
1426     /* XXX need to handle errors here */
1427     hostdata->connected = cmd;
1428 #ifdef SCSI2
1429     if (!cmd->device->tagged_queue)
1430 #endif    
1431         hostdata->busy[cmd->target] |= (1 << cmd->lun);
1432 
1433     initialize_SCp(cmd);
1434 
1435 
1436     return 0;
1437 }
1438 
1439 /* 
1440  * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance, 
1441  *      unsigned char *phase, int *count, unsigned char **data)
1442  *
1443  * Purpose : transfers data in given phase using polled I/O
1444  *
1445  * Inputs : instance - instance of driver, *phase - pointer to 
1446  *      what phase is expected, *count - pointer to number of 
1447  *      bytes to transfer, **data - pointer to data pointer.
1448  * 
1449  * Returns : -1 when different phase is entered without transferring
1450  *      maximum number of bytes, 0 if all bytes or transfered or exit
1451  *      is in same phase.
1452  *
1453  *      Also, *phase, *count, *data are modified in place.
1454  *
1455  * XXX Note : handling for bus free may be useful.
1456  */
1457 
1458 /*
1459  * Note : this code is not as quick as it could be, however it 
1460  * IS 100% reliable, and for the actual data transfer where speed
1461  * counts, we will always do a pseudo DMA or DMA transfer.
1462  */
1463 
1464 static int NCR5380_transfer_pio (struct Scsi_Host *instance, 
     /* [previous][next][first][last][top][bottom][index][help] */
1465         unsigned char *phase, int *count, unsigned char **data) {
1466     NCR5380_local_declare();
1467     register unsigned char p = *phase, tmp;
1468     register int c = *count;
1469     register unsigned char *d = *data;
1470     NCR5380_setup(instance);
1471 
1472     /* 
1473      * The NCR5380 chip will only drive the SCSI bus when the 
1474      * phase specified in the appropriate bits of the TARGET COMMAND
1475      * REGISTER match the STATUS REGISTER
1476      */
1477 
1478     NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1479 
1480     do {
1481         /* 
1482          * Wait for assertion of REQ, after which the phase bits will be 
1483          * valid 
1484          */
1485         while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ));
1486 
1487 #if (NDEBUG & NDEBUG_HANDSHAKE)
1488         printk("scsi%d : REQ detected\n", instance->host_no);
1489 #endif
1490 
1491         /* Check for phase mismatch */  
1492         if ((tmp & PHASE_MASK) != p) {
1493 #if (NDEBUG & NDEBUG_PIO)
1494             printk("scsi%d : phase mismatch\n", instance->host_no);
1495             NCR5380_print_phase(instance);
1496 #endif
1497             break;
1498         }
1499 
1500         /* Do actual transfer from SCSI bus to / from memory */
1501         if (!(p & SR_IO)) 
1502             NCR5380_write(OUTPUT_DATA_REG, *d);
1503         else 
1504             *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1505 
1506         ++d;
1507 
1508         /* 
1509          * The SCSI standard suggests that in MSGOUT phase, the initiator
1510          * should drop ATN on the last byte of the message phase
1511          * after REQ has been asserted for the handshake but before
1512          * the initiator raises ACK.
1513          */
1514 
1515         if (!(p & SR_IO)) {
1516             if (!((p & SR_MSG) && c > 1)) {
1517                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
1518                     ICR_ASSERT_DATA);
1519 #if (NDEBUG & NDEBUG_PIO)
1520         NCR5380_print(instance);
1521 #endif
1522                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
1523                         ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1524             } else {
1525                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1526                     ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1527 #if (NDEBUG & NDEBUG_PIO)
1528         NCR5380_print(instance);
1529 #endif
1530                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
1531                     ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1532             }
1533         } else {
1534 #if (NDEBUG & NDEBUG_PIO)
1535         NCR5380_print(instance);
1536 #endif
1537         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1538         }
1539 
1540         while (NCR5380_read(STATUS_REG) & SR_REQ);
1541 
1542 #if (NDEBUG & NDEBUG_HANDSHAKE)
1543             printk("scsi%d : req false, handshake complete\n", instance->host_no);
1544 #endif
1545 
1546 /*
1547  * We have several special cases to consider during REQ/ACK handshaking : 
1548  * 1.  We were in MSGOUT phase, and we are on the last byte of the 
1549  *      message.  ATN must be dropped as ACK is dropped.
1550  *
1551  * 2.  We are in a MSGIN phase, and we are on the last byte of the  
1552  *      message.  We must exit with ACK asserted, so that the calling
1553  *      code may raise ATN before dropping ACK to reject the message.
1554  *
1555  * 3.  ACK and ATN are clear and the target may proceed as normal.
1556  */
1557         if (!(p == PHASE_MSGIN && c == 1)) {  
1558             if (p == PHASE_MSGOUT && c > 1)
1559                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1560             else
1561                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1562         } 
1563     } while (--c);
1564 
1565 #if (NDEBUG & NDEBUG_PIO) 
1566     printk("scsi%d : residual %d\n", instance->host_no, c);
1567 #endif
1568 
1569     *count = c;
1570     *data = d;
1571     tmp = NCR5380_read(STATUS_REG);
1572     if (tmp & SR_REQ)
1573         *phase = tmp & PHASE_MASK;
1574     else 
1575         *phase = PHASE_UNKNOWN;
1576 
1577     if (!c || (*phase == p))
1578         return 0;
1579     else 
1580         return -1;
1581 }
1582 
1583 #if defined(REAL_DMA) || defined(PSEUDO_DMA) || defined (REAL_DMA_POLL)
1584 /* 
1585  * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance, 
1586  *      unsigned char *phase, int *count, unsigned char **data)
1587  *
1588  * Purpose : transfers data in given phase using either real
1589  *      or pseudo DMA.
1590  *
1591  * Inputs : instance - instance of driver, *phase - pointer to 
1592  *      what phase is expected, *count - pointer to number of 
1593  *      bytes to transfer, **data - pointer to data pointer.
1594  * 
1595  * Returns : -1 when different phase is entered without transferring
1596  *      maximum number of bytes, 0 if all bytes or transfered or exit
1597  *      is in same phase.
1598  *
1599  *      Also, *phase, *count, *data are modified in place.
1600  *
1601  */
1602 
1603 
1604 static int NCR5380_transfer_dma (struct Scsi_Host *instance, 
     /* [previous][next][first][last][top][bottom][index][help] */
1605     unsigned char *phase, int *count, unsigned char **data) {
1606     NCR5380_local_declare();
1607     register int c = *count;
1608     register unsigned char p = *phase;
1609     register unsigned char *d = *data;
1610     unsigned char tmp;
1611     int foo;
1612 #if defined(REAL_DMA_POLL)
1613     int cnt, toPIO;
1614     unsigned char saved_data = 0, overrun = 0, residue;
1615 #endif
1616 
1617     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) 
1618         instance->hostdata;
1619 
1620     NCR5380_setup(instance);
1621 
1622     if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1623         *phase = tmp;
1624         return -1;
1625     }
1626 #if defined(REAL_DMA) || defined(REAL_DMA_POLL) 
1627 #ifdef READ_OVERRUNS
1628      if (p & SR_IO) {
1629        c -= 2;
1630      }
1631 #endif
1632 #if (NDEBUG & NDEBUG_DMA)
1633     printk("scsi%d : initializing DMA channel %d for %s, %d bytes %s %0x\n",
1634         instance->host_no, instance->dma_channel, (p & SR_IO) ? "reading" :
1635         "writing", c, (p & SR_IO) ? "to" : "from", (unsigned) d);
1636 #endif
1637     hostdata->dma_len = (p & SR_IO) ?
1638         NCR5380_dma_read_setup(instance, d, c) : 
1639         NCR5380_dma_write_setup(instance, d, c);
1640 #endif
1641 
1642     NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1643 
1644 #ifdef REAL_DMA
1645     NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY);
1646 #elif defined(REAL_DMA_POLL)
1647     NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE);
1648 #else
1649     /*
1650      * Note : on my sample board, watch-dog timeouts occured when interrupts
1651      * were not disabled for the duration of a single DMA transfer, from 
1652      * before the setting of DMA mode to after transfer of the last byte.
1653      */
1654 
1655 #if defined(PSEUDO_DMA) && !defined(UNSAFE)
1656     cli();
1657 #endif
1658     NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE);
1659 #endif /* def REAL_DMA */
1660 
1661 #if (NDEBUG & NDEBUG_DMA) & 0
1662     printk("scsi%d : mode reg = 0x%X\n", instance->host_no, NCR5380_read(MODE_REG));
1663 #endif
1664 
1665 /* 
1666  * FOO stuff. For some UNAPPARENT reason, I'm getting 
1667  * watchdog timers fired on bootup for NO APPARENT REASON, meaning it's
1668  * probably a timing problem.
1669  *
1670  * Since this is the only place I have back-to-back writes, perhaps this 
1671  * is the problem?
1672  */
1673 
1674     if (p & SR_IO) {
1675 #ifndef FOO
1676         udelay(1);
1677 #endif
1678         NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
1679     } else {
1680 #ifndef FOO
1681         udelay(1);
1682 #endif
1683         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1684 #ifndef FOO
1685         udelay(1);
1686 #endif
1687         NCR5380_write(START_DMA_SEND_REG, 0);
1688 #ifndef FOO
1689         udelay(1);
1690 #endif
1691     }
1692 
1693 #if defined(REAL_DMA_POLL)
1694     do {
1695         tmp = NCR5380_read(BUS_AND_STATUS_REG);
1696     } while ((tmp & BASR_PHASE_MATCH) && !(tmp & (BASR_BUSY_ERROR | 
1697         BASR_END_DMA_TRANSFER)));
1698 
1699 /*
1700   At this point, either we've completed DMA, or we have a phase mismatch,
1701   or we've unexpectedly lost BUSY (which is a real error).
1702 
1703   For write DMAs, we want to wait until the last byte has been
1704   transferred out over the bus before we turn off DMA mode.  Alas, there
1705   seems to be no terribly good way of doing this on a 5380 under all
1706   conditions.  For non-scatter-gather operations, we can wait until REQ
1707   and ACK both go false, or until a phase mismatch occurs.  Gather-writes
1708   are nastier, since the device will be expecting more data than we
1709   are prepared to send it, and REQ will remain asserted.  On a 53C8[01] we
1710   could test LAST BIT SENT to assure transfer (I imagine this is precisely
1711   why this signal was added to the newer chips) but on the older 538[01]
1712   this signal does not exist.  The workaround for this lack is a watchdog;
1713   we bail out of the wait-loop after a modest amount of wait-time if
1714   the usual exit conditions are not met.  Not a terribly clean or
1715   correct solution :-%
1716 
1717   Reads are equally tricky due to a nasty characteristic of the NCR5380.
1718   If the chip is in DMA mode for an READ, it will respond to a target's
1719   REQ by latching the SCSI data into the INPUT DATA register and asserting
1720   ACK, even if it has _already_ been notified by the DMA controller that
1721   the current DMA transfer has completed!  If the NCR5380 is then taken
1722   out of DMA mode, this already-acknowledged byte is lost.
1723 
1724   This is not a problem for "one DMA transfer per command" reads, because
1725   the situation will never arise... either all of the data is DMA'ed
1726   properly, or the target switches to MESSAGE IN phase to signal a
1727   disconnection (either operation bringing the DMA to a clean halt).
1728   However, in order to handle scatter-reads, we must work around the
1729   problem.  The chosen fix is to DMA N-2 bytes, then check for the
1730   condition before taking the NCR5380 out of DMA mode.  One or two extra
1731   bytes are transferred via PIO as necessary to fill out the original
1732   request.
1733 */
1734 
1735     if (p & SR_IO) {
1736 #ifdef READ_OVERRUNS
1737       udelay(10);
1738       if (((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH|BASR_ACK)) ==
1739            (BASR_PHASE_MATCH | BASR_ACK))) {
1740         saved_data = NCR5380_read(INPUT_DATA_REGISTER);
1741         overrun = 1;
1742       }
1743 #endif
1744     } else {
1745       int limit = 100;
1746       while (((tmp = NCR5380_read(BUS_AND_STATUS_REG)) & BASR_ACK) ||
1747             (NCR5380_read(STATUS_REG) & SR_REQ)) {
1748         if (!(tmp & BASR_PHASE_MATCH)) break;
1749         if (--limit < 0) break;
1750       }
1751     }
1752 
1753 
1754 #if (NDEBUG & NDEBUG_DMA)
1755     printk("scsi%d : polled DMA transfer complete, basr 0x%X, sr 0x%X\n",
1756            instance->host_no, tmp, NCR5380_read(STATUS_REG));
1757 #endif
1758 
1759     NCR5380_write(MODE_REG, MR_BASE);
1760     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1761 
1762     residue = NCR5380_dma_residual(instance);
1763     c -= residue;
1764     *count -= c;
1765     *data += c;
1766     *phase = NCR5380_read(STATUS_REG) & PHASE_MASK;
1767 
1768 #ifdef READ_OVERRUNS
1769     if (*phase == p && (p & SR_IO) && residue == 0) {
1770       if (overrun) {
1771 #if (NDEBUG & NDEBUG_DMA)
1772         printk("Got an input overrun, using saved byte\n");
1773 #endif
1774         **data = saved_data;
1775         *data += 1;
1776         *count -= 1;
1777         cnt = toPIO = 1;
1778       } else {
1779         printk("No overrun??\n");
1780         cnt = toPIO = 2;
1781       }
1782 #if (NDEBUG & NDEBUG_DMA)
1783       printk("Doing %d-byte PIO to 0x%X\n", cnt, *data);
1784 #endif
1785       NCR5380_transfer_pio(instance, phase, &cnt, data);
1786       *count -= toPIO - cnt;
1787     }
1788 #endif        
1789 
1790 #if (NDEBUG & NDEBUG_DMA)
1791      printk("Return with data ptr = 0x%X, count %d, last 0x%X, next 0x%X\n",
1792             *data, *count, *(*data+*count-1), *(*data+*count));
1793 #endif
1794      return 0;
1795      
1796 #elif defined(REAL_DMA)
1797     return 0;
1798 #else /* defined(REAL_DMA_POLL) */
1799     if (p & SR_IO) {
1800         if (!(foo = NCR5380_pread(instance, d, c - 1))) {
1801             /*
1802              * We can't disable DMA mode after successfully transferring 
1803              * what we plan to be the last byte, since that would open up
1804              * a race condition where if the target asserted REQ before 
1805              * we got the DMA mode reset, the NCR5380 would have latched
1806              * an additional byte into the INPUT DATA register and we'd
1807              * have dropped it.
1808              * 
1809              * The workaround was to transfer one fewer bytes than we 
1810              * intended to with the pseudo-DMA read function, wait for 
1811              * the chip to latch the last byte, read it, and then disable
1812              * pseudo-DMA mode.
1813              * 
1814              * After REQ is asserted, the NCR5380 asserts DRQ and ACK.
1815              * REQ is deasserted when ACK is asserted, and not reasserted
1816              * until ACK goes false.  Since the NCR5380 won't lower ACK
1817              * until DACK is asserted, which won't happen unless we twiddle
1818              * the DMA port or we take the NCR5380 out of DMA mode, we 
1819              * can guarantee that we won't handshake another extra 
1820              * byte.
1821              */
1822 
1823             while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ));
1824             /* Wait for clean handshake */
1825             while (NCR5380_read(STATUS_REG) & SR_REQ);
1826             d[c - 1] = NCR5380_read(INPUT_DATA_REG);
1827         }
1828     } else {
1829         int timeout;
1830         if (!(foo = NCR5380_pwrite(instance, d, c))) {
1831             /*
1832              * Wait for the last byte to be sent.  If REQ is being asserted for 
1833              * the byte we're interested, we'll ACK it and it will go false.  
1834              */
1835             if (!(hostdata->flags & FLAG_HAS_LAST_BYTE_SENT)) {
1836                 timeout = 20000;
1837 #if 1
1838 #if 1
1839                 while (!(NCR5380_read(BUS_AND_STATUS_REG) & 
1840                         BASR_DRQ) && (NCR5380_read(BUS_AND_STATUS_REG) &
1841                         BASR_PHASE_MATCH));
1842 #else
1843                 if (NCR5380_read(STATUS_REG) & SR_REQ) {
1844                     for (; timeout && 
1845                         !(NCR5380_read(BUS_AND_STATUS_REG) & BASR_ACK); 
1846                         --timeout);
1847                     for (; timeout && (NCR5380_read(STATUS_REG) & SR_REQ);
1848                         --timeout);
1849                 } 
1850 #endif
1851         
1852 
1853 #if (NDEBUG & NDEBUG_LAST_BYTE_SENT)
1854                 if (!timeout) 
1855                     printk("scsi%d : timed out on last byte\n",
1856                             instance->host_no);
1857 #endif
1858 
1859 
1860                 if (hostdata->flags & FLAG_CHECK_LAST_BYTE_SENT) {
1861                     hostdata->flags &= ~FLAG_CHECK_LAST_BYTE_SENT;
1862                     if (NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT) {
1863                         hostdata->flags |= FLAG_HAS_LAST_BYTE_SENT;
1864 #if (NDEBUG & NDEBUG_LAST_BYTE_SENT)
1865                         printk("scsi%d : last bit sent works\n", 
1866                             instance->host_no);
1867 #endif
1868                     }
1869                 }
1870             } else 
1871                 while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT));
1872 #else
1873             udelay (5);
1874 #endif
1875         }
1876     }
1877 
1878     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1879     NCR5380_write(MODE_REG, MR_BASE);
1880 
1881     *data = d + c;
1882     *count = 0;
1883     *phase = (NCR5380_read(STATUS_REG & PHASE_MASK));
1884 #if defined(PSEUDO_DMA) && !defined(UNSAFE)
1885     sti();
1886 #endif /* defined(REAL_DMA_POLL) */
1887     return foo;
1888 #endif /* def REAL_DMA */
1889 }
1890 #endif /* defined(REAL_DMA) | defined(PSEUDO_DMA) */
1891 
1892 /*
1893  * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
1894  *
1895  * Purpose : run through the various SCSI phases and do as the target 
1896  *      directs us to.  Operates on the currently connected command, 
1897  *      instance->connected.
1898  *
1899  * Inputs : instance, instance for which we are doing commands
1900  *
1901  * Side effects : SCSI things happen, the disconnected queue will be 
1902  *      modified if a command disconnects, *instance->connected will
1903  *      change.
1904  *
1905  * XXX Note : we need to watch for bus free or a reset condition here 
1906  *      to recover from an unexpected bus free condition.
1907  */
1908  
1909 static void NCR5380_information_transfer (struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
1910     NCR5380_local_declare();
1911     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) 
1912         instance->hostdata;
1913     unsigned char msgout = NOP;
1914     int sink = 0;
1915     int len, transfersize;
1916     unsigned char *data;
1917     unsigned char phase, tmp, extended_msg[10], old_phase=0xff;
1918     Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
1919     NCR5380_setup(instance);
1920 
1921     while (1) {
1922         tmp = NCR5380_read(STATUS_REG);
1923         /* We only have a valid SCSI phase when REQ is asserted */
1924         if (tmp & SR_REQ) {
1925             phase = (tmp & PHASE_MASK); 
1926             if (phase != old_phase) {
1927                 old_phase = phase;
1928 #if (NDEBUG & NDEBUG_INFORMATION)
1929                 NCR5380_print_phase(instance);
1930 #endif
1931             }
1932             
1933             if (sink && (phase != PHASE_MSGOUT)) {
1934                 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1935 
1936                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | 
1937                     ICR_ASSERT_ACK);
1938                 while (NCR5380_read(STATUS_REG) & SR_REQ);
1939                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
1940                     ICR_ASSERT_ATN);
1941                 sink = 0;
1942                 continue;
1943             }
1944 
1945             switch (phase) {
1946             case PHASE_DATAIN:
1947             case PHASE_DATAOUT:
1948 #if (NDEBUG & NDEBUG_NO_DATAOUT)
1949                 printk("scsi%d : NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n",
1950                     instance->host_no);
1951                 sink = 1;
1952                 msgout = ABORT;
1953                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1954                 break;
1955 #endif
1956                 /* 
1957                  * If there is no room left in the current buffer in the
1958                  * scatter-gather list, move onto the next one.
1959                  */
1960 
1961                 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1962                     ++cmd->SCp.buffer;
1963                     --cmd->SCp.buffers_residual;
1964                     cmd->SCp.this_residual = cmd->SCp.buffer->length;
1965                     cmd->SCp.ptr = cmd->SCp.buffer->address;
1966 #if (NDEBUG & NDEBUG_INFORMATION)
1967                     printk("scsi%d : %d bytes and %d buffers left\n",
1968                         instance->host_no, cmd->SCp.this_residual,
1969                         cmd->SCp.buffers_residual);
1970 #endif
1971                 }
1972 
1973                 /*
1974                  * The prefered transfer method is going to be 
1975                  * PSEUDO-DMA for systems that are strictly PIO,
1976                  * since we can let the hardware do the handshaking.
1977                  *
1978                  * For this to work, we need to know the transfersize
1979                  * ahead of time, since the pseudo-DMA code will sit
1980                  * in an unconditional loop.
1981                  */
1982 
1983 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
1984 #ifdef NCR5380_dma_xfer_len
1985                 if (!cmd->device->borken &&
1986                     (transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) {
1987 #else
1988                 transfersize = cmd->transfersize;
1989 
1990 #ifdef LIMIT_TRANSFERSIZE  /* If we have problems with interrupt service */
1991                 if( transfersize > 512 )
1992                     transfersize = 512;
1993 #endif  /* LIMIT_TRANSFERSIZE */
1994 
1995                 if (!cmd->device->borken && transfersize && 
1996                     cmd->SCp.this_residual && !(cmd->SCp.this_residual % 
1997                     transfersize)) {
1998 #endif
1999                     len = transfersize;
2000                     if (NCR5380_transfer_dma(instance, &phase,
2001                         &len, (unsigned char **) &cmd->SCp.ptr)) {
2002                         /*
2003                          * If the watchdog timer fires, all future accesses to this
2004                          * device will use the polled-IO.
2005                          */ 
2006                         printk("scsi%d : switching target %d lun %d to slow handshake\n",
2007                             instance->host_no, cmd->target, cmd->lun);
2008                         cmd->device->borken = 1;
2009                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
2010                             ICR_ASSERT_ATN);
2011                         sink = 1;
2012                         msgout = ABORT;
2013                         /* XXX - need to source or sink data here, as appropriate */
2014                     } else
2015                         cmd->SCp.this_residual -= transfersize - len;
2016                 } else
2017 #endif /* defined(REAL_DMA) || defined(REAL_DMA_POLL) */
2018                   NCR5380_transfer_pio(instance, &phase, 
2019                     (int *) &cmd->SCp.this_residual, (unsigned char **)
2020                     &cmd->SCp.ptr);
2021                 break;
2022             case PHASE_MSGIN:
2023                 len = 1;
2024                 data = &tmp;
2025                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2026                 cmd->SCp.Message = tmp;
2027 
2028                 switch (tmp) {
2029                 /*
2030                  * Linking lets us reduce the time required to get the 
2031                  * next command out to the device, hopefully this will
2032                  * mean we don't waste another revolution due to the delays
2033                  * required by ARBITRATION and another SELECTION.
2034                  *
2035                  * In the current implementation proposal, low level drivers
2036                  * merely have to start the next command, pointed to by 
2037                  * next_link, done() is called as with unlinked commands.
2038                  */
2039 #ifdef LINKED
2040                 case LINKED_CMD_COMPLETE:
2041                 case LINKED_FLG_CMD_COMPLETE:
2042                     /* Accept message by clearing ACK */
2043                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2044                     
2045 #if (NDEBUG & NDEBUG_LINKED) 
2046                     printk("scsi%d : target %d lun %d linked command complete.\n",
2047                         instance->host_no, cmd->target, cmd->lun);
2048 #endif
2049                     /* 
2050                      * Sanity check : A linked command should only terminate with
2051                      * one of these messages if there are more linked commands
2052                      * available.
2053                      */
2054 
2055                     if (!cmd->next_link) {
2056                          printk("scsi%d : target %d lun %d linked command complete, no next_link\n"
2057                             instance->host_no, cmd->target, cmd->lun);
2058                             sink = 1;
2059                             msgout = ABORT;
2060                             NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2061                                 ICR_ASSERT_ATN);
2062                             break;
2063                     }
2064 
2065                     initialize_SCp(cmd->next_link);
2066                     /* The next command is still part of this process */
2067                     cmd->next_link->tag = cmd->tag;
2068                     cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
2069 #if (NDEBUG & NDEBUG_LINKED) 
2070                     printk("scsi%d : target %d lun %d linked request done, calling scsi_done().\n",
2071                         instance->host_no, cmd->target, cmd->lun);
2072 #endif
2073                     cmd->scsi_done(cmd);
2074                     cmd = hostdata->connected;
2075                     break;
2076 #endif /* def LINKED */
2077                 case ABORT:
2078                 case COMMAND_COMPLETE: 
2079                     /* Accept message by clearing ACK */
2080                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2081                     hostdata->connected = NULL;
2082 #if (NDEBUG & NDEBUG_QUEUES)
2083                     printk("scsi%d : command for target %d, lun %d completed\n",
2084                         instance->host_no, cmd->target, cmd->lun);
2085 #endif
2086                     hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
2087 
2088                     /* 
2089                      * I'm not sure what the correct thing to do here is : 
2090                      * 
2091                      * If the command that just executed is NOT a request 
2092                      * sense, the obvious thing to do is to set the result
2093                      * code to the values of the stored parameters.
2094                      * 
2095                      * If it was a REQUEST SENSE command, we need some way 
2096                      * to differentiate between the failure code of the original
2097                      * and the failure code of the REQUEST sense - the obvious
2098                      * case is success, where we fall through and leave the result
2099                      * code unchanged.
2100                      * 
2101                      * The non-obvious place is where the REQUEST SENSE failed 
2102                      */
2103 
2104                     if (cmd->cmnd[0] != REQUEST_SENSE) 
2105                         cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
2106                     else if (cmd->SCp.Status != GOOD)
2107                         cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
2108                     
2109 #ifdef AUTOSENSE
2110                     if ((cmd->cmnd[0] != REQUEST_SENSE) && 
2111                         (cmd->SCp.Status == CHECK_CONDITION)) {
2112 #if (NDEBUG & NDEBUG_AUTOSENSE) 
2113                         printk("scsi%d : performing request sense\n", 
2114                             instance->host_no);
2115 #endif
2116                         cmd->cmnd[0] = REQUEST_SENSE;
2117                         cmd->cmnd[1] &= 0xe0;
2118                         cmd->cmnd[2] = 0;
2119                         cmd->cmnd[3] = 0;
2120                         cmd->cmnd[4] = sizeof(cmd->sense_buffer);
2121                         cmd->cmnd[5] = 0;
2122 
2123                         cmd->SCp.buffer = NULL;
2124                         cmd->SCp.buffers_residual = 0;
2125                         cmd->SCp.ptr = (char *) cmd->sense_buffer;
2126                         cmd->SCp.this_residual = sizeof(cmd->sense_buffer);
2127 
2128                         cli();
2129                         cmd->host_scribble = (unsigned char *) 
2130                             hostdata->issue_queue;
2131                         hostdata->issue_queue = (Scsi_Cmnd *) cmd;
2132                         sti();
2133 #if (NDEBUG & NDEBUG_QUEUES)
2134                         printk("scsi%d : REQUEST SENSE added to head of issue queue\n");
2135 #endif
2136                    } else
2137 #endif /* def AUTOSENSE */
2138                         cmd->scsi_done(cmd);
2139 
2140                     NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2141                     /* 
2142                      * Restore phase bits to 0 so an interrupted selection, 
2143                      * arbitration can resume.
2144                      */
2145                     NCR5380_write(TARGET_COMMAND_REG, 0);
2146                     
2147                     while ((NCR5380_read(STATUS_REG) & SR_BSY) && 
2148                         !hostdata->connected);
2149                     return;
2150                 case MESSAGE_REJECT:
2151                     /* Accept message by clearing ACK */
2152                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2153                     switch (hostdata->last_message) {
2154                     case HEAD_OF_QUEUE_TAG:
2155                     case ORDERED_QUEUE_TAG:
2156                     case SIMPLE_QUEUE_TAG:
2157                         cmd->device->tagged_queue = 0;
2158                         hostdata->busy[cmd->target] |= (1 << cmd->lun);
2159                         break;
2160                     default:
2161                         break;
2162                     }
2163                 case DISCONNECT:
2164                     /* Accept message by clearing ACK */
2165                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2166                     cmd->device->disconnect = 1;
2167                     cli();
2168                     cmd->host_scribble = (unsigned char *) 
2169                         hostdata->disconnected_queue;
2170                     hostdata->connected = NULL;
2171                     hostdata->disconnected_queue = cmd;
2172                     sti();
2173 #if (NDEBUG & NDEBUG_QUEUES)
2174                     printk("scsi%d : command for target %d lun %d was moved from connected to"
2175                            "  the disconnected_queue\n", instance->host_no, 
2176                             cmd->target, cmd->lun);
2177 #endif
2178                     /* 
2179                      * Restore phase bits to 0 so an interrupted selection, 
2180                      * arbitration can resume.
2181                      */
2182                     NCR5380_write(TARGET_COMMAND_REG, 0);
2183  
2184                     /* Enable reselect interrupts */
2185                     NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2186                     /* Wait for bus free to avoid nasty timeouts */
2187                     while ((NCR5380_read(STATUS_REG) & SR_BSY) && 
2188                         !hostdata->connected);
2189                     return;
2190                 /* 
2191                  * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
2192                  * operation, in violation of the SCSI spec so we can safely 
2193                  * ignore SAVE/RESTORE pointers calls.
2194                  *
2195                  * Unfortunately, some disks violate the SCSI spec and 
2196                  * don't issue the required SAVE_POINTERS message before
2197                  * disconnecting, and we have to break spec to remain 
2198                  * compatible.
2199                  */
2200                 case SAVE_POINTERS:
2201                 case RESTORE_POINTERS:
2202                     /* Accept message by clearing ACK */
2203                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2204                     break;
2205                 case EXTENDED_MESSAGE:
2206 /* 
2207  * Extended messages are sent in the following format :
2208  * Byte         
2209  * 0            EXTENDED_MESSAGE == 1
2210  * 1            length (includes one byte for code, doesn't 
2211  *              include first two bytes)
2212  * 2            code
2213  * 3..length+1  arguments
2214  *
2215  * Start the extended message buffer with the EXTENDED_MESSAGE
2216  * byte, since print_msg() wants the whole thing.  
2217  */
2218                     extended_msg[0] = EXTENDED_MESSAGE;
2219                     /* Accept first byte by clearing ACK */
2220                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2221 
2222 #if (NDEBUG & NDEBUG_EXTENDED)
2223                     printk("scsi%d : receiving extended message\n",
2224                         instance->host_no);
2225 #endif
2226 
2227                     len = 2;
2228                     data = extended_msg + 1;
2229                     phase = PHASE_MSGIN;
2230                     NCR5380_transfer_pio(instance, &phase, &len, &data);
2231 
2232 #if (NDEBUG & NDEBUG_EXTENDED)
2233                     printk("scsi%d : length=%d, code=0x%02x\n", 
2234                         instance->host_no, (int) extended_msg[1],
2235                         (int) extended_msg[2]);
2236 #endif
2237 
2238                     if (!len && extended_msg[1] <= 
2239                         (sizeof (extended_msg) - 1)) {
2240                         /* Accept third byte by clearing ACK */
2241                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2242                         len = extended_msg[1] - 1;
2243                         data = extended_msg + 3;
2244                         phase = PHASE_MSGIN;
2245 
2246                         NCR5380_transfer_pio(instance, &phase, &len, &data);
2247 
2248 #if (NDEBUG & NDEBUG_EXTENDED)
2249                     printk("scsi%d : message received, residual %d\n",
2250                         instance->host_no, len);
2251 #endif
2252 
2253                         switch (extended_msg[2]) {
2254                         case EXTENDED_SDTR:
2255                         case EXTENDED_WDTR:
2256                         case EXTENDED_MODIFY_DATA_POINTER:
2257                         case EXTENDED_EXTENDED_IDENTIFY:
2258                             tmp = 0;
2259                         }
2260                     } else if (len) {
2261                         printk("scsi%d: error receiving extended message\n",
2262                             instance->host_no);
2263                         tmp = 0;
2264                     } else {
2265                         printk("scsi%d: extended message code %02x length %d is too long\n",
2266                             instance->host_no, extended_msg[2], extended_msg[1]);
2267                         tmp = 0;
2268                     }
2269                 /* Fall through to reject message */
2270                     
2271                 /* 
2272                  * If we get something weird that we aren't expecting, 
2273                  * reject it.
2274                  */
2275                 default:
2276                     if (!tmp) {
2277                         printk("scsi%d: rejecting message ", instance->host_no);
2278                         print_msg (extended_msg);
2279                         printk("\n");
2280                     } else if (tmp != EXTENDED_MESSAGE)
2281                         printk("scsi%d: rejecting unknown message %02x from target %d, lun %d\n",
2282                             instance->host_no, tmp, cmd->target, cmd->lun);
2283                     else
2284                         printk("scsi%d: rejecting unknown extended message code %02x, length %d from target %d, lun %d\n",
2285                             instance->host_no, extended_msg[1], extended_msg[0], cmd->target, cmd->lun);
2286    
2287                     msgout = MESSAGE_REJECT;
2288                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
2289                         ICR_ASSERT_ATN);
2290                     break;
2291                 } /* switch (tmp) */
2292                 break;
2293             case PHASE_MSGOUT:
2294                 len = 1;
2295                 data = &msgout;
2296                 hostdata->last_message = msgout;
2297                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2298                 if (msgout == ABORT) {
2299                     hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
2300                     hostdata->connected = NULL;
2301                     cmd->result = DID_ERROR << 16;
2302                     cmd->scsi_done(cmd);
2303                     NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2304                     return;
2305                 }
2306                 msgout = NOP;
2307                 break;
2308             case PHASE_CMDOUT:
2309                 len = COMMAND_SIZE(cmd->cmnd[0]);
2310                 data = cmd->cmnd;
2311                 /* 
2312                  * XXX for performance reasons, on machines with a 
2313                  * PSEUDO-DMA architecture we should probably 
2314                  * use the dma transfer function.  
2315                  */
2316                 NCR5380_transfer_pio(instance, &phase, &len, 
2317                     &data);
2318 #ifdef USLEEP
2319                 if (!disconnect && should_disconnect(cmd->cmnd[0])) {
2320                     hostdata->time_expires = jiffies + USLEEP_SLEEP;
2321 #if (NDEBUG & NDEBUG_USLEEP)
2322                 printk("scsi%d : issued command, sleeping until %ul\n", instance->host_no,
2323                     hostdata->time_expires);
2324 #endif
2325                     NCR5380_set_timer (instance);
2326                     return;
2327                 }
2328 #endif /* def USLEEP */
2329                 break;
2330             case PHASE_STATIN:
2331                 len = 1;
2332                 data = &tmp;
2333                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2334                 cmd->SCp.Status = tmp;
2335                 break;
2336             default:
2337                 printk("scsi%d : unknown phase\n", instance->host_no);
2338 #ifdef NDEBUG
2339                 NCR5380_print(instance);
2340 #endif
2341             } /* switch(phase) */
2342         } /* if (tmp * SR_REQ) */ 
2343 #ifdef USLEEP
2344         else {
2345             if (!disconnect && hostdata->time_expires && jiffies > 
2346                 hostdata->time_expires) {
2347                 hostdata->time_expires = jiffies + USLEEP_SLEEP;
2348 #if (NDEBUG & NDEBUG_USLEEP)
2349                 printk("scsi%d : poll timed out, sleeping until %ul\n", instance->host_no,
2350                     hostdata->time_expires);
2351 #endif
2352                 NCR5380_set_timer (instance);
2353                 return;
2354             }
2355         }
2356 #endif
2357     } /* while (1) */
2358 }
2359 
2360 /*
2361  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2362  *
2363  * Purpose : does reselection, initializing the instance->connected 
2364  *      field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q 
2365  *      nexus has been reestablished,
2366  *      
2367  * Inputs : instance - this instance of the NCR5380.
2368  *
2369  */
2370 
2371 
2372 static void NCR5380_reselect (struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
2373     NCR5380_local_declare();
2374     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
2375         instance->hostdata;
2376     unsigned char target_mask;
2377     unsigned char lun, phase;
2378     int len;
2379 #ifdef SCSI2
2380     unsigned char tag;
2381 #endif
2382     unsigned char msg[3];
2383     unsigned char *data;
2384     Scsi_Cmnd *tmp = NULL, *prev;
2385     int abort = 0;
2386     NCR5380_setup(instance);
2387 
2388     /*
2389      * Disable arbitration, etc. since the host adapter obviously
2390      * lost, and tell an interrupted NCR5380_select() to restart.
2391      */
2392 
2393     NCR5380_write(MODE_REG, MR_BASE);
2394     hostdata->restart_select = 1;
2395 
2396     target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2397 
2398 #if (NDEBUG & NDEBUG_RESELECTION)
2399     printk("scsi%d : reselect\n", instance->host_no);
2400 #endif
2401 
2402     /* 
2403      * At this point, we have detected that our SCSI ID is on the bus,
2404      * SEL is true and BSY was false for at least one bus settle delay
2405      * (400 ns).
2406      *
2407      * We must assert BSY ourselves, until the target drops the SEL
2408      * signal.
2409      */
2410 
2411     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2412     
2413     while (NCR5380_read(STATUS_REG) & SR_SEL);
2414     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2415 
2416     /*
2417      * Wait for target to go into MSGIN.
2418      */
2419 
2420     while (!(NCR5380_read(STATUS_REG) & SR_REQ));
2421 
2422     len = 1;
2423     data = msg;
2424     phase = PHASE_MSGIN;
2425     NCR5380_transfer_pio(instance, &phase, &len, &data);
2426 
2427 
2428     if (!msg[0] & 0x80) {
2429         printk("scsi%d : expecting IDENTIFY message, got ",
2430             instance->host_no);
2431         print_msg(msg);
2432         abort = 1;
2433     } else {
2434         /* Accept message by clearing ACK */
2435         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2436         lun = (msg[0] & 0x07);
2437 
2438         /* 
2439          * We need to add code for SCSI-II to track which devices have
2440          * I_T_L_Q nexuses established, and which have simple I_T_L
2441          * nexuses so we can chose to do additional data transfer.
2442          */
2443 
2444 #ifdef SCSI2
2445 #error "SCSI-II tagged queueing is not supported yet"
2446 #endif
2447 
2448         /* 
2449          * Find the command corresponding to the I_T_L or I_T_L_Q  nexus we 
2450          * just reestablished, and remove it from the disconnected queue.
2451          */
2452 
2453 
2454         for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL; 
2455             tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble) 
2456             if ((target_mask == (1 << tmp->target)) && (lun == tmp->lun)
2457 #ifdef SCSI2
2458             && (tag == tmp->tag) 
2459 #endif
2460 ) {
2461             if (prev)
2462                 prev->host_scribble = tmp->host_scribble;
2463             else
2464                 hostdata->disconnected_queue = (Scsi_Cmnd *) tmp->host_scribble;
2465             tmp->host_scribble = NULL;
2466             break;
2467         }
2468 
2469         if (!tmp) {
2470 #ifdef SCSI2
2471             printk("scsi%d : warning : target bitmask %02x lun %d tag %d not in disconnect_queue.\n",
2472                     instance->host_no, target_mask, lun, tag);
2473 #else
2474             printk("scsi%d : warning : target bitmask %02x lun %d not in disconnect_queue.\n",
2475                     instance->host_no, target_mask, lun);
2476 #endif
2477         /* 
2478          * Since we have an established nexus that we can't do anything with,
2479          * we must abort it.  
2480          */
2481         abort = 1;
2482         }
2483     }
2484 
2485     if (abort) {
2486         msg[0] = ABORT;
2487         len = 1;
2488         data = msg;
2489         phase = PHASE_MSGOUT;
2490         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2491         NCR5380_transfer_pio(instance, &phase, &len, &data);
2492     } else {
2493         hostdata->connected = tmp;
2494 #if (NDEBUG & NDEBUG_RESELECTION)
2495         printk"scsi%d : nexus established, target = %d, lun = %d, tag = %d\n",
2496             instance->host_no, tmp->target, tmp->lun, tmp->tag);
2497 #endif
2498     }
2499 }
2500 
2501 /*
2502  * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
2503  *
2504  * Purpose : called by interrupt handler when DMA finishes or a phase
2505  *      mismatch occurs (which would finish the DMA transfer).  
2506  *
2507  * Inputs : instance - this instance of the NCR5380.
2508  *
2509  * Returns : pointer to the Scsi_Cmnd structure for which the I_T_L
2510  *      nexus has been reestablished, on failure NULL is returned.
2511  */
2512 
2513 #ifdef REAL_DMA
2514 static void NCR5380_dma_complete (NCR5380_instance *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
2515     NCR5380_local_declare();
2516     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *
2517         instance->hostdata);
2518     int transferred;
2519     NCR5380_setup(instance);
2520     
2521     /*
2522      * XXX this might not be right.
2523      *
2524      * Wait for final byte to transfer, ie wait for ACK to go false.
2525      *
2526      * We should use the Last Byte Sent bit, unfortunately this is 
2527      * not available on the 5380/5381 (only the various CMOS chips)
2528      */
2529 
2530     while (NCR5380_read(BUS_AND_STATUS_REG) & BASR_ACK);
2531 
2532     NCR5380_write(MODE_REG, MR_BASE);
2533     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2534 
2535     /*
2536      * The only places we should see a phase mismatch and have to send
2537      * data from the same set of pointers will be the data transfer
2538      * phases.  So, residual, requested length are only important here.
2539      */
2540 
2541     if (!(hostdata->connected->SCp.phase & SR_CD)) {
2542         transferred = instance->dmalen - NCR5380_dma_residual();
2543         hostdata->connected->SCp.this_residual -= transferred;
2544         hostdata->connected->SCp.ptr += transferred;
2545     }
2546 }
2547 #endif /* def REAL_DMA */
2548 
2549 /*
2550  * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
2551  *
2552  * Purpose : abort a command
2553  *
2554  * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the 
2555  *      host byte of the result field to, if zero DID_ABORTED is 
2556  *      used.
2557  *
2558  * Returns : 0 - success, -1 on failure.
2559  *
2560  * XXX - there is no way to abort the command that is currently 
2561  *       connected, you have to wait for it to complete.  If this is 
2562  *       a problem, we could implement longjmp() / setjmp(), setjmp()
2563  *       called where the loop started in NCR5380_main().
2564  */
2565 
2566 #ifndef NCR5380_abort
2567 static
2568 #endif
2569 int NCR5380_abort (Scsi_Cmnd *cmd) {
     /* [previous][next][first][last][top][bottom][index][help] */
2570     NCR5380_local_declare();
2571     struct Scsi_Host *instance = cmd->host;
2572     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
2573         instance->hostdata;
2574     Scsi_Cmnd *tmp, **prev;
2575     unsigned char msg, phase, *msgptr;
2576     int len;
2577 
2578     printk("scsi%d : aborting command\n", instance->host_no);
2579     print_Scsi_Cmnd (cmd);
2580 
2581     NCR5380_print_status (instance);
2582 
2583     cli();
2584     NCR5380_setup(instance);
2585     
2586 #if (NDEBUG & NDEBUG_ABORT)
2587     printk("scsi%d : abort called\n", instance->host_no);
2588     printk("        basr 0x%X, sr 0x%X\n", 
2589            NCR5380_read(BUS_AND_STATUS_REG), NCR5380_read(STATUS_REG));
2590 #endif
2591 
2592 #if 0
2593 /*
2594  * Case 1 : If the command is the currently executing command, 
2595  * we'll set the aborted flag and return control so that 
2596  * information transfer routine can exit cleanly.
2597  */
2598 
2599     if (hostdata->connected == cmd) {
2600 #if (NDEBUG & NDEBUG_ABORT)
2601         printk("scsi%d : aborting connected command\n", instance->host_no);
2602 #endif
2603         hostdata->aborted = 1;
2604 /*
2605  * We should perform BSY checking, and make sure we haven't slipped
2606  * into BUS FREE.
2607  */
2608 
2609         NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN);
2610 /* 
2611  * Since we can't change phases until we've completed the current 
2612  * handshake, we have to source or sink a byte of data if the current
2613  * phase is not MSGOUT.
2614  */
2615 
2616 /* 
2617  * Return control to the executing NCR drive so we can clear the
2618  * aborted flag and get back into our main loop.
2619  */ 
2620  
2621         return 0;
2622     }
2623 #endif
2624 
2625 /* 
2626  * Case 2 : If the command hasn't been issued yet, we simply remove it 
2627  *          from the issue queue.
2628  */
2629     for (prev = (Scsi_Cmnd **) &(hostdata->issue_queue), 
2630         tmp = (Scsi_Cmnd *) hostdata->issue_queue;
2631         tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp = 
2632         (Scsi_Cmnd *) tmp->host_scribble) 
2633         if (cmd == tmp) {
2634             (*prev) = (Scsi_Cmnd *) tmp->host_scribble;
2635             tmp->host_scribble = NULL;
2636             tmp->result = DID_ABORT << 16;
2637             sti();
2638 #if (NDEBUG & NDEBUG_ABORT)
2639     printk("scsi%d : abort removed command from issue queue.\n", 
2640         instance->host_no);
2641 #endif
2642             tmp->done(tmp);
2643             return SCSI_ABORT_SUCCESS;
2644         }
2645 
2646 /* 
2647  * Case 3 : If any commands are connected, we're going to fail the abort
2648  *          and let the high level SCSI driver retry at a later time or 
2649  *          issue a reset.
2650  *
2651  *          Timeouts, and therefore aborted commands, will be highly unlikely
2652  *          and handling them cleanly in this situation would make the common
2653  *          case of noresets less efficient, and would pollute our code.  So,
2654  *          we fail.
2655  */
2656 
2657     if (hostdata->connected) {
2658         sti();
2659 #if (NDEBUG & NDEBUG_ABORT)
2660     printk("scsi%d : abort failed, command connected.\n", instance->host_no);
2661 #endif
2662         return SCSI_ABORT_NOT_RUNNING;
2663     }
2664 
2665 /*
2666  * Case 4: If the command is currently disconnected from the bus, and 
2667  *      there are no connected commands, we reconnect the I_T_L or 
2668  *      I_T_L_Q nexus associated with it, go into message out, and send 
2669  *      an abort message.
2670  *
2671  * This case is especially ugly. In order to reestablish the nexus, we
2672  * need to call NCR5380_select().  The easiest way to implement this 
2673  * function was to abort if the bus was busy, and let the interrupt
2674  * handler triggered on the SEL for reselect take care of lost arbitrations
2675  * where necessary, meaning interrupts need to be enabled.
2676  *
2677  * When interrupts are enabled, the queues may change - so we 
2678  * can't remove it from the disconnected queue before selecting it
2679  * because that could cause a failure in hashing the nexus if that 
2680  * device reselected.
2681  * 
2682  * Since the queues may change, we can't use the pointers from when we
2683  * first locate it.
2684  *
2685  * So, we must first locate the command, and if NCR5380_select()
2686  * succeeds, then issue the abort, relocate the command and remove
2687  * it from the disconnected queue.
2688  */
2689 
2690     for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp; 
2691         tmp = (Scsi_Cmnd *) tmp->host_scribble) 
2692         if (cmd == tmp) {
2693             sti(); 
2694 #if (NDEBUG & NDEBUG_ABORT)
2695     printk("scsi%d : aborting disconnected command.\n", instance->host_no);
2696 #endif
2697   
2698             if (NCR5380_select (instance, cmd, (int) cmd->tag)) 
2699                 return SCSI_ABORT_BUSY;
2700 
2701 #if (NDEBUG & NDEBUG_ABORT)
2702     printk("scsi%d : nexus reestablished.\n", instance->host_no);
2703 #endif
2704 
2705             msg = ABORT;
2706             msgptr = &msg;
2707             len = 1;
2708             phase = PHASE_MSGOUT;
2709             NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2710             NCR5380_transfer_pio (instance, &phase, &len, &msgptr);
2711 
2712             cli();
2713             for (prev = (Scsi_Cmnd **) &(hostdata->disconnected_queue), 
2714                 tmp = (Scsi_Cmnd *) hostdata->disconnected_queue;
2715                 tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp = 
2716                 (Scsi_Cmnd *) tmp->host_scribble) 
2717                     if (cmd == tmp) {
2718                     *prev = (Scsi_Cmnd *) tmp->host_scribble;
2719                     tmp->host_scribble = NULL;
2720                     tmp->result = DID_ABORT << 16;
2721                     sti();
2722                     tmp->done(tmp);
2723                     return SCSI_ABORT_SUCCESS;
2724                 }
2725         }
2726 
2727 /*
2728  * Case 5 : If we reached this point, the command was not found in any of 
2729  *          the queues.
2730  *
2731  * We probably reached this point because of an unlikely race condition
2732  * between the command completing successfully and the abortion code,
2733  * so we won't panic, but we will notify the user in case something really
2734  * broke.
2735  */
2736 
2737     sti();
2738     printk("scsi%d : warning : SCSI command probably completed successfully\n"
2739            "         before abortion\n", instance->host_no); 
2740     return SCSI_ABORT_NOT_RUNNING;
2741 }
2742 
2743 
2744 /* 
2745  * Function : int NCR5380_reset (Scsi_Cmnd *cmd)
2746  * 
2747  * Purpose : reset the SCSI bus.
2748  *
2749  * Returns : SCSI_RESET_WAKEUP
2750  *
2751  */ 
2752 
2753 #ifndef NCR5380_reset
2754 static
2755 #endif
2756 int NCR5380_reset (Scsi_Cmnd *cmd) {
     /* [previous][next][first][last][top][bottom][index][help] */
2757     NCR5380_local_declare();
2758     NCR5380_setup(cmd->host);
2759 
2760     NCR5380_print_status (cmd->host);
2761 
2762     cli();
2763     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
2764     udelay(25);
2765     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2766     sti();
2767 
2768     return SCSI_RESET_WAKEUP;
2769 }
2770 

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