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 (20*HZ/1000) 478 #endif 479 /* 300 RPM (floppy speed) */ 480 #ifndef USLEEP_POLL 481 #define USLEEP_POLL (200*HZ/1000) 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 + (250 * HZ / 1000); 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 %d, USLEEP_WAITLONG %d, " 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 #undef SPRINTF 720 #define SPRINTF(args...) seq_printf(m, ## args) 721 static 722 void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m); 723 static 724 void lprint_command(unsigned char *cmd, struct seq_file *m); 725 static 726 void lprint_opcode(int opcode, struct seq_file *m); 727 728 static int __maybe_unused NCR5380_show_info(struct seq_file *m, 729 struct Scsi_Host *instance) 730 { 731 struct NCR5380_hostdata *hostdata; 732 struct scsi_cmnd *ptr; 733 734 hostdata = (struct NCR5380_hostdata *) instance->hostdata; 735 736 #ifdef PSEUDO_DMA 737 SPRINTF("Highwater I/O busy spin counts: write %d, read %d\n", 738 hostdata->spin_max_w, hostdata->spin_max_r); 739 #endif 740 spin_lock_irq(instance->host_lock); 741 if (!hostdata->connected) 742 SPRINTF("scsi%d: no currently connected command\n", instance->host_no); 743 else 744 lprint_Scsi_Cmnd((struct scsi_cmnd *) hostdata->connected, m); 745 SPRINTF("scsi%d: issue_queue\n", instance->host_no); 746 for (ptr = (struct scsi_cmnd *) hostdata->issue_queue; ptr; ptr = (struct scsi_cmnd *) ptr->host_scribble) 747 lprint_Scsi_Cmnd(ptr, m); 748 749 SPRINTF("scsi%d: disconnected_queue\n", instance->host_no); 750 for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr; ptr = (struct scsi_cmnd *) ptr->host_scribble) 751 lprint_Scsi_Cmnd(ptr, m); 752 spin_unlock_irq(instance->host_lock); 753 return 0; 754 } 755 756 static void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m) 757 { 758 SPRINTF("scsi%d : destination target %d, lun %llu\n", cmd->device->host->host_no, cmd->device->id, cmd->device->lun); 759 SPRINTF(" command = "); 760 lprint_command(cmd->cmnd, m); 761 } 762 763 static void lprint_command(unsigned char *command, struct seq_file *m) 764 { 765 int i, s; 766 lprint_opcode(command[0], m); 767 for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i) 768 SPRINTF("%02x ", command[i]); 769 SPRINTF("\n"); 770 } 771 772 static void lprint_opcode(int opcode, struct seq_file *m) 773 { 774 SPRINTF("%2d (0x%02x)", opcode, opcode); 775 } 776 777 778 /** 779 * NCR5380_init - initialise an NCR5380 780 * @instance: adapter to configure 781 * @flags: control flags 782 * 783 * Initializes *instance and corresponding 5380 chip, 784 * with flags OR'd into the initial flags value. 785 * 786 * Notes : I assume that the host, hostno, and id bits have been 787 * set correctly. I don't care about the irq and other fields. 788 * 789 * Returns 0 for success 790 * 791 * Locks: interrupts must be enabled when we are called 792 */ 793 794 static int NCR5380_init(struct Scsi_Host *instance, int flags) 795 { 796 NCR5380_local_declare(); 797 int i, pass; 798 unsigned long timeout; 799 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 800 801 if(in_interrupt()) 802 printk(KERN_ERR "NCR5380_init called with interrupts off!\n"); 803 /* 804 * On NCR53C400 boards, NCR5380 registers are mapped 8 past 805 * the base address. 806 */ 807 808 #ifdef NCR53C400 809 if (flags & FLAG_NCR53C400) 810 instance->NCR5380_instance_name += NCR53C400_address_adjust; 811 #endif 812 813 NCR5380_setup(instance); 814 815 hostdata->aborted = 0; 816 hostdata->id_mask = 1 << instance->this_id; 817 for (i = hostdata->id_mask; i <= 0x80; i <<= 1) 818 if (i > hostdata->id_mask) 819 hostdata->id_higher_mask |= i; 820 for (i = 0; i < 8; ++i) 821 hostdata->busy[i] = 0; 822 #ifdef REAL_DMA 823 hostdata->dmalen = 0; 824 #endif 825 hostdata->targets_present = 0; 826 hostdata->connected = NULL; 827 hostdata->issue_queue = NULL; 828 hostdata->disconnected_queue = NULL; 829 830 INIT_DELAYED_WORK(&hostdata->coroutine, NCR5380_main); 831 832 /* The CHECK code seems to break the 53C400. Will check it later maybe */ 833 if (flags & FLAG_NCR53C400) 834 hostdata->flags = FLAG_HAS_LAST_BYTE_SENT | flags; 835 else 836 hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT | flags; 837 838 hostdata->host = instance; 839 hostdata->time_expires = 0; 840 841 prepare_info(instance); 842 843 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 844 NCR5380_write(MODE_REG, MR_BASE); 845 NCR5380_write(TARGET_COMMAND_REG, 0); 846 NCR5380_write(SELECT_ENABLE_REG, 0); 847 848 #ifdef NCR53C400 849 if (hostdata->flags & FLAG_NCR53C400) { 850 NCR5380_write(C400_CONTROL_STATUS_REG, CSR_BASE); 851 } 852 #endif 853 854 /* 855 * Detect and correct bus wedge problems. 856 * 857 * If the system crashed, it may have crashed in a state 858 * where a SCSI command was still executing, and the 859 * SCSI bus is not in a BUS FREE STATE. 860 * 861 * If this is the case, we'll try to abort the currently 862 * established nexus which we know nothing about, and that 863 * failing, do a hard reset of the SCSI bus 864 */ 865 866 for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) { 867 switch (pass) { 868 case 1: 869 case 3: 870 case 5: 871 printk(KERN_INFO "scsi%d: SCSI bus busy, waiting up to five seconds\n", instance->host_no); 872 timeout = jiffies + 5 * HZ; 873 NCR5380_poll_politely(instance, STATUS_REG, SR_BSY, 0, 5*HZ); 874 break; 875 case 2: 876 printk(KERN_WARNING "scsi%d: bus busy, attempting abort\n", instance->host_no); 877 do_abort(instance); 878 break; 879 case 4: 880 printk(KERN_WARNING "scsi%d: bus busy, attempting reset\n", instance->host_no); 881 do_reset(instance); 882 break; 883 case 6: 884 printk(KERN_ERR "scsi%d: bus locked solid or invalid override\n", instance->host_no); 885 return -ENXIO; 886 } 887 } 888 return 0; 889 } 890 891 /** 892 * NCR5380_exit - remove an NCR5380 893 * @instance: adapter to remove 894 */ 895 896 static void NCR5380_exit(struct Scsi_Host *instance) 897 { 898 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 899 900 cancel_delayed_work_sync(&hostdata->coroutine); 901 } 902 903 /** 904 * NCR5380_queue_command - queue a command 905 * @cmd: SCSI command 906 * @done: completion handler 907 * 908 * cmd is added to the per instance issue_queue, with minor 909 * twiddling done to the host specific fields of cmd. If the 910 * main coroutine is not running, it is restarted. 911 * 912 * Locks: host lock taken by caller 913 */ 914 915 static int NCR5380_queue_command_lck(struct scsi_cmnd *cmd, void (*done) (struct scsi_cmnd *)) 916 { 917 struct Scsi_Host *instance = cmd->device->host; 918 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 919 struct scsi_cmnd *tmp; 920 921 #if (NDEBUG & NDEBUG_NO_WRITE) 922 switch (cmd->cmnd[0]) { 923 case WRITE_6: 924 case WRITE_10: 925 printk("scsi%d : WRITE attempted with NO_WRITE debugging flag set\n", instance->host_no); 926 cmd->result = (DID_ERROR << 16); 927 done(cmd); 928 return 0; 929 } 930 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */ 931 932 /* 933 * We use the host_scribble field as a pointer to the next command 934 * in a queue 935 */ 936 937 cmd->host_scribble = NULL; 938 cmd->scsi_done = done; 939 cmd->result = 0; 940 941 /* 942 * Insert the cmd into the issue queue. Note that REQUEST SENSE 943 * commands are added to the head of the queue since any command will 944 * clear the contingent allegiance condition that exists and the 945 * sense data is only guaranteed to be valid while the condition exists. 946 */ 947 948 if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) { 949 LIST(cmd, hostdata->issue_queue); 950 cmd->host_scribble = (unsigned char *) hostdata->issue_queue; 951 hostdata->issue_queue = cmd; 952 } else { 953 for (tmp = (struct scsi_cmnd *) hostdata->issue_queue; tmp->host_scribble; tmp = (struct scsi_cmnd *) tmp->host_scribble); 954 LIST(cmd, tmp); 955 tmp->host_scribble = (unsigned char *) cmd; 956 } 957 dprintk(NDEBUG_QUEUES, "scsi%d : command added to %s of queue\n", instance->host_no, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"); 958 959 /* Run the coroutine if it isn't already running. */ 960 /* Kick off command processing */ 961 schedule_delayed_work(&hostdata->coroutine, 0); 962 return 0; 963 } 964 965 static DEF_SCSI_QCMD(NCR5380_queue_command) 966 967 /** 968 * NCR5380_main - NCR state machines 969 * 970 * NCR5380_main is a coroutine that runs as long as more work can 971 * be done on the NCR5380 host adapters in a system. Both 972 * NCR5380_queue_command() and NCR5380_intr() will try to start it 973 * in case it is not running. 974 * 975 * Locks: called as its own thread with no locks held. Takes the 976 * host lock and called routines may take the isa dma lock. 977 */ 978 979 static void NCR5380_main(struct work_struct *work) 980 { 981 struct NCR5380_hostdata *hostdata = 982 container_of(work, struct NCR5380_hostdata, coroutine.work); 983 struct Scsi_Host *instance = hostdata->host; 984 struct scsi_cmnd *tmp, *prev; 985 int done; 986 987 spin_lock_irq(instance->host_lock); 988 do { 989 /* Lock held here */ 990 done = 1; 991 if (!hostdata->connected && !hostdata->selecting) { 992 dprintk(NDEBUG_MAIN, "scsi%d : not connected\n", instance->host_no); 993 /* 994 * Search through the issue_queue for a command destined 995 * for a target that's not busy. 996 */ 997 for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (struct scsi_cmnd *) tmp->host_scribble) 998 { 999 if (prev != tmp) 1000 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); 1001 /* When we find one, remove it from the issue queue. */ 1002 if (!(hostdata->busy[tmp->device->id] & 1003 (1 << (u8)(tmp->device->lun & 0xff)))) { 1004 if (prev) { 1005 REMOVE(prev, prev->host_scribble, tmp, tmp->host_scribble); 1006 prev->host_scribble = tmp->host_scribble; 1007 } else { 1008 REMOVE(-1, hostdata->issue_queue, tmp, tmp->host_scribble); 1009 hostdata->issue_queue = (struct scsi_cmnd *) tmp->host_scribble; 1010 } 1011 tmp->host_scribble = NULL; 1012 1013 /* 1014 * Attempt to establish an I_T_L nexus here. 1015 * On success, instance->hostdata->connected is set. 1016 * On failure, we must add the command back to the 1017 * issue queue so we can keep trying. 1018 */ 1019 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); 1020 1021 /* 1022 * A successful selection is defined as one that 1023 * leaves us with the command connected and 1024 * in hostdata->connected, OR has terminated the 1025 * command. 1026 * 1027 * With successful commands, we fall through 1028 * and see if we can do an information transfer, 1029 * with failures we will restart. 1030 */ 1031 hostdata->selecting = NULL; 1032 /* RvC: have to preset this to indicate a new command is being performed */ 1033 1034 /* 1035 * REQUEST SENSE commands are issued without tagged 1036 * queueing, even on SCSI-II devices because the 1037 * contingent allegiance condition exists for the 1038 * entire unit. 1039 */ 1040 1041 if (!NCR5380_select(instance, tmp)) { 1042 break; 1043 } else { 1044 LIST(tmp, hostdata->issue_queue); 1045 tmp->host_scribble = (unsigned char *) hostdata->issue_queue; 1046 hostdata->issue_queue = tmp; 1047 done = 0; 1048 dprintk(NDEBUG_MAIN|NDEBUG_QUEUES, "scsi%d : main(): select() failed, returned to issue_queue\n", instance->host_no); 1049 } 1050 /* lock held here still */ 1051 } /* if target/lun is not busy */ 1052 } /* for */ 1053 /* exited locked */ 1054 } /* if (!hostdata->connected) */ 1055 if (hostdata->selecting) { 1056 tmp = (struct scsi_cmnd *) hostdata->selecting; 1057 /* Selection will drop and retake the lock */ 1058 if (!NCR5380_select(instance, tmp)) { 1059 /* Ok ?? */ 1060 } else { 1061 /* RvC: device failed, so we wait a long time 1062 this is needed for Mustek scanners, that 1063 do not respond to commands immediately 1064 after a scan */ 1065 printk(KERN_DEBUG "scsi%d: device %d did not respond in time\n", instance->host_no, tmp->device->id); 1066 LIST(tmp, hostdata->issue_queue); 1067 tmp->host_scribble = (unsigned char *) hostdata->issue_queue; 1068 hostdata->issue_queue = tmp; 1069 NCR5380_set_timer(hostdata, USLEEP_WAITLONG); 1070 } 1071 } /* if hostdata->selecting */ 1072 if (hostdata->connected 1073 #ifdef REAL_DMA 1074 && !hostdata->dmalen 1075 #endif 1076 && (!hostdata->time_expires || time_before_eq(hostdata->time_expires, jiffies)) 1077 ) { 1078 dprintk(NDEBUG_MAIN, "scsi%d : main() : performing information transfer\n", instance->host_no); 1079 NCR5380_information_transfer(instance); 1080 dprintk(NDEBUG_MAIN, "scsi%d : main() : done set false\n", instance->host_no); 1081 done = 0; 1082 } else 1083 break; 1084 } while (!done); 1085 1086 spin_unlock_irq(instance->host_lock); 1087 } 1088 1089 #ifndef DONT_USE_INTR 1090 1091 /** 1092 * NCR5380_intr - generic NCR5380 irq handler 1093 * @irq: interrupt number 1094 * @dev_id: device info 1095 * 1096 * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses 1097 * from the disconnected queue, and restarting NCR5380_main() 1098 * as required. 1099 * 1100 * Locks: takes the needed instance locks 1101 */ 1102 1103 static irqreturn_t NCR5380_intr(int dummy, void *dev_id) 1104 { 1105 NCR5380_local_declare(); 1106 struct Scsi_Host *instance = dev_id; 1107 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 1108 int done; 1109 unsigned char basr; 1110 unsigned long flags; 1111 1112 dprintk(NDEBUG_INTR, "scsi : NCR5380 irq %d triggered\n", 1113 instance->irq); 1114 1115 do { 1116 done = 1; 1117 spin_lock_irqsave(instance->host_lock, flags); 1118 /* Look for pending interrupts */ 1119 NCR5380_setup(instance); 1120 basr = NCR5380_read(BUS_AND_STATUS_REG); 1121 /* XXX dispatch to appropriate routine if found and done=0 */ 1122 if (basr & BASR_IRQ) { 1123 NCR5380_dprint(NDEBUG_INTR, instance); 1124 if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) { 1125 done = 0; 1126 dprintk(NDEBUG_INTR, "scsi%d : SEL interrupt\n", instance->host_no); 1127 NCR5380_reselect(instance); 1128 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1129 } else if (basr & BASR_PARITY_ERROR) { 1130 dprintk(NDEBUG_INTR, "scsi%d : PARITY interrupt\n", instance->host_no); 1131 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1132 } else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) { 1133 dprintk(NDEBUG_INTR, "scsi%d : RESET interrupt\n", instance->host_no); 1134 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1135 } else { 1136 #if defined(REAL_DMA) 1137 /* 1138 * We should only get PHASE MISMATCH and EOP interrupts 1139 * if we have DMA enabled, so do a sanity check based on 1140 * the current setting of the MODE register. 1141 */ 1142 1143 if ((NCR5380_read(MODE_REG) & MR_DMA) && ((basr & BASR_END_DMA_TRANSFER) || !(basr & BASR_PHASE_MATCH))) { 1144 int transferred; 1145 1146 if (!hostdata->connected) 1147 panic("scsi%d : received end of DMA interrupt with no connected cmd\n", instance->hostno); 1148 1149 transferred = (hostdata->dmalen - NCR5380_dma_residual(instance)); 1150 hostdata->connected->SCp.this_residual -= transferred; 1151 hostdata->connected->SCp.ptr += transferred; 1152 hostdata->dmalen = 0; 1153 1154 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1155 1156 /* FIXME: we need to poll briefly then defer a workqueue task ! */ 1157 NCR5380_poll_politely(hostdata, BUS_AND_STATUS_REG, BASR_ACK, 0, 2*HZ); 1158 1159 NCR5380_write(MODE_REG, MR_BASE); 1160 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1161 } 1162 #else 1163 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)); 1164 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1165 #endif 1166 } 1167 } /* if BASR_IRQ */ 1168 spin_unlock_irqrestore(instance->host_lock, flags); 1169 if(!done) 1170 schedule_delayed_work(&hostdata->coroutine, 0); 1171 } while (!done); 1172 return IRQ_HANDLED; 1173 } 1174 1175 #endif 1176 1177 /* 1178 * Function : int NCR5380_select(struct Scsi_Host *instance, 1179 * struct scsi_cmnd *cmd) 1180 * 1181 * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command, 1182 * including ARBITRATION, SELECTION, and initial message out for 1183 * IDENTIFY and queue messages. 1184 * 1185 * Inputs : instance - instantiation of the 5380 driver on which this 1186 * target lives, cmd - SCSI command to execute. 1187 * 1188 * Returns : -1 if selection could not execute for some reason, 1189 * 0 if selection succeeded or failed because the target 1190 * did not respond. 1191 * 1192 * Side effects : 1193 * If bus busy, arbitration failed, etc, NCR5380_select() will exit 1194 * with registers as they should have been on entry - ie 1195 * SELECT_ENABLE will be set appropriately, the NCR5380 1196 * will cease to drive any SCSI bus signals. 1197 * 1198 * If successful : I_T_L or I_T_L_Q nexus will be established, 1199 * instance->connected will be set to cmd. 1200 * SELECT interrupt will be disabled. 1201 * 1202 * If failed (no target) : cmd->scsi_done() will be called, and the 1203 * cmd->result host byte set to DID_BAD_TARGET. 1204 * 1205 * Locks: caller holds hostdata lock in IRQ mode 1206 */ 1207 1208 static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd) 1209 { 1210 NCR5380_local_declare(); 1211 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 1212 unsigned char tmp[3], phase; 1213 unsigned char *data; 1214 int len; 1215 unsigned long timeout; 1216 unsigned char value; 1217 int err; 1218 NCR5380_setup(instance); 1219 1220 if (hostdata->selecting) 1221 goto part2; 1222 1223 hostdata->restart_select = 0; 1224 1225 NCR5380_dprint(NDEBUG_ARBITRATION, instance); 1226 dprintk(NDEBUG_ARBITRATION, "scsi%d : starting arbitration, id = %d\n", instance->host_no, instance->this_id); 1227 1228 /* 1229 * Set the phase bits to 0, otherwise the NCR5380 won't drive the 1230 * data bus during SELECTION. 1231 */ 1232 1233 NCR5380_write(TARGET_COMMAND_REG, 0); 1234 1235 /* 1236 * Start arbitration. 1237 */ 1238 1239 NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask); 1240 NCR5380_write(MODE_REG, MR_ARBITRATE); 1241 1242 1243 /* We can be relaxed here, interrupts are on, we are 1244 in workqueue context, the birds are singing in the trees */ 1245 spin_unlock_irq(instance->host_lock); 1246 err = NCR5380_poll_politely(instance, INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS, ICR_ARBITRATION_PROGRESS, 5*HZ); 1247 spin_lock_irq(instance->host_lock); 1248 if (err < 0) { 1249 printk(KERN_DEBUG "scsi: arbitration timeout at %d\n", __LINE__); 1250 NCR5380_write(MODE_REG, MR_BASE); 1251 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1252 goto failed; 1253 } 1254 1255 dprintk(NDEBUG_ARBITRATION, "scsi%d : arbitration complete\n", instance->host_no); 1256 1257 /* 1258 * The arbitration delay is 2.2us, but this is a minimum and there is 1259 * no maximum so we can safely sleep for ceil(2.2) usecs to accommodate 1260 * the integral nature of udelay(). 1261 * 1262 */ 1263 1264 udelay(3); 1265 1266 /* Check for lost arbitration */ 1267 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)) { 1268 NCR5380_write(MODE_REG, MR_BASE); 1269 dprintk(NDEBUG_ARBITRATION, "scsi%d : lost arbitration, deasserting MR_ARBITRATE\n", instance->host_no); 1270 goto failed; 1271 } 1272 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_SEL); 1273 1274 if (!(hostdata->flags & FLAG_DTC3181E) && 1275 /* RvC: DTC3181E has some trouble with this 1276 * so we simply removed it. Seems to work with 1277 * only Mustek scanner attached 1278 */ 1279 (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) { 1280 NCR5380_write(MODE_REG, MR_BASE); 1281 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1282 dprintk(NDEBUG_ARBITRATION, "scsi%d : lost arbitration, deasserting ICR_ASSERT_SEL\n", instance->host_no); 1283 goto failed; 1284 } 1285 /* 1286 * Again, bus clear + bus settle time is 1.2us, however, this is 1287 * a minimum so we'll udelay ceil(1.2) 1288 */ 1289 1290 udelay(2); 1291 1292 dprintk(NDEBUG_ARBITRATION, "scsi%d : won arbitration\n", instance->host_no); 1293 1294 /* 1295 * Now that we have won arbitration, start Selection process, asserting 1296 * the host and target ID's on the SCSI bus. 1297 */ 1298 1299 NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << scmd_id(cmd)))); 1300 1301 /* 1302 * Raise ATN while SEL is true before BSY goes false from arbitration, 1303 * since this is the only way to guarantee that we'll get a MESSAGE OUT 1304 * phase immediately after selection. 1305 */ 1306 1307 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY | ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL)); 1308 NCR5380_write(MODE_REG, MR_BASE); 1309 1310 /* 1311 * Reselect interrupts must be turned off prior to the dropping of BSY, 1312 * otherwise we will trigger an interrupt. 1313 */ 1314 NCR5380_write(SELECT_ENABLE_REG, 0); 1315 1316 /* 1317 * The initiator shall then wait at least two deskew delays and release 1318 * the BSY signal. 1319 */ 1320 udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */ 1321 1322 /* Reset BSY */ 1323 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL)); 1324 1325 /* 1326 * Something weird happens when we cease to drive BSY - looks 1327 * like the board/chip is letting us do another read before the 1328 * appropriate propagation delay has expired, and we're confusing 1329 * a BSY signal from ourselves as the target's response to SELECTION. 1330 * 1331 * A small delay (the 'C++' frontend breaks the pipeline with an 1332 * unnecessary jump, making it work on my 386-33/Trantor T128, the 1333 * tighter 'C' code breaks and requires this) solves the problem - 1334 * the 1 us delay is arbitrary, and only used because this delay will 1335 * be the same on other platforms and since it works here, it should 1336 * work there. 1337 * 1338 * wingel suggests that this could be due to failing to wait 1339 * one deskew delay. 1340 */ 1341 1342 udelay(1); 1343 1344 dprintk(NDEBUG_SELECTION, "scsi%d : selecting target %d\n", instance->host_no, scmd_id(cmd)); 1345 1346 /* 1347 * The SCSI specification calls for a 250 ms timeout for the actual 1348 * selection. 1349 */ 1350 1351 timeout = jiffies + (250 * HZ / 1000); 1352 1353 /* 1354 * XXX very interesting - we're seeing a bounce where the BSY we 1355 * asserted is being reflected / still asserted (propagation delay?) 1356 * and it's detecting as true. Sigh. 1357 */ 1358 1359 hostdata->select_time = 0; /* we count the clock ticks at which we polled */ 1360 hostdata->selecting = cmd; 1361 1362 part2: 1363 /* RvC: here we enter after a sleeping period, or immediately after 1364 execution of part 1 1365 we poll only once ech clock tick */ 1366 value = NCR5380_read(STATUS_REG) & (SR_BSY | SR_IO); 1367 1368 if (!value && (hostdata->select_time < HZ/4)) { 1369 /* RvC: we still must wait for a device response */ 1370 hostdata->select_time++; /* after 25 ticks the device has failed */ 1371 NCR5380_set_timer(hostdata, 1); 1372 return 0; /* RvC: we return here with hostdata->selecting set, 1373 to go to sleep */ 1374 } 1375 1376 hostdata->selecting = NULL;/* clear this pointer, because we passed the 1377 waiting period */ 1378 if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) { 1379 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1380 NCR5380_reselect(instance); 1381 printk("scsi%d : reselection after won arbitration?\n", instance->host_no); 1382 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1383 return -1; 1384 } 1385 /* 1386 * No less than two deskew delays after the initiator detects the 1387 * BSY signal is true, it shall release the SEL signal and may 1388 * change the DATA BUS. -wingel 1389 */ 1390 1391 udelay(1); 1392 1393 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 1394 1395 if (!(NCR5380_read(STATUS_REG) & SR_BSY)) { 1396 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1397 if (hostdata->targets_present & (1 << scmd_id(cmd))) { 1398 printk(KERN_DEBUG "scsi%d : weirdness\n", instance->host_no); 1399 if (hostdata->restart_select) 1400 printk(KERN_DEBUG "\trestart select\n"); 1401 NCR5380_dprint(NDEBUG_SELECTION, instance); 1402 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1403 return -1; 1404 } 1405 cmd->result = DID_BAD_TARGET << 16; 1406 cmd->scsi_done(cmd); 1407 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1408 dprintk(NDEBUG_SELECTION, "scsi%d : target did not respond within 250ms\n", instance->host_no); 1409 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1410 return 0; 1411 } 1412 hostdata->targets_present |= (1 << scmd_id(cmd)); 1413 1414 /* 1415 * Since we followed the SCSI spec, and raised ATN while SEL 1416 * was true but before BSY was false during selection, the information 1417 * transfer phase should be a MESSAGE OUT phase so that we can send the 1418 * IDENTIFY message. 1419 * 1420 * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG 1421 * message (2 bytes) with a tag ID that we increment with every command 1422 * until it wraps back to 0. 1423 * 1424 * XXX - it turns out that there are some broken SCSI-II devices, 1425 * which claim to support tagged queuing but fail when more than 1426 * some number of commands are issued at once. 1427 */ 1428 1429 /* Wait for start of REQ/ACK handshake */ 1430 1431 spin_unlock_irq(instance->host_lock); 1432 err = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ); 1433 spin_lock_irq(instance->host_lock); 1434 1435 if(err) { 1436 printk(KERN_ERR "scsi%d: timeout at NCR5380.c:%d\n", instance->host_no, __LINE__); 1437 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 1438 goto failed; 1439 } 1440 1441 dprintk(NDEBUG_SELECTION, "scsi%d : target %d selected, going into MESSAGE OUT phase.\n", instance->host_no, cmd->device->id); 1442 tmp[0] = IDENTIFY(((instance->irq == NO_IRQ) ? 0 : 1), cmd->device->lun); 1443 1444 len = 1; 1445 cmd->tag = 0; 1446 1447 /* Send message(s) */ 1448 data = tmp; 1449 phase = PHASE_MSGOUT; 1450 NCR5380_transfer_pio(instance, &phase, &len, &data); 1451 dprintk(NDEBUG_SELECTION, "scsi%d : nexus established.\n", instance->host_no); 1452 /* XXX need to handle errors here */ 1453 hostdata->connected = cmd; 1454 hostdata->busy[cmd->device->id] |= (1 << (cmd->device->lun & 0xFF)); 1455 1456 initialize_SCp(cmd); 1457 1458 return 0; 1459 1460 /* Selection failed */ 1461 failed: 1462 return -1; 1463 1464 } 1465 1466 /* 1467 * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance, 1468 * unsigned char *phase, int *count, unsigned char **data) 1469 * 1470 * Purpose : transfers data in given phase using polled I/O 1471 * 1472 * Inputs : instance - instance of driver, *phase - pointer to 1473 * what phase is expected, *count - pointer to number of 1474 * bytes to transfer, **data - pointer to data pointer. 1475 * 1476 * Returns : -1 when different phase is entered without transferring 1477 * maximum number of bytes, 0 if all bytes or transferred or exit 1478 * is in same phase. 1479 * 1480 * Also, *phase, *count, *data are modified in place. 1481 * 1482 * XXX Note : handling for bus free may be useful. 1483 */ 1484 1485 /* 1486 * Note : this code is not as quick as it could be, however it 1487 * IS 100% reliable, and for the actual data transfer where speed 1488 * counts, we will always do a pseudo DMA or DMA transfer. 1489 */ 1490 1491 static int NCR5380_transfer_pio(struct Scsi_Host *instance, unsigned char *phase, int *count, unsigned char **data) { 1492 NCR5380_local_declare(); 1493 unsigned char p = *phase, tmp; 1494 int c = *count; 1495 unsigned char *d = *data; 1496 /* 1497 * RvC: some administrative data to process polling time 1498 */ 1499 int break_allowed = 0; 1500 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 1501 NCR5380_setup(instance); 1502 1503 if (!(p & SR_IO)) 1504 dprintk(NDEBUG_PIO, "scsi%d : pio write %d bytes\n", instance->host_no, c); 1505 else 1506 dprintk(NDEBUG_PIO, "scsi%d : pio read %d bytes\n", instance->host_no, c); 1507 1508 /* 1509 * The NCR5380 chip will only drive the SCSI bus when the 1510 * phase specified in the appropriate bits of the TARGET COMMAND 1511 * REGISTER match the STATUS REGISTER 1512 */ 1513 1514 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p)); 1515 1516 /* RvC: don't know if this is necessary, but other SCSI I/O is short 1517 * so breaks are not necessary there 1518 */ 1519 if ((p == PHASE_DATAIN) || (p == PHASE_DATAOUT)) { 1520 break_allowed = 1; 1521 } 1522 do { 1523 /* 1524 * Wait for assertion of REQ, after which the phase bits will be 1525 * valid 1526 */ 1527 1528 /* RvC: we simply poll once, after that we stop temporarily 1529 * and let the device buffer fill up 1530 * if breaking is not allowed, we keep polling as long as needed 1531 */ 1532 1533 /* FIXME */ 1534 while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ) && !break_allowed); 1535 if (!(tmp & SR_REQ)) { 1536 /* timeout condition */ 1537 NCR5380_set_timer(hostdata, USLEEP_SLEEP); 1538 break; 1539 } 1540 1541 dprintk(NDEBUG_HANDSHAKE, "scsi%d : REQ detected\n", instance->host_no); 1542 1543 /* Check for phase mismatch */ 1544 if ((tmp & PHASE_MASK) != p) { 1545 dprintk(NDEBUG_HANDSHAKE, "scsi%d : phase mismatch\n", instance->host_no); 1546 NCR5380_dprint_phase(NDEBUG_HANDSHAKE, instance); 1547 break; 1548 } 1549 /* Do actual transfer from SCSI bus to / from memory */ 1550 if (!(p & SR_IO)) 1551 NCR5380_write(OUTPUT_DATA_REG, *d); 1552 else 1553 *d = NCR5380_read(CURRENT_SCSI_DATA_REG); 1554 1555 ++d; 1556 1557 /* 1558 * The SCSI standard suggests that in MSGOUT phase, the initiator 1559 * should drop ATN on the last byte of the message phase 1560 * after REQ has been asserted for the handshake but before 1561 * the initiator raises ACK. 1562 */ 1563 1564 if (!(p & SR_IO)) { 1565 if (!((p & SR_MSG) && c > 1)) { 1566 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA); 1567 NCR5380_dprint(NDEBUG_PIO, instance); 1568 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ACK); 1569 } else { 1570 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ATN); 1571 NCR5380_dprint(NDEBUG_PIO, instance); 1572 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK); 1573 } 1574 } else { 1575 NCR5380_dprint(NDEBUG_PIO, instance); 1576 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK); 1577 } 1578 1579 /* FIXME - if this fails bus reset ?? */ 1580 NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, 0, 5*HZ); 1581 dprintk(NDEBUG_HANDSHAKE, "scsi%d : req false, handshake complete\n", instance->host_no); 1582 1583 /* 1584 * We have several special cases to consider during REQ/ACK handshaking : 1585 * 1. We were in MSGOUT phase, and we are on the last byte of the 1586 * message. ATN must be dropped as ACK is dropped. 1587 * 1588 * 2. We are in a MSGIN phase, and we are on the last byte of the 1589 * message. We must exit with ACK asserted, so that the calling 1590 * code may raise ATN before dropping ACK to reject the message. 1591 * 1592 * 3. ACK and ATN are clear and the target may proceed as normal. 1593 */ 1594 if (!(p == PHASE_MSGIN && c == 1)) { 1595 if (p == PHASE_MSGOUT && c > 1) 1596 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 1597 else 1598 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1599 } 1600 } while (--c); 1601 1602 dprintk(NDEBUG_PIO, "scsi%d : residual %d\n", instance->host_no, c); 1603 1604 *count = c; 1605 *data = d; 1606 tmp = NCR5380_read(STATUS_REG); 1607 if (tmp & SR_REQ) 1608 *phase = tmp & PHASE_MASK; 1609 else 1610 *phase = PHASE_UNKNOWN; 1611 1612 if (!c || (*phase == p)) 1613 return 0; 1614 else 1615 return -1; 1616 } 1617 1618 /** 1619 * do_reset - issue a reset command 1620 * @host: adapter to reset 1621 * 1622 * Issue a reset sequence to the NCR5380 and try and get the bus 1623 * back into sane shape. 1624 * 1625 * Locks: caller holds queue lock 1626 */ 1627 1628 static void do_reset(struct Scsi_Host *host) { 1629 NCR5380_local_declare(); 1630 NCR5380_setup(host); 1631 1632 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK)); 1633 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST); 1634 udelay(25); 1635 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1636 } 1637 1638 /* 1639 * Function : do_abort (Scsi_Host *host) 1640 * 1641 * Purpose : abort the currently established nexus. Should only be 1642 * called from a routine which can drop into a 1643 * 1644 * Returns : 0 on success, -1 on failure. 1645 * 1646 * Locks: queue lock held by caller 1647 * FIXME: sort this out and get new_eh running 1648 */ 1649 1650 static int do_abort(struct Scsi_Host *host) { 1651 NCR5380_local_declare(); 1652 unsigned char *msgptr, phase, tmp; 1653 int len; 1654 int rc; 1655 NCR5380_setup(host); 1656 1657 1658 /* Request message out phase */ 1659 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 1660 1661 /* 1662 * Wait for the target to indicate a valid phase by asserting 1663 * REQ. Once this happens, we'll have either a MSGOUT phase 1664 * and can immediately send the ABORT message, or we'll have some 1665 * other phase and will have to source/sink data. 1666 * 1667 * We really don't care what value was on the bus or what value 1668 * the target sees, so we just handshake. 1669 */ 1670 1671 rc = NCR5380_poll_politely(host, STATUS_REG, SR_REQ, SR_REQ, 60 * HZ); 1672 1673 if(rc < 0) 1674 return -1; 1675 1676 tmp = (unsigned char)rc; 1677 1678 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp)); 1679 1680 if ((tmp & PHASE_MASK) != PHASE_MSGOUT) { 1681 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK); 1682 rc = NCR5380_poll_politely(host, STATUS_REG, SR_REQ, 0, 3*HZ); 1683 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 1684 if(rc == -1) 1685 return -1; 1686 } 1687 tmp = ABORT; 1688 msgptr = &tmp; 1689 len = 1; 1690 phase = PHASE_MSGOUT; 1691 NCR5380_transfer_pio(host, &phase, &len, &msgptr); 1692 1693 /* 1694 * If we got here, and the command completed successfully, 1695 * we're about to go into bus free state. 1696 */ 1697 1698 return len ? -1 : 0; 1699 } 1700 1701 #if defined(REAL_DMA) || defined(PSEUDO_DMA) || defined (REAL_DMA_POLL) 1702 /* 1703 * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance, 1704 * unsigned char *phase, int *count, unsigned char **data) 1705 * 1706 * Purpose : transfers data in given phase using either real 1707 * or pseudo DMA. 1708 * 1709 * Inputs : instance - instance of driver, *phase - pointer to 1710 * what phase is expected, *count - pointer to number of 1711 * bytes to transfer, **data - pointer to data pointer. 1712 * 1713 * Returns : -1 when different phase is entered without transferring 1714 * maximum number of bytes, 0 if all bytes or transferred or exit 1715 * is in same phase. 1716 * 1717 * Also, *phase, *count, *data are modified in place. 1718 * 1719 * Locks: io_request lock held by caller 1720 */ 1721 1722 1723 static int NCR5380_transfer_dma(struct Scsi_Host *instance, unsigned char *phase, int *count, unsigned char **data) { 1724 NCR5380_local_declare(); 1725 register int c = *count; 1726 register unsigned char p = *phase; 1727 register unsigned char *d = *data; 1728 unsigned char tmp; 1729 int foo; 1730 #if defined(REAL_DMA_POLL) 1731 int cnt, toPIO; 1732 unsigned char saved_data = 0, overrun = 0, residue; 1733 #endif 1734 1735 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 1736 1737 NCR5380_setup(instance); 1738 1739 if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) { 1740 *phase = tmp; 1741 return -1; 1742 } 1743 #if defined(REAL_DMA) || defined(REAL_DMA_POLL) 1744 #ifdef READ_OVERRUNS 1745 if (p & SR_IO) { 1746 c -= 2; 1747 } 1748 #endif 1749 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); 1750 hostdata->dma_len = (p & SR_IO) ? NCR5380_dma_read_setup(instance, d, c) : NCR5380_dma_write_setup(instance, d, c); 1751 #endif 1752 1753 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p)); 1754 1755 #ifdef REAL_DMA 1756 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY); 1757 #elif defined(REAL_DMA_POLL) 1758 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE); 1759 #else 1760 /* 1761 * Note : on my sample board, watch-dog timeouts occurred when interrupts 1762 * were not disabled for the duration of a single DMA transfer, from 1763 * before the setting of DMA mode to after transfer of the last byte. 1764 */ 1765 1766 #if defined(PSEUDO_DMA) && defined(UNSAFE) 1767 spin_unlock_irq(instance->host_lock); 1768 #endif 1769 /* KLL May need eop and parity in 53c400 */ 1770 if (hostdata->flags & FLAG_NCR53C400) 1771 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | 1772 MR_ENABLE_PAR_CHECK | MR_ENABLE_PAR_INTR | 1773 MR_ENABLE_EOP_INTR | MR_MONITOR_BSY); 1774 else 1775 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE); 1776 #endif /* def REAL_DMA */ 1777 1778 dprintk(NDEBUG_DMA, "scsi%d : mode reg = 0x%X\n", instance->host_no, NCR5380_read(MODE_REG)); 1779 1780 /* 1781 * On the PAS16 at least I/O recovery delays are not needed here. 1782 * Everyone else seems to want them. 1783 */ 1784 1785 if (p & SR_IO) { 1786 io_recovery_delay(1); 1787 NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0); 1788 } else { 1789 io_recovery_delay(1); 1790 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA); 1791 io_recovery_delay(1); 1792 NCR5380_write(START_DMA_SEND_REG, 0); 1793 io_recovery_delay(1); 1794 } 1795 1796 #if defined(REAL_DMA_POLL) 1797 do { 1798 tmp = NCR5380_read(BUS_AND_STATUS_REG); 1799 } while ((tmp & BASR_PHASE_MATCH) && !(tmp & (BASR_BUSY_ERROR | BASR_END_DMA_TRANSFER))); 1800 1801 /* 1802 At this point, either we've completed DMA, or we have a phase mismatch, 1803 or we've unexpectedly lost BUSY (which is a real error). 1804 1805 For write DMAs, we want to wait until the last byte has been 1806 transferred out over the bus before we turn off DMA mode. Alas, there 1807 seems to be no terribly good way of doing this on a 5380 under all 1808 conditions. For non-scatter-gather operations, we can wait until REQ 1809 and ACK both go false, or until a phase mismatch occurs. Gather-writes 1810 are nastier, since the device will be expecting more data than we 1811 are prepared to send it, and REQ will remain asserted. On a 53C8[01] we 1812 could test LAST BIT SENT to assure transfer (I imagine this is precisely 1813 why this signal was added to the newer chips) but on the older 538[01] 1814 this signal does not exist. The workaround for this lack is a watchdog; 1815 we bail out of the wait-loop after a modest amount of wait-time if 1816 the usual exit conditions are not met. Not a terribly clean or 1817 correct solution :-% 1818 1819 Reads are equally tricky due to a nasty characteristic of the NCR5380. 1820 If the chip is in DMA mode for an READ, it will respond to a target's 1821 REQ by latching the SCSI data into the INPUT DATA register and asserting 1822 ACK, even if it has _already_ been notified by the DMA controller that 1823 the current DMA transfer has completed! If the NCR5380 is then taken 1824 out of DMA mode, this already-acknowledged byte is lost. 1825 1826 This is not a problem for "one DMA transfer per command" reads, because 1827 the situation will never arise... either all of the data is DMA'ed 1828 properly, or the target switches to MESSAGE IN phase to signal a 1829 disconnection (either operation bringing the DMA to a clean halt). 1830 However, in order to handle scatter-reads, we must work around the 1831 problem. The chosen fix is to DMA N-2 bytes, then check for the 1832 condition before taking the NCR5380 out of DMA mode. One or two extra 1833 bytes are transferred via PIO as necessary to fill out the original 1834 request. 1835 */ 1836 1837 if (p & SR_IO) { 1838 #ifdef READ_OVERRUNS 1839 udelay(10); 1840 if (((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) == (BASR_PHASE_MATCH | BASR_ACK))) { 1841 saved_data = NCR5380_read(INPUT_DATA_REGISTER); 1842 overrun = 1; 1843 } 1844 #endif 1845 } else { 1846 int limit = 100; 1847 while (((tmp = NCR5380_read(BUS_AND_STATUS_REG)) & BASR_ACK) || (NCR5380_read(STATUS_REG) & SR_REQ)) { 1848 if (!(tmp & BASR_PHASE_MATCH)) 1849 break; 1850 if (--limit < 0) 1851 break; 1852 } 1853 } 1854 1855 dprintk(NDEBUG_DMA, "scsi%d : polled DMA transfer complete, basr 0x%X, sr 0x%X\n", instance->host_no, tmp, NCR5380_read(STATUS_REG)); 1856 1857 NCR5380_write(MODE_REG, MR_BASE); 1858 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1859 1860 residue = NCR5380_dma_residual(instance); 1861 c -= residue; 1862 *count -= c; 1863 *data += c; 1864 *phase = NCR5380_read(STATUS_REG) & PHASE_MASK; 1865 1866 #ifdef READ_OVERRUNS 1867 if (*phase == p && (p & SR_IO) && residue == 0) { 1868 if (overrun) { 1869 dprintk(NDEBUG_DMA, "Got an input overrun, using saved byte\n"); 1870 **data = saved_data; 1871 *data += 1; 1872 *count -= 1; 1873 cnt = toPIO = 1; 1874 } else { 1875 printk("No overrun??\n"); 1876 cnt = toPIO = 2; 1877 } 1878 dprintk(NDEBUG_DMA, "Doing %d-byte PIO to 0x%X\n", cnt, *data); 1879 NCR5380_transfer_pio(instance, phase, &cnt, data); 1880 *count -= toPIO - cnt; 1881 } 1882 #endif 1883 1884 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)); 1885 return 0; 1886 1887 #elif defined(REAL_DMA) 1888 return 0; 1889 #else /* defined(REAL_DMA_POLL) */ 1890 if (p & SR_IO) { 1891 #ifdef DMA_WORKS_RIGHT 1892 foo = NCR5380_pread(instance, d, c); 1893 #else 1894 int diff = 1; 1895 if (hostdata->flags & FLAG_NCR53C400) { 1896 diff = 0; 1897 } 1898 if (!(foo = NCR5380_pread(instance, d, c - diff))) { 1899 /* 1900 * We can't disable DMA mode after successfully transferring 1901 * what we plan to be the last byte, since that would open up 1902 * a race condition where if the target asserted REQ before 1903 * we got the DMA mode reset, the NCR5380 would have latched 1904 * an additional byte into the INPUT DATA register and we'd 1905 * have dropped it. 1906 * 1907 * The workaround was to transfer one fewer bytes than we 1908 * intended to with the pseudo-DMA read function, wait for 1909 * the chip to latch the last byte, read it, and then disable 1910 * pseudo-DMA mode. 1911 * 1912 * After REQ is asserted, the NCR5380 asserts DRQ and ACK. 1913 * REQ is deasserted when ACK is asserted, and not reasserted 1914 * until ACK goes false. Since the NCR5380 won't lower ACK 1915 * until DACK is asserted, which won't happen unless we twiddle 1916 * the DMA port or we take the NCR5380 out of DMA mode, we 1917 * can guarantee that we won't handshake another extra 1918 * byte. 1919 */ 1920 1921 if (!(hostdata->flags & FLAG_NCR53C400)) { 1922 while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ)); 1923 /* Wait for clean handshake */ 1924 while (NCR5380_read(STATUS_REG) & SR_REQ); 1925 d[c - 1] = NCR5380_read(INPUT_DATA_REG); 1926 } 1927 } 1928 #endif 1929 } else { 1930 #ifdef DMA_WORKS_RIGHT 1931 foo = NCR5380_pwrite(instance, d, c); 1932 #else 1933 int timeout; 1934 dprintk(NDEBUG_C400_PWRITE, "About to pwrite %d bytes\n", c); 1935 if (!(foo = NCR5380_pwrite(instance, d, c))) { 1936 /* 1937 * Wait for the last byte to be sent. If REQ is being asserted for 1938 * the byte we're interested, we'll ACK it and it will go false. 1939 */ 1940 if (!(hostdata->flags & FLAG_HAS_LAST_BYTE_SENT)) { 1941 timeout = 20000; 1942 while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) && (NCR5380_read(BUS_AND_STATUS_REG) & BASR_PHASE_MATCH)); 1943 1944 if (!timeout) 1945 dprintk(NDEBUG_LAST_BYTE_SENT, "scsi%d : timed out on last byte\n", instance->host_no); 1946 1947 if (hostdata->flags & FLAG_CHECK_LAST_BYTE_SENT) { 1948 hostdata->flags &= ~FLAG_CHECK_LAST_BYTE_SENT; 1949 if (NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT) { 1950 hostdata->flags |= FLAG_HAS_LAST_BYTE_SENT; 1951 dprintk(NDEBUG_LAST_BYTE_SENT, "scsi%d : last byte sent works\n", instance->host_no); 1952 } 1953 } 1954 } else { 1955 dprintk(NDEBUG_C400_PWRITE, "Waiting for LASTBYTE\n"); 1956 while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT)); 1957 dprintk(NDEBUG_C400_PWRITE, "Got LASTBYTE\n"); 1958 } 1959 } 1960 #endif 1961 } 1962 NCR5380_write(MODE_REG, MR_BASE); 1963 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 1964 1965 if ((!(p & SR_IO)) && (hostdata->flags & FLAG_NCR53C400)) { 1966 dprintk(NDEBUG_C400_PWRITE, "53C400w: Checking for IRQ\n"); 1967 if (NCR5380_read(BUS_AND_STATUS_REG) & BASR_IRQ) { 1968 dprintk(NDEBUG_C400_PWRITE, "53C400w: got it, reading reset interrupt reg\n"); 1969 NCR5380_read(RESET_PARITY_INTERRUPT_REG); 1970 } else { 1971 printk("53C400w: IRQ NOT THERE!\n"); 1972 } 1973 } 1974 *data = d + c; 1975 *count = 0; 1976 *phase = NCR5380_read(STATUS_REG) & PHASE_MASK; 1977 #if defined(PSEUDO_DMA) && defined(UNSAFE) 1978 spin_lock_irq(instance->host_lock); 1979 #endif /* defined(REAL_DMA_POLL) */ 1980 return foo; 1981 #endif /* def REAL_DMA */ 1982 } 1983 #endif /* defined(REAL_DMA) | defined(PSEUDO_DMA) */ 1984 1985 /* 1986 * Function : NCR5380_information_transfer (struct Scsi_Host *instance) 1987 * 1988 * Purpose : run through the various SCSI phases and do as the target 1989 * directs us to. Operates on the currently connected command, 1990 * instance->connected. 1991 * 1992 * Inputs : instance, instance for which we are doing commands 1993 * 1994 * Side effects : SCSI things happen, the disconnected queue will be 1995 * modified if a command disconnects, *instance->connected will 1996 * change. 1997 * 1998 * XXX Note : we need to watch for bus free or a reset condition here 1999 * to recover from an unexpected bus free condition. 2000 * 2001 * Locks: io_request_lock held by caller in IRQ mode 2002 */ 2003 2004 static void NCR5380_information_transfer(struct Scsi_Host *instance) { 2005 NCR5380_local_declare(); 2006 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)instance->hostdata; 2007 unsigned char msgout = NOP; 2008 int sink = 0; 2009 int len; 2010 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL) 2011 int transfersize; 2012 #endif 2013 unsigned char *data; 2014 unsigned char phase, tmp, extended_msg[10], old_phase = 0xff; 2015 struct scsi_cmnd *cmd = (struct scsi_cmnd *) hostdata->connected; 2016 /* RvC: we need to set the end of the polling time */ 2017 unsigned long poll_time = jiffies + USLEEP_POLL; 2018 2019 NCR5380_setup(instance); 2020 2021 while (1) { 2022 tmp = NCR5380_read(STATUS_REG); 2023 /* We only have a valid SCSI phase when REQ is asserted */ 2024 if (tmp & SR_REQ) { 2025 phase = (tmp & PHASE_MASK); 2026 if (phase != old_phase) { 2027 old_phase = phase; 2028 NCR5380_dprint_phase(NDEBUG_INFORMATION, instance); 2029 } 2030 if (sink && (phase != PHASE_MSGOUT)) { 2031 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp)); 2032 2033 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK); 2034 while (NCR5380_read(STATUS_REG) & SR_REQ); 2035 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 2036 sink = 0; 2037 continue; 2038 } 2039 switch (phase) { 2040 case PHASE_DATAIN: 2041 case PHASE_DATAOUT: 2042 #if (NDEBUG & NDEBUG_NO_DATAOUT) 2043 printk("scsi%d : NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n", instance->host_no); 2044 sink = 1; 2045 do_abort(instance); 2046 cmd->result = DID_ERROR << 16; 2047 cmd->scsi_done(cmd); 2048 return; 2049 #endif 2050 /* 2051 * If there is no room left in the current buffer in the 2052 * scatter-gather list, move onto the next one. 2053 */ 2054 2055 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) { 2056 ++cmd->SCp.buffer; 2057 --cmd->SCp.buffers_residual; 2058 cmd->SCp.this_residual = cmd->SCp.buffer->length; 2059 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer); 2060 dprintk(NDEBUG_INFORMATION, "scsi%d : %d bytes and %d buffers left\n", instance->host_no, cmd->SCp.this_residual, cmd->SCp.buffers_residual); 2061 } 2062 /* 2063 * The preferred transfer method is going to be 2064 * PSEUDO-DMA for systems that are strictly PIO, 2065 * since we can let the hardware do the handshaking. 2066 * 2067 * For this to work, we need to know the transfersize 2068 * ahead of time, since the pseudo-DMA code will sit 2069 * in an unconditional loop. 2070 */ 2071 2072 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL) 2073 /* KLL 2074 * PSEUDO_DMA is defined here. If this is the g_NCR5380 2075 * driver then it will always be defined, so the 2076 * FLAG_NO_PSEUDO_DMA is used to inhibit PDMA in the base 2077 * NCR5380 case. I think this is a fairly clean solution. 2078 * We supplement these 2 if's with the flag. 2079 */ 2080 #ifdef NCR5380_dma_xfer_len 2081 if (!cmd->device->borken && !(hostdata->flags & FLAG_NO_PSEUDO_DMA) && (transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) { 2082 #else 2083 transfersize = cmd->transfersize; 2084 2085 #ifdef LIMIT_TRANSFERSIZE /* If we have problems with interrupt service */ 2086 if (transfersize > 512) 2087 transfersize = 512; 2088 #endif /* LIMIT_TRANSFERSIZE */ 2089 2090 if (!cmd->device->borken && transfersize && !(hostdata->flags & FLAG_NO_PSEUDO_DMA) && cmd->SCp.this_residual && !(cmd->SCp.this_residual % transfersize)) { 2091 /* Limit transfers to 32K, for xx400 & xx406 2092 * pseudoDMA that transfers in 128 bytes blocks. */ 2093 if (transfersize > 32 * 1024) 2094 transfersize = 32 * 1024; 2095 #endif 2096 len = transfersize; 2097 if (NCR5380_transfer_dma(instance, &phase, &len, (unsigned char **) &cmd->SCp.ptr)) { 2098 /* 2099 * If the watchdog timer fires, all future accesses to this 2100 * device will use the polled-IO. 2101 */ 2102 scmd_printk(KERN_INFO, cmd, 2103 "switching to slow handshake\n"); 2104 cmd->device->borken = 1; 2105 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 2106 sink = 1; 2107 do_abort(instance); 2108 cmd->result = DID_ERROR << 16; 2109 cmd->scsi_done(cmd); 2110 /* XXX - need to source or sink data here, as appropriate */ 2111 } else 2112 cmd->SCp.this_residual -= transfersize - len; 2113 } else 2114 #endif /* defined(PSEUDO_DMA) || defined(REAL_DMA_POLL) */ 2115 NCR5380_transfer_pio(instance, &phase, (int *) &cmd->SCp.this_residual, (unsigned char **) 2116 &cmd->SCp.ptr); 2117 break; 2118 case PHASE_MSGIN: 2119 len = 1; 2120 data = &tmp; 2121 NCR5380_transfer_pio(instance, &phase, &len, &data); 2122 cmd->SCp.Message = tmp; 2123 2124 switch (tmp) { 2125 /* 2126 * Linking lets us reduce the time required to get the 2127 * next command out to the device, hopefully this will 2128 * mean we don't waste another revolution due to the delays 2129 * required by ARBITRATION and another SELECTION. 2130 * 2131 * In the current implementation proposal, low level drivers 2132 * merely have to start the next command, pointed to by 2133 * next_link, done() is called as with unlinked commands. 2134 */ 2135 #ifdef LINKED 2136 case LINKED_CMD_COMPLETE: 2137 case LINKED_FLG_CMD_COMPLETE: 2138 /* Accept message by clearing ACK */ 2139 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2140 dprintk(NDEBUG_LINKED, "scsi%d : target %d lun %llu linked command complete.\n", instance->host_no, cmd->device->id, cmd->device->lun); 2141 /* 2142 * Sanity check : A linked command should only terminate with 2143 * one of these messages if there are more linked commands 2144 * available. 2145 */ 2146 if (!cmd->next_link) { 2147 printk("scsi%d : target %d lun %llu linked command complete, no next_link\n" instance->host_no, cmd->device->id, cmd->device->lun); 2148 sink = 1; 2149 do_abort(instance); 2150 return; 2151 } 2152 initialize_SCp(cmd->next_link); 2153 /* The next command is still part of this process */ 2154 cmd->next_link->tag = cmd->tag; 2155 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 2156 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); 2157 cmd->scsi_done(cmd); 2158 cmd = hostdata->connected; 2159 break; 2160 #endif /* def LINKED */ 2161 case ABORT: 2162 case COMMAND_COMPLETE: 2163 /* Accept message by clearing ACK */ 2164 sink = 1; 2165 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2166 hostdata->connected = NULL; 2167 dprintk(NDEBUG_QUEUES, "scsi%d : command for target %d, lun %llu completed\n", instance->host_no, cmd->device->id, cmd->device->lun); 2168 hostdata->busy[cmd->device->id] &= ~(1 << (cmd->device->lun & 0xFF)); 2169 2170 /* 2171 * I'm not sure what the correct thing to do here is : 2172 * 2173 * If the command that just executed is NOT a request 2174 * sense, the obvious thing to do is to set the result 2175 * code to the values of the stored parameters. 2176 * 2177 * If it was a REQUEST SENSE command, we need some way 2178 * to differentiate between the failure code of the original 2179 * and the failure code of the REQUEST sense - the obvious 2180 * case is success, where we fall through and leave the result 2181 * code unchanged. 2182 * 2183 * The non-obvious place is where the REQUEST SENSE failed 2184 */ 2185 2186 if (cmd->cmnd[0] != REQUEST_SENSE) 2187 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8); 2188 else if (status_byte(cmd->SCp.Status) != GOOD) 2189 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16); 2190 2191 if ((cmd->cmnd[0] == REQUEST_SENSE) && 2192 hostdata->ses.cmd_len) { 2193 scsi_eh_restore_cmnd(cmd, &hostdata->ses); 2194 hostdata->ses.cmd_len = 0 ; 2195 } 2196 2197 if ((cmd->cmnd[0] != REQUEST_SENSE) && (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) { 2198 scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0); 2199 2200 dprintk(NDEBUG_AUTOSENSE, "scsi%d : performing request sense\n", instance->host_no); 2201 2202 LIST(cmd, hostdata->issue_queue); 2203 cmd->host_scribble = (unsigned char *) 2204 hostdata->issue_queue; 2205 hostdata->issue_queue = (struct scsi_cmnd *) cmd; 2206 dprintk(NDEBUG_QUEUES, "scsi%d : REQUEST SENSE added to head of issue queue\n", instance->host_no); 2207 } else { 2208 cmd->scsi_done(cmd); 2209 } 2210 2211 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2212 /* 2213 * Restore phase bits to 0 so an interrupted selection, 2214 * arbitration can resume. 2215 */ 2216 NCR5380_write(TARGET_COMMAND_REG, 0); 2217 2218 while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected) 2219 barrier(); 2220 return; 2221 case MESSAGE_REJECT: 2222 /* Accept message by clearing ACK */ 2223 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2224 switch (hostdata->last_message) { 2225 case HEAD_OF_QUEUE_TAG: 2226 case ORDERED_QUEUE_TAG: 2227 case SIMPLE_QUEUE_TAG: 2228 cmd->device->simple_tags = 0; 2229 hostdata->busy[cmd->device->id] |= (1 << (cmd->device->lun & 0xFF)); 2230 break; 2231 default: 2232 break; 2233 } 2234 case DISCONNECT:{ 2235 /* Accept message by clearing ACK */ 2236 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2237 cmd->device->disconnect = 1; 2238 LIST(cmd, hostdata->disconnected_queue); 2239 cmd->host_scribble = (unsigned char *) 2240 hostdata->disconnected_queue; 2241 hostdata->connected = NULL; 2242 hostdata->disconnected_queue = cmd; 2243 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); 2244 /* 2245 * Restore phase bits to 0 so an interrupted selection, 2246 * arbitration can resume. 2247 */ 2248 NCR5380_write(TARGET_COMMAND_REG, 0); 2249 2250 /* Enable reselect interrupts */ 2251 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2252 /* Wait for bus free to avoid nasty timeouts - FIXME timeout !*/ 2253 /* NCR538_poll_politely(instance, STATUS_REG, SR_BSY, 0, 30 * HZ); */ 2254 while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected) 2255 barrier(); 2256 return; 2257 } 2258 /* 2259 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect 2260 * operation, in violation of the SCSI spec so we can safely 2261 * ignore SAVE/RESTORE pointers calls. 2262 * 2263 * Unfortunately, some disks violate the SCSI spec and 2264 * don't issue the required SAVE_POINTERS message before 2265 * disconnecting, and we have to break spec to remain 2266 * compatible. 2267 */ 2268 case SAVE_POINTERS: 2269 case RESTORE_POINTERS: 2270 /* Accept message by clearing ACK */ 2271 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2272 break; 2273 case EXTENDED_MESSAGE: 2274 /* 2275 * Extended messages are sent in the following format : 2276 * Byte 2277 * 0 EXTENDED_MESSAGE == 1 2278 * 1 length (includes one byte for code, doesn't 2279 * include first two bytes) 2280 * 2 code 2281 * 3..length+1 arguments 2282 * 2283 * Start the extended message buffer with the EXTENDED_MESSAGE 2284 * byte, since spi_print_msg() wants the whole thing. 2285 */ 2286 extended_msg[0] = EXTENDED_MESSAGE; 2287 /* Accept first byte by clearing ACK */ 2288 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2289 dprintk(NDEBUG_EXTENDED, "scsi%d : receiving extended message\n", instance->host_no); 2290 2291 len = 2; 2292 data = extended_msg + 1; 2293 phase = PHASE_MSGIN; 2294 NCR5380_transfer_pio(instance, &phase, &len, &data); 2295 2296 dprintk(NDEBUG_EXTENDED, "scsi%d : length=%d, code=0x%02x\n", instance->host_no, (int) extended_msg[1], (int) extended_msg[2]); 2297 2298 if (!len && extended_msg[1] <= (sizeof(extended_msg) - 1)) { 2299 /* Accept third byte by clearing ACK */ 2300 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2301 len = extended_msg[1] - 1; 2302 data = extended_msg + 3; 2303 phase = PHASE_MSGIN; 2304 2305 NCR5380_transfer_pio(instance, &phase, &len, &data); 2306 dprintk(NDEBUG_EXTENDED, "scsi%d : message received, residual %d\n", instance->host_no, len); 2307 2308 switch (extended_msg[2]) { 2309 case EXTENDED_SDTR: 2310 case EXTENDED_WDTR: 2311 case EXTENDED_MODIFY_DATA_POINTER: 2312 case EXTENDED_EXTENDED_IDENTIFY: 2313 tmp = 0; 2314 } 2315 } else if (len) { 2316 printk("scsi%d: error receiving extended message\n", instance->host_no); 2317 tmp = 0; 2318 } else { 2319 printk("scsi%d: extended message code %02x length %d is too long\n", instance->host_no, extended_msg[2], extended_msg[1]); 2320 tmp = 0; 2321 } 2322 /* Fall through to reject message */ 2323 2324 /* 2325 * If we get something weird that we aren't expecting, 2326 * reject it. 2327 */ 2328 default: 2329 if (!tmp) { 2330 printk("scsi%d: rejecting message ", instance->host_no); 2331 spi_print_msg(extended_msg); 2332 printk("\n"); 2333 } else if (tmp != EXTENDED_MESSAGE) 2334 scmd_printk(KERN_INFO, cmd, 2335 "rejecting unknown message %02x\n",tmp); 2336 else 2337 scmd_printk(KERN_INFO, cmd, 2338 "rejecting unknown extended message code %02x, length %d\n", extended_msg[1], extended_msg[0]); 2339 2340 msgout = MESSAGE_REJECT; 2341 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN); 2342 break; 2343 } /* switch (tmp) */ 2344 break; 2345 case PHASE_MSGOUT: 2346 len = 1; 2347 data = &msgout; 2348 hostdata->last_message = msgout; 2349 NCR5380_transfer_pio(instance, &phase, &len, &data); 2350 if (msgout == ABORT) { 2351 hostdata->busy[cmd->device->id] &= ~(1 << (cmd->device->lun & 0xFF)); 2352 hostdata->connected = NULL; 2353 cmd->result = DID_ERROR << 16; 2354 cmd->scsi_done(cmd); 2355 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask); 2356 return; 2357 } 2358 msgout = NOP; 2359 break; 2360 case PHASE_CMDOUT: 2361 len = cmd->cmd_len; 2362 data = cmd->cmnd; 2363 /* 2364 * XXX for performance reasons, on machines with a 2365 * PSEUDO-DMA architecture we should probably 2366 * use the dma transfer function. 2367 */ 2368 NCR5380_transfer_pio(instance, &phase, &len, &data); 2369 if (!cmd->device->disconnect && should_disconnect(cmd->cmnd[0])) { 2370 NCR5380_set_timer(hostdata, USLEEP_SLEEP); 2371 dprintk(NDEBUG_USLEEP, "scsi%d : issued command, sleeping until %lu\n", instance->host_no, hostdata->time_expires); 2372 return; 2373 } 2374 break; 2375 case PHASE_STATIN: 2376 len = 1; 2377 data = &tmp; 2378 NCR5380_transfer_pio(instance, &phase, &len, &data); 2379 cmd->SCp.Status = tmp; 2380 break; 2381 default: 2382 printk("scsi%d : unknown phase\n", instance->host_no); 2383 NCR5380_dprint(NDEBUG_ANY, instance); 2384 } /* switch(phase) */ 2385 } /* if (tmp * SR_REQ) */ 2386 else { 2387 /* RvC: go to sleep if polling time expired 2388 */ 2389 if (!cmd->device->disconnect && time_after_eq(jiffies, poll_time)) { 2390 NCR5380_set_timer(hostdata, USLEEP_SLEEP); 2391 dprintk(NDEBUG_USLEEP, "scsi%d : poll timed out, sleeping until %lu\n", instance->host_no, hostdata->time_expires); 2392 return; 2393 } 2394 } 2395 } /* while (1) */ 2396 } 2397 2398 /* 2399 * Function : void NCR5380_reselect (struct Scsi_Host *instance) 2400 * 2401 * Purpose : does reselection, initializing the instance->connected 2402 * field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q 2403 * nexus has been reestablished, 2404 * 2405 * Inputs : instance - this instance of the NCR5380. 2406 * 2407 * Locks: io_request_lock held by caller if IRQ driven 2408 */ 2409 2410 static void NCR5380_reselect(struct Scsi_Host *instance) { 2411 NCR5380_local_declare(); 2412 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) 2413 instance->hostdata; 2414 unsigned char target_mask; 2415 unsigned char lun, phase; 2416 int len; 2417 unsigned char msg[3]; 2418 unsigned char *data; 2419 struct scsi_cmnd *tmp = NULL, *prev; 2420 int abort = 0; 2421 NCR5380_setup(instance); 2422 2423 /* 2424 * Disable arbitration, etc. since the host adapter obviously 2425 * lost, and tell an interrupted NCR5380_select() to restart. 2426 */ 2427 2428 NCR5380_write(MODE_REG, MR_BASE); 2429 hostdata->restart_select = 1; 2430 2431 target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask); 2432 dprintk(NDEBUG_SELECTION, "scsi%d : reselect\n", instance->host_no); 2433 2434 /* 2435 * At this point, we have detected that our SCSI ID is on the bus, 2436 * SEL is true and BSY was false for at least one bus settle delay 2437 * (400 ns). 2438 * 2439 * We must assert BSY ourselves, until the target drops the SEL 2440 * signal. 2441 */ 2442 2443 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY); 2444 2445 /* FIXME: timeout too long, must fail to workqueue */ 2446 if(NCR5380_poll_politely(instance, STATUS_REG, SR_SEL, 0, 2*HZ)<0) 2447 abort = 1; 2448 2449 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2450 2451 /* 2452 * Wait for target to go into MSGIN. 2453 * FIXME: timeout needed and fail to work queeu 2454 */ 2455 2456 if(NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, 2*HZ)) 2457 abort = 1; 2458 2459 len = 1; 2460 data = msg; 2461 phase = PHASE_MSGIN; 2462 NCR5380_transfer_pio(instance, &phase, &len, &data); 2463 2464 if (!(msg[0] & 0x80)) { 2465 printk(KERN_ERR "scsi%d : expecting IDENTIFY message, got ", instance->host_no); 2466 spi_print_msg(msg); 2467 abort = 1; 2468 } else { 2469 /* Accept message by clearing ACK */ 2470 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2471 lun = (msg[0] & 0x07); 2472 2473 /* 2474 * We need to add code for SCSI-II to track which devices have 2475 * I_T_L_Q nexuses established, and which have simple I_T_L 2476 * nexuses so we can chose to do additional data transfer. 2477 */ 2478 2479 /* 2480 * Find the command corresponding to the I_T_L or I_T_L_Q nexus we 2481 * just reestablished, and remove it from the disconnected queue. 2482 */ 2483 2484 2485 for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL; tmp; prev = tmp, tmp = (struct scsi_cmnd *) tmp->host_scribble) 2486 if ((target_mask == (1 << tmp->device->id)) && (lun == (u8)tmp->device->lun) 2487 ) { 2488 if (prev) { 2489 REMOVE(prev, prev->host_scribble, tmp, tmp->host_scribble); 2490 prev->host_scribble = tmp->host_scribble; 2491 } else { 2492 REMOVE(-1, hostdata->disconnected_queue, tmp, tmp->host_scribble); 2493 hostdata->disconnected_queue = (struct scsi_cmnd *) tmp->host_scribble; 2494 } 2495 tmp->host_scribble = NULL; 2496 break; 2497 } 2498 if (!tmp) { 2499 printk(KERN_ERR "scsi%d : warning : target bitmask %02x lun %d not in disconnect_queue.\n", instance->host_no, target_mask, lun); 2500 /* 2501 * Since we have an established nexus that we can't do anything with, 2502 * we must abort it. 2503 */ 2504 abort = 1; 2505 } 2506 } 2507 2508 if (abort) { 2509 do_abort(instance); 2510 } else { 2511 hostdata->connected = tmp; 2512 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); 2513 } 2514 } 2515 2516 /* 2517 * Function : void NCR5380_dma_complete (struct Scsi_Host *instance) 2518 * 2519 * Purpose : called by interrupt handler when DMA finishes or a phase 2520 * mismatch occurs (which would finish the DMA transfer). 2521 * 2522 * Inputs : instance - this instance of the NCR5380. 2523 * 2524 * Returns : pointer to the scsi_cmnd structure for which the I_T_L 2525 * nexus has been reestablished, on failure NULL is returned. 2526 */ 2527 2528 #ifdef REAL_DMA 2529 static void NCR5380_dma_complete(NCR5380_instance * instance) { 2530 NCR5380_local_declare(); 2531 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 2532 int transferred; 2533 NCR5380_setup(instance); 2534 2535 /* 2536 * XXX this might not be right. 2537 * 2538 * Wait for final byte to transfer, ie wait for ACK to go false. 2539 * 2540 * We should use the Last Byte Sent bit, unfortunately this is 2541 * not available on the 5380/5381 (only the various CMOS chips) 2542 * 2543 * FIXME: timeout, and need to handle long timeout/irq case 2544 */ 2545 2546 NCR5380_poll_politely(instance, BUS_AND_STATUS_REG, BASR_ACK, 0, 5*HZ); 2547 2548 NCR5380_write(MODE_REG, MR_BASE); 2549 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); 2550 2551 /* 2552 * The only places we should see a phase mismatch and have to send 2553 * data from the same set of pointers will be the data transfer 2554 * phases. So, residual, requested length are only important here. 2555 */ 2556 2557 if (!(hostdata->connected->SCp.phase & SR_CD)) { 2558 transferred = instance->dmalen - NCR5380_dma_residual(); 2559 hostdata->connected->SCp.this_residual -= transferred; 2560 hostdata->connected->SCp.ptr += transferred; 2561 } 2562 } 2563 #endif /* def REAL_DMA */ 2564 2565 /* 2566 * Function : int NCR5380_abort (struct scsi_cmnd *cmd) 2567 * 2568 * Purpose : abort a command 2569 * 2570 * Inputs : cmd - the scsi_cmnd to abort, code - code to set the 2571 * host byte of the result field to, if zero DID_ABORTED is 2572 * used. 2573 * 2574 * Returns : SUCCESS - success, FAILED on failure. 2575 * 2576 * XXX - there is no way to abort the command that is currently 2577 * connected, you have to wait for it to complete. If this is 2578 * a problem, we could implement longjmp() / setjmp(), setjmp() 2579 * called where the loop started in NCR5380_main(). 2580 * 2581 * Locks: host lock taken by caller 2582 */ 2583 2584 static int NCR5380_abort(struct scsi_cmnd *cmd) 2585 { 2586 NCR5380_local_declare(); 2587 struct Scsi_Host *instance = cmd->device->host; 2588 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata; 2589 struct scsi_cmnd *tmp, **prev; 2590 2591 scmd_printk(KERN_WARNING, cmd, "aborting command\n"); 2592 2593 NCR5380_print_status(instance); 2594 2595 NCR5380_setup(instance); 2596 2597 dprintk(NDEBUG_ABORT, "scsi%d : abort called\n", instance->host_no); 2598 dprintk(NDEBUG_ABORT, " basr 0x%X, sr 0x%X\n", NCR5380_read(BUS_AND_STATUS_REG), NCR5380_read(STATUS_REG)); 2599 2600 #if 0 2601 /* 2602 * Case 1 : If the command is the currently executing command, 2603 * we'll set the aborted flag and return control so that 2604 * information transfer routine can exit cleanly. 2605 */ 2606 2607 if (hostdata->connected == cmd) { 2608 dprintk(NDEBUG_ABORT, "scsi%d : aborting connected command\n", instance->host_no); 2609 hostdata->aborted = 1; 2610 /* 2611 * We should perform BSY checking, and make sure we haven't slipped 2612 * into BUS FREE. 2613 */ 2614 2615 NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN); 2616 /* 2617 * Since we can't change phases until we've completed the current 2618 * handshake, we have to source or sink a byte of data if the current 2619 * phase is not MSGOUT. 2620 */ 2621 2622 /* 2623 * Return control to the executing NCR drive so we can clear the 2624 * aborted flag and get back into our main loop. 2625 */ 2626 2627 return SUCCESS; 2628 } 2629 #endif 2630 2631 /* 2632 * Case 2 : If the command hasn't been issued yet, we simply remove it 2633 * from the issue queue. 2634 */ 2635 2636 dprintk(NDEBUG_ABORT, "scsi%d : abort going into loop.\n", instance->host_no); 2637 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) 2638 if (cmd == tmp) { 2639 REMOVE(5, *prev, tmp, tmp->host_scribble); 2640 (*prev) = (struct scsi_cmnd *) tmp->host_scribble; 2641 tmp->host_scribble = NULL; 2642 tmp->result = DID_ABORT << 16; 2643 dprintk(NDEBUG_ABORT, "scsi%d : abort removed command from issue queue.\n", instance->host_no); 2644 tmp->scsi_done(tmp); 2645 return SUCCESS; 2646 } 2647 #if (NDEBUG & NDEBUG_ABORT) 2648 /* KLL */ 2649 else if (prev == tmp) 2650 printk(KERN_ERR "scsi%d : LOOP\n", instance->host_no); 2651 #endif 2652 2653 /* 2654 * Case 3 : If any commands are connected, we're going to fail the abort 2655 * and let the high level SCSI driver retry at a later time or 2656 * issue a reset. 2657 * 2658 * Timeouts, and therefore aborted commands, will be highly unlikely 2659 * and handling them cleanly in this situation would make the common 2660 * case of noresets less efficient, and would pollute our code. So, 2661 * we fail. 2662 */ 2663 2664 if (hostdata->connected) { 2665 dprintk(NDEBUG_ABORT, "scsi%d : abort failed, command connected.\n", instance->host_no); 2666 return FAILED; 2667 } 2668 /* 2669 * Case 4: If the command is currently disconnected from the bus, and 2670 * there are no connected commands, we reconnect the I_T_L or 2671 * I_T_L_Q nexus associated with it, go into message out, and send 2672 * an abort message. 2673 * 2674 * This case is especially ugly. In order to reestablish the nexus, we 2675 * need to call NCR5380_select(). The easiest way to implement this 2676 * function was to abort if the bus was busy, and let the interrupt 2677 * handler triggered on the SEL for reselect take care of lost arbitrations 2678 * where necessary, meaning interrupts need to be enabled. 2679 * 2680 * When interrupts are enabled, the queues may change - so we 2681 * can't remove it from the disconnected queue before selecting it 2682 * because that could cause a failure in hashing the nexus if that 2683 * device reselected. 2684 * 2685 * Since the queues may change, we can't use the pointers from when we 2686 * first locate it. 2687 * 2688 * So, we must first locate the command, and if NCR5380_select() 2689 * succeeds, then issue the abort, relocate the command and remove 2690 * it from the disconnected queue. 2691 */ 2692 2693 for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp; tmp = (struct scsi_cmnd *) tmp->host_scribble) 2694 if (cmd == tmp) { 2695 dprintk(NDEBUG_ABORT, "scsi%d : aborting disconnected command.\n", instance->host_no); 2696 2697 if (NCR5380_select(instance, cmd)) 2698 return FAILED; 2699 dprintk(NDEBUG_ABORT, "scsi%d : nexus reestablished.\n", instance->host_no); 2700 2701 do_abort(instance); 2702 2703 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) 2704 if (cmd == tmp) { 2705 REMOVE(5, *prev, tmp, tmp->host_scribble); 2706 *prev = (struct scsi_cmnd *) tmp->host_scribble; 2707 tmp->host_scribble = NULL; 2708 tmp->result = DID_ABORT << 16; 2709 tmp->scsi_done(tmp); 2710 return SUCCESS; 2711 } 2712 } 2713 /* 2714 * Case 5 : If we reached this point, the command was not found in any of 2715 * the queues. 2716 * 2717 * We probably reached this point because of an unlikely race condition 2718 * between the command completing successfully and the abortion code, 2719 * so we won't panic, but we will notify the user in case something really 2720 * broke. 2721 */ 2722 printk(KERN_WARNING "scsi%d : warning : SCSI command probably completed successfully\n" 2723 " before abortion\n", instance->host_no); 2724 return FAILED; 2725 } 2726 2727 2728 /* 2729 * Function : int NCR5380_bus_reset (struct scsi_cmnd *cmd) 2730 * 2731 * Purpose : reset the SCSI bus. 2732 * 2733 * Returns : SUCCESS 2734 * 2735 * Locks: host lock taken by caller 2736 */ 2737 2738 static int NCR5380_bus_reset(struct scsi_cmnd *cmd) 2739 { 2740 struct Scsi_Host *instance = cmd->device->host; 2741 2742 NCR5380_local_declare(); 2743 NCR5380_setup(instance); 2744 NCR5380_print_status(instance); 2745 2746 spin_lock_irq(instance->host_lock); 2747 do_reset(instance); 2748 spin_unlock_irq(instance->host_lock); 2749 2750 return SUCCESS; 2751 } 2752