drivers/scsi/NCR5380.c

   1 // SPDX-License-Identifier: GPL-2.0
   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  * For more information, please consult
  16  *
  17  * NCR 5380 Family
  18  * SCSI Protocol Controller
  19  * Databook
  20  *
  21  * NCR Microelectronics
  22  * 1635 Aeroplaza Drive
  23  * Colorado Springs, CO 80916
  24  * 1+ (719) 578-3400
  25  * 1+ (800) 334-5454
  26  */
  27
  28 /*
  29  * With contributions from Ray Van Tassle, Ingmar Baumgart,
  30  * Ronald van Cuijlenborg, Alan Cox and others.
  31  */
  32
  33 /* Ported to Atari by Roman Hodek and others. */
  34
  35 /* Adapted for the Sun 3 by Sam Creasey. */
  36
  37 /*
  38  * Design
  39  *
  40  * This is a generic 5380 driver.  To use it on a different platform,
  41  * one simply writes appropriate system specific macros (ie, data
  42  * transfer - some PC's will use the I/O bus, 68K's must use
  43  * memory mapped) and drops this file in their 'C' wrapper.
  44  *
  45  * As far as command queueing, two queues are maintained for
  46  * each 5380 in the system - commands that haven't been issued yet,
  47  * and commands that are currently executing.  This means that an
  48  * unlimited number of commands may be queued, letting
  49  * more commands propagate from the higher driver levels giving higher
  50  * throughput.  Note that both I_T_L and I_T_L_Q nexuses are supported,
  51  * allowing multiple commands to propagate all the way to a SCSI-II device
  52  * while a command is already executing.
  53  *
  54  *
  55  * Issues specific to the NCR5380 :
  56  *
  57  * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead
  58  * piece of hardware that requires you to sit in a loop polling for
  59  * the REQ signal as long as you are connected.  Some devices are
  60  * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect
  61  * while doing long seek operations. [...] These
  62  * broken devices are the exception rather than the rule and I'd rather
  63  * spend my time optimizing for the normal case.
  64  *
  65  * Architecture :
  66  *
  67  * At the heart of the design is a coroutine, NCR5380_main,
  68  * which is started from a workqueue for each NCR5380 host in the
  69  * system.  It attempts to establish I_T_L or I_T_L_Q nexuses by
  70  * removing the commands from the issue queue and calling
  71  * NCR5380_select() if a nexus is not established.
  72  *
  73  * Once a nexus is established, the NCR5380_information_transfer()
  74  * phase goes through the various phases as instructed by the target.
  75  * if the target goes into MSG IN and sends a DISCONNECT message,
  76  * the command structure is placed into the per instance disconnected
  77  * queue, and NCR5380_main tries to find more work.  If the target is
  78  * idle for too long, the system will try to sleep.
  79  *
  80  * If a command has disconnected, eventually an interrupt will trigger,
  81  * calling NCR5380_intr()  which will in turn call NCR5380_reselect
  82  * to reestablish a nexus.  This will run main if necessary.
  83  *
  84  * On command termination, the done function will be called as
  85  * appropriate.
  86  *
  87  * SCSI pointers are maintained in the SCp field of SCSI command
  88  * structures, being initialized after the command is connected
  89  * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
  90  * Note that in violation of the standard, an implicit SAVE POINTERS operation
  91  * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
  92  */
  93
  94 /*
  95  * Using this file :
  96  * This file a skeleton Linux SCSI driver for the NCR 5380 series
  97  * of chips.  To use it, you write an architecture specific functions
  98  * and macros and include this file in your driver.
  99  *
 100  * These macros MUST be defined :
 101  *
 102  * NCR5380_read(register)  - read from the specified register
 103  *
 104  * NCR5380_write(register, value) - write to the specific register
 105  *
 106  * NCR5380_implementation_fields  - additional fields needed for this
 107  * specific implementation of the NCR5380
 108  *
 109  * Either real DMA *or* pseudo DMA may be implemented
 110  *
 111  * NCR5380_dma_xfer_len   - determine size of DMA/PDMA transfer
 112  * NCR5380_dma_send_setup - execute DMA/PDMA from memory to 5380
 113  * NCR5380_dma_recv_setup - execute DMA/PDMA from 5380 to memory
 114  * NCR5380_dma_residual   - residual byte count
 115  *
 116  * The generic driver is initialized by calling NCR5380_init(instance),
 117  * after setting the appropriate host specific fields and ID.
 118  */
 119
 120 #ifndef NCR5380_io_delay
 121 #define NCR5380_io_delay(x)
 122 #endif
 123
 124 #ifndef NCR5380_acquire_dma_irq
 125 #define NCR5380_acquire_dma_irq(x)      (1)
 126 #endif
 127
 128 #ifndef NCR5380_release_dma_irq
 129 #define NCR5380_release_dma_irq(x)
 130 #endif
 131
 132 static unsigned int disconnect_mask = ~0;
 133 module_param(disconnect_mask, int, 0444);
 134
 135 static int do_abort(struct Scsi_Host *);
 136 static void do_reset(struct Scsi_Host *);
 137 static void bus_reset_cleanup(struct Scsi_Host *);
 138
 139 /**
 140  * initialize_SCp - init the scsi pointer field
 141  * @cmd: command block to set up
 142  *
 143  * Set up the internal fields in the SCSI command.
 144  */
 145
 146 static inline void initialize_SCp(struct scsi_cmnd *cmd)
 147 {
 148         /*
 149          * Initialize the Scsi Pointer field so that all of the commands in the
 150          * various queues are valid.
 151          */
 152
 153         if (scsi_bufflen(cmd)) {
 154                 cmd->SCp.buffer = scsi_sglist(cmd);
 155                 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
 156                 cmd->SCp.this_residual = cmd->SCp.buffer->length;
 157         } else {
 158                 cmd->SCp.buffer = NULL;
 159                 cmd->SCp.ptr = NULL;
 160                 cmd->SCp.this_residual = 0;
 161         }
 162
 163         cmd->SCp.Status = 0;
 164         cmd->SCp.Message = 0;
 165 }
 166
 167 static inline void advance_sg_buffer(struct scsi_cmnd *cmd)
 168 {
 169         struct scatterlist *s = cmd->SCp.buffer;
 170
 171         if (!cmd->SCp.this_residual && s && !sg_is_last(s)) {
 172                 cmd->SCp.buffer = sg_next(s);
 173                 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
 174                 cmd->SCp.this_residual = cmd->SCp.buffer->length;
 175         }
 176 }
 177
 178 static inline void set_resid_from_SCp(struct scsi_cmnd *cmd)
 179 {
 180         int resid = cmd->SCp.this_residual;
 181         struct scatterlist *s = cmd->SCp.buffer;
 182
 183         if (s)
 184                 while (!sg_is_last(s)) {
 185                         s = sg_next(s);
 186                         resid += s->length;
 187                 }
 188         scsi_set_resid(cmd, resid);
 189 }
 190
 191 /**
 192  * NCR5380_poll_politely2 - wait for two chip register values
 193  * @hostdata: host private data
 194  * @reg1: 5380 register to poll
 195  * @bit1: Bitmask to check
 196  * @val1: Expected value
 197  * @reg2: Second 5380 register to poll
 198  * @bit2: Second bitmask to check
 199  * @val2: Second expected value
 200  * @wait: Time-out in jiffies
 201  *
 202  * Polls the chip in a reasonably efficient manner waiting for an
 203  * event to occur. After a short quick poll we begin to yield the CPU
 204  * (if possible). In irq contexts the time-out is arbitrarily limited.
 205  * Callers may hold locks as long as they are held in irq mode.
 206  *
 207  * Returns 0 if either or both event(s) occurred otherwise -ETIMEDOUT.
 208  */
 209
 210 static int NCR5380_poll_politely2(struct NCR5380_hostdata *hostdata,
 211                                   unsigned int reg1, u8 bit1, u8 val1,
 212                                   unsigned int reg2, u8 bit2, u8 val2,
 213                                   unsigned long wait)
 214 {
 215         unsigned long n = hostdata->poll_loops;
 216         unsigned long deadline = jiffies + wait;
 217
 218         do {
 219                 if ((NCR5380_read(reg1) & bit1) == val1)
 220                         return 0;
 221                 if ((NCR5380_read(reg2) & bit2) == val2)
 222                         return 0;
 223                 cpu_relax();
 224         } while (n--);
 225
 226         if (irqs_disabled() || in_interrupt())
 227                 return -ETIMEDOUT;
 228
 229         /* Repeatedly sleep for 1 ms until deadline */
 230         while (time_is_after_jiffies(deadline)) {
 231                 schedule_timeout_uninterruptible(1);
 232                 if ((NCR5380_read(reg1) & bit1) == val1)
 233                         return 0;
 234                 if ((NCR5380_read(reg2) & bit2) == val2)
 235                         return 0;
 236         }
 237
 238         return -ETIMEDOUT;
 239 }
 240
 241 #if NDEBUG
 242 static struct {
 243         unsigned char mask;
 244         const char *name;
 245 } signals[] = {
 246         {SR_DBP, "PARITY"},
 247         {SR_RST, "RST"},
 248         {SR_BSY, "BSY"},
 249         {SR_REQ, "REQ"},
 250         {SR_MSG, "MSG"},
 251         {SR_CD, "CD"},
 252         {SR_IO, "IO"},
 253         {SR_SEL, "SEL"},
 254         {0, NULL}
 255 },
 256 basrs[] = {
 257         {BASR_END_DMA_TRANSFER, "END OF DMA"},
 258         {BASR_DRQ, "DRQ"},
 259         {BASR_PARITY_ERROR, "PARITY ERROR"},
 260         {BASR_IRQ, "IRQ"},
 261         {BASR_PHASE_MATCH, "PHASE MATCH"},
 262         {BASR_BUSY_ERROR, "BUSY ERROR"},
 263         {BASR_ATN, "ATN"},
 264         {BASR_ACK, "ACK"},
 265         {0, NULL}
 266 },
 267 icrs[] = {
 268         {ICR_ASSERT_RST, "ASSERT RST"},
 269         {ICR_ARBITRATION_PROGRESS, "ARB. IN PROGRESS"},
 270         {ICR_ARBITRATION_LOST, "LOST ARB."},
 271         {ICR_ASSERT_ACK, "ASSERT ACK"},
 272         {ICR_ASSERT_BSY, "ASSERT BSY"},
 273         {ICR_ASSERT_SEL, "ASSERT SEL"},
 274         {ICR_ASSERT_ATN, "ASSERT ATN"},
 275         {ICR_ASSERT_DATA, "ASSERT DATA"},
 276         {0, NULL}
 277 },
 278 mrs[] = {
 279         {MR_BLOCK_DMA_MODE, "BLOCK DMA MODE"},
 280         {MR_TARGET, "TARGET"},
 281         {MR_ENABLE_PAR_CHECK, "PARITY CHECK"},
 282         {MR_ENABLE_PAR_INTR, "PARITY INTR"},
 283         {MR_ENABLE_EOP_INTR, "EOP INTR"},
 284         {MR_MONITOR_BSY, "MONITOR BSY"},
 285         {MR_DMA_MODE, "DMA MODE"},
 286         {MR_ARBITRATE, "ARBITRATE"},
 287         {0, NULL}
 288 };
 289
 290 /**
 291  * NCR5380_print - print scsi bus signals
 292  * @instance: adapter state to dump
 293  *
 294  * Print the SCSI bus signals for debugging purposes
 295  */
 296
 297 static void NCR5380_print(struct Scsi_Host *instance)
 298 {
 299         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 300         unsigned char status, basr, mr, icr, i;
 301
 302         status = NCR5380_read(STATUS_REG);
 303         mr = NCR5380_read(MODE_REG);
 304         icr = NCR5380_read(INITIATOR_COMMAND_REG);
 305         basr = NCR5380_read(BUS_AND_STATUS_REG);
 306
 307         printk(KERN_DEBUG "SR =   0x%02x : ", status);
 308         for (i = 0; signals[i].mask; ++i)
 309                 if (status & signals[i].mask)
 310                         printk(KERN_CONT "%s, ", signals[i].name);
 311         printk(KERN_CONT "\nBASR = 0x%02x : ", basr);
 312         for (i = 0; basrs[i].mask; ++i)
 313                 if (basr & basrs[i].mask)
 314                         printk(KERN_CONT "%s, ", basrs[i].name);
 315         printk(KERN_CONT "\nICR =  0x%02x : ", icr);
 316         for (i = 0; icrs[i].mask; ++i)
 317                 if (icr & icrs[i].mask)
 318                         printk(KERN_CONT "%s, ", icrs[i].name);
 319         printk(KERN_CONT "\nMR =   0x%02x : ", mr);
 320         for (i = 0; mrs[i].mask; ++i)
 321                 if (mr & mrs[i].mask)
 322                         printk(KERN_CONT "%s, ", mrs[i].name);
 323         printk(KERN_CONT "\n");
 324 }
 325
 326 static struct {
 327         unsigned char value;
 328         const char *name;
 329 } phases[] = {
 330         {PHASE_DATAOUT, "DATAOUT"},
 331         {PHASE_DATAIN, "DATAIN"},
 332         {PHASE_CMDOUT, "CMDOUT"},
 333         {PHASE_STATIN, "STATIN"},
 334         {PHASE_MSGOUT, "MSGOUT"},
 335         {PHASE_MSGIN, "MSGIN"},
 336         {PHASE_UNKNOWN, "UNKNOWN"}
 337 };
 338
 339 /**
 340  * NCR5380_print_phase - show SCSI phase
 341  * @instance: adapter to dump
 342  *
 343  * Print the current SCSI phase for debugging purposes
 344  */
 345
 346 static void NCR5380_print_phase(struct Scsi_Host *instance)
 347 {
 348         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 349         unsigned char status;
 350         int i;
 351
 352         status = NCR5380_read(STATUS_REG);
 353         if (!(status & SR_REQ))
 354                 shost_printk(KERN_DEBUG, instance, "REQ not asserted, phase unknown.\n");
 355         else {
 356                 for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
 357                      (phases[i].value != (status & PHASE_MASK)); ++i)
 358                         ;
 359                 shost_printk(KERN_DEBUG, instance, "phase %s\n", phases[i].name);
 360         }
 361 }
 362 #endif
 363
 364 /**
 365  * NCR5380_info - report driver and host information
 366  * @instance: relevant scsi host instance
 367  *
 368  * For use as the host template info() handler.
 369  */
 370
 371 static const char *NCR5380_info(struct Scsi_Host *instance)
 372 {
 373         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 374
 375         return hostdata->info;
 376 }
 377
 378 /**
 379  * NCR5380_init - initialise an NCR5380
 380  * @instance: adapter to configure
 381  * @flags: control flags
 382  *
 383  * Initializes *instance and corresponding 5380 chip,
 384  * with flags OR'd into the initial flags value.
 385  *
 386  * Notes : I assume that the host, hostno, and id bits have been
 387  * set correctly. I don't care about the irq and other fields.
 388  *
 389  * Returns 0 for success
 390  */
 391
 392 static int NCR5380_init(struct Scsi_Host *instance, int flags)
 393 {
 394         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 395         int i;
 396         unsigned long deadline;
 397         unsigned long accesses_per_ms;
 398
 399         instance->max_lun = 7;
 400
 401         hostdata->host = instance;
 402         hostdata->id_mask = 1 << instance->this_id;
 403         hostdata->id_higher_mask = 0;
 404         for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
 405                 if (i > hostdata->id_mask)
 406                         hostdata->id_higher_mask |= i;
 407         for (i = 0; i < 8; ++i)
 408                 hostdata->busy[i] = 0;
 409         hostdata->dma_len = 0;
 410
 411         spin_lock_init(&hostdata->lock);
 412         hostdata->connected = NULL;
 413         hostdata->sensing = NULL;
 414         INIT_LIST_HEAD(&hostdata->autosense);
 415         INIT_LIST_HEAD(&hostdata->unissued);
 416         INIT_LIST_HEAD(&hostdata->disconnected);
 417
 418         hostdata->flags = flags;
 419
 420         INIT_WORK(&hostdata->main_task, NCR5380_main);
 421         hostdata->work_q = alloc_workqueue("ncr5380_%d",
 422                                 WQ_UNBOUND | WQ_MEM_RECLAIM,
 423                                 1, instance->host_no);
 424         if (!hostdata->work_q)
 425                 return -ENOMEM;
 426
 427         snprintf(hostdata->info, sizeof(hostdata->info),
 428                 "%s, irq %d, io_port 0x%lx, base 0x%lx, can_queue %d, cmd_per_lun %d, sg_tablesize %d, this_id %d, flags { %s%s%s}",
 429                 instance->hostt->name, instance->irq, hostdata->io_port,
 430                 hostdata->base, instance->can_queue, instance->cmd_per_lun,
 431                 instance->sg_tablesize, instance->this_id,
 432                 hostdata->flags & FLAG_DMA_FIXUP     ? "DMA_FIXUP "     : "",
 433                 hostdata->flags & FLAG_NO_PSEUDO_DMA ? "NO_PSEUDO_DMA " : "",
 434                 hostdata->flags & FLAG_TOSHIBA_DELAY ? "TOSHIBA_DELAY " : "");
 435
 436         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
 437         NCR5380_write(MODE_REG, MR_BASE);
 438         NCR5380_write(TARGET_COMMAND_REG, 0);
 439         NCR5380_write(SELECT_ENABLE_REG, 0);
 440
 441         /* Calibrate register polling loop */
 442         i = 0;
 443         deadline = jiffies + 1;
 444         do {
 445                 cpu_relax();
 446         } while (time_is_after_jiffies(deadline));
 447         deadline += msecs_to_jiffies(256);
 448         do {
 449                 NCR5380_read(STATUS_REG);
 450                 ++i;
 451                 cpu_relax();
 452         } while (time_is_after_jiffies(deadline));
 453         accesses_per_ms = i / 256;
 454         hostdata->poll_loops = NCR5380_REG_POLL_TIME * accesses_per_ms / 2;
 455
 456         return 0;
 457 }
 458
 459 /**
 460  * NCR5380_maybe_reset_bus - Detect and correct bus wedge problems.
 461  * @instance: adapter to check
 462  *
 463  * If the system crashed, it may have crashed with a connected target and
 464  * the SCSI bus busy. Check for BUS FREE phase. If not, try to abort the
 465  * currently established nexus, which we know nothing about. Failing that
 466  * do a bus reset.
 467  *
 468  * Note that a bus reset will cause the chip to assert IRQ.
 469  *
 470  * Returns 0 if successful, otherwise -ENXIO.
 471  */
 472
 473 static int NCR5380_maybe_reset_bus(struct Scsi_Host *instance)
 474 {
 475         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 476         int pass;
 477
 478         for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) {
 479                 switch (pass) {
 480                 case 1:
 481                 case 3:
 482                 case 5:
 483                         shost_printk(KERN_ERR, instance, "SCSI bus busy, waiting up to five seconds\n");
 484                         NCR5380_poll_politely(hostdata,
 485                                               STATUS_REG, SR_BSY, 0, 5 * HZ);
 486                         break;
 487                 case 2:
 488                         shost_printk(KERN_ERR, instance, "bus busy, attempting abort\n");
 489                         do_abort(instance);
 490                         break;
 491                 case 4:
 492                         shost_printk(KERN_ERR, instance, "bus busy, attempting reset\n");
 493                         do_reset(instance);
 494                         /* Wait after a reset; the SCSI standard calls for
 495                          * 250ms, we wait 500ms to be on the safe side.
 496                          * But some Toshiba CD-ROMs need ten times that.
 497                          */
 498                         if (hostdata->flags & FLAG_TOSHIBA_DELAY)
 499                                 msleep(2500);
 500                         else
 501                                 msleep(500);
 502                         break;
 503                 case 6:
 504                         shost_printk(KERN_ERR, instance, "bus locked solid\n");
 505                         return -ENXIO;
 506                 }
 507         }
 508         return 0;
 509 }
 510
 511 /**
 512  * NCR5380_exit - remove an NCR5380
 513  * @instance: adapter to remove
 514  *
 515  * Assumes that no more work can be queued (e.g. by NCR5380_intr).
 516  */
 517
 518 static void NCR5380_exit(struct Scsi_Host *instance)
 519 {
 520         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 521
 522         cancel_work_sync(&hostdata->main_task);
 523         destroy_workqueue(hostdata->work_q);
 524 }
 525
 526 /**
 527  * complete_cmd - finish processing a command and return it to the SCSI ML
 528  * @instance: the host instance
 529  * @cmd: command to complete
 530  */
 531
 532 static void complete_cmd(struct Scsi_Host *instance,
 533                          struct scsi_cmnd *cmd)
 534 {
 535         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 536
 537         dsprintk(NDEBUG_QUEUES, instance, "complete_cmd: cmd %p\n", cmd);
 538
 539         if (hostdata->sensing == cmd) {
 540                 /* Autosense processing ends here */
 541                 if (status_byte(cmd->result) != GOOD) {
 542                         scsi_eh_restore_cmnd(cmd, &hostdata->ses);
 543                 } else {
 544                         scsi_eh_restore_cmnd(cmd, &hostdata->ses);
 545                         set_driver_byte(cmd, DRIVER_SENSE);
 546                 }
 547                 hostdata->sensing = NULL;
 548         }
 549
 550         cmd->scsi_done(cmd);
 551 }
 552
 553 /**
 554  * NCR5380_queue_command - queue a command
 555  * @instance: the relevant SCSI adapter
 556  * @cmd: SCSI command
 557  *
 558  * cmd is added to the per-instance issue queue, with minor
 559  * twiddling done to the host specific fields of cmd.  If the
 560  * main coroutine is not running, it is restarted.
 561  */
 562
 563 static int NCR5380_queue_command(struct Scsi_Host *instance,
 564                                  struct scsi_cmnd *cmd)
 565 {
 566         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 567         struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
 568         unsigned long flags;
 569
 570 #if (NDEBUG & NDEBUG_NO_WRITE)
 571         switch (cmd->cmnd[0]) {
 572         case WRITE_6:
 573         case WRITE_10:
 574                 shost_printk(KERN_DEBUG, instance, "WRITE attempted with NDEBUG_NO_WRITE set\n");
 575                 cmd->result = (DID_ERROR << 16);
 576                 cmd->scsi_done(cmd);
 577                 return 0;
 578         }
 579 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
 580
 581         cmd->result = 0;
 582
 583         spin_lock_irqsave(&hostdata->lock, flags);
 584
 585         if (!NCR5380_acquire_dma_irq(instance)) {
 586                 spin_unlock_irqrestore(&hostdata->lock, flags);
 587
 588                 return SCSI_MLQUEUE_HOST_BUSY;
 589         }
 590
 591         /*
 592          * Insert the cmd into the issue queue. Note that REQUEST SENSE
 593          * commands are added to the head of the queue since any command will
 594          * clear the contingent allegiance condition that exists and the
 595          * sense data is only guaranteed to be valid while the condition exists.
 596          */
 597
 598         if (cmd->cmnd[0] == REQUEST_SENSE)
 599                 list_add(&ncmd->list, &hostdata->unissued);
 600         else
 601                 list_add_tail(&ncmd->list, &hostdata->unissued);
 602
 603         spin_unlock_irqrestore(&hostdata->lock, flags);
 604
 605         dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n",
 606                  cmd, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
 607
 608         /* Kick off command processing */
 609         queue_work(hostdata->work_q, &hostdata->main_task);
 610         return 0;
 611 }
 612
 613 static inline void maybe_release_dma_irq(struct Scsi_Host *instance)
 614 {
 615         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 616
 617         /* Caller does the locking needed to set & test these data atomically */
 618         if (list_empty(&hostdata->disconnected) &&
 619             list_empty(&hostdata->unissued) &&
 620             list_empty(&hostdata->autosense) &&
 621             !hostdata->connected &&
 622             !hostdata->selecting) {
 623                 NCR5380_release_dma_irq(instance);
 624         }
 625 }
 626
 627 /**
 628  * dequeue_next_cmd - dequeue a command for processing
 629  * @instance: the scsi host instance
 630  *
 631  * Priority is given to commands on the autosense queue. These commands
 632  * need autosense because of a CHECK CONDITION result.
 633  *
 634  * Returns a command pointer if a command is found for a target that is
 635  * not already busy. Otherwise returns NULL.
 636  */
 637
 638 static struct scsi_cmnd *dequeue_next_cmd(struct Scsi_Host *instance)
 639 {
 640         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 641         struct NCR5380_cmd *ncmd;
 642         struct scsi_cmnd *cmd;
 643
 644         if (hostdata->sensing || list_empty(&hostdata->autosense)) {
 645                 list_for_each_entry(ncmd, &hostdata->unissued, list) {
 646                         cmd = NCR5380_to_scmd(ncmd);
 647                         dsprintk(NDEBUG_QUEUES, instance, "dequeue: cmd=%p target=%d busy=0x%02x lun=%llu\n",
 648                                  cmd, scmd_id(cmd), hostdata->busy[scmd_id(cmd)], cmd->device->lun);
 649
 650                         if (!(hostdata->busy[scmd_id(cmd)] & (1 << cmd->device->lun))) {
 651                                 list_del(&ncmd->list);
 652                                 dsprintk(NDEBUG_QUEUES, instance,
 653                                          "dequeue: removed %p from issue queue\n", cmd);
 654                                 return cmd;
 655                         }
 656                 }
 657         } else {
 658                 /* Autosense processing begins here */
 659                 ncmd = list_first_entry(&hostdata->autosense,
 660                                         struct NCR5380_cmd, list);
 661                 list_del(&ncmd->list);
 662                 cmd = NCR5380_to_scmd(ncmd);
 663                 dsprintk(NDEBUG_QUEUES, instance,
 664                          "dequeue: removed %p from autosense queue\n", cmd);
 665                 scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
 666                 hostdata->sensing = cmd;
 667                 return cmd;
 668         }
 669         return NULL;
 670 }
 671
 672 static void requeue_cmd(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
 673 {
 674         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 675         struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
 676
 677         if (hostdata->sensing == cmd) {
 678                 scsi_eh_restore_cmnd(cmd, &hostdata->ses);
 679                 list_add(&ncmd->list, &hostdata->autosense);
 680                 hostdata->sensing = NULL;
 681         } else
 682                 list_add(&ncmd->list, &hostdata->unissued);
 683 }
 684
 685 /**
 686  * NCR5380_main - NCR state machines
 687  *
 688  * NCR5380_main is a coroutine that runs as long as more work can
 689  * be done on the NCR5380 host adapters in a system.  Both
 690  * NCR5380_queue_command() and NCR5380_intr() will try to start it
 691  * in case it is not running.
 692  */
 693
 694 static void NCR5380_main(struct work_struct *work)
 695 {
 696         struct NCR5380_hostdata *hostdata =
 697                 container_of(work, struct NCR5380_hostdata, main_task);
 698         struct Scsi_Host *instance = hostdata->host;
 699         int done;
 700
 701         do {
 702                 done = 1;
 703
 704                 spin_lock_irq(&hostdata->lock);
 705                 while (!hostdata->connected && !hostdata->selecting) {
 706                         struct scsi_cmnd *cmd = dequeue_next_cmd(instance);
 707
 708                         if (!cmd)
 709                                 break;
 710
 711                         dsprintk(NDEBUG_MAIN, instance, "main: dequeued %p\n", cmd);
 712
 713                         /*
 714                          * Attempt to establish an I_T_L nexus here.
 715                          * On success, instance->hostdata->connected is set.
 716                          * On failure, we must add the command back to the
 717                          * issue queue so we can keep trying.
 718                          */
 719                         /*
 720                          * REQUEST SENSE commands are issued without tagged
 721                          * queueing, even on SCSI-II devices because the
 722                          * contingent allegiance condition exists for the
 723                          * entire unit.
 724                          */
 725
 726                         if (!NCR5380_select(instance, cmd)) {
 727                                 dsprintk(NDEBUG_MAIN, instance, "main: select complete\n");
 728                         } else {
 729                                 dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, instance,
 730                                          "main: select failed, returning %p to queue\n", cmd);
 731                                 requeue_cmd(instance, cmd);
 732                         }
 733                 }
 734                 if (hostdata->connected && !hostdata->dma_len) {
 735                         dsprintk(NDEBUG_MAIN, instance, "main: performing information transfer\n");
 736                         NCR5380_information_transfer(instance);
 737                         done = 0;
 738                 }
 739                 if (!hostdata->connected) {
 740                         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
 741                         maybe_release_dma_irq(instance);
 742                 }
 743                 spin_unlock_irq(&hostdata->lock);
 744                 if (!done)
 745                         cond_resched();
 746         } while (!done);
 747 }
 748
 749 /*
 750  * NCR5380_dma_complete - finish DMA transfer
 751  * @instance: the scsi host instance
 752  *
 753  * Called by the interrupt handler when DMA finishes or a phase
 754  * mismatch occurs (which would end the DMA transfer).
 755  */
 756
 757 static void NCR5380_dma_complete(struct Scsi_Host *instance)
 758 {
 759         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 760         int transferred;
 761         unsigned char **data;
 762         int *count;
 763         int saved_data = 0, overrun = 0;
 764         unsigned char p;
 765
 766         if (hostdata->read_overruns) {
 767                 p = hostdata->connected->SCp.phase;
 768                 if (p & SR_IO) {
 769                         udelay(10);
 770                         if ((NCR5380_read(BUS_AND_STATUS_REG) &
 771                              (BASR_PHASE_MATCH | BASR_ACK)) ==
 772                             (BASR_PHASE_MATCH | BASR_ACK)) {
 773                                 saved_data = NCR5380_read(INPUT_DATA_REG);
 774                                 overrun = 1;
 775                                 dsprintk(NDEBUG_DMA, instance, "read overrun handled\n");
 776                         }
 777                 }
 778         }
 779
 780 #ifdef CONFIG_SUN3
 781         if ((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) {
 782                 pr_err("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n",
 783                        instance->host_no);
 784                 BUG();
 785         }
 786
 787         if ((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) ==
 788             (BASR_PHASE_MATCH | BASR_ACK)) {
 789                 pr_err("scsi%d: BASR %02x\n", instance->host_no,
 790                        NCR5380_read(BUS_AND_STATUS_REG));
 791                 pr_err("scsi%d: bus stuck in data phase -- probably a single byte overrun!\n",
 792                        instance->host_no);
 793                 BUG();
 794         }
 795 #endif
 796
 797         NCR5380_write(MODE_REG, MR_BASE);
 798         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
 799         NCR5380_read(RESET_PARITY_INTERRUPT_REG);
 800
 801         transferred = hostdata->dma_len - NCR5380_dma_residual(hostdata);
 802         hostdata->dma_len = 0;
 803
 804         data = (unsigned char **)&hostdata->connected->SCp.ptr;
 805         count = &hostdata->connected->SCp.this_residual;
 806         *data += transferred;
 807         *count -= transferred;
 808
 809         if (hostdata->read_overruns) {
 810                 int cnt, toPIO;
 811
 812                 if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
 813                         cnt = toPIO = hostdata->read_overruns;
 814                         if (overrun) {
 815                                 dsprintk(NDEBUG_DMA, instance,
 816                                          "Got an input overrun, using saved byte\n");
 817                                 *(*data)++ = saved_data;
 818                                 (*count)--;
 819                                 cnt--;
 820                                 toPIO--;
 821                         }
 822                         if (toPIO > 0) {
 823                                 dsprintk(NDEBUG_DMA, instance,
 824                                          "Doing %d byte PIO to 0x%p\n", cnt, *data);
 825                                 NCR5380_transfer_pio(instance, &p, &cnt, data);
 826                                 *count -= toPIO - cnt;
 827                         }
 828                 }
 829         }
 830 }
 831
 832 /**
 833  * NCR5380_intr - generic NCR5380 irq handler
 834  * @irq: interrupt number
 835  * @dev_id: device info
 836  *
 837  * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
 838  * from the disconnected queue, and restarting NCR5380_main()
 839  * as required.
 840  *
 841  * The chip can assert IRQ in any of six different conditions. The IRQ flag
 842  * is then cleared by reading the Reset Parity/Interrupt Register (RPIR).
 843  * Three of these six conditions are latched in the Bus and Status Register:
 844  * - End of DMA (cleared by ending DMA Mode)
 845  * - Parity error (cleared by reading RPIR)
 846  * - Loss of BSY (cleared by reading RPIR)
 847  * Two conditions have flag bits that are not latched:
 848  * - Bus phase mismatch (non-maskable in DMA Mode, cleared by ending DMA Mode)
 849  * - Bus reset (non-maskable)
 850  * The remaining condition has no flag bit at all:
 851  * - Selection/reselection
 852  *
 853  * Hence, establishing the cause(s) of any interrupt is partly guesswork.
 854  * In "The DP8490 and DP5380 Comparison Guide", National Semiconductor
 855  * claimed that "the design of the [DP8490] interrupt logic ensures
 856  * interrupts will not be lost (they can be on the DP5380)."
 857  * The L5380/53C80 datasheet from LOGIC Devices has more details.
 858  *
 859  * Checking for bus reset by reading RST is futile because of interrupt
 860  * latency, but a bus reset will reset chip logic. Checking for parity error
 861  * is unnecessary because that interrupt is never enabled. A Loss of BSY
 862  * condition will clear DMA Mode. We can tell when this occurs because the
 863  * the Busy Monitor interrupt is enabled together with DMA Mode.
 864  */
 865
 866 static irqreturn_t __maybe_unused NCR5380_intr(int irq, void *dev_id)
 867 {
 868         struct Scsi_Host *instance = dev_id;
 869         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 870         int handled = 0;
 871         unsigned char basr;
 872         unsigned long flags;
 873
 874         spin_lock_irqsave(&hostdata->lock, flags);
 875
 876         basr = NCR5380_read(BUS_AND_STATUS_REG);
 877         if (basr & BASR_IRQ) {
 878                 unsigned char mr = NCR5380_read(MODE_REG);
 879                 unsigned char sr = NCR5380_read(STATUS_REG);
 880
 881                 dsprintk(NDEBUG_INTR, instance, "IRQ %d, BASR 0x%02x, SR 0x%02x, MR 0x%02x\n",
 882                          irq, basr, sr, mr);
 883
 884                 if ((mr & MR_DMA_MODE) || (mr & MR_MONITOR_BSY)) {
 885                         /* Probably End of DMA, Phase Mismatch or Loss of BSY.
 886                          * We ack IRQ after clearing Mode Register. Workarounds
 887                          * for End of DMA errata need to happen in DMA Mode.
 888                          */
 889
 890                         dsprintk(NDEBUG_INTR, instance, "interrupt in DMA mode\n");
 891
 892                         if (hostdata->connected) {
 893                                 NCR5380_dma_complete(instance);
 894                                 queue_work(hostdata->work_q, &hostdata->main_task);
 895                         } else {
 896                                 NCR5380_write(MODE_REG, MR_BASE);
 897                                 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
 898                         }
 899                 } else if ((NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_mask) &&
 900                     (sr & (SR_SEL | SR_IO | SR_BSY | SR_RST)) == (SR_SEL | SR_IO)) {
 901                         /* Probably reselected */
 902                         NCR5380_write(SELECT_ENABLE_REG, 0);
 903                         NCR5380_read(RESET_PARITY_INTERRUPT_REG);
 904
 905                         dsprintk(NDEBUG_INTR, instance, "interrupt with SEL and IO\n");
 906
 907                         if (!hostdata->connected) {
 908                                 NCR5380_reselect(instance);
 909                                 queue_work(hostdata->work_q, &hostdata->main_task);
 910                         }
 911                         if (!hostdata->connected)
 912                                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
 913                 } else {
 914                         /* Probably Bus Reset */
 915                         NCR5380_read(RESET_PARITY_INTERRUPT_REG);
 916
 917                         if (sr & SR_RST) {
 918                                 /* Certainly Bus Reset */
 919                                 shost_printk(KERN_WARNING, instance,
 920                                              "bus reset interrupt\n");
 921                                 bus_reset_cleanup(instance);
 922                         } else {
 923                                 dsprintk(NDEBUG_INTR, instance, "unknown interrupt\n");
 924                         }
 925 #ifdef SUN3_SCSI_VME
 926                         dregs->csr |= CSR_DMA_ENABLE;
 927 #endif
 928                 }
 929                 handled = 1;
 930         } else {
 931                 dsprintk(NDEBUG_INTR, instance, "interrupt without IRQ bit\n");
 932 #ifdef SUN3_SCSI_VME
 933                 dregs->csr |= CSR_DMA_ENABLE;
 934 #endif
 935         }
 936
 937         spin_unlock_irqrestore(&hostdata->lock, flags);
 938
 939         return IRQ_RETVAL(handled);
 940 }
 941
 942 /**
 943  * NCR5380_select - attempt arbitration and selection for a given command
 944  * @instance: the Scsi_Host instance
 945  * @cmd: the scsi_cmnd to execute
 946  *
 947  * This routine establishes an I_T_L nexus for a SCSI command. This involves
 948  * ARBITRATION, SELECTION and MESSAGE OUT phases and an IDENTIFY message.
 949  *
 950  * Returns true if the operation should be retried.
 951  * Returns false if it should not be retried.
 952  *
 953  * Side effects :
 954  * If bus busy, arbitration failed, etc, NCR5380_select() will exit
 955  * with registers as they should have been on entry - ie
 956  * SELECT_ENABLE will be set appropriately, the NCR5380
 957  * will cease to drive any SCSI bus signals.
 958  *
 959  * If successful : the I_T_L nexus will be established, and
 960  * hostdata->connected will be set to cmd.
 961  * SELECT interrupt will be disabled.
 962  *
 963  * If failed (no target) : cmd->scsi_done() will be called, and the
 964  * cmd->result host byte set to DID_BAD_TARGET.
 965  */
 966
 967 static bool NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
 968         __releases(&hostdata->lock) __acquires(&hostdata->lock)
 969 {
 970         struct NCR5380_hostdata *hostdata = shost_priv(instance);
 971         unsigned char tmp[3], phase;
 972         unsigned char *data;
 973         int len;
 974         int err;
 975         bool ret = true;
 976         bool can_disconnect = instance->irq != NO_IRQ &&
 977                               cmd->cmnd[0] != REQUEST_SENSE &&
 978                               (disconnect_mask & BIT(scmd_id(cmd)));
 979
 980         NCR5380_dprint(NDEBUG_ARBITRATION, instance);
 981         dsprintk(NDEBUG_ARBITRATION, instance, "starting arbitration, id = %d\n",
 982                  instance->this_id);
 983
 984         /*
 985          * Arbitration and selection phases are slow and involve dropping the
 986          * lock, so we have to watch out for EH. An exception handler may
 987          * change 'selecting' to NULL. This function will then return false
 988          * so that the caller will forget about 'cmd'. (During information
 989          * transfer phases, EH may change 'connected' to NULL.)
 990          */
 991         hostdata->selecting = cmd;
 992
 993         /*
 994          * Set the phase bits to 0, otherwise the NCR5380 won't drive the
 995          * data bus during SELECTION.
 996          */
 997
 998         NCR5380_write(TARGET_COMMAND_REG, 0);
 999
1000         /*
1001          * Start arbitration.
1002          */
1003
1004         NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1005         NCR5380_write(MODE_REG, MR_ARBITRATE);
1006
1007         /* The chip now waits for BUS FREE phase. Then after the 800 ns
1008          * Bus Free Delay, arbitration will begin.
1009          */
1010
1011         spin_unlock_irq(&hostdata->lock);
1012         err = NCR5380_poll_politely2(hostdata, MODE_REG, MR_ARBITRATE, 0,
1013                         INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS,
1014                                                ICR_ARBITRATION_PROGRESS, HZ);
1015         spin_lock_irq(&hostdata->lock);
1016         if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) {
1017                 /* Reselection interrupt */
1018                 goto out;
1019         }
1020         if (!hostdata->selecting) {
1021                 /* Command was aborted */
1022                 NCR5380_write(MODE_REG, MR_BASE);
1023                 return false;
1024         }
1025         if (err < 0) {
1026                 NCR5380_write(MODE_REG, MR_BASE);
1027                 shost_printk(KERN_ERR, instance,
1028                              "select: arbitration timeout\n");
1029                 goto out;
1030         }
1031         spin_unlock_irq(&hostdata->lock);
1032
1033         /* The SCSI-2 arbitration delay is 2.4 us */
1034         udelay(3);
1035
1036         /* Check for lost arbitration */
1037         if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1038             (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
1039             (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1040                 NCR5380_write(MODE_REG, MR_BASE);
1041                 dsprintk(NDEBUG_ARBITRATION, instance, "lost arbitration, deasserting MR_ARBITRATE\n");
1042                 spin_lock_irq(&hostdata->lock);
1043                 goto out;
1044         }
1045
1046         /* After/during arbitration, BSY should be asserted.
1047          * IBM DPES-31080 Version S31Q works now
1048          * Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman)
1049          */
1050         NCR5380_write(INITIATOR_COMMAND_REG,
1051                       ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY);
1052
1053         /*
1054          * Again, bus clear + bus settle time is 1.2us, however, this is
1055          * a minimum so we'll udelay ceil(1.2)
1056          */
1057
1058         if (hostdata->flags & FLAG_TOSHIBA_DELAY)
1059                 udelay(15);
1060         else
1061                 udelay(2);
1062
1063         spin_lock_irq(&hostdata->lock);
1064
1065         /* NCR5380_reselect() clears MODE_REG after a reselection interrupt */
1066         if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE))
1067                 goto out;
1068
1069         if (!hostdata->selecting) {
1070                 NCR5380_write(MODE_REG, MR_BASE);
1071                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1072                 return false;
1073         }
1074
1075         dsprintk(NDEBUG_ARBITRATION, instance, "won arbitration\n");
1076
1077         /*
1078          * Now that we have won arbitration, start Selection process, asserting
1079          * the host and target ID's on the SCSI bus.
1080          */
1081
1082         NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask | (1 << scmd_id(cmd)));
1083
1084         /*
1085          * Raise ATN while SEL is true before BSY goes false from arbitration,
1086          * since this is the only way to guarantee that we'll get a MESSAGE OUT
1087          * phase immediately after selection.
1088          */
1089
1090         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY |
1091                       ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL);
1092         NCR5380_write(MODE_REG, MR_BASE);
1093
1094         /*
1095          * Reselect interrupts must be turned off prior to the dropping of BSY,
1096          * otherwise we will trigger an interrupt.
1097          */
1098         NCR5380_write(SELECT_ENABLE_REG, 0);
1099
1100         spin_unlock_irq(&hostdata->lock);
1101
1102         /*
1103          * The initiator shall then wait at least two deskew delays and release
1104          * the BSY signal.
1105          */
1106         udelay(1);        /* wingel -- wait two bus deskew delay >2*45ns */
1107
1108         /* Reset BSY */
1109         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA |
1110                       ICR_ASSERT_ATN | ICR_ASSERT_SEL);
1111
1112         /*
1113          * Something weird happens when we cease to drive BSY - looks
1114          * like the board/chip is letting us do another read before the
1115          * appropriate propagation delay has expired, and we're confusing
1116          * a BSY signal from ourselves as the target's response to SELECTION.
1117          *
1118          * A small delay (the 'C++' frontend breaks the pipeline with an
1119          * unnecessary jump, making it work on my 386-33/Trantor T128, the
1120          * tighter 'C' code breaks and requires this) solves the problem -
1121          * the 1 us delay is arbitrary, and only used because this delay will
1122          * be the same on other platforms and since it works here, it should
1123          * work there.
1124          *
1125          * wingel suggests that this could be due to failing to wait
1126          * one deskew delay.
1127          */
1128
1129         udelay(1);
1130
1131         dsprintk(NDEBUG_SELECTION, instance, "selecting target %d\n", scmd_id(cmd));
1132
1133         /*
1134          * The SCSI specification calls for a 250 ms timeout for the actual
1135          * selection.
1136          */
1137
1138         err = NCR5380_poll_politely(hostdata, STATUS_REG, SR_BSY, SR_BSY,
1139                                     msecs_to_jiffies(250));
1140
1141         if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1142                 spin_lock_irq(&hostdata->lock);
1143                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1144                 NCR5380_reselect(instance);
1145                 shost_printk(KERN_ERR, instance, "reselection after won arbitration?\n");
1146                 goto out;
1147         }
1148
1149         if (err < 0) {
1150                 spin_lock_irq(&hostdata->lock);
1151                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1152
1153                 /* Can't touch cmd if it has been reclaimed by the scsi ML */
1154                 if (!hostdata->selecting)
1155                         return false;
1156
1157                 cmd->result = DID_BAD_TARGET << 16;
1158                 complete_cmd(instance, cmd);
1159                 dsprintk(NDEBUG_SELECTION, instance,
1160                         "target did not respond within 250ms\n");
1161                 ret = false;
1162                 goto out;
1163         }
1164
1165         /*
1166          * No less than two deskew delays after the initiator detects the
1167          * BSY signal is true, it shall release the SEL signal and may
1168          * change the DATA BUS.                                     -wingel
1169          */
1170
1171         udelay(1);
1172
1173         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1174
1175         /*
1176          * Since we followed the SCSI spec, and raised ATN while SEL
1177          * was true but before BSY was false during selection, the information
1178          * transfer phase should be a MESSAGE OUT phase so that we can send the
1179          * IDENTIFY message.
1180          */
1181
1182         /* Wait for start of REQ/ACK handshake */
1183
1184         err = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ);
1185         spin_lock_irq(&hostdata->lock);
1186         if (err < 0) {
1187                 shost_printk(KERN_ERR, instance, "select: REQ timeout\n");
1188                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1189                 goto out;
1190         }
1191         if (!hostdata->selecting) {
1192                 do_abort(instance);
1193                 return false;
1194         }
1195
1196         dsprintk(NDEBUG_SELECTION, instance, "target %d selected, going into MESSAGE OUT phase.\n",
1197                  scmd_id(cmd));
1198         tmp[0] = IDENTIFY(can_disconnect, cmd->device->lun);
1199
1200         len = 1;
1201         data = tmp;
1202         phase = PHASE_MSGOUT;
1203         NCR5380_transfer_pio(instance, &phase, &len, &data);
1204         if (len) {
1205                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1206                 cmd->result = DID_ERROR << 16;
1207                 complete_cmd(instance, cmd);
1208                 dsprintk(NDEBUG_SELECTION, instance, "IDENTIFY message transfer failed\n");
1209                 ret = false;
1210                 goto out;
1211         }
1212
1213         dsprintk(NDEBUG_SELECTION, instance, "nexus established.\n");
1214
1215         hostdata->connected = cmd;
1216         hostdata->busy[cmd->device->id] |= 1 << cmd->device->lun;
1217
1218 #ifdef SUN3_SCSI_VME
1219         dregs->csr |= CSR_INTR;
1220 #endif
1221
1222         initialize_SCp(cmd);
1223
1224         ret = false;
1225
1226 out:
1227         if (!hostdata->selecting)
1228                 return false;
1229         hostdata->selecting = NULL;
1230         return ret;
1231 }
1232
1233 /*
1234  * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
1235  * unsigned char *phase, int *count, unsigned char **data)
1236  *
1237  * Purpose : transfers data in given phase using polled I/O
1238  *
1239  * Inputs : instance - instance of driver, *phase - pointer to
1240  * what phase is expected, *count - pointer to number of
1241  * bytes to transfer, **data - pointer to data pointer.
1242  *
1243  * Returns : -1 when different phase is entered without transferring
1244  * maximum number of bytes, 0 if all bytes are transferred or exit
1245  * is in same phase.
1246  *
1247  * Also, *phase, *count, *data are modified in place.
1248  *
1249  * XXX Note : handling for bus free may be useful.
1250  */
1251
1252 /*
1253  * Note : this code is not as quick as it could be, however it
1254  * IS 100% reliable, and for the actual data transfer where speed
1255  * counts, we will always do a pseudo DMA or DMA transfer.
1256  */
1257
1258 static int NCR5380_transfer_pio(struct Scsi_Host *instance,
1259                                 unsigned char *phase, int *count,
1260                                 unsigned char **data)
1261 {
1262         struct NCR5380_hostdata *hostdata = shost_priv(instance);
1263         unsigned char p = *phase, tmp;
1264         int c = *count;
1265         unsigned char *d = *data;
1266
1267         /*
1268          * The NCR5380 chip will only drive the SCSI bus when the
1269          * phase specified in the appropriate bits of the TARGET COMMAND
1270          * REGISTER match the STATUS REGISTER
1271          */
1272
1273         NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1274
1275         do {
1276                 /*
1277                  * Wait for assertion of REQ, after which the phase bits will be
1278                  * valid
1279                  */
1280
1281                 if (NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ) < 0)
1282                         break;
1283
1284                 dsprintk(NDEBUG_HANDSHAKE, instance, "REQ asserted\n");
1285
1286                 /* Check for phase mismatch */
1287                 if ((NCR5380_read(STATUS_REG) & PHASE_MASK) != p) {
1288                         dsprintk(NDEBUG_PIO, instance, "phase mismatch\n");
1289                         NCR5380_dprint_phase(NDEBUG_PIO, instance);
1290                         break;
1291                 }
1292
1293                 /* Do actual transfer from SCSI bus to / from memory */
1294                 if (!(p & SR_IO))
1295                         NCR5380_write(OUTPUT_DATA_REG, *d);
1296                 else
1297                         *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1298
1299                 ++d;
1300
1301                 /*
1302                  * The SCSI standard suggests that in MSGOUT phase, the initiator
1303                  * should drop ATN on the last byte of the message phase
1304                  * after REQ has been asserted for the handshake but before
1305                  * the initiator raises ACK.
1306                  */
1307
1308                 if (!(p & SR_IO)) {
1309                         if (!((p & SR_MSG) && c > 1)) {
1310                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1311                                 NCR5380_dprint(NDEBUG_PIO, instance);
1312                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1313                                               ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1314                         } else {
1315                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1316                                               ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1317                                 NCR5380_dprint(NDEBUG_PIO, instance);
1318                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1319                                               ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1320                         }
1321                 } else {
1322                         NCR5380_dprint(NDEBUG_PIO, instance);
1323                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1324                 }
1325
1326                 if (NCR5380_poll_politely(hostdata,
1327                                           STATUS_REG, SR_REQ, 0, 5 * HZ) < 0)
1328                         break;
1329
1330                 dsprintk(NDEBUG_HANDSHAKE, instance, "REQ negated, handshake complete\n");
1331
1332 /*
1333  * We have several special cases to consider during REQ/ACK handshaking :
1334  * 1.  We were in MSGOUT phase, and we are on the last byte of the
1335  * message.  ATN must be dropped as ACK is dropped.
1336  *
1337  * 2.  We are in a MSGIN phase, and we are on the last byte of the
1338  * message.  We must exit with ACK asserted, so that the calling
1339  * code may raise ATN before dropping ACK to reject the message.
1340  *
1341  * 3.  ACK and ATN are clear and the target may proceed as normal.
1342  */
1343                 if (!(p == PHASE_MSGIN && c == 1)) {
1344                         if (p == PHASE_MSGOUT && c > 1)
1345                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1346                         else
1347                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1348                 }
1349         } while (--c);
1350
1351         dsprintk(NDEBUG_PIO, instance, "residual %d\n", c);
1352
1353         *count = c;
1354         *data = d;
1355         tmp = NCR5380_read(STATUS_REG);
1356         /* The phase read from the bus is valid if either REQ is (already)
1357          * asserted or if ACK hasn't been released yet. The latter applies if
1358          * we're in MSG IN, DATA IN or STATUS and all bytes have been received.
1359          */
1360         if ((tmp & SR_REQ) || ((tmp & SR_IO) && c == 0))
1361                 *phase = tmp & PHASE_MASK;
1362         else
1363                 *phase = PHASE_UNKNOWN;
1364
1365         if (!c || (*phase == p))
1366                 return 0;
1367         else
1368                 return -1;
1369 }
1370
1371 /**
1372  * do_reset - issue a reset command
1373  * @instance: adapter to reset
1374  *
1375  * Issue a reset sequence to the NCR5380 and try and get the bus
1376  * back into sane shape.
1377  *
1378  * This clears the reset interrupt flag because there may be no handler for
1379  * it. When the driver is initialized, the NCR5380_intr() handler has not yet
1380  * been installed. And when in EH we may have released the ST DMA interrupt.
1381  */
1382
1383 static void do_reset(struct Scsi_Host *instance)
1384 {
1385         struct NCR5380_hostdata __maybe_unused *hostdata = shost_priv(instance);
1386         unsigned long flags;
1387
1388         local_irq_save(flags);
1389         NCR5380_write(TARGET_COMMAND_REG,
1390                       PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK));
1391         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
1392         udelay(50);
1393         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1394         (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1395         local_irq_restore(flags);
1396 }
1397
1398 /**
1399  * do_abort - abort the currently established nexus by going to
1400  * MESSAGE OUT phase and sending an ABORT message.
1401  * @instance: relevant scsi host instance
1402  *
1403  * Returns 0 on success, negative error code on failure.
1404  */
1405
1406 static int do_abort(struct Scsi_Host *instance)
1407 {
1408         struct NCR5380_hostdata *hostdata = shost_priv(instance);
1409         unsigned char *msgptr, phase, tmp;
1410         int len;
1411         int rc;
1412
1413         /* Request message out phase */
1414         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1415
1416         /*
1417          * Wait for the target to indicate a valid phase by asserting
1418          * REQ.  Once this happens, we'll have either a MSGOUT phase
1419          * and can immediately send the ABORT message, or we'll have some
1420          * other phase and will have to source/sink data.
1421          *
1422          * We really don't care what value was on the bus or what value
1423          * the target sees, so we just handshake.
1424          */
1425
1426         rc = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, 10 * HZ);
1427         if (rc < 0)
1428                 goto out;
1429
1430         tmp = NCR5380_read(STATUS_REG) & PHASE_MASK;
1431
1432         NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1433
1434         if (tmp != PHASE_MSGOUT) {
1435                 NCR5380_write(INITIATOR_COMMAND_REG,
1436                               ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1437                 rc = NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, 0, 3 * HZ);
1438                 if (rc < 0)
1439                         goto out;
1440                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1441         }
1442
1443         tmp = ABORT;
1444         msgptr = &tmp;
1445         len = 1;
1446         phase = PHASE_MSGOUT;
1447         NCR5380_transfer_pio(instance, &phase, &len, &msgptr);
1448         if (len)
1449                 rc = -ENXIO;
1450
1451         /*
1452          * If we got here, and the command completed successfully,
1453          * we're about to go into bus free state.
1454          */
1455
1456 out:
1457         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1458         return rc;
1459 }
1460
1461 /*
1462  * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
1463  * unsigned char *phase, int *count, unsigned char **data)
1464  *
1465  * Purpose : transfers data in given phase using either real
1466  * or pseudo DMA.
1467  *
1468  * Inputs : instance - instance of driver, *phase - pointer to
1469  * what phase is expected, *count - pointer to number of
1470  * bytes to transfer, **data - pointer to data pointer.
1471  *
1472  * Returns : -1 when different phase is entered without transferring
1473  * maximum number of bytes, 0 if all bytes or transferred or exit
1474  * is in same phase.
1475  *
1476  * Also, *phase, *count, *data are modified in place.
1477  */
1478
1479
1480 static int NCR5380_transfer_dma(struct Scsi_Host *instance,
1481                                 unsigned char *phase, int *count,
1482                                 unsigned char **data)
1483 {
1484         struct NCR5380_hostdata *hostdata = shost_priv(instance);
1485         int c = *count;
1486         unsigned char p = *phase;
1487         unsigned char *d = *data;
1488         unsigned char tmp;
1489         int result = 0;
1490
1491         if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1492                 *phase = tmp;
1493                 return -1;
1494         }
1495
1496         hostdata->connected->SCp.phase = p;
1497
1498         if (p & SR_IO) {
1499                 if (hostdata->read_overruns)
1500                         c -= hostdata->read_overruns;
1501                 else if (hostdata->flags & FLAG_DMA_FIXUP)
1502                         --c;
1503         }
1504
1505         dsprintk(NDEBUG_DMA, instance, "initializing DMA %s: length %d, address %p\n",
1506                  (p & SR_IO) ? "receive" : "send", c, d);
1507
1508 #ifdef CONFIG_SUN3
1509         /* send start chain */
1510         sun3scsi_dma_start(c, *data);
1511 #endif
1512
1513         NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1514         NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY |
1515                                 MR_ENABLE_EOP_INTR);
1516
1517         if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) {
1518                 /* On the Medusa, it is a must to initialize the DMA before
1519                  * starting the NCR. This is also the cleaner way for the TT.
1520                  */
1521                 if (p & SR_IO)
1522                         result = NCR5380_dma_recv_setup(hostdata, d, c);
1523                 else
1524                         result = NCR5380_dma_send_setup(hostdata, d, c);
1525         }
1526
1527         /*
1528          * On the PAS16 at least I/O recovery delays are not needed here.
1529          * Everyone else seems to want them.
1530          */
1531
1532         if (p & SR_IO) {
1533                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1534                 NCR5380_io_delay(1);
1535                 NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
1536         } else {
1537                 NCR5380_io_delay(1);
1538                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1539                 NCR5380_io_delay(1);
1540                 NCR5380_write(START_DMA_SEND_REG, 0);
1541                 NCR5380_io_delay(1);
1542         }
1543
1544 #ifdef CONFIG_SUN3
1545 #ifdef SUN3_SCSI_VME
1546         dregs->csr |= CSR_DMA_ENABLE;
1547 #endif
1548         sun3_dma_active = 1;
1549 #endif
1550
1551         if (hostdata->flags & FLAG_LATE_DMA_SETUP) {
1552                 /* On the Falcon, the DMA setup must be done after the last
1553                  * NCR access, else the DMA setup gets trashed!
1554                  */
1555                 if (p & SR_IO)
1556                         result = NCR5380_dma_recv_setup(hostdata, d, c);
1557                 else
1558                         result = NCR5380_dma_send_setup(hostdata, d, c);
1559         }
1560
1561         /* On failure, NCR5380_dma_xxxx_setup() returns a negative int. */
1562         if (result < 0)
1563                 return result;
1564
1565         /* For real DMA, result is the byte count. DMA interrupt is expected. */
1566         if (result > 0) {
1567                 hostdata->dma_len = result;
1568                 return 0;
1569         }
1570
1571         /* The result is zero iff pseudo DMA send/receive was completed. */
1572         hostdata->dma_len = c;
1573
1574 /*
1575  * A note regarding the DMA errata workarounds for early NMOS silicon.
1576  *
1577  * For DMA sends, we want to wait until the last byte has been
1578  * transferred out over the bus before we turn off DMA mode.  Alas, there
1579  * seems to be no terribly good way of doing this on a 5380 under all
1580  * conditions.  For non-scatter-gather operations, we can wait until REQ
1581  * and ACK both go false, or until a phase mismatch occurs.  Gather-sends
1582  * are nastier, since the device will be expecting more data than we
1583  * are prepared to send it, and REQ will remain asserted.  On a 53C8[01] we
1584  * could test Last Byte Sent to assure transfer (I imagine this is precisely
1585  * why this signal was added to the newer chips) but on the older 538[01]
1586  * this signal does not exist.  The workaround for this lack is a watchdog;
1587  * we bail out of the wait-loop after a modest amount of wait-time if
1588  * the usual exit conditions are not met.  Not a terribly clean or
1589  * correct solution :-%
1590  *
1591  * DMA receive is equally tricky due to a nasty characteristic of the NCR5380.
1592  * If the chip is in DMA receive mode, it will respond to a target's
1593  * REQ by latching the SCSI data into the INPUT DATA register and asserting
1594  * ACK, even if it has _already_ been notified by the DMA controller that
1595  * the current DMA transfer has completed!  If the NCR5380 is then taken
1596  * out of DMA mode, this already-acknowledged byte is lost. This is
1597  * not a problem for "one DMA transfer per READ command", because
1598  * the situation will never arise... either all of the data is DMA'ed
1599  * properly, or the target switches to MESSAGE IN phase to signal a
1600  * disconnection (either operation bringing the DMA to a clean halt).
1601  * However, in order to handle scatter-receive, we must work around the
1602  * problem.  The chosen fix is to DMA fewer bytes, then check for the
1603  * condition before taking the NCR5380 out of DMA mode.  One or two extra
1604  * bytes are transferred via PIO as necessary to fill out the original
1605  * request.
1606  */
1607
1608         if (hostdata->flags & FLAG_DMA_FIXUP) {
1609                 if (p & SR_IO) {
1610                         /*
1611                          * The workaround was to transfer fewer bytes than we
1612                          * intended to with the pseudo-DMA read function, wait for
1613                          * the chip to latch the last byte, read it, and then disable
1614                          * pseudo-DMA mode.
1615                          *
1616                          * After REQ is asserted, the NCR5380 asserts DRQ and ACK.
1617                          * REQ is deasserted when ACK is asserted, and not reasserted
1618                          * until ACK goes false.  Since the NCR5380 won't lower ACK
1619                          * until DACK is asserted, which won't happen unless we twiddle
1620                          * the DMA port or we take the NCR5380 out of DMA mode, we
1621                          * can guarantee that we won't handshake another extra
1622                          * byte.
1623                          */
1624
1625                         if (NCR5380_poll_politely(hostdata, BUS_AND_STATUS_REG,
1626                                                   BASR_DRQ, BASR_DRQ, HZ) < 0) {
1627                                 result = -1;
1628                                 shost_printk(KERN_ERR, instance, "PDMA read: DRQ timeout\n");
1629                         }
1630                         if (NCR5380_poll_politely(hostdata, STATUS_REG,
1631                                                   SR_REQ, 0, HZ) < 0) {
1632                                 result = -1;
1633                                 shost_printk(KERN_ERR, instance, "PDMA read: !REQ timeout\n");
1634                         }
1635                         d[*count - 1] = NCR5380_read(INPUT_DATA_REG);
1636                 } else {
1637                         /*
1638                          * Wait for the last byte to be sent.  If REQ is being asserted for
1639                          * the byte we're interested, we'll ACK it and it will go false.
1640                          */
1641                         if (NCR5380_poll_politely2(hostdata,
1642                              BUS_AND_STATUS_REG, BASR_DRQ, BASR_DRQ,
1643                              BUS_AND_STATUS_REG, BASR_PHASE_MATCH, 0, HZ) < 0) {
1644                                 result = -1;
1645                                 shost_printk(KERN_ERR, instance, "PDMA write: DRQ and phase timeout\n");
1646                         }
1647                 }
1648         }
1649
1650         NCR5380_dma_complete(instance);
1651         return result;
1652 }
1653
1654 /*
1655  * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
1656  *
1657  * Purpose : run through the various SCSI phases and do as the target
1658  * directs us to.  Operates on the currently connected command,
1659  * instance->connected.
1660  *
1661  * Inputs : instance, instance for which we are doing commands
1662  *
1663  * Side effects : SCSI things happen, the disconnected queue will be
1664  * modified if a command disconnects, *instance->connected will
1665  * change.
1666  *
1667  * XXX Note : we need to watch for bus free or a reset condition here
1668  * to recover from an unexpected bus free condition.
1669  */
1670
1671 static void NCR5380_information_transfer(struct Scsi_Host *instance)
1672         __releases(&hostdata->lock) __acquires(&hostdata->lock)
1673 {
1674         struct NCR5380_hostdata *hostdata = shost_priv(instance);
1675         unsigned char msgout = NOP;
1676         int sink = 0;
1677         int len;
1678         int transfersize;
1679         unsigned char *data;
1680         unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
1681         struct scsi_cmnd *cmd;
1682
1683 #ifdef SUN3_SCSI_VME
1684         dregs->csr |= CSR_INTR;
1685 #endif
1686
1687         while ((cmd = hostdata->connected)) {
1688                 struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
1689
1690                 tmp = NCR5380_read(STATUS_REG);
1691                 /* We only have a valid SCSI phase when REQ is asserted */
1692                 if (tmp & SR_REQ) {
1693                         phase = (tmp & PHASE_MASK);
1694                         if (phase != old_phase) {
1695                                 old_phase = phase;
1696                                 NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
1697                         }
1698 #ifdef CONFIG_SUN3
1699                         if (phase == PHASE_CMDOUT &&
1700                             sun3_dma_setup_done != cmd) {
1701                                 int count;
1702
1703                                 advance_sg_buffer(cmd);
1704
1705                                 count = sun3scsi_dma_xfer_len(hostdata, cmd);
1706
1707                                 if (count > 0) {
1708                                         if (rq_data_dir(cmd->request))
1709                                                 sun3scsi_dma_send_setup(hostdata,
1710                                                                         cmd->SCp.ptr, count);
1711                                         else
1712                                                 sun3scsi_dma_recv_setup(hostdata,
1713                                                                         cmd->SCp.ptr, count);
1714                                         sun3_dma_setup_done = cmd;
1715                                 }
1716 #ifdef SUN3_SCSI_VME
1717                                 dregs->csr |= CSR_INTR;
1718 #endif
1719                         }
1720 #endif /* CONFIG_SUN3 */
1721
1722                         if (sink && (phase != PHASE_MSGOUT)) {
1723                                 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1724
1725                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
1726                                               ICR_ASSERT_ACK);
1727                                 while (NCR5380_read(STATUS_REG) & SR_REQ)
1728                                         ;
1729                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1730                                               ICR_ASSERT_ATN);
1731                                 sink = 0;
1732                                 continue;
1733                         }
1734
1735                         switch (phase) {
1736                         case PHASE_DATAOUT:
1737 #if (NDEBUG & NDEBUG_NO_DATAOUT)
1738                                 shost_printk(KERN_DEBUG, instance, "NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n");
1739                                 sink = 1;
1740                                 do_abort(instance);
1741                                 cmd->result = DID_ERROR << 16;
1742                                 complete_cmd(instance, cmd);
1743                                 hostdata->connected = NULL;
1744                                 hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
1745                                 return;
1746 #endif
1747                         case PHASE_DATAIN:
1748                                 /*
1749                                  * If there is no room left in the current buffer in the
1750                                  * scatter-gather list, move onto the next one.
1751                                  */
1752
1753                                 advance_sg_buffer(cmd);
1754                                 dsprintk(NDEBUG_INFORMATION, instance,
1755                                         "this residual %d, sg ents %d\n",
1756                                         cmd->SCp.this_residual,
1757                                         sg_nents(cmd->SCp.buffer));
1758
1759                                 /*
1760                                  * The preferred transfer method is going to be
1761                                  * PSEUDO-DMA for systems that are strictly PIO,
1762                                  * since we can let the hardware do the handshaking.
1763                                  *
1764                                  * For this to work, we need to know the transfersize
1765                                  * ahead of time, since the pseudo-DMA code will sit
1766                                  * in an unconditional loop.
1767                                  */
1768
1769                                 transfersize = 0;
1770                                 if (!cmd->device->borken)
1771                                         transfersize = NCR5380_dma_xfer_len(hostdata, cmd);
1772
1773                                 if (transfersize > 0) {
1774                                         len = transfersize;
1775                                         if (NCR5380_transfer_dma(instance, &phase,
1776                                             &len, (unsigned char **)&cmd->SCp.ptr)) {
1777                                                 /*
1778                                                  * If the watchdog timer fires, all future
1779                                                  * accesses to this device will use the
1780                                                  * polled-IO.
1781                                                  */
1782                                                 scmd_printk(KERN_INFO, cmd,
1783                                                         "switching to slow handshake\n");
1784                                                 cmd->device->borken = 1;
1785                                                 do_reset(instance);
1786                                                 bus_reset_cleanup(instance);
1787                                         }
1788                                 } else {
1789                                         /* Transfer a small chunk so that the
1790                                          * irq mode lock is not held too long.
1791                                          */
1792                                         transfersize = min(cmd->SCp.this_residual,
1793                                                            NCR5380_PIO_CHUNK_SIZE);
1794                                         len = transfersize;
1795                                         NCR5380_transfer_pio(instance, &phase, &len,
1796                                                              (unsigned char **)&cmd->SCp.ptr);
1797                                         cmd->SCp.this_residual -= transfersize - len;
1798                                 }
1799 #ifdef CONFIG_SUN3
1800                                 if (sun3_dma_setup_done == cmd)
1801                                         sun3_dma_setup_done = NULL;
1802 #endif
1803                                 return;
1804                         case PHASE_MSGIN:
1805                                 len = 1;
1806                                 data = &tmp;
1807                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
1808                                 cmd->SCp.Message = tmp;
1809
1810                                 switch (tmp) {
1811                                 case ABORT:
1812                                 case COMMAND_COMPLETE:
1813                                         /* Accept message by clearing ACK */
1814                                         sink = 1;
1815                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1816                                         dsprintk(NDEBUG_QUEUES, instance,
1817                                                  "COMMAND COMPLETE %p target %d lun %llu\n",
1818                                                  cmd, scmd_id(cmd), cmd->device->lun);
1819
1820                                         hostdata->connected = NULL;
1821                                         hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
1822
1823                                         cmd->result &= ~0xffff;
1824                                         cmd->result |= cmd->SCp.Status;
1825                                         cmd->result |= cmd->SCp.Message << 8;
1826
1827                                         set_resid_from_SCp(cmd);
1828
1829                                         if (cmd->cmnd[0] == REQUEST_SENSE)
1830                                                 complete_cmd(instance, cmd);
1831                                         else {
1832                                                 if (cmd->SCp.Status == SAM_STAT_CHECK_CONDITION ||
1833                                                     cmd->SCp.Status == SAM_STAT_COMMAND_TERMINATED) {
1834                                                         dsprintk(NDEBUG_QUEUES, instance, "autosense: adding cmd %p to tail of autosense queue\n",
1835                                                                  cmd);
1836                                                         list_add_tail(&ncmd->list,
1837                                                                       &hostdata->autosense);
1838                                                 } else
1839                                                         complete_cmd(instance, cmd);
1840                                         }
1841
1842                                         /*
1843                                          * Restore phase bits to 0 so an interrupted selection,
1844                                          * arbitration can resume.
1845                                          */
1846                                         NCR5380_write(TARGET_COMMAND_REG, 0);
1847
1848                                         return;
1849                                 case MESSAGE_REJECT:
1850                                         /* Accept message by clearing ACK */
1851                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1852                                         switch (hostdata->last_message) {
1853                                         case HEAD_OF_QUEUE_TAG:
1854                                         case ORDERED_QUEUE_TAG:
1855                                         case SIMPLE_QUEUE_TAG:
1856                                                 cmd->device->simple_tags = 0;
1857                                                 hostdata->busy[cmd->device->id] |= (1 << (cmd->device->lun & 0xFF));
1858                                                 break;
1859                                         default:
1860                                                 break;
1861                                         }
1862                                         break;
1863                                 case DISCONNECT:
1864                                         /* Accept message by clearing ACK */
1865                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1866                                         hostdata->connected = NULL;
1867                                         list_add(&ncmd->list, &hostdata->disconnected);
1868                                         dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES,
1869                                                  instance, "connected command %p for target %d lun %llu moved to disconnected queue\n",
1870                                                  cmd, scmd_id(cmd), cmd->device->lun);
1871
1872                                         /*
1873                                          * Restore phase bits to 0 so an interrupted selection,
1874                                          * arbitration can resume.
1875                                          */
1876                                         NCR5380_write(TARGET_COMMAND_REG, 0);
1877
1878 #ifdef SUN3_SCSI_VME
1879                                         dregs->csr |= CSR_DMA_ENABLE;
1880 #endif
1881                                         return;
1882                                         /*
1883                                          * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
1884                                          * operation, in violation of the SCSI spec so we can safely
1885                                          * ignore SAVE/RESTORE pointers calls.
1886                                          *
1887                                          * Unfortunately, some disks violate the SCSI spec and
1888                                          * don't issue the required SAVE_POINTERS message before
1889                                          * disconnecting, and we have to break spec to remain
1890                                          * compatible.
1891                                          */
1892                                 case SAVE_POINTERS:
1893                                 case RESTORE_POINTERS:
1894                                         /* Accept message by clearing ACK */
1895                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1896                                         break;
1897                                 case EXTENDED_MESSAGE:
1898                                         /*
1899                                          * Start the message buffer with the EXTENDED_MESSAGE
1900                                          * byte, since spi_print_msg() wants the whole thing.
1901                                          */
1902                                         extended_msg[0] = EXTENDED_MESSAGE;
1903                                         /* Accept first byte by clearing ACK */
1904                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1905
1906                                         spin_unlock_irq(&hostdata->lock);
1907
1908                                         dsprintk(NDEBUG_EXTENDED, instance, "receiving extended message\n");
1909
1910                                         len = 2;
1911                                         data = extended_msg + 1;
1912                                         phase = PHASE_MSGIN;
1913                                         NCR5380_transfer_pio(instance, &phase, &len, &data);
1914                                         dsprintk(NDEBUG_EXTENDED, instance, "length %d, code 0x%02x\n",
1915                                                  (int)extended_msg[1],
1916                                                  (int)extended_msg[2]);
1917
1918                                         if (!len && extended_msg[1] > 0 &&
1919                                             extended_msg[1] <= sizeof(extended_msg) - 2) {
1920                                                 /* Accept third byte by clearing ACK */
1921                                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1922                                                 len = extended_msg[1] - 1;
1923                                                 data = extended_msg + 3;
1924                                                 phase = PHASE_MSGIN;
1925
1926                                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
1927                                                 dsprintk(NDEBUG_EXTENDED, instance, "message received, residual %d\n",
1928                                                          len);
1929
1930                                                 switch (extended_msg[2]) {
1931                                                 case EXTENDED_SDTR:
1932                                                 case EXTENDED_WDTR:
1933                                                         tmp = 0;
1934                                                 }
1935                                         } else if (len) {
1936                                                 shost_printk(KERN_ERR, instance, "error receiving extended message\n");
1937                                                 tmp = 0;
1938                                         } else {
1939                                                 shost_printk(KERN_NOTICE, instance, "extended message code %02x length %d is too long\n",
1940                                                              extended_msg[2], extended_msg[1]);
1941                                                 tmp = 0;
1942                                         }
1943
1944                                         spin_lock_irq(&hostdata->lock);
1945                                         if (!hostdata->connected)
1946                                                 return;
1947
1948                                         /* Reject message */
1949                                         fallthrough;
1950                                 default:
1951                                         /*
1952                                          * If we get something weird that we aren't expecting,
1953                                          * log it.
1954                                          */
1955                                         if (tmp == EXTENDED_MESSAGE)
1956                                                 scmd_printk(KERN_INFO, cmd,
1957                                                             "rejecting unknown extended message code %02x, length %d\n",
1958                                                             extended_msg[2], extended_msg[1]);
1959                                         else if (tmp)
1960                                                 scmd_printk(KERN_INFO, cmd,
1961                                                             "rejecting unknown message code %02x\n",
1962                                                             tmp);
1963
1964                                         msgout = MESSAGE_REJECT;
1965                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1966                                         break;
1967                                 } /* switch (tmp) */
1968                                 break;
1969                         case PHASE_MSGOUT:
1970                                 len = 1;
1971                                 data = &msgout;
1972                                 hostdata->last_message = msgout;
1973                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
1974                                 if (msgout == ABORT) {
1975                                         hostdata->connected = NULL;
1976                                         hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
1977                                         cmd->result = DID_ERROR << 16;
1978                                         complete_cmd(instance, cmd);
1979                                         return;
1980                                 }
1981                                 msgout = NOP;
1982                                 break;
1983                         case PHASE_CMDOUT:
1984                                 len = cmd->cmd_len;
1985                                 data = cmd->cmnd;
1986                                 /*
1987                                  * XXX for performance reasons, on machines with a
1988                                  * PSEUDO-DMA architecture we should probably
1989                                  * use the dma transfer function.
1990                                  */
1991                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
1992                                 break;
1993                         case PHASE_STATIN:
1994                                 len = 1;
1995                                 data = &tmp;
1996                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
1997                                 cmd->SCp.Status = tmp;
1998                                 break;
1999                         default:
2000                                 shost_printk(KERN_ERR, instance, "unknown phase\n");
2001                                 NCR5380_dprint(NDEBUG_ANY, instance);
2002                         } /* switch(phase) */
2003                 } else {
2004                         spin_unlock_irq(&hostdata->lock);
2005                         NCR5380_poll_politely(hostdata, STATUS_REG, SR_REQ, SR_REQ, HZ);
2006                         spin_lock_irq(&hostdata->lock);
2007                 }
2008         }
2009 }
2010
2011 /*
2012  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2013  *
2014  * Purpose : does reselection, initializing the instance->connected
2015  * field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
2016  * nexus has been reestablished,
2017  *
2018  * Inputs : instance - this instance of the NCR5380.
2019  */
2020
2021 static void NCR5380_reselect(struct Scsi_Host *instance)
2022 {
2023         struct NCR5380_hostdata *hostdata = shost_priv(instance);
2024         unsigned char target_mask;
2025         unsigned char lun;
2026         unsigned char msg[3];
2027         struct NCR5380_cmd *ncmd;
2028         struct scsi_cmnd *tmp;
2029
2030         /*
2031          * Disable arbitration, etc. since the host adapter obviously
2032          * lost, and tell an interrupted NCR5380_select() to restart.
2033          */
2034
2035         NCR5380_write(MODE_REG, MR_BASE);
2036
2037         target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2038         if (!target_mask || target_mask & (target_mask - 1)) {
2039                 shost_printk(KERN_WARNING, instance,
2040                              "reselect: bad target_mask 0x%02x\n", target_mask);
2041                 return;
2042         }
2043
2044         /*
2045          * At this point, we have detected that our SCSI ID is on the bus,
2046          * SEL is true and BSY was false for at least one bus settle delay
2047          * (400 ns).
2048          *
2049          * We must assert BSY ourselves, until the target drops the SEL
2050          * signal.
2051          */
2052
2053         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2054         if (NCR5380_poll_politely(hostdata,
2055                                   STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) {
2056                 shost_printk(KERN_ERR, instance, "reselect: !SEL timeout\n");
2057                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2058                 return;
2059         }
2060         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2061
2062         /*
2063          * Wait for target to go into MSGIN.
2064          */
2065
2066         if (NCR5380_poll_politely(hostdata,
2067                                   STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) {
2068                 if ((NCR5380_read(STATUS_REG) & (SR_BSY | SR_SEL)) == 0)
2069                         /* BUS FREE phase */
2070                         return;
2071                 shost_printk(KERN_ERR, instance, "reselect: REQ timeout\n");
2072                 do_abort(instance);
2073                 return;
2074         }
2075
2076 #ifdef CONFIG_SUN3
2077         /* acknowledge toggle to MSGIN */
2078         NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN));
2079
2080         /* peek at the byte without really hitting the bus */
2081         msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG);
2082 #else
2083         {
2084                 int len = 1;
2085                 unsigned char *data = msg;
2086                 unsigned char phase = PHASE_MSGIN;
2087
2088                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2089
2090                 if (len) {
2091                         do_abort(instance);
2092                         return;
2093                 }
2094         }
2095 #endif /* CONFIG_SUN3 */
2096
2097         if (!(msg[0] & 0x80)) {
2098                 shost_printk(KERN_ERR, instance, "expecting IDENTIFY message, got ");
2099                 spi_print_msg(msg);
2100                 printk("\n");
2101                 do_abort(instance);
2102                 return;
2103         }
2104         lun = msg[0] & 0x07;
2105
2106         /*
2107          * We need to add code for SCSI-II to track which devices have
2108          * I_T_L_Q nexuses established, and which have simple I_T_L
2109          * nexuses so we can chose to do additional data transfer.
2110          */
2111
2112         /*
2113          * Find the command corresponding to the I_T_L or I_T_L_Q  nexus we
2114          * just reestablished, and remove it from the disconnected queue.
2115          */
2116
2117         tmp = NULL;
2118         list_for_each_entry(ncmd, &hostdata->disconnected, list) {
2119                 struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2120
2121                 if (target_mask == (1 << scmd_id(cmd)) &&
2122                     lun == (u8)cmd->device->lun) {
2123                         list_del(&ncmd->list);
2124                         tmp = cmd;
2125                         break;
2126                 }
2127         }
2128
2129         if (tmp) {
2130                 dsprintk(NDEBUG_RESELECTION | NDEBUG_QUEUES, instance,
2131                          "reselect: removed %p from disconnected queue\n", tmp);
2132         } else {
2133                 int target = ffs(target_mask) - 1;
2134
2135                 shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n",
2136                              target_mask, lun);
2137                 /*
2138                  * Since we have an established nexus that we can't do anything
2139                  * with, we must abort it.
2140                  */
2141                 if (do_abort(instance) == 0)
2142                         hostdata->busy[target] &= ~(1 << lun);
2143                 return;
2144         }
2145
2146 #ifdef CONFIG_SUN3
2147         if (sun3_dma_setup_done != tmp) {
2148                 int count;
2149
2150                 advance_sg_buffer(tmp);
2151
2152                 count = sun3scsi_dma_xfer_len(hostdata, tmp);
2153
2154                 if (count > 0) {
2155                         if (rq_data_dir(tmp->request))
2156                                 sun3scsi_dma_send_setup(hostdata,
2157                                                         tmp->SCp.ptr, count);
2158                         else
2159                                 sun3scsi_dma_recv_setup(hostdata,
2160                                                         tmp->SCp.ptr, count);
2161                         sun3_dma_setup_done = tmp;
2162                 }
2163         }
2164
2165         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
2166 #endif /* CONFIG_SUN3 */
2167
2168         /* Accept message by clearing ACK */
2169         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2170
2171         hostdata->connected = tmp;
2172         dsprintk(NDEBUG_RESELECTION, instance, "nexus established, target %d, lun %llu\n",
2173                  scmd_id(tmp), tmp->device->lun);
2174 }
2175
2176 /**
2177  * list_find_cmd - test for presence of a command in a linked list
2178  * @haystack: list of commands
2179  * @needle: command to search for
2180  */
2181
2182 static bool list_find_cmd(struct list_head *haystack,
2183                           struct scsi_cmnd *needle)
2184 {
2185         struct NCR5380_cmd *ncmd;
2186
2187         list_for_each_entry(ncmd, haystack, list)
2188                 if (NCR5380_to_scmd(ncmd) == needle)
2189                         return true;
2190         return false;
2191 }
2192
2193 /**
2194  * list_remove_cmd - remove a command from linked list
2195  * @haystack: list of commands
2196  * @needle: command to remove
2197  */
2198
2199 static bool list_del_cmd(struct list_head *haystack,
2200                          struct scsi_cmnd *needle)
2201 {
2202         if (list_find_cmd(haystack, needle)) {
2203                 struct NCR5380_cmd *ncmd = scsi_cmd_priv(needle);
2204
2205                 list_del(&ncmd->list);
2206                 return true;
2207         }
2208         return false;
2209 }
2210
2211 /**
2212  * NCR5380_abort - scsi host eh_abort_handler() method
2213  * @cmd: the command to be aborted
2214  *
2215  * Try to abort a given command by removing it from queues and/or sending
2216  * the target an abort message. This may not succeed in causing a target
2217  * to abort the command. Nonetheless, the low-level driver must forget about
2218  * the command because the mid-layer reclaims it and it may be re-issued.
2219  *
2220  * The normal path taken by a command is as follows. For EH we trace this
2221  * same path to locate and abort the command.
2222  *
2223  * unissued -> selecting -> [unissued -> selecting ->]... connected ->
2224  * [disconnected -> connected ->]...
2225  * [autosense -> connected ->] done
2226  *
2227  * If cmd was not found at all then presumably it has already been completed,
2228  * in which case return SUCCESS to try to avoid further EH measures.
2229  *
2230  * If the command has not completed yet, we must not fail to find it.
2231  * We have no option but to forget the aborted command (even if it still
2232  * lacks sense data). The mid-layer may re-issue a command that is in error
2233  * recovery (see scsi_send_eh_cmnd), but the logic and data structures in
2234  * this driver are such that a command can appear on one queue only.
2235  *
2236  * The lock protects driver data structures, but EH handlers also use it
2237  * to serialize their own execution and prevent their own re-entry.
2238  */
2239
2240 static int NCR5380_abort(struct scsi_cmnd *cmd)
2241 {
2242         struct Scsi_Host *instance = cmd->device->host;
2243         struct NCR5380_hostdata *hostdata = shost_priv(instance);
2244         unsigned long flags;
2245         int result = SUCCESS;
2246
2247         spin_lock_irqsave(&hostdata->lock, flags);
2248
2249 #if (NDEBUG & NDEBUG_ANY)
2250         scmd_printk(KERN_INFO, cmd, __func__);
2251 #endif
2252         NCR5380_dprint(NDEBUG_ANY, instance);
2253         NCR5380_dprint_phase(NDEBUG_ANY, instance);
2254
2255         if (list_del_cmd(&hostdata->unissued, cmd)) {
2256                 dsprintk(NDEBUG_ABORT, instance,
2257                          "abort: removed %p from issue queue\n", cmd);
2258                 cmd->result = DID_ABORT << 16;
2259                 cmd->scsi_done(cmd); /* No tag or busy flag to worry about */
2260                 goto out;
2261         }
2262
2263         if (hostdata->selecting == cmd) {
2264                 dsprintk(NDEBUG_ABORT, instance,
2265                          "abort: cmd %p == selecting\n", cmd);
2266                 hostdata->selecting = NULL;
2267                 cmd->result = DID_ABORT << 16;
2268                 complete_cmd(instance, cmd);
2269                 goto out;
2270         }
2271
2272         if (list_del_cmd(&hostdata->disconnected, cmd)) {
2273                 dsprintk(NDEBUG_ABORT, instance,
2274                          "abort: removed %p from disconnected list\n", cmd);
2275                 /* Can't call NCR5380_select() and send ABORT because that
2276                  * means releasing the lock. Need a bus reset.
2277                  */
2278                 set_host_byte(cmd, DID_ERROR);
2279                 complete_cmd(instance, cmd);
2280                 result = FAILED;
2281                 goto out;
2282         }
2283
2284         if (hostdata->connected == cmd) {
2285                 dsprintk(NDEBUG_ABORT, instance, "abort: cmd %p is connected\n", cmd);
2286                 hostdata->connected = NULL;
2287                 hostdata->dma_len = 0;
2288                 if (do_abort(instance) < 0) {
2289                         set_host_byte(cmd, DID_ERROR);
2290                         complete_cmd(instance, cmd);
2291                         result = FAILED;
2292                         goto out;
2293                 }
2294                 set_host_byte(cmd, DID_ABORT);
2295                 complete_cmd(instance, cmd);
2296                 goto out;
2297         }
2298
2299         if (list_del_cmd(&hostdata->autosense, cmd)) {
2300                 dsprintk(NDEBUG_ABORT, instance,
2301                          "abort: removed %p from sense queue\n", cmd);
2302                 complete_cmd(instance, cmd);
2303         }
2304
2305 out:
2306         if (result == FAILED)
2307                 dsprintk(NDEBUG_ABORT, instance, "abort: failed to abort %p\n", cmd);
2308         else {
2309                 hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
2310                 dsprintk(NDEBUG_ABORT, instance, "abort: successfully aborted %p\n", cmd);
2311         }
2312
2313         queue_work(hostdata->work_q, &hostdata->main_task);
2314         spin_unlock_irqrestore(&hostdata->lock, flags);
2315
2316         return result;
2317 }
2318
2319
2320 static void bus_reset_cleanup(struct Scsi_Host *instance)
2321 {
2322         struct NCR5380_hostdata *hostdata = shost_priv(instance);
2323         int i;
2324         struct NCR5380_cmd *ncmd;
2325
2326         /* reset NCR registers */
2327         NCR5380_write(MODE_REG, MR_BASE);
2328         NCR5380_write(TARGET_COMMAND_REG, 0);
2329         NCR5380_write(SELECT_ENABLE_REG, 0);
2330
2331         /* After the reset, there are no more connected or disconnected commands
2332          * and no busy units; so clear the low-level status here to avoid
2333          * conflicts when the mid-level code tries to wake up the affected
2334          * commands!
2335          */
2336
2337         if (hostdata->selecting) {
2338                 hostdata->selecting->result = DID_RESET << 16;
2339                 complete_cmd(instance, hostdata->selecting);
2340                 hostdata->selecting = NULL;
2341         }
2342
2343         list_for_each_entry(ncmd, &hostdata->disconnected, list) {
2344                 struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2345
2346                 set_host_byte(cmd, DID_RESET);
2347                 complete_cmd(instance, cmd);
2348         }
2349         INIT_LIST_HEAD(&hostdata->disconnected);
2350
2351         list_for_each_entry(ncmd, &hostdata->autosense, list) {
2352                 struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2353
2354                 cmd->scsi_done(cmd);
2355         }
2356         INIT_LIST_HEAD(&hostdata->autosense);
2357
2358         if (hostdata->connected) {
2359                 set_host_byte(hostdata->connected, DID_RESET);
2360                 complete_cmd(instance, hostdata->connected);
2361                 hostdata->connected = NULL;
2362         }
2363
2364         for (i = 0; i < 8; ++i)
2365                 hostdata->busy[i] = 0;
2366         hostdata->dma_len = 0;
2367
2368         queue_work(hostdata->work_q, &hostdata->main_task);
2369 }
2370
2371 /**
2372  * NCR5380_host_reset - reset the SCSI host
2373  * @cmd: SCSI command undergoing EH
2374  *
2375  * Returns SUCCESS
2376  */
2377
2378 static int NCR5380_host_reset(struct scsi_cmnd *cmd)
2379 {
2380         struct Scsi_Host *instance = cmd->device->host;
2381         struct NCR5380_hostdata *hostdata = shost_priv(instance);
2382         unsigned long flags;
2383         struct NCR5380_cmd *ncmd;
2384
2385         spin_lock_irqsave(&hostdata->lock, flags);
2386
2387 #if (NDEBUG & NDEBUG_ANY)
2388         shost_printk(KERN_INFO, instance, __func__);
2389 #endif
2390         NCR5380_dprint(NDEBUG_ANY, instance);
2391         NCR5380_dprint_phase(NDEBUG_ANY, instance);
2392
2393         list_for_each_entry(ncmd, &hostdata->unissued, list) {
2394                 struct scsi_cmnd *scmd = NCR5380_to_scmd(ncmd);
2395
2396                 scmd->result = DID_RESET << 16;
2397                 scmd->scsi_done(scmd);
2398         }
2399         INIT_LIST_HEAD(&hostdata->unissued);
2400
2401         do_reset(instance);
2402         bus_reset_cleanup(instance);
2403
2404         spin_unlock_irqrestore(&hostdata->lock, flags);
2405
2406         return SUCCESS;
2407 }