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