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 irq, struct pt_regs * regs) {
     /* [previous][next][first][last][top][bottom][index][help] */
 604     probe_irq = irq;
 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, struct pt_regs * regs) {
     /* [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 occurred 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;
1916 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
1917     int transfersize;
1918 #endif
1919     unsigned char *data;
1920     unsigned char phase, tmp, extended_msg[10], old_phase=0xff;
1921     Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
1922     NCR5380_setup(instance);
1923 
1924     while (1) {
1925         tmp = NCR5380_read(STATUS_REG);
1926         /* We only have a valid SCSI phase when REQ is asserted */
1927         if (tmp & SR_REQ) {
1928             phase = (tmp & PHASE_MASK); 
1929             if (phase != old_phase) {
1930                 old_phase = phase;
1931 #if (NDEBUG & NDEBUG_INFORMATION)
1932                 NCR5380_print_phase(instance);
1933 #endif
1934             }
1935             
1936             if (sink && (phase != PHASE_MSGOUT)) {
1937                 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1938 
1939                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | 
1940                     ICR_ASSERT_ACK);
1941                 while (NCR5380_read(STATUS_REG) & SR_REQ);
1942                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
1943                     ICR_ASSERT_ATN);
1944                 sink = 0;
1945                 continue;
1946             }
1947 
1948             switch (phase) {
1949             case PHASE_DATAIN:
1950             case PHASE_DATAOUT:
1951 #if (NDEBUG & NDEBUG_NO_DATAOUT)
1952                 printk("scsi%d : NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n",
1953                     instance->host_no);
1954                 sink = 1;
1955                 msgout = ABORT;
1956                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1957                 break;
1958 #endif
1959                 /* 
1960                  * If there is no room left in the current buffer in the
1961                  * scatter-gather list, move onto the next one.
1962                  */
1963 
1964                 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1965                     ++cmd->SCp.buffer;
1966                     --cmd->SCp.buffers_residual;
1967                     cmd->SCp.this_residual = cmd->SCp.buffer->length;
1968                     cmd->SCp.ptr = cmd->SCp.buffer->address;
1969 #if (NDEBUG & NDEBUG_INFORMATION)
1970                     printk("scsi%d : %d bytes and %d buffers left\n",
1971                         instance->host_no, cmd->SCp.this_residual,
1972                         cmd->SCp.buffers_residual);
1973 #endif
1974                 }
1975 
1976                 /*
1977                  * The preferred transfer method is going to be 
1978                  * PSEUDO-DMA for systems that are strictly PIO,
1979                  * since we can let the hardware do the handshaking.
1980                  *
1981                  * For this to work, we need to know the transfersize
1982                  * ahead of time, since the pseudo-DMA code will sit
1983                  * in an unconditional loop.
1984                  */
1985 
1986 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
1987 #ifdef NCR5380_dma_xfer_len
1988                 if (!cmd->device->borken &&
1989                     (transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) {
1990 #else
1991                 transfersize = cmd->transfersize;
1992 
1993 #ifdef LIMIT_TRANSFERSIZE  /* If we have problems with interrupt service */
1994                 if( transfersize > 512 )
1995                     transfersize = 512;
1996 #endif  /* LIMIT_TRANSFERSIZE */
1997 
1998                 if (!cmd->device->borken && transfersize && 
1999                     cmd->SCp.this_residual && !(cmd->SCp.this_residual % 
2000                     transfersize)) {
2001 #endif
2002                     len = transfersize;
2003                     if (NCR5380_transfer_dma(instance, &phase,
2004                         &len, (unsigned char **) &cmd->SCp.ptr)) {
2005                         /*
2006                          * If the watchdog timer fires, all future accesses to this
2007                          * device will use the polled-IO.
2008                          */ 
2009                         printk("scsi%d : switching target %d lun %d to slow handshake\n",
2010                             instance->host_no, cmd->target, cmd->lun);
2011                         cmd->device->borken = 1;
2012                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
2013                             ICR_ASSERT_ATN);
2014                         sink = 1;
2015                         msgout = ABORT;
2016                         /* XXX - need to source or sink data here, as appropriate */
2017                     } else
2018                         cmd->SCp.this_residual -= transfersize - len;
2019                 } else
2020 #endif /* defined(PSEUDO_DMA) || defined(REAL_DMA_POLL) */
2021                   NCR5380_transfer_pio(instance, &phase, 
2022                     (int *) &cmd->SCp.this_residual, (unsigned char **)
2023                     &cmd->SCp.ptr);
2024                 break;
2025             case PHASE_MSGIN:
2026                 len = 1;
2027                 data = &tmp;
2028                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2029                 cmd->SCp.Message = tmp;
2030 
2031                 switch (tmp) {
2032                 /*
2033                  * Linking lets us reduce the time required to get the 
2034                  * next command out to the device, hopefully this will
2035                  * mean we don't waste another revolution due to the delays
2036                  * required by ARBITRATION and another SELECTION.
2037                  *
2038                  * In the current implementation proposal, low level drivers
2039                  * merely have to start the next command, pointed to by 
2040                  * next_link, done() is called as with unlinked commands.
2041                  */
2042 #ifdef LINKED
2043                 case LINKED_CMD_COMPLETE:
2044                 case LINKED_FLG_CMD_COMPLETE:
2045                     /* Accept message by clearing ACK */
2046                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2047                     
2048 #if (NDEBUG & NDEBUG_LINKED) 
2049                     printk("scsi%d : target %d lun %d linked command complete.\n",
2050                         instance->host_no, cmd->target, cmd->lun);
2051 #endif
2052                     /* 
2053                      * Sanity check : A linked command should only terminate with
2054                      * one of these messages if there are more linked commands
2055                      * available.
2056                      */
2057 
2058                     if (!cmd->next_link) {
2059                          printk("scsi%d : target %d lun %d linked command complete, no next_link\n"
2060                             instance->host_no, cmd->target, cmd->lun);
2061                             sink = 1;
2062                             msgout = ABORT;
2063                             NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2064                                 ICR_ASSERT_ATN);
2065                             break;
2066                     }
2067 
2068                     initialize_SCp(cmd->next_link);
2069                     /* The next command is still part of this process */
2070                     cmd->next_link->tag = cmd->tag;
2071                     cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
2072 #if (NDEBUG & NDEBUG_LINKED) 
2073                     printk("scsi%d : target %d lun %d linked request done, calling scsi_done().\n",
2074                         instance->host_no, cmd->target, cmd->lun);
2075 #endif
2076                     cmd->scsi_done(cmd);
2077                     cmd = hostdata->connected;
2078                     break;
2079 #endif /* def LINKED */
2080                 case ABORT:
2081                 case COMMAND_COMPLETE: 
2082                     /* Accept message by clearing ACK */
2083                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2084                     hostdata->connected = NULL;
2085 #if (NDEBUG & NDEBUG_QUEUES)
2086                     printk("scsi%d : command for target %d, lun %d completed\n",
2087                         instance->host_no, cmd->target, cmd->lun);
2088 #endif
2089                     hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
2090 
2091                     /* 
2092                      * I'm not sure what the correct thing to do here is : 
2093                      * 
2094                      * If the command that just executed is NOT a request 
2095                      * sense, the obvious thing to do is to set the result
2096                      * code to the values of the stored parameters.
2097                      * 
2098                      * If it was a REQUEST SENSE command, we need some way 
2099                      * to differentiate between the failure code of the original
2100                      * and the failure code of the REQUEST sense - the obvious
2101                      * case is success, where we fall through and leave the result
2102                      * code unchanged.
2103                      * 
2104                      * The non-obvious place is where the REQUEST SENSE failed 
2105                      */
2106 
2107                     if (cmd->cmnd[0] != REQUEST_SENSE) 
2108                         cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 
2109                     else if (cmd->SCp.Status != GOOD)
2110                         cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
2111                     
2112 #ifdef AUTOSENSE
2113                     if ((cmd->cmnd[0] != REQUEST_SENSE) && 
2114                         (cmd->SCp.Status == CHECK_CONDITION)) {
2115 #if (NDEBUG & NDEBUG_AUTOSENSE) 
2116                         printk("scsi%d : performing request sense\n", 
2117                             instance->host_no);
2118 #endif
2119                         cmd->cmnd[0] = REQUEST_SENSE;
2120                         cmd->cmnd[1] &= 0xe0;
2121                         cmd->cmnd[2] = 0;
2122                         cmd->cmnd[3] = 0;
2123                         cmd->cmnd[4] = sizeof(cmd->sense_buffer);
2124                         cmd->cmnd[5] = 0;
2125 
2126                         cmd->SCp.buffer = NULL;
2127                         cmd->SCp.buffers_residual = 0;
2128                         cmd->SCp.ptr = (char *) cmd->sense_buffer;
2129                         cmd->SCp.this_residual = sizeof(cmd->sense_buffer);
2130 
2131                         cli();
2132                         cmd->host_scribble = (unsigned char *) 
2133                             hostdata->issue_queue;
2134                         hostdata->issue_queue = (Scsi_Cmnd *) cmd;
2135                         sti();
2136 #if (NDEBUG & NDEBUG_QUEUES)
2137                         printk("scsi%d : REQUEST SENSE added to head of issue queue\n");
2138 #endif
2139                    } else
2140 #endif /* def AUTOSENSE */
2141                         cmd->scsi_done(cmd);
2142 
2143                     NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2144                     /* 
2145                      * Restore phase bits to 0 so an interrupted selection, 
2146                      * arbitration can resume.
2147                      */
2148                     NCR5380_write(TARGET_COMMAND_REG, 0);
2149                     
2150                     while ((NCR5380_read(STATUS_REG) & SR_BSY) && 
2151                         !hostdata->connected);
2152                     return;
2153                 case MESSAGE_REJECT:
2154                     /* Accept message by clearing ACK */
2155                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2156                     switch (hostdata->last_message) {
2157                     case HEAD_OF_QUEUE_TAG:
2158                     case ORDERED_QUEUE_TAG:
2159                     case SIMPLE_QUEUE_TAG:
2160                         cmd->device->tagged_queue = 0;
2161                         hostdata->busy[cmd->target] |= (1 << cmd->lun);
2162                         break;
2163                     default:
2164                         break;
2165                     }
2166                 case DISCONNECT:
2167                     /* Accept message by clearing ACK */
2168                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2169                     cmd->device->disconnect = 1;
2170                     cli();
2171                     cmd->host_scribble = (unsigned char *) 
2172                         hostdata->disconnected_queue;
2173                     hostdata->connected = NULL;
2174                     hostdata->disconnected_queue = cmd;
2175                     sti();
2176 #if (NDEBUG & NDEBUG_QUEUES)
2177                     printk("scsi%d : command for target %d lun %d was moved from connected to"
2178                            "  the disconnected_queue\n", instance->host_no, 
2179                             cmd->target, cmd->lun);
2180 #endif
2181                     /* 
2182                      * Restore phase bits to 0 so an interrupted selection, 
2183                      * arbitration can resume.
2184                      */
2185                     NCR5380_write(TARGET_COMMAND_REG, 0);
2186  
2187                     /* Enable reselect interrupts */
2188                     NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2189                     /* Wait for bus free to avoid nasty timeouts */
2190                     while ((NCR5380_read(STATUS_REG) & SR_BSY) && 
2191                         !hostdata->connected);
2192                     return;
2193                 /* 
2194                  * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
2195                  * operation, in violation of the SCSI spec so we can safely 
2196                  * ignore SAVE/RESTORE pointers calls.
2197                  *
2198                  * Unfortunately, some disks violate the SCSI spec and 
2199                  * don't issue the required SAVE_POINTERS message before
2200                  * disconnecting, and we have to break spec to remain 
2201                  * compatible.
2202                  */
2203                 case SAVE_POINTERS:
2204                 case RESTORE_POINTERS:
2205                     /* Accept message by clearing ACK */
2206                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2207                     break;
2208                 case EXTENDED_MESSAGE:
2209 /* 
2210  * Extended messages are sent in the following format :
2211  * Byte         
2212  * 0            EXTENDED_MESSAGE == 1
2213  * 1            length (includes one byte for code, doesn't 
2214  *              include first two bytes)
2215  * 2            code
2216  * 3..length+1  arguments
2217  *
2218  * Start the extended message buffer with the EXTENDED_MESSAGE
2219  * byte, since print_msg() wants the whole thing.  
2220  */
2221                     extended_msg[0] = EXTENDED_MESSAGE;
2222                     /* Accept first byte by clearing ACK */
2223                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2224 
2225 #if (NDEBUG & NDEBUG_EXTENDED)
2226                     printk("scsi%d : receiving extended message\n",
2227                         instance->host_no);
2228 #endif
2229 
2230                     len = 2;
2231                     data = extended_msg + 1;
2232                     phase = PHASE_MSGIN;
2233                     NCR5380_transfer_pio(instance, &phase, &len, &data);
2234 
2235 #if (NDEBUG & NDEBUG_EXTENDED)
2236                     printk("scsi%d : length=%d, code=0x%02x\n", 
2237                         instance->host_no, (int) extended_msg[1],
2238                         (int) extended_msg[2]);
2239 #endif
2240 
2241                     if (!len && extended_msg[1] <= 
2242                         (sizeof (extended_msg) - 1)) {
2243                         /* Accept third byte by clearing ACK */
2244                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2245                         len = extended_msg[1] - 1;
2246                         data = extended_msg + 3;
2247                         phase = PHASE_MSGIN;
2248 
2249                         NCR5380_transfer_pio(instance, &phase, &len, &data);
2250 
2251 #if (NDEBUG & NDEBUG_EXTENDED)
2252                     printk("scsi%d : message received, residual %d\n",
2253                         instance->host_no, len);
2254 #endif
2255 
2256                         switch (extended_msg[2]) {
2257                         case EXTENDED_SDTR:
2258                         case EXTENDED_WDTR:
2259                         case EXTENDED_MODIFY_DATA_POINTER:
2260                         case EXTENDED_EXTENDED_IDENTIFY:
2261                             tmp = 0;
2262                         }
2263                     } else if (len) {
2264                         printk("scsi%d: error receiving extended message\n",
2265                             instance->host_no);
2266                         tmp = 0;
2267                     } else {
2268                         printk("scsi%d: extended message code %02x length %d is too long\n",
2269                             instance->host_no, extended_msg[2], extended_msg[1]);
2270                         tmp = 0;
2271                     }
2272                 /* Fall through to reject message */
2273                     
2274                 /* 
2275                  * If we get something weird that we aren't expecting, 
2276                  * reject it.
2277                  */
2278                 default:
2279                     if (!tmp) {
2280                         printk("scsi%d: rejecting message ", instance->host_no);
2281                         print_msg (extended_msg);
2282                         printk("\n");
2283                     } else if (tmp != EXTENDED_MESSAGE)
2284                         printk("scsi%d: rejecting unknown message %02x from target %d, lun %d\n",
2285                             instance->host_no, tmp, cmd->target, cmd->lun);
2286                     else
2287                         printk("scsi%d: rejecting unknown extended message code %02x, length %d from target %d, lun %d\n",
2288                             instance->host_no, extended_msg[1], extended_msg[0], cmd->target, cmd->lun);
2289    
2290                     msgout = MESSAGE_REJECT;
2291                     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | 
2292                         ICR_ASSERT_ATN);
2293                     break;
2294                 } /* switch (tmp) */
2295                 break;
2296             case PHASE_MSGOUT:
2297                 len = 1;
2298                 data = &msgout;
2299                 hostdata->last_message = msgout;
2300                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2301                 if (msgout == ABORT) {
2302                     hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
2303                     hostdata->connected = NULL;
2304                     cmd->result = DID_ERROR << 16;
2305                     cmd->scsi_done(cmd);
2306                     NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2307                     return;
2308                 }
2309                 msgout = NOP;
2310                 break;
2311             case PHASE_CMDOUT:
2312                 len = cmd->cmd_len;
2313                 data = cmd->cmnd;
2314                 /* 
2315                  * XXX for performance reasons, on machines with a 
2316                  * PSEUDO-DMA architecture we should probably 
2317                  * use the dma transfer function.  
2318                  */
2319                 NCR5380_transfer_pio(instance, &phase, &len, 
2320                     &data);
2321 #ifdef USLEEP
2322                 if (!disconnect && should_disconnect(cmd->cmnd[0])) {
2323                     hostdata->time_expires = jiffies + USLEEP_SLEEP;
2324 #if (NDEBUG & NDEBUG_USLEEP)
2325                 printk("scsi%d : issued command, sleeping until %ul\n", instance->host_no,
2326                     hostdata->time_expires);
2327 #endif
2328                     NCR5380_set_timer (instance);
2329                     return;
2330                 }
2331 #endif /* def USLEEP */
2332                 break;
2333             case PHASE_STATIN:
2334                 len = 1;
2335                 data = &tmp;
2336                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2337                 cmd->SCp.Status = tmp;
2338                 break;
2339             default:
2340                 printk("scsi%d : unknown phase\n", instance->host_no);
2341 #ifdef NDEBUG
2342                 NCR5380_print(instance);
2343 #endif
2344             } /* switch(phase) */
2345         } /* if (tmp * SR_REQ) */ 
2346 #ifdef USLEEP
2347         else {
2348             if (!disconnect && hostdata->time_expires && jiffies > 
2349                 hostdata->time_expires) {
2350                 hostdata->time_expires = jiffies + USLEEP_SLEEP;
2351 #if (NDEBUG & NDEBUG_USLEEP)
2352                 printk("scsi%d : poll timed out, sleeping until %ul\n", instance->host_no,
2353                     hostdata->time_expires);
2354 #endif
2355                 NCR5380_set_timer (instance);
2356                 return;
2357             }
2358         }
2359 #endif
2360     } /* while (1) */
2361 }
2362 
2363 /*
2364  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2365  *
2366  * Purpose : does reselection, initializing the instance->connected 
2367  *      field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q 
2368  *      nexus has been reestablished,
2369  *      
2370  * Inputs : instance - this instance of the NCR5380.
2371  *
2372  */
2373 
2374 
2375 static void NCR5380_reselect (struct Scsi_Host *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
2376     NCR5380_local_declare();
2377     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
2378         instance->hostdata;
2379     unsigned char target_mask;
2380     unsigned char lun, phase;
2381     int len;
2382 #ifdef SCSI2
2383     unsigned char tag;
2384 #endif
2385     unsigned char msg[3];
2386     unsigned char *data;
2387     Scsi_Cmnd *tmp = NULL, *prev;
2388     int abort = 0;
2389     NCR5380_setup(instance);
2390 
2391     /*
2392      * Disable arbitration, etc. since the host adapter obviously
2393      * lost, and tell an interrupted NCR5380_select() to restart.
2394      */
2395 
2396     NCR5380_write(MODE_REG, MR_BASE);
2397     hostdata->restart_select = 1;
2398 
2399     target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2400 
2401 #if (NDEBUG & NDEBUG_RESELECTION)
2402     printk("scsi%d : reselect\n", instance->host_no);
2403 #endif
2404 
2405     /* 
2406      * At this point, we have detected that our SCSI ID is on the bus,
2407      * SEL is true and BSY was false for at least one bus settle delay
2408      * (400 ns).
2409      *
2410      * We must assert BSY ourselves, until the target drops the SEL
2411      * signal.
2412      */
2413 
2414     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2415     
2416     while (NCR5380_read(STATUS_REG) & SR_SEL);
2417     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2418 
2419     /*
2420      * Wait for target to go into MSGIN.
2421      */
2422 
2423     while (!(NCR5380_read(STATUS_REG) & SR_REQ));
2424 
2425     len = 1;
2426     data = msg;
2427     phase = PHASE_MSGIN;
2428     NCR5380_transfer_pio(instance, &phase, &len, &data);
2429 
2430 
2431     if (!msg[0] & 0x80) {
2432         printk("scsi%d : expecting IDENTIFY message, got ",
2433             instance->host_no);
2434         print_msg(msg);
2435         abort = 1;
2436     } else {
2437         /* Accept message by clearing ACK */
2438         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2439         lun = (msg[0] & 0x07);
2440 
2441         /* 
2442          * We need to add code for SCSI-II to track which devices have
2443          * I_T_L_Q nexuses established, and which have simple I_T_L
2444          * nexuses so we can chose to do additional data transfer.
2445          */
2446 
2447 #ifdef SCSI2
2448 #error "SCSI-II tagged queueing is not supported yet"
2449 #endif
2450 
2451         /* 
2452          * Find the command corresponding to the I_T_L or I_T_L_Q  nexus we 
2453          * just reestablished, and remove it from the disconnected queue.
2454          */
2455 
2456 
2457         for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL; 
2458             tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble) 
2459             if ((target_mask == (1 << tmp->target)) && (lun == tmp->lun)
2460 #ifdef SCSI2
2461             && (tag == tmp->tag) 
2462 #endif
2463 ) {
2464             if (prev)
2465                 prev->host_scribble = tmp->host_scribble;
2466             else
2467                 hostdata->disconnected_queue = (Scsi_Cmnd *) tmp->host_scribble;
2468             tmp->host_scribble = NULL;
2469             break;
2470         }
2471 
2472         if (!tmp) {
2473 #ifdef SCSI2
2474             printk("scsi%d : warning : target bitmask %02x lun %d tag %d not in disconnect_queue.\n",
2475                     instance->host_no, target_mask, lun, tag);
2476 #else
2477             printk("scsi%d : warning : target bitmask %02x lun %d not in disconnect_queue.\n",
2478                     instance->host_no, target_mask, lun);
2479 #endif
2480         /* 
2481          * Since we have an established nexus that we can't do anything with,
2482          * we must abort it.  
2483          */
2484         abort = 1;
2485         }
2486     }
2487 
2488     if (abort) {
2489         msg[0] = ABORT;
2490         len = 1;
2491         data = msg;
2492         phase = PHASE_MSGOUT;
2493         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2494         NCR5380_transfer_pio(instance, &phase, &len, &data);
2495     } else {
2496         hostdata->connected = tmp;
2497 #if (NDEBUG & NDEBUG_RESELECTION)
2498         printk"scsi%d : nexus established, target = %d, lun = %d, tag = %d\n",
2499             instance->host_no, tmp->target, tmp->lun, tmp->tag);
2500 #endif
2501     }
2502 }
2503 
2504 /*
2505  * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
2506  *
2507  * Purpose : called by interrupt handler when DMA finishes or a phase
2508  *      mismatch occurs (which would finish the DMA transfer).  
2509  *
2510  * Inputs : instance - this instance of the NCR5380.
2511  *
2512  * Returns : pointer to the Scsi_Cmnd structure for which the I_T_L
2513  *      nexus has been reestablished, on failure NULL is returned.
2514  */
2515 
2516 #ifdef REAL_DMA
2517 static void NCR5380_dma_complete (NCR5380_instance *instance) {
     /* [previous][next][first][last][top][bottom][index][help] */
2518     NCR5380_local_declare();
2519     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *
2520         instance->hostdata);
2521     int transferred;
2522     NCR5380_setup(instance);
2523     
2524     /*
2525      * XXX this might not be right.
2526      *
2527      * Wait for final byte to transfer, ie wait for ACK to go false.
2528      *
2529      * We should use the Last Byte Sent bit, unfortunately this is 
2530      * not available on the 5380/5381 (only the various CMOS chips)
2531      */
2532 
2533     while (NCR5380_read(BUS_AND_STATUS_REG) & BASR_ACK);
2534 
2535     NCR5380_write(MODE_REG, MR_BASE);
2536     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2537 
2538     /*
2539      * The only places we should see a phase mismatch and have to send
2540      * data from the same set of pointers will be the data transfer
2541      * phases.  So, residual, requested length are only important here.
2542      */
2543 
2544     if (!(hostdata->connected->SCp.phase & SR_CD)) {
2545         transferred = instance->dmalen - NCR5380_dma_residual();
2546         hostdata->connected->SCp.this_residual -= transferred;
2547         hostdata->connected->SCp.ptr += transferred;
2548     }
2549 }
2550 #endif /* def REAL_DMA */
2551 
2552 /*
2553  * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
2554  *
2555  * Purpose : abort a command
2556  *
2557  * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the 
2558  *      host byte of the result field to, if zero DID_ABORTED is 
2559  *      used.
2560  *
2561  * Returns : 0 - success, -1 on failure.
2562  *
2563  * XXX - there is no way to abort the command that is currently 
2564  *       connected, you have to wait for it to complete.  If this is 
2565  *       a problem, we could implement longjmp() / setjmp(), setjmp()
2566  *       called where the loop started in NCR5380_main().
2567  */
2568 
2569 #ifndef NCR5380_abort
2570 static
2571 #endif
2572 int NCR5380_abort (Scsi_Cmnd *cmd) {
     /* [previous][next][first][last][top][bottom][index][help] */
2573     NCR5380_local_declare();
2574     struct Scsi_Host *instance = cmd->host;
2575     struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
2576         instance->hostdata;
2577     Scsi_Cmnd *tmp, **prev;
2578     unsigned char msg, phase, *msgptr;
2579     int len;
2580 
2581     printk("scsi%d : aborting command\n", instance->host_no);
2582     print_Scsi_Cmnd (cmd);
2583 
2584     NCR5380_print_status (instance);
2585 
2586     cli();
2587     NCR5380_setup(instance);
2588     
2589 #if (NDEBUG & NDEBUG_ABORT)
2590     printk("scsi%d : abort called\n", instance->host_no);
2591     printk("        basr 0x%X, sr 0x%X\n", 
2592            NCR5380_read(BUS_AND_STATUS_REG), NCR5380_read(STATUS_REG));
2593 #endif
2594 
2595 #if 0
2596 /*
2597  * Case 1 : If the command is the currently executing command, 
2598  * we'll set the aborted flag and return control so that 
2599  * information transfer routine can exit cleanly.
2600  */
2601 
2602     if (hostdata->connected == cmd) {
2603 #if (NDEBUG & NDEBUG_ABORT)
2604         printk("scsi%d : aborting connected command\n", instance->host_no);
2605 #endif
2606         hostdata->aborted = 1;
2607 /*
2608  * We should perform BSY checking, and make sure we haven't slipped
2609  * into BUS FREE.
2610  */
2611 
2612         NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN);
2613 /* 
2614  * Since we can't change phases until we've completed the current 
2615  * handshake, we have to source or sink a byte of data if the current
2616  * phase is not MSGOUT.
2617  */
2618 
2619 /* 
2620  * Return control to the executing NCR drive so we can clear the
2621  * aborted flag and get back into our main loop.
2622  */ 
2623  
2624         return 0;
2625     }
2626 #endif
2627 
2628 /* 
2629  * Case 2 : If the command hasn't been issued yet, we simply remove it 
2630  *          from the issue queue.
2631  */
2632     for (prev = (Scsi_Cmnd **) &(hostdata->issue_queue), 
2633         tmp = (Scsi_Cmnd *) hostdata->issue_queue;
2634         tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp = 
2635         (Scsi_Cmnd *) tmp->host_scribble) 
2636         if (cmd == tmp) {
2637             (*prev) = (Scsi_Cmnd *) tmp->host_scribble;
2638             tmp->host_scribble = NULL;
2639             tmp->result = DID_ABORT << 16;
2640             sti();
2641 #if (NDEBUG & NDEBUG_ABORT)
2642     printk("scsi%d : abort removed command from issue queue.\n", 
2643         instance->host_no);
2644 #endif
2645             tmp->done(tmp);
2646             return SCSI_ABORT_SUCCESS;
2647         }
2648 
2649 /* 
2650  * Case 3 : If any commands are connected, we're going to fail the abort
2651  *          and let the high level SCSI driver retry at a later time or 
2652  *          issue a reset.
2653  *
2654  *          Timeouts, and therefore aborted commands, will be highly unlikely
2655  *          and handling them cleanly in this situation would make the common
2656  *          case of noresets less efficient, and would pollute our code.  So,
2657  *          we fail.
2658  */
2659 
2660     if (hostdata->connected) {
2661         sti();
2662 #if (NDEBUG & NDEBUG_ABORT)
2663     printk("scsi%d : abort failed, command connected.\n", instance->host_no);
2664 #endif
2665         return SCSI_ABORT_NOT_RUNNING;
2666     }
2667 
2668 /*
2669  * Case 4: If the command is currently disconnected from the bus, and 
2670  *      there are no connected commands, we reconnect the I_T_L or 
2671  *      I_T_L_Q nexus associated with it, go into message out, and send 
2672  *      an abort message.
2673  *
2674  * This case is especially ugly. In order to reestablish the nexus, we
2675  * need to call NCR5380_select().  The easiest way to implement this 
2676  * function was to abort if the bus was busy, and let the interrupt
2677  * handler triggered on the SEL for reselect take care of lost arbitrations
2678  * where necessary, meaning interrupts need to be enabled.
2679  *
2680  * When interrupts are enabled, the queues may change - so we 
2681  * can't remove it from the disconnected queue before selecting it
2682  * because that could cause a failure in hashing the nexus if that 
2683  * device reselected.
2684  * 
2685  * Since the queues may change, we can't use the pointers from when we
2686  * first locate it.
2687  *
2688  * So, we must first locate the command, and if NCR5380_select()
2689  * succeeds, then issue the abort, relocate the command and remove
2690  * it from the disconnected queue.
2691  */
2692 
2693     for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp; 
2694         tmp = (Scsi_Cmnd *) tmp->host_scribble) 
2695         if (cmd == tmp) {
2696             sti(); 
2697 #if (NDEBUG & NDEBUG_ABORT)
2698     printk("scsi%d : aborting disconnected command.\n", instance->host_no);
2699 #endif
2700   
2701             if (NCR5380_select (instance, cmd, (int) cmd->tag)) 
2702                 return SCSI_ABORT_BUSY;
2703 
2704 #if (NDEBUG & NDEBUG_ABORT)
2705     printk("scsi%d : nexus reestablished.\n", instance->host_no);
2706 #endif
2707 
2708             msg = ABORT;
2709             msgptr = &msg;
2710             len = 1;
2711             phase = PHASE_MSGOUT;
2712             NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2713             NCR5380_transfer_pio (instance, &phase, &len, &msgptr);
2714 
2715             cli();
2716             for (prev = (Scsi_Cmnd **) &(hostdata->disconnected_queue), 
2717                 tmp = (Scsi_Cmnd *) hostdata->disconnected_queue;
2718                 tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp = 
2719                 (Scsi_Cmnd *) tmp->host_scribble) 
2720                     if (cmd == tmp) {
2721                     *prev = (Scsi_Cmnd *) tmp->host_scribble;
2722                     tmp->host_scribble = NULL;
2723                     tmp->result = DID_ABORT << 16;
2724                     sti();
2725                     tmp->done(tmp);
2726                     return SCSI_ABORT_SUCCESS;
2727                 }
2728         }
2729 
2730 /*
2731  * Case 5 : If we reached this point, the command was not found in any of 
2732  *          the queues.
2733  *
2734  * We probably reached this point because of an unlikely race condition
2735  * between the command completing successfully and the abortion code,
2736  * so we won't panic, but we will notify the user in case something really
2737  * broke.
2738  */
2739 
2740     sti();
2741     printk("scsi%d : warning : SCSI command probably completed successfully\n"
2742            "         before abortion\n", instance->host_no); 
2743     return SCSI_ABORT_NOT_RUNNING;
2744 }
2745 
2746 
2747 /* 
2748  * Function : int NCR5380_reset (Scsi_Cmnd *cmd)
2749  * 
2750  * Purpose : reset the SCSI bus.
2751  *
2752  * Returns : SCSI_RESET_WAKEUP
2753  *
2754  */ 
2755 
2756 #ifndef NCR5380_reset
2757 static
2758 #endif
2759 int NCR5380_reset (Scsi_Cmnd *cmd) {
     /* [previous][next][first][last][top][bottom][index][help] */
2760     NCR5380_local_declare();
2761     NCR5380_setup(cmd->host);
2762 
2763     NCR5380_print_status (cmd->host);
2764 
2765     cli();
2766     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
2767     udelay(25);
2768     NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2769     sti();
2770 
2771     return SCSI_RESET_WAKEUP;
2772 }
2773 

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