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 * 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 } 2412