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