1/* NCR53C9x.c: Generic SCSI driver code for NCR53C9x chips. 2 * 3 * Originally esp.c : EnhancedScsiProcessor Sun SCSI driver code. 4 * 5 * Copyright (C) 1995, 1998 David S. Miller (davem@caip.rutgers.edu) 6 * 7 * Most DMA dependencies put in driver specific files by 8 * Jesper Skov (jskov@cygnus.co.uk) 9 * 10 * Set up to use esp_read/esp_write (preprocessor macros in NCR53c9x.h) by 11 * Tymm Twillman (tymm@coe.missouri.edu) 12 */ 13 14/* TODO: 15 * 16 * 1) Maybe disable parity checking in config register one for SCSI1 17 * targets. (Gilmore says parity error on the SBus can lock up 18 * old sun4c's) 19 * 2) Add support for DMA2 pipelining. 20 * 3) Add tagged queueing. 21 * 4) Maybe change use of "esp" to something more "NCR"'ish. 22 */ 23 24#include <linux/module.h> 25 26#include <linux/kernel.h> 27#include <linux/delay.h> 28#include <linux/types.h> 29#include <linux/string.h> 30#include <linux/slab.h> 31#include <linux/blkdev.h> 32#include <linux/interrupt.h> 33#include <linux/proc_fs.h> 34#include <linux/stat.h> 35#include <linux/init.h> 36 37#include "scsi.h" 38#include <scsi/scsi_host.h> 39#include "NCR53C9x.h" 40 41#include <asm/system.h> 42#include <asm/ptrace.h> 43#include <asm/pgtable.h> 44#include <asm/io.h> 45#include <asm/irq.h> 46 47/* Command phase enumeration. */ 48enum { 49 not_issued = 0x00, /* Still in the issue_SC queue. */ 50 51 /* Various forms of selecting a target. */ 52#define in_slct_mask 0x10 53 in_slct_norm = 0x10, /* ESP is arbitrating, normal selection */ 54 in_slct_stop = 0x11, /* ESP will select, then stop with IRQ */ 55 in_slct_msg = 0x12, /* select, then send a message */ 56 in_slct_tag = 0x13, /* select and send tagged queue msg */ 57 in_slct_sneg = 0x14, /* select and acquire sync capabilities */ 58 59 /* Any post selection activity. */ 60#define in_phases_mask 0x20 61 in_datain = 0x20, /* Data is transferring from the bus */ 62 in_dataout = 0x21, /* Data is transferring to the bus */ 63 in_data_done = 0x22, /* Last DMA data operation done (maybe) */ 64 in_msgin = 0x23, /* Eating message from target */ 65 in_msgincont = 0x24, /* Eating more msg bytes from target */ 66 in_msgindone = 0x25, /* Decide what to do with what we got */ 67 in_msgout = 0x26, /* Sending message to target */ 68 in_msgoutdone = 0x27, /* Done sending msg out */ 69 in_cmdbegin = 0x28, /* Sending cmd after abnormal selection */ 70 in_cmdend = 0x29, /* Done sending slow cmd */ 71 in_status = 0x2a, /* Was in status phase, finishing cmd */ 72 in_freeing = 0x2b, /* freeing the bus for cmd cmplt or disc */ 73 in_the_dark = 0x2c, /* Don't know what bus phase we are in */ 74 75 /* Special states, ie. not normal bus transitions... */ 76#define in_spec_mask 0x80 77 in_abortone = 0x80, /* Aborting one command currently */ 78 in_abortall = 0x81, /* Blowing away all commands we have */ 79 in_resetdev = 0x82, /* SCSI target reset in progress */ 80 in_resetbus = 0x83, /* SCSI bus reset in progress */ 81 in_tgterror = 0x84, /* Target did something stupid */ 82}; 83 84enum { 85 /* Zero has special meaning, see skipahead[12]. */ 86/*0*/ do_never, 87 88/*1*/ do_phase_determine, 89/*2*/ do_reset_bus, 90/*3*/ do_reset_complete, 91/*4*/ do_work_bus, 92/*5*/ do_intr_end 93}; 94 95/* The master ring of all esp hosts we are managing in this driver. */ 96static struct NCR_ESP *espchain; 97int nesps = 0, esps_in_use = 0, esps_running = 0; 98 99irqreturn_t esp_intr(int irq, void *dev_id); 100 101/* Debugging routines */ 102static struct esp_cmdstrings { 103 unchar cmdchar; 104 char *text; 105} esp_cmd_strings[] = { 106 /* Miscellaneous */ 107 { ESP_CMD_NULL, "ESP_NOP", }, 108 { ESP_CMD_FLUSH, "FIFO_FLUSH", }, 109 { ESP_CMD_RC, "RSTESP", }, 110 { ESP_CMD_RS, "RSTSCSI", }, 111 /* Disconnected State Group */ 112 { ESP_CMD_RSEL, "RESLCTSEQ", }, 113 { ESP_CMD_SEL, "SLCTNATN", }, 114 { ESP_CMD_SELA, "SLCTATN", }, 115 { ESP_CMD_SELAS, "SLCTATNSTOP", }, 116 { ESP_CMD_ESEL, "ENSLCTRESEL", }, 117 { ESP_CMD_DSEL, "DISSELRESEL", }, 118 { ESP_CMD_SA3, "SLCTATN3", }, 119 { ESP_CMD_RSEL3, "RESLCTSEQ", }, 120 /* Target State Group */ 121 { ESP_CMD_SMSG, "SNDMSG", }, 122 { ESP_CMD_SSTAT, "SNDSTATUS", }, 123 { ESP_CMD_SDATA, "SNDDATA", }, 124 { ESP_CMD_DSEQ, "DISCSEQ", }, 125 { ESP_CMD_TSEQ, "TERMSEQ", }, 126 { ESP_CMD_TCCSEQ, "TRGTCMDCOMPSEQ", }, 127 { ESP_CMD_DCNCT, "DISC", }, 128 { ESP_CMD_RMSG, "RCVMSG", }, 129 { ESP_CMD_RCMD, "RCVCMD", }, 130 { ESP_CMD_RDATA, "RCVDATA", }, 131 { ESP_CMD_RCSEQ, "RCVCMDSEQ", }, 132 /* Initiator State Group */ 133 { ESP_CMD_TI, "TRANSINFO", }, 134 { ESP_CMD_ICCSEQ, "INICMDSEQCOMP", }, 135 { ESP_CMD_MOK, "MSGACCEPTED", }, 136 { ESP_CMD_TPAD, "TPAD", }, 137 { ESP_CMD_SATN, "SATN", }, 138 { ESP_CMD_RATN, "RATN", }, 139}; 140#define NUM_ESP_COMMANDS ((sizeof(esp_cmd_strings)) / (sizeof(struct esp_cmdstrings))) 141 142/* Print textual representation of an ESP command */ 143static inline void esp_print_cmd(unchar espcmd) 144{ 145 unchar dma_bit = espcmd & ESP_CMD_DMA; 146 int i; 147 148 espcmd &= ~dma_bit; 149 for(i=0; i<NUM_ESP_COMMANDS; i++) 150 if(esp_cmd_strings[i].cmdchar == espcmd) 151 break; 152 if(i==NUM_ESP_COMMANDS) 153 printk("ESP_Unknown"); 154 else 155 printk("%s%s", esp_cmd_strings[i].text, 156 ((dma_bit) ? "+DMA" : "")); 157} 158 159/* Print the status register's value */ 160static inline void esp_print_statreg(unchar statreg) 161{ 162 unchar phase; 163 164 printk("STATUS<"); 165 phase = statreg & ESP_STAT_PMASK; 166 printk("%s,", (phase == ESP_DOP ? "DATA-OUT" : 167 (phase == ESP_DIP ? "DATA-IN" : 168 (phase == ESP_CMDP ? "COMMAND" : 169 (phase == ESP_STATP ? "STATUS" : 170 (phase == ESP_MOP ? "MSG-OUT" : 171 (phase == ESP_MIP ? "MSG_IN" : 172 "unknown"))))))); 173 if(statreg & ESP_STAT_TDONE) 174 printk("TRANS_DONE,"); 175 if(statreg & ESP_STAT_TCNT) 176 printk("TCOUNT_ZERO,"); 177 if(statreg & ESP_STAT_PERR) 178 printk("P_ERROR,"); 179 if(statreg & ESP_STAT_SPAM) 180 printk("SPAM,"); 181 if(statreg & ESP_STAT_INTR) 182 printk("IRQ,"); 183 printk(">"); 184} 185 186/* Print the interrupt register's value */ 187static inline void esp_print_ireg(unchar intreg) 188{ 189 printk("INTREG< "); 190 if(intreg & ESP_INTR_S) 191 printk("SLCT_NATN "); 192 if(intreg & ESP_INTR_SATN) 193 printk("SLCT_ATN "); 194 if(intreg & ESP_INTR_RSEL) 195 printk("RSLCT "); 196 if(intreg & ESP_INTR_FDONE) 197 printk("FDONE "); 198 if(intreg & ESP_INTR_BSERV) 199 printk("BSERV "); 200 if(intreg & ESP_INTR_DC) 201 printk("DISCNCT "); 202 if(intreg & ESP_INTR_IC) 203 printk("ILL_CMD "); 204 if(intreg & ESP_INTR_SR) 205 printk("SCSI_BUS_RESET "); 206 printk(">"); 207} 208 209/* Print the sequence step registers contents */ 210static inline void esp_print_seqreg(unchar stepreg) 211{ 212 stepreg &= ESP_STEP_VBITS; 213 printk("STEP<%s>", 214 (stepreg == ESP_STEP_ASEL ? "SLCT_ARB_CMPLT" : 215 (stepreg == ESP_STEP_SID ? "1BYTE_MSG_SENT" : 216 (stepreg == ESP_STEP_NCMD ? "NOT_IN_CMD_PHASE" : 217 (stepreg == ESP_STEP_PPC ? "CMD_BYTES_LOST" : 218 (stepreg == ESP_STEP_FINI4 ? "CMD_SENT_OK" : 219 "UNKNOWN")))))); 220} 221 222static char *phase_string(int phase) 223{ 224 switch(phase) { 225 case not_issued: 226 return "UNISSUED"; 227 case in_slct_norm: 228 return "SLCTNORM"; 229 case in_slct_stop: 230 return "SLCTSTOP"; 231 case in_slct_msg: 232 return "SLCTMSG"; 233 case in_slct_tag: 234 return "SLCTTAG"; 235 case in_slct_sneg: 236 return "SLCTSNEG"; 237 case in_datain: 238 return "DATAIN"; 239 case in_dataout: 240 return "DATAOUT"; 241 case in_data_done: 242 return "DATADONE"; 243 case in_msgin: 244 return "MSGIN"; 245 case in_msgincont: 246 return "MSGINCONT"; 247 case in_msgindone: 248 return "MSGINDONE"; 249 case in_msgout: 250 return "MSGOUT"; 251 case in_msgoutdone: 252 return "MSGOUTDONE"; 253 case in_cmdbegin: 254 return "CMDBEGIN"; 255 case in_cmdend: 256 return "CMDEND"; 257 case in_status: 258 return "STATUS"; 259 case in_freeing: 260 return "FREEING"; 261 case in_the_dark: 262 return "CLUELESS"; 263 case in_abortone: 264 return "ABORTONE"; 265 case in_abortall: 266 return "ABORTALL"; 267 case in_resetdev: 268 return "RESETDEV"; 269 case in_resetbus: 270 return "RESETBUS"; 271 case in_tgterror: 272 return "TGTERROR"; 273 default: 274 return "UNKNOWN"; 275 }; 276} 277 278#ifdef DEBUG_STATE_MACHINE 279static inline void esp_advance_phase(Scsi_Cmnd *s, int newphase) 280{ 281 ESPLOG(("<%s>", phase_string(newphase))); 282 s->SCp.sent_command = s->SCp.phase; 283 s->SCp.phase = newphase; 284} 285#else 286#define esp_advance_phase(__s, __newphase) \ 287 (__s)->SCp.sent_command = (__s)->SCp.phase; \ 288 (__s)->SCp.phase = (__newphase); 289#endif 290 291#ifdef DEBUG_ESP_CMDS 292static inline void esp_cmd(struct NCR_ESP *esp, struct ESP_regs *eregs, 293 unchar cmd) 294{ 295 esp->espcmdlog[esp->espcmdent] = cmd; 296 esp->espcmdent = (esp->espcmdent + 1) & 31; 297 esp_write(eregs->esp_cmnd, cmd); 298} 299#else 300#define esp_cmd(__esp, __eregs, __cmd) esp_write((__eregs)->esp_cmnd, (__cmd)) 301#endif 302 303/* How we use the various Linux SCSI data structures for operation. 304 * 305 * struct scsi_cmnd: 306 * 307 * We keep track of the syncronous capabilities of a target 308 * in the device member, using sync_min_period and 309 * sync_max_offset. These are the values we directly write 310 * into the ESP registers while running a command. If offset 311 * is zero the ESP will use asynchronous transfers. 312 * If the borken flag is set we assume we shouldn't even bother 313 * trying to negotiate for synchronous transfer as this target 314 * is really stupid. If we notice the target is dropping the 315 * bus, and we have been allowing it to disconnect, we clear 316 * the disconnect flag. 317 */ 318 319/* Manipulation of the ESP command queues. Thanks to the aha152x driver 320 * and its author, Juergen E. Fischer, for the methods used here. 321 * Note that these are per-ESP queues, not global queues like 322 * the aha152x driver uses. 323 */ 324static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC) 325{ 326 Scsi_Cmnd *end; 327 328 new_SC->host_scribble = (unsigned char *) NULL; 329 if(!*SC) 330 *SC = new_SC; 331 else { 332 for(end=*SC;end->host_scribble;end=(Scsi_Cmnd *)end->host_scribble) 333 ; 334 end->host_scribble = (unsigned char *) new_SC; 335 } 336} 337 338static inline void prepend_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC) 339{ 340 new_SC->host_scribble = (unsigned char *) *SC; 341 *SC = new_SC; 342} 343 344static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd **SC) 345{ 346 Scsi_Cmnd *ptr; 347 348 ptr = *SC; 349 if(ptr) 350 *SC = (Scsi_Cmnd *) (*SC)->host_scribble; 351 return ptr; 352} 353 354static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, int target, int lun) 355{ 356 Scsi_Cmnd *ptr, *prev; 357 358 for(ptr = *SC, prev = NULL; 359 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun)); 360 prev = ptr, ptr = (Scsi_Cmnd *) ptr->host_scribble) 361 ; 362 if(ptr) { 363 if(prev) 364 prev->host_scribble=ptr->host_scribble; 365 else 366 *SC=(Scsi_Cmnd *)ptr->host_scribble; 367 } 368 return ptr; 369} 370 371/* Resetting various pieces of the ESP scsi driver chipset */ 372 373/* Reset the ESP chip, _not_ the SCSI bus. */ 374static void esp_reset_esp(struct NCR_ESP *esp, struct ESP_regs *eregs) 375{ 376 int family_code, version, i; 377 volatile int trash; 378 379 /* Now reset the ESP chip */ 380 esp_cmd(esp, eregs, ESP_CMD_RC); 381 esp_cmd(esp, eregs, ESP_CMD_NULL | ESP_CMD_DMA); 382 if(esp->erev == fast) 383 esp_write(eregs->esp_cfg2, ESP_CONFIG2_FENAB); 384 esp_cmd(esp, eregs, ESP_CMD_NULL | ESP_CMD_DMA); 385 386 /* This is the only point at which it is reliable to read 387 * the ID-code for a fast ESP chip variant. 388 */ 389 esp->max_period = ((35 * esp->ccycle) / 1000); 390 if(esp->erev == fast) { 391 char *erev2string[] = { 392 "Emulex FAS236", 393 "Emulex FPESP100A", 394 "fast", 395 "QLogic FAS366", 396 "Emulex FAS216", 397 "Symbios Logic 53CF9x-2", 398 "unknown!" 399 }; 400 401 version = esp_read(eregs->esp_uid); 402 family_code = (version & 0xf8) >> 3; 403 if(family_code == 0x02) { 404 if ((version & 7) == 2) 405 esp->erev = fas216; 406 else 407 esp->erev = fas236; 408 } else if(family_code == 0x0a) 409 esp->erev = fas366; /* Version is usually '5'. */ 410 else if(family_code == 0x00) { 411 if ((version & 7) == 2) 412 esp->erev = fas100a; /* NCR53C9X */ 413 else 414 esp->erev = espunknown; 415 } else if(family_code == 0x14) { 416 if ((version & 7) == 2) 417 esp->erev = fsc; 418 else 419 esp->erev = espunknown; 420 } else if(family_code == 0x00) { 421 if ((version & 7) == 2) 422 esp->erev = fas100a; /* NCR53C9X */ 423 else 424 esp->erev = espunknown; 425 } else 426 esp->erev = espunknown; 427 ESPLOG(("esp%d: FAST chip is %s (family=%d, version=%d)\n", 428 esp->esp_id, erev2string[esp->erev - fas236], 429 family_code, (version & 7))); 430 431 esp->min_period = ((4 * esp->ccycle) / 1000); 432 } else { 433 esp->min_period = ((5 * esp->ccycle) / 1000); 434 } 435 436 /* Reload the configuration registers */ 437 esp_write(eregs->esp_cfact, esp->cfact); 438 esp->prev_stp = 0; 439 esp_write(eregs->esp_stp, 0); 440 esp->prev_soff = 0; 441 esp_write(eregs->esp_soff, 0); 442 esp_write(eregs->esp_timeo, esp->neg_defp); 443 esp->max_period = (esp->max_period + 3)>>2; 444 esp->min_period = (esp->min_period + 3)>>2; 445 446 esp_write(eregs->esp_cfg1, esp->config1); 447 switch(esp->erev) { 448 case esp100: 449 /* nothing to do */ 450 break; 451 case esp100a: 452 esp_write(eregs->esp_cfg2, esp->config2); 453 break; 454 case esp236: 455 /* Slow 236 */ 456 esp_write(eregs->esp_cfg2, esp->config2); 457 esp->prev_cfg3 = esp->config3[0]; 458 esp_write(eregs->esp_cfg3, esp->prev_cfg3); 459 break; 460 case fas366: 461 panic("esp: FAS366 support not present, please notify " 462 "jongk@cs.utwente.nl"); 463 break; 464 case fas216: 465 case fas236: 466 case fsc: 467 /* Fast ESP variants */ 468 esp_write(eregs->esp_cfg2, esp->config2); 469 for(i=0; i<8; i++) 470 esp->config3[i] |= ESP_CONFIG3_FCLK; 471 esp->prev_cfg3 = esp->config3[0]; 472 esp_write(eregs->esp_cfg3, esp->prev_cfg3); 473 if(esp->diff) 474 esp->radelay = 0; 475 else 476 esp->radelay = 16; 477 /* Different timeout constant for these chips */ 478 esp->neg_defp = 479 FSC_NEG_DEFP(esp->cfreq, 480 (esp->cfact == ESP_CCF_F0 ? 481 ESP_CCF_F7 + 1 : esp->cfact)); 482 esp_write(eregs->esp_timeo, esp->neg_defp); 483 /* Enable Active Negotiation if possible */ 484 if((esp->erev == fsc) && !esp->diff) 485 esp_write(eregs->esp_cfg4, ESP_CONFIG4_EAN); 486 break; 487 case fas100a: 488 /* Fast 100a */ 489 esp_write(eregs->esp_cfg2, esp->config2); 490 for(i=0; i<8; i++) 491 esp->config3[i] |= ESP_CONFIG3_FCLOCK; 492 esp->prev_cfg3 = esp->config3[0]; 493 esp_write(eregs->esp_cfg3, esp->prev_cfg3); 494 esp->radelay = 32; 495 break; 496 default: 497 panic("esp: what could it be... I wonder..."); 498 break; 499 }; 500 501 /* Eat any bitrot in the chip */ 502 trash = esp_read(eregs->esp_intrpt); 503 udelay(100); 504} 505 506/* This places the ESP into a known state at boot time. */ 507void esp_bootup_reset(struct NCR_ESP *esp, struct ESP_regs *eregs) 508{ 509 volatile unchar trash; 510 511 /* Reset the DMA */ 512 if(esp->dma_reset) 513 esp->dma_reset(esp); 514 515 /* Reset the ESP */ 516 esp_reset_esp(esp, eregs); 517 518 /* Reset the SCSI bus, but tell ESP not to generate an irq */ 519 esp_write(eregs->esp_cfg1, (esp_read(eregs->esp_cfg1) | ESP_CONFIG1_SRRDISAB)); 520 esp_cmd(esp, eregs, ESP_CMD_RS); 521 udelay(400); 522 esp_write(eregs->esp_cfg1, esp->config1); 523 524 /* Eat any bitrot in the chip and we are done... */ 525 trash = esp_read(eregs->esp_intrpt); 526} 527 528/* Allocate structure and insert basic data such as SCSI chip frequency 529 * data and a pointer to the device 530 */ 531struct NCR_ESP* esp_allocate(struct scsi_host_template *tpnt, void *esp_dev, 532 int hotplug) 533{ 534 struct NCR_ESP *esp, *elink; 535 struct Scsi_Host *esp_host; 536 537 if (hotplug) 538 esp_host = scsi_host_alloc(tpnt, sizeof(struct NCR_ESP)); 539 else 540 esp_host = scsi_register(tpnt, sizeof(struct NCR_ESP)); 541 if(!esp_host) 542 panic("Cannot register ESP SCSI host"); 543 esp = (struct NCR_ESP *) esp_host->hostdata; 544 if(!esp) 545 panic("No esp in hostdata"); 546 esp->ehost = esp_host; 547 esp->edev = esp_dev; 548 esp->esp_id = nesps++; 549 550 /* Set bitshift value (only used on Amiga with multiple ESPs) */ 551 esp->shift = 2; 552 553 /* Put into the chain of esp chips detected */ 554 if(espchain) { 555 elink = espchain; 556 while(elink->next) elink = elink->next; 557 elink->next = esp; 558 } else { 559 espchain = esp; 560 } 561 esp->next = NULL; 562 563 return esp; 564} 565 566void esp_deallocate(struct NCR_ESP *esp) 567{ 568 struct NCR_ESP *elink; 569 570 if(espchain == esp) { 571 espchain = NULL; 572 } else { 573 for(elink = espchain; elink && (elink->next != esp); elink = elink->next); 574 if(elink) 575 elink->next = esp->next; 576 } 577 nesps--; 578} 579 580/* Complete initialization of ESP structure and device 581 * Caller must have initialized appropriate parts of the ESP structure 582 * between the call to esp_allocate and this function. 583 */ 584void esp_initialize(struct NCR_ESP *esp) 585{ 586 struct ESP_regs *eregs = esp->eregs; 587 unsigned int fmhz; 588 unchar ccf; 589 int i; 590 591 /* Check out the clock properties of the chip. */ 592 593 /* This is getting messy but it has to be done 594 * correctly or else you get weird behavior all 595 * over the place. We are trying to basically 596 * figure out three pieces of information. 597 * 598 * a) Clock Conversion Factor 599 * 600 * This is a representation of the input 601 * crystal clock frequency going into the 602 * ESP on this machine. Any operation whose 603 * timing is longer than 400ns depends on this 604 * value being correct. For example, you'll 605 * get blips for arbitration/selection during 606 * high load or with multiple targets if this 607 * is not set correctly. 608 * 609 * b) Selection Time-Out 610 * 611 * The ESP isn't very bright and will arbitrate 612 * for the bus and try to select a target 613 * forever if you let it. This value tells 614 * the ESP when it has taken too long to 615 * negotiate and that it should interrupt 616 * the CPU so we can see what happened. 617 * The value is computed as follows (from 618 * NCR/Symbios chip docs). 619 * 620 * (Time Out Period) * (Input Clock) 621 * STO = ---------------------------------- 622 * (8192) * (Clock Conversion Factor) 623 * 624 * You usually want the time out period to be 625 * around 250ms, I think we'll set it a little 626 * bit higher to account for fully loaded SCSI 627 * bus's and slow devices that don't respond so 628 * quickly to selection attempts. (yeah, I know 629 * this is out of spec. but there is a lot of 630 * buggy pieces of firmware out there so bite me) 631 * 632 * c) Imperical constants for synchronous offset 633 * and transfer period register values 634 * 635 * This entails the smallest and largest sync 636 * period we could ever handle on this ESP. 637 */ 638 639 fmhz = esp->cfreq; 640 641 if(fmhz <= (5000000)) 642 ccf = 0; 643 else 644 ccf = (((5000000 - 1) + (fmhz))/(5000000)); 645 if(!ccf || ccf > 8) { 646 /* If we can't find anything reasonable, 647 * just assume 20MHZ. This is the clock 648 * frequency of the older sun4c's where I've 649 * been unable to find the clock-frequency 650 * PROM property. All other machines provide 651 * useful values it seems. 652 */ 653 ccf = ESP_CCF_F4; 654 fmhz = (20000000); 655 } 656 if(ccf==(ESP_CCF_F7+1)) 657 esp->cfact = ESP_CCF_F0; 658 else if(ccf == ESP_CCF_NEVER) 659 esp->cfact = ESP_CCF_F2; 660 else 661 esp->cfact = ccf; 662 esp->cfreq = fmhz; 663 esp->ccycle = ESP_MHZ_TO_CYCLE(fmhz); 664 esp->ctick = ESP_TICK(ccf, esp->ccycle); 665 esp->neg_defp = ESP_NEG_DEFP(fmhz, ccf); 666 esp->sync_defp = SYNC_DEFP_SLOW; 667 668 printk("SCSI ID %d Clk %dMHz CCF=%d TOut %d ", 669 esp->scsi_id, (esp->cfreq / 1000000), 670 ccf, (int) esp->neg_defp); 671 672 /* Fill in ehost data */ 673 esp->ehost->base = (unsigned long)eregs; 674 esp->ehost->this_id = esp->scsi_id; 675 esp->ehost->irq = esp->irq; 676 677 /* SCSI id mask */ 678 esp->scsi_id_mask = (1 << esp->scsi_id); 679 680 /* Probe the revision of this esp */ 681 esp->config1 = (ESP_CONFIG1_PENABLE | (esp->scsi_id & 7)); 682 esp->config2 = (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY); 683 esp_write(eregs->esp_cfg2, esp->config2); 684 if((esp_read(eregs->esp_cfg2) & ~(ESP_CONFIG2_MAGIC)) != 685 (ESP_CONFIG2_SCSI2ENAB | ESP_CONFIG2_REGPARITY)) { 686 printk("NCR53C90(esp100)\n"); 687 esp->erev = esp100; 688 } else { 689 esp->config2 = 0; 690 esp_write(eregs->esp_cfg2, 0); 691 esp_write(eregs->esp_cfg3, 5); 692 if(esp_read(eregs->esp_cfg3) != 5) { 693 printk("NCR53C90A(esp100a)\n"); 694 esp->erev = esp100a; 695 } else { 696 int target; 697 698 for(target=0; target<8; target++) 699 esp->config3[target] = 0; 700 esp->prev_cfg3 = 0; 701 esp_write(eregs->esp_cfg3, 0); 702 if(ccf > ESP_CCF_F5) { 703 printk("NCR53C9XF(espfast)\n"); 704 esp->erev = fast; 705 esp->sync_defp = SYNC_DEFP_FAST; 706 } else { 707 printk("NCR53C9x(esp236)\n"); 708 esp->erev = esp236; 709 } 710 } 711 } 712 713 /* Initialize the command queues */ 714 esp->current_SC = NULL; 715 esp->disconnected_SC = NULL; 716 esp->issue_SC = NULL; 717 718 /* Clear the state machines. */ 719 esp->targets_present = 0; 720 esp->resetting_bus = 0; 721 esp->snip = 0; 722 723 init_waitqueue_head(&esp->reset_queue); 724 725 esp->fas_premature_intr_workaround = 0; 726 for(i = 0; i < 32; i++) 727 esp->espcmdlog[i] = 0; 728 esp->espcmdent = 0; 729 for(i = 0; i < 16; i++) { 730 esp->cur_msgout[i] = 0; 731 esp->cur_msgin[i] = 0; 732 } 733 esp->prevmsgout = esp->prevmsgin = 0; 734 esp->msgout_len = esp->msgin_len = 0; 735 736 /* Clear the one behind caches to hold unmatchable values. */ 737 esp->prev_soff = esp->prev_stp = esp->prev_cfg3 = 0xff; 738 739 /* Reset the thing before we try anything... */ 740 esp_bootup_reset(esp, eregs); 741 742 esps_in_use++; 743} 744 745/* The info function will return whatever useful 746 * information the developer sees fit. If not provided, then 747 * the name field will be used instead. 748 */ 749const char *esp_info(struct Scsi_Host *host) 750{ 751 struct NCR_ESP *esp; 752 753 esp = (struct NCR_ESP *) host->hostdata; 754 switch(esp->erev) { 755 case esp100: 756 return "ESP100 (NCR53C90)"; 757 case esp100a: 758 return "ESP100A (NCR53C90A)"; 759 case esp236: 760 return "ESP236 (NCR53C9x)"; 761 case fas216: 762 return "Emulex FAS216"; 763 case fas236: 764 return "Emulex FAS236"; 765 case fas366: 766 return "QLogic FAS366"; 767 case fas100a: 768 return "FPESP100A"; 769 case fsc: 770 return "Symbios Logic 53CF9x-2"; 771 default: 772 panic("Bogon ESP revision"); 773 }; 774} 775 776/* From Wolfgang Stanglmeier's NCR scsi driver. */ 777struct info_str 778{ 779 char *buffer; 780 int length; 781 int offset; 782 int pos; 783}; 784 785static void copy_mem_info(struct info_str *info, char *data, int len) 786{ 787 if (info->pos + len > info->length) 788 len = info->length - info->pos; 789 790 if (info->pos + len < info->offset) { 791 info->pos += len; 792 return; 793 } 794 if (info->pos < info->offset) { 795 data += (info->offset - info->pos); 796 len -= (info->offset - info->pos); 797 } 798 799 if (len > 0) { 800 memcpy(info->buffer + info->pos, data, len); 801 info->pos += len; 802 } 803} 804 805static int copy_info(struct info_str *info, char *fmt, ...) 806{ 807 va_list args; 808 char buf[81]; 809 int len; 810 811 va_start(args, fmt); 812 len = vsprintf(buf, fmt, args); 813 va_end(args); 814 815 copy_mem_info(info, buf, len); 816 return len; 817} 818 819static int esp_host_info(struct NCR_ESP *esp, char *ptr, off_t offset, int len) 820{ 821 struct scsi_device *sdev; 822 struct info_str info; 823 int i; 824 825 info.buffer = ptr; 826 info.length = len; 827 info.offset = offset; 828 info.pos = 0; 829 830 copy_info(&info, "ESP Host Adapter:\n"); 831 copy_info(&info, "\tESP Model\t\t"); 832 switch(esp->erev) { 833 case esp100: 834 copy_info(&info, "ESP100 (NCR53C90)\n"); 835 break; 836 case esp100a: 837 copy_info(&info, "ESP100A (NCR53C90A)\n"); 838 break; 839 case esp236: 840 copy_info(&info, "ESP236 (NCR53C9x)\n"); 841 break; 842 case fas216: 843 copy_info(&info, "Emulex FAS216\n"); 844 break; 845 case fas236: 846 copy_info(&info, "Emulex FAS236\n"); 847 break; 848 case fas100a: 849 copy_info(&info, "FPESP100A\n"); 850 break; 851 case fast: 852 copy_info(&info, "Generic FAST\n"); 853 break; 854 case fas366: 855 copy_info(&info, "QLogic FAS366\n"); 856 break; 857 case fsc: 858 copy_info(&info, "Symbios Logic 53C9x-2\n"); 859 break; 860 case espunknown: 861 default: 862 copy_info(&info, "Unknown!\n"); 863 break; 864 }; 865 copy_info(&info, "\tLive Targets\t\t[ "); 866 for(i = 0; i < 15; i++) { 867 if(esp->targets_present & (1 << i)) 868 copy_info(&info, "%d ", i); 869 } 870 copy_info(&info, "]\n\n"); 871 872 /* Now describe the state of each existing target. */ 873 copy_info(&info, "Target #\tconfig3\t\tSync Capabilities\tDisconnect\n"); 874 875 shost_for_each_device(sdev, esp->ehost) { 876 struct esp_device *esp_dev = sdev->hostdata; 877 uint id = sdev->id; 878 879 if (!(esp->targets_present & (1 << id))) 880 continue; 881 882 copy_info(&info, "%d\t\t", id); 883 copy_info(&info, "%08lx\t", esp->config3[id]); 884 copy_info(&info, "[%02lx,%02lx]\t\t\t", 885 esp_dev->sync_max_offset, 886 esp_dev->sync_min_period); 887 copy_info(&info, "%s\n", esp_dev->disconnect ? "yes" : "no"); 888 } 889 890 return info.pos > info.offset? info.pos - info.offset : 0; 891} 892 893/* ESP proc filesystem code. */ 894int esp_proc_info(struct Scsi_Host *shost, char *buffer, char **start, off_t offset, int length, 895 int inout) 896{ 897 struct NCR_ESP *esp = (struct NCR_ESP *)shost->hostdata; 898 899 if(inout) 900 return -EINVAL; /* not yet */ 901 if(start) 902 *start = buffer; 903 return esp_host_info(esp, buffer, offset, length); 904} 905 906static void esp_get_dmabufs(struct NCR_ESP *esp, Scsi_Cmnd *sp) 907{ 908 if(sp->use_sg == 0) { 909 sp->SCp.this_residual = sp->request_bufflen; 910 sp->SCp.buffer = (struct scatterlist *) sp->request_buffer; 911 sp->SCp.buffers_residual = 0; 912 if (esp->dma_mmu_get_scsi_one) 913 esp->dma_mmu_get_scsi_one(esp, sp); 914 else 915 sp->SCp.ptr = 916 (char *) virt_to_phys(sp->request_buffer); 917 } else { 918 sp->SCp.buffer = (struct scatterlist *) sp->request_buffer; 919 sp->SCp.buffers_residual = sp->use_sg - 1; 920 sp->SCp.this_residual = sp->SCp.buffer->length; 921 if (esp->dma_mmu_get_scsi_sgl) 922 esp->dma_mmu_get_scsi_sgl(esp, sp); 923 else 924 sp->SCp.ptr = 925 (char *) virt_to_phys((page_address(sp->SCp.buffer->page) + sp->SCp.buffer->offset)); 926 } 927} 928 929static void esp_release_dmabufs(struct NCR_ESP *esp, Scsi_Cmnd *sp) 930{ 931 if(sp->use_sg == 0) { 932 if (esp->dma_mmu_release_scsi_one) 933 esp->dma_mmu_release_scsi_one(esp, sp); 934 } else { 935 if (esp->dma_mmu_release_scsi_sgl) 936 esp->dma_mmu_release_scsi_sgl(esp, sp); 937 } 938} 939 940static void esp_restore_pointers(struct NCR_ESP *esp, Scsi_Cmnd *sp) 941{ 942 struct esp_pointers *ep = &esp->data_pointers[scmd_id(sp)]; 943 944 sp->SCp.ptr = ep->saved_ptr; 945 sp->SCp.buffer = ep->saved_buffer; 946 sp->SCp.this_residual = ep->saved_this_residual; 947 sp->SCp.buffers_residual = ep->saved_buffers_residual; 948} 949 950static void esp_save_pointers(struct NCR_ESP *esp, Scsi_Cmnd *sp) 951{ 952 struct esp_pointers *ep = &esp->data_pointers[scmd_id(sp)]; 953 954 ep->saved_ptr = sp->SCp.ptr; 955 ep->saved_buffer = sp->SCp.buffer; 956 ep->saved_this_residual = sp->SCp.this_residual; 957 ep->saved_buffers_residual = sp->SCp.buffers_residual; 958} 959 960/* Some rules: 961 * 962 * 1) Never ever panic while something is live on the bus. 963 * If there is to be any chance of syncing the disks this 964 * rule is to be obeyed. 965 * 966 * 2) Any target that causes a foul condition will no longer 967 * have synchronous transfers done to it, no questions 968 * asked. 969 * 970 * 3) Keep register accesses to a minimum. Think about some 971 * day when we have Xbus machines this is running on and 972 * the ESP chip is on the other end of the machine on a 973 * different board from the cpu where this is running. 974 */ 975 976/* Fire off a command. We assume the bus is free and that the only 977 * case where we could see an interrupt is where we have disconnected 978 * commands active and they are trying to reselect us. 979 */ 980static inline void esp_check_cmd(struct NCR_ESP *esp, Scsi_Cmnd *sp) 981{ 982 switch(sp->cmd_len) { 983 case 6: 984 case 10: 985 case 12: 986 esp->esp_slowcmd = 0; 987 break; 988 989 default: 990 esp->esp_slowcmd = 1; 991 esp->esp_scmdleft = sp->cmd_len; 992 esp->esp_scmdp = &sp->cmnd[0]; 993 break; 994 }; 995} 996 997static inline void build_sync_nego_msg(struct NCR_ESP *esp, int period, int offset) 998{ 999 esp->cur_msgout[0] = EXTENDED_MESSAGE; 1000 esp->cur_msgout[1] = 3; 1001 esp->cur_msgout[2] = EXTENDED_SDTR; 1002 esp->cur_msgout[3] = period; 1003 esp->cur_msgout[4] = offset; 1004 esp->msgout_len = 5; 1005} 1006 1007static void esp_exec_cmd(struct NCR_ESP *esp) 1008{ 1009 struct ESP_regs *eregs = esp->eregs; 1010 struct esp_device *esp_dev; 1011 Scsi_Cmnd *SCptr; 1012 struct scsi_device *SDptr; 1013 volatile unchar *cmdp = esp->esp_command; 1014 unsigned char the_esp_command; 1015 int lun, target; 1016 int i; 1017 1018 /* Hold off if we have disconnected commands and 1019 * an IRQ is showing... 1020 */ 1021 if(esp->disconnected_SC && esp->dma_irq_p(esp)) 1022 return; 1023 1024 /* Grab first member of the issue queue. */ 1025 SCptr = esp->current_SC = remove_first_SC(&esp->issue_SC); 1026 1027 /* Safe to panic here because current_SC is null. */ 1028 if(!SCptr) 1029 panic("esp: esp_exec_cmd and issue queue is NULL"); 1030 1031 SDptr = SCptr->device; 1032 esp_dev = SDptr->hostdata; 1033 lun = SCptr->device->lun; 1034 target = SCptr->device->id; 1035 1036 esp->snip = 0; 1037 esp->msgout_len = 0; 1038 1039 /* Send it out whole, or piece by piece? The ESP 1040 * only knows how to automatically send out 6, 10, 1041 * and 12 byte commands. I used to think that the 1042 * Linux SCSI code would never throw anything other 1043 * than that to us, but then again there is the 1044 * SCSI generic driver which can send us anything. 1045 */ 1046 esp_check_cmd(esp, SCptr); 1047 1048 /* If arbitration/selection is successful, the ESP will leave 1049 * ATN asserted, causing the target to go into message out 1050 * phase. The ESP will feed the target the identify and then 1051 * the target can only legally go to one of command, 1052 * datain/out, status, or message in phase, or stay in message 1053 * out phase (should we be trying to send a sync negotiation 1054 * message after the identify). It is not allowed to drop 1055 * BSY, but some buggy targets do and we check for this 1056 * condition in the selection complete code. Most of the time 1057 * we'll make the command bytes available to the ESP and it 1058 * will not interrupt us until it finishes command phase, we 1059 * cannot do this for command sizes the ESP does not 1060 * understand and in this case we'll get interrupted right 1061 * when the target goes into command phase. 1062 * 1063 * It is absolutely _illegal_ in the presence of SCSI-2 devices 1064 * to use the ESP select w/o ATN command. When SCSI-2 devices are 1065 * present on the bus we _must_ always go straight to message out 1066 * phase with an identify message for the target. Being that 1067 * selection attempts in SCSI-1 w/o ATN was an option, doing SCSI-2 1068 * selections should not confuse SCSI-1 we hope. 1069 */ 1070 1071 if(esp_dev->sync) { 1072 /* this targets sync is known */ 1073#ifdef CONFIG_SCSI_MAC_ESP 1074do_sync_known: 1075#endif 1076 if(esp_dev->disconnect) 1077 *cmdp++ = IDENTIFY(1, lun); 1078 else 1079 *cmdp++ = IDENTIFY(0, lun); 1080 1081 if(esp->esp_slowcmd) { 1082 the_esp_command = (ESP_CMD_SELAS | ESP_CMD_DMA); 1083 esp_advance_phase(SCptr, in_slct_stop); 1084 } else { 1085 the_esp_command = (ESP_CMD_SELA | ESP_CMD_DMA); 1086 esp_advance_phase(SCptr, in_slct_norm); 1087 } 1088 } else if(!(esp->targets_present & (1<<target)) || !(esp_dev->disconnect)) { 1089 /* After the bootup SCSI code sends both the 1090 * TEST_UNIT_READY and INQUIRY commands we want 1091 * to at least attempt allowing the device to 1092 * disconnect. 1093 */ 1094 ESPMISC(("esp: Selecting device for first time. target=%d " 1095 "lun=%d\n", target, SCptr->device->lun)); 1096 if(!SDptr->borken && !esp_dev->disconnect) 1097 esp_dev->disconnect = 1; 1098 1099 *cmdp++ = IDENTIFY(0, lun); 1100 esp->prevmsgout = NOP; 1101 esp_advance_phase(SCptr, in_slct_norm); 1102 the_esp_command = (ESP_CMD_SELA | ESP_CMD_DMA); 1103 1104 /* Take no chances... */ 1105 esp_dev->sync_max_offset = 0; 1106 esp_dev->sync_min_period = 0; 1107 } else { 1108 int toshiba_cdrom_hwbug_wkaround = 0; 1109 1110#ifdef CONFIG_SCSI_MAC_ESP 1111 /* Never allow synchronous transfers (disconnect OK) on 1112 * Macintosh. Well, maybe later when we figured out how to 1113 * do DMA on the machines that support it ... 1114 */ 1115 esp_dev->disconnect = 1; 1116 esp_dev->sync_max_offset = 0; 1117 esp_dev->sync_min_period = 0; 1118 esp_dev->sync = 1; 1119 esp->snip = 0; 1120 goto do_sync_known; 1121#endif 1122 /* We've talked to this guy before, 1123 * but never negotiated. Let's try 1124 * sync negotiation. 1125 */ 1126 if(!SDptr->borken) { 1127 if((SDptr->type == TYPE_ROM) && 1128 (!strncmp(SDptr->vendor, "TOSHIBA", 7))) { 1129 /* Nice try sucker... */ 1130 ESPMISC(("esp%d: Disabling sync for buggy " 1131 "Toshiba CDROM.\n", esp->esp_id)); 1132 toshiba_cdrom_hwbug_wkaround = 1; 1133 build_sync_nego_msg(esp, 0, 0); 1134 } else { 1135 build_sync_nego_msg(esp, esp->sync_defp, 15); 1136 } 1137 } else { 1138 build_sync_nego_msg(esp, 0, 0); 1139 } 1140 esp_dev->sync = 1; 1141 esp->snip = 1; 1142 1143 /* A fix for broken SCSI1 targets, when they disconnect 1144 * they lock up the bus and confuse ESP. So disallow 1145 * disconnects for SCSI1 targets for now until we 1146 * find a better fix. 1147 * 1148 * Addendum: This is funny, I figured out what was going 1149 * on. The blotzed SCSI1 target would disconnect, 1150 * one of the other SCSI2 targets or both would be 1151 * disconnected as well. The SCSI1 target would 1152 * stay disconnected long enough that we start 1153 * up a command on one of the SCSI2 targets. As 1154 * the ESP is arbitrating for the bus the SCSI1 1155 * target begins to arbitrate as well to reselect 1156 * the ESP. The SCSI1 target refuses to drop it's 1157 * ID bit on the data bus even though the ESP is 1158 * at ID 7 and is the obvious winner for any 1159 * arbitration. The ESP is a poor sport and refuses 1160 * to lose arbitration, it will continue indefinitely 1161 * trying to arbitrate for the bus and can only be 1162 * stopped via a chip reset or SCSI bus reset. 1163 * Therefore _no_ disconnects for SCSI1 targets 1164 * thank you very much. ;-) 1165 */ 1166 if(((SDptr->scsi_level < 3) && (SDptr->type != TYPE_TAPE)) || 1167 toshiba_cdrom_hwbug_wkaround || SDptr->borken) { 1168 ESPMISC((KERN_INFO "esp%d: Disabling DISCONNECT for target %d " 1169 "lun %d\n", esp->esp_id, SCptr->device->id, SCptr->device->lun)); 1170 esp_dev->disconnect = 0; 1171 *cmdp++ = IDENTIFY(0, lun); 1172 } else { 1173 *cmdp++ = IDENTIFY(1, lun); 1174 } 1175 1176 /* ESP fifo is only so big... 1177 * Make this look like a slow command. 1178 */ 1179 esp->esp_slowcmd = 1; 1180 esp->esp_scmdleft = SCptr->cmd_len; 1181 esp->esp_scmdp = &SCptr->cmnd[0]; 1182 1183 the_esp_command = (ESP_CMD_SELAS | ESP_CMD_DMA); 1184 esp_advance_phase(SCptr, in_slct_msg); 1185 } 1186 1187 if(!esp->esp_slowcmd) 1188 for(i = 0; i < SCptr->cmd_len; i++) 1189 *cmdp++ = SCptr->cmnd[i]; 1190 1191 esp_write(eregs->esp_busid, (target & 7)); 1192 if (esp->prev_soff != esp_dev->sync_max_offset || 1193 esp->prev_stp != esp_dev->sync_min_period || 1194 (esp->erev > esp100a && 1195 esp->prev_cfg3 != esp->config3[target])) { 1196 esp->prev_soff = esp_dev->sync_max_offset; 1197 esp_write(eregs->esp_soff, esp->prev_soff); 1198 esp->prev_stp = esp_dev->sync_min_period; 1199 esp_write(eregs->esp_stp, esp->prev_stp); 1200 if(esp->erev > esp100a) { 1201 esp->prev_cfg3 = esp->config3[target]; 1202 esp_write(eregs->esp_cfg3, esp->prev_cfg3); 1203 } 1204 } 1205 i = (cmdp - esp->esp_command); 1206 1207 /* Set up the DMA and ESP counters */ 1208 if(esp->do_pio_cmds){ 1209 int j = 0; 1210 1211 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 1212 1213 for(;j<i;j++) 1214 esp_write(eregs->esp_fdata, esp->esp_command[j]); 1215 the_esp_command &= ~ESP_CMD_DMA; 1216 1217 /* Tell ESP to "go". */ 1218 esp_cmd(esp, eregs, the_esp_command); 1219 } else { 1220 /* Set up the ESP counters */ 1221 esp_write(eregs->esp_tclow, i); 1222 esp_write(eregs->esp_tcmed, 0); 1223 esp->dma_init_write(esp, esp->esp_command_dvma, i); 1224 1225 /* Tell ESP to "go". */ 1226 esp_cmd(esp, eregs, the_esp_command); 1227 } 1228} 1229 1230/* Queue a SCSI command delivered from the mid-level Linux SCSI code. */ 1231int esp_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) 1232{ 1233 struct NCR_ESP *esp; 1234 1235 /* Set up func ptr and initial driver cmd-phase. */ 1236 SCpnt->scsi_done = done; 1237 SCpnt->SCp.phase = not_issued; 1238 1239 esp = (struct NCR_ESP *) SCpnt->device->host->hostdata; 1240 1241 if(esp->dma_led_on) 1242 esp->dma_led_on(esp); 1243 1244 /* We use the scratch area. */ 1245 ESPQUEUE(("esp_queue: target=%d lun=%d ", SCpnt->device->id, SCpnt->lun)); 1246 ESPDISC(("N<%02x,%02x>", SCpnt->device->id, SCpnt->lun)); 1247 1248 esp_get_dmabufs(esp, SCpnt); 1249 esp_save_pointers(esp, SCpnt); 1250 1251 SCpnt->SCp.Status = CHECK_CONDITION; 1252 SCpnt->SCp.Message = 0xff; 1253 SCpnt->SCp.sent_command = 0; 1254 1255 /* Place into our queue. */ 1256 if(SCpnt->cmnd[0] == REQUEST_SENSE) { 1257 ESPQUEUE(("RQSENSE\n")); 1258 prepend_SC(&esp->issue_SC, SCpnt); 1259 } else { 1260 ESPQUEUE(("\n")); 1261 append_SC(&esp->issue_SC, SCpnt); 1262 } 1263 1264 /* Run it now if we can. */ 1265 if(!esp->current_SC && !esp->resetting_bus) 1266 esp_exec_cmd(esp); 1267 1268 return 0; 1269} 1270 1271/* Dump driver state. */ 1272static void esp_dump_cmd(Scsi_Cmnd *SCptr) 1273{ 1274 ESPLOG(("[tgt<%02x> lun<%02x> " 1275 "pphase<%s> cphase<%s>]", 1276 SCptr->device->id, SCptr->device->lun, 1277 phase_string(SCptr->SCp.sent_command), 1278 phase_string(SCptr->SCp.phase))); 1279} 1280 1281static void esp_dump_state(struct NCR_ESP *esp, 1282 struct ESP_regs *eregs) 1283{ 1284 Scsi_Cmnd *SCptr = esp->current_SC; 1285#ifdef DEBUG_ESP_CMDS 1286 int i; 1287#endif 1288 1289 ESPLOG(("esp%d: dumping state\n", esp->esp_id)); 1290 1291 /* Print DMA status */ 1292 esp->dma_dump_state(esp); 1293 1294 ESPLOG(("esp%d: SW [sreg<%02x> sstep<%02x> ireg<%02x>]\n", 1295 esp->esp_id, esp->sreg, esp->seqreg, esp->ireg)); 1296 ESPLOG(("esp%d: HW reread [sreg<%02x> sstep<%02x> ireg<%02x>]\n", 1297 esp->esp_id, esp_read(eregs->esp_status), esp_read(eregs->esp_sstep), 1298 esp_read(eregs->esp_intrpt))); 1299#ifdef DEBUG_ESP_CMDS 1300 printk("esp%d: last ESP cmds [", esp->esp_id); 1301 i = (esp->espcmdent - 1) & 31; 1302 printk("<"); 1303 esp_print_cmd(esp->espcmdlog[i]); 1304 printk(">"); 1305 i = (i - 1) & 31; 1306 printk("<"); 1307 esp_print_cmd(esp->espcmdlog[i]); 1308 printk(">"); 1309 i = (i - 1) & 31; 1310 printk("<"); 1311 esp_print_cmd(esp->espcmdlog[i]); 1312 printk(">"); 1313 i = (i - 1) & 31; 1314 printk("<"); 1315 esp_print_cmd(esp->espcmdlog[i]); 1316 printk(">"); 1317 printk("]\n"); 1318#endif /* (DEBUG_ESP_CMDS) */ 1319 1320 if(SCptr) { 1321 ESPLOG(("esp%d: current command ", esp->esp_id)); 1322 esp_dump_cmd(SCptr); 1323 } 1324 ESPLOG(("\n")); 1325 SCptr = esp->disconnected_SC; 1326 ESPLOG(("esp%d: disconnected ", esp->esp_id)); 1327 while(SCptr) { 1328 esp_dump_cmd(SCptr); 1329 SCptr = (Scsi_Cmnd *) SCptr->host_scribble; 1330 } 1331 ESPLOG(("\n")); 1332} 1333 1334/* Abort a command. The host_lock is acquired by caller. */ 1335int esp_abort(Scsi_Cmnd *SCptr) 1336{ 1337 struct NCR_ESP *esp = (struct NCR_ESP *) SCptr->device->host->hostdata; 1338 struct ESP_regs *eregs = esp->eregs; 1339 int don; 1340 1341 ESPLOG(("esp%d: Aborting command\n", esp->esp_id)); 1342 esp_dump_state(esp, eregs); 1343 1344 /* Wheee, if this is the current command on the bus, the 1345 * best we can do is assert ATN and wait for msgout phase. 1346 * This should even fix a hung SCSI bus when we lose state 1347 * in the driver and timeout because the eventual phase change 1348 * will cause the ESP to (eventually) give an interrupt. 1349 */ 1350 if(esp->current_SC == SCptr) { 1351 esp->cur_msgout[0] = ABORT; 1352 esp->msgout_len = 1; 1353 esp->msgout_ctr = 0; 1354 esp_cmd(esp, eregs, ESP_CMD_SATN); 1355 return SUCCESS; 1356 } 1357 1358 /* If it is still in the issue queue then we can safely 1359 * call the completion routine and report abort success. 1360 */ 1361 don = esp->dma_ports_p(esp); 1362 if(don) { 1363 esp->dma_ints_off(esp); 1364 synchronize_irq(esp->irq); 1365 } 1366 if(esp->issue_SC) { 1367 Scsi_Cmnd **prev, *this; 1368 for(prev = (&esp->issue_SC), this = esp->issue_SC; 1369 this; 1370 prev = (Scsi_Cmnd **) &(this->host_scribble), 1371 this = (Scsi_Cmnd *) this->host_scribble) { 1372 if(this == SCptr) { 1373 *prev = (Scsi_Cmnd *) this->host_scribble; 1374 this->host_scribble = NULL; 1375 esp_release_dmabufs(esp, this); 1376 this->result = DID_ABORT << 16; 1377 this->done(this); 1378 if(don) 1379 esp->dma_ints_on(esp); 1380 return SUCCESS; 1381 } 1382 } 1383 } 1384 1385 /* Yuck, the command to abort is disconnected, it is not 1386 * worth trying to abort it now if something else is live 1387 * on the bus at this time. So, we let the SCSI code wait 1388 * a little bit and try again later. 1389 */ 1390 if(esp->current_SC) { 1391 if(don) 1392 esp->dma_ints_on(esp); 1393 return FAILED; 1394 } 1395 1396 /* It's disconnected, we have to reconnect to re-establish 1397 * the nexus and tell the device to abort. However, we really 1398 * cannot 'reconnect' per se. Don't try to be fancy, just 1399 * indicate failure, which causes our caller to reset the whole 1400 * bus. 1401 */ 1402 1403 if(don) 1404 esp->dma_ints_on(esp); 1405 return FAILED; 1406} 1407 1408/* We've sent ESP_CMD_RS to the ESP, the interrupt had just 1409 * arrived indicating the end of the SCSI bus reset. Our job 1410 * is to clean out the command queues and begin re-execution 1411 * of SCSI commands once more. 1412 */ 1413static int esp_finish_reset(struct NCR_ESP *esp, 1414 struct ESP_regs *eregs) 1415{ 1416 Scsi_Cmnd *sp = esp->current_SC; 1417 1418 /* Clean up currently executing command, if any. */ 1419 if (sp != NULL) { 1420 esp_release_dmabufs(esp, sp); 1421 sp->result = (DID_RESET << 16); 1422 sp->scsi_done(sp); 1423 esp->current_SC = NULL; 1424 } 1425 1426 /* Clean up disconnected queue, they have been invalidated 1427 * by the bus reset. 1428 */ 1429 if (esp->disconnected_SC) { 1430 while((sp = remove_first_SC(&esp->disconnected_SC)) != NULL) { 1431 esp_release_dmabufs(esp, sp); 1432 sp->result = (DID_RESET << 16); 1433 sp->scsi_done(sp); 1434 } 1435 } 1436 1437 /* SCSI bus reset is complete. */ 1438 esp->resetting_bus = 0; 1439 wake_up(&esp->reset_queue); 1440 1441 /* Ok, now it is safe to get commands going once more. */ 1442 if(esp->issue_SC) 1443 esp_exec_cmd(esp); 1444 1445 return do_intr_end; 1446} 1447 1448static int esp_do_resetbus(struct NCR_ESP *esp, 1449 struct ESP_regs *eregs) 1450{ 1451 ESPLOG(("esp%d: Resetting scsi bus\n", esp->esp_id)); 1452 esp->resetting_bus = 1; 1453 esp_cmd(esp, eregs, ESP_CMD_RS); 1454 1455 return do_intr_end; 1456} 1457 1458/* Reset ESP chip, reset hanging bus, then kill active and 1459 * disconnected commands for targets without soft reset. 1460 * 1461 * The host_lock is acquired by caller. 1462 */ 1463int esp_reset(Scsi_Cmnd *SCptr) 1464{ 1465 struct NCR_ESP *esp = (struct NCR_ESP *) SCptr->device->host->hostdata; 1466 1467 spin_lock_irq(esp->ehost->host_lock); 1468 (void) esp_do_resetbus(esp, esp->eregs); 1469 spin_unlock_irq(esp->ehost->host_lock); 1470 1471 wait_event(esp->reset_queue, (esp->resetting_bus == 0)); 1472 1473 return SUCCESS; 1474} 1475 1476/* Internal ESP done function. */ 1477static void esp_done(struct NCR_ESP *esp, int error) 1478{ 1479 Scsi_Cmnd *done_SC; 1480 1481 if(esp->current_SC) { 1482 done_SC = esp->current_SC; 1483 esp->current_SC = NULL; 1484 esp_release_dmabufs(esp, done_SC); 1485 done_SC->result = error; 1486 done_SC->scsi_done(done_SC); 1487 1488 /* Bus is free, issue any commands in the queue. */ 1489 if(esp->issue_SC && !esp->current_SC) 1490 esp_exec_cmd(esp); 1491 } else { 1492 /* Panic is safe as current_SC is null so we may still 1493 * be able to accept more commands to sync disk buffers. 1494 */ 1495 ESPLOG(("panicing\n")); 1496 panic("esp: done() called with NULL esp->current_SC"); 1497 } 1498} 1499 1500/* Wheee, ESP interrupt engine. */ 1501 1502/* Forward declarations. */ 1503static int esp_do_phase_determine(struct NCR_ESP *esp, 1504 struct ESP_regs *eregs); 1505static int esp_do_data_finale(struct NCR_ESP *esp, struct ESP_regs *eregs); 1506static int esp_select_complete(struct NCR_ESP *esp, struct ESP_regs *eregs); 1507static int esp_do_status(struct NCR_ESP *esp, struct ESP_regs *eregs); 1508static int esp_do_msgin(struct NCR_ESP *esp, struct ESP_regs *eregs); 1509static int esp_do_msgindone(struct NCR_ESP *esp, struct ESP_regs *eregs); 1510static int esp_do_msgout(struct NCR_ESP *esp, struct ESP_regs *eregs); 1511static int esp_do_cmdbegin(struct NCR_ESP *esp, struct ESP_regs *eregs); 1512 1513#define sreg_datainp(__sreg) (((__sreg) & ESP_STAT_PMASK) == ESP_DIP) 1514#define sreg_dataoutp(__sreg) (((__sreg) & ESP_STAT_PMASK) == ESP_DOP) 1515 1516/* We try to avoid some interrupts by jumping ahead and see if the ESP 1517 * has gotten far enough yet. Hence the following. 1518 */ 1519static inline int skipahead1(struct NCR_ESP *esp, struct ESP_regs *eregs, 1520 Scsi_Cmnd *scp, int prev_phase, int new_phase) 1521{ 1522 if(scp->SCp.sent_command != prev_phase) 1523 return 0; 1524 1525 if(esp->dma_irq_p(esp)) { 1526 /* Yes, we are able to save an interrupt. */ 1527 esp->sreg = (esp_read(eregs->esp_status) & ~(ESP_STAT_INTR)); 1528 esp->ireg = esp_read(eregs->esp_intrpt); 1529 if(!(esp->ireg & ESP_INTR_SR)) 1530 return 0; 1531 else 1532 return do_reset_complete; 1533 } 1534 /* Ho hum, target is taking forever... */ 1535 scp->SCp.sent_command = new_phase; /* so we don't recurse... */ 1536 return do_intr_end; 1537} 1538 1539static inline int skipahead2(struct NCR_ESP *esp, 1540 struct ESP_regs *eregs, 1541 Scsi_Cmnd *scp, int prev_phase1, int prev_phase2, 1542 int new_phase) 1543{ 1544 if(scp->SCp.sent_command != prev_phase1 && 1545 scp->SCp.sent_command != prev_phase2) 1546 return 0; 1547 if(esp->dma_irq_p(esp)) { 1548 /* Yes, we are able to save an interrupt. */ 1549 esp->sreg = (esp_read(eregs->esp_status) & ~(ESP_STAT_INTR)); 1550 esp->ireg = esp_read(eregs->esp_intrpt); 1551 if(!(esp->ireg & ESP_INTR_SR)) 1552 return 0; 1553 else 1554 return do_reset_complete; 1555 } 1556 /* Ho hum, target is taking forever... */ 1557 scp->SCp.sent_command = new_phase; /* so we don't recurse... */ 1558 return do_intr_end; 1559} 1560 1561/* Misc. esp helper macros. */ 1562#define esp_setcount(__eregs, __cnt) \ 1563 esp_write((__eregs)->esp_tclow, ((__cnt) & 0xff)); \ 1564 esp_write((__eregs)->esp_tcmed, (((__cnt) >> 8) & 0xff)) 1565 1566#define esp_getcount(__eregs) \ 1567 ((esp_read((__eregs)->esp_tclow)&0xff) | \ 1568 ((esp_read((__eregs)->esp_tcmed)&0xff) << 8)) 1569 1570#define fcount(__esp, __eregs) \ 1571 (esp_read((__eregs)->esp_fflags) & ESP_FF_FBYTES) 1572 1573#define fnzero(__esp, __eregs) \ 1574 (esp_read((__eregs)->esp_fflags) & ESP_FF_ONOTZERO) 1575 1576#define esp_maybe_nop(__esp, __eregs) \ 1577 if((__esp)->erev == esp100) \ 1578 esp_cmd((__esp), (__eregs), ESP_CMD_NULL) 1579 1580#define sreg_to_dataphase(__sreg) \ 1581 ((((__sreg) & ESP_STAT_PMASK) == ESP_DOP) ? in_dataout : in_datain) 1582 1583/* The ESP100 when in synchronous data phase, can mistake a long final 1584 * REQ pulse from the target as an extra byte, it places whatever is on 1585 * the data lines into the fifo. For now, we will assume when this 1586 * happens that the target is a bit quirky and we don't want to 1587 * be talking synchronously to it anyways. Regardless, we need to 1588 * tell the ESP to eat the extraneous byte so that we can proceed 1589 * to the next phase. 1590 */ 1591static inline int esp100_sync_hwbug(struct NCR_ESP *esp, struct ESP_regs *eregs, 1592 Scsi_Cmnd *sp, int fifocnt) 1593{ 1594 /* Do not touch this piece of code. */ 1595 if((!(esp->erev == esp100)) || 1596 (!(sreg_datainp((esp->sreg = esp_read(eregs->esp_status))) && !fifocnt) && 1597 !(sreg_dataoutp(esp->sreg) && !fnzero(esp, eregs)))) { 1598 if(sp->SCp.phase == in_dataout) 1599 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 1600 return 0; 1601 } else { 1602 /* Async mode for this guy. */ 1603 build_sync_nego_msg(esp, 0, 0); 1604 1605 /* Ack the bogus byte, but set ATN first. */ 1606 esp_cmd(esp, eregs, ESP_CMD_SATN); 1607 esp_cmd(esp, eregs, ESP_CMD_MOK); 1608 return 1; 1609 } 1610} 1611 1612/* This closes the window during a selection with a reselect pending, because 1613 * we use DMA for the selection process the FIFO should hold the correct 1614 * contents if we get reselected during this process. So we just need to 1615 * ack the possible illegal cmd interrupt pending on the esp100. 1616 */ 1617static inline int esp100_reconnect_hwbug(struct NCR_ESP *esp, 1618 struct ESP_regs *eregs) 1619{ 1620 volatile unchar junk; 1621 1622 if(esp->erev != esp100) 1623 return 0; 1624 junk = esp_read(eregs->esp_intrpt); 1625 1626 if(junk & ESP_INTR_SR) 1627 return 1; 1628 return 0; 1629} 1630 1631/* This verifies the BUSID bits during a reselection so that we know which 1632 * target is talking to us. 1633 */ 1634static inline int reconnect_target(struct NCR_ESP *esp, struct ESP_regs *eregs) 1635{ 1636 int it, me = esp->scsi_id_mask, targ = 0; 1637 1638 if(2 != fcount(esp, eregs)) 1639 return -1; 1640 it = esp_read(eregs->esp_fdata); 1641 if(!(it & me)) 1642 return -1; 1643 it &= ~me; 1644 if(it & (it - 1)) 1645 return -1; 1646 while(!(it & 1)) 1647 targ++, it >>= 1; 1648 return targ; 1649} 1650 1651/* This verifies the identify from the target so that we know which lun is 1652 * being reconnected. 1653 */ 1654static inline int reconnect_lun(struct NCR_ESP *esp, struct ESP_regs *eregs) 1655{ 1656 int lun; 1657 1658 if((esp->sreg & ESP_STAT_PMASK) != ESP_MIP) 1659 return -1; 1660 lun = esp_read(eregs->esp_fdata); 1661 1662 /* Yes, you read this correctly. We report lun of zero 1663 * if we see parity error. ESP reports parity error for 1664 * the lun byte, and this is the only way to hope to recover 1665 * because the target is connected. 1666 */ 1667 if(esp->sreg & ESP_STAT_PERR) 1668 return 0; 1669 1670 /* Check for illegal bits being set in the lun. */ 1671 if((lun & 0x40) || !(lun & 0x80)) 1672 return -1; 1673 1674 return lun & 7; 1675} 1676 1677/* This puts the driver in a state where it can revitalize a command that 1678 * is being continued due to reselection. 1679 */ 1680static inline void esp_connect(struct NCR_ESP *esp, struct ESP_regs *eregs, 1681 Scsi_Cmnd *sp) 1682{ 1683 struct scsi_device *dp = sp->device; 1684 struct esp_device *esp_dev = dp->hostdata; 1685 1686 if(esp->prev_soff != esp_dev->sync_max_offset || 1687 esp->prev_stp != esp_dev->sync_min_period || 1688 (esp->erev > esp100a && 1689 esp->prev_cfg3 != esp->config3[scmd_id(sp)])) { 1690 esp->prev_soff = esp_dev->sync_max_offset; 1691 esp_write(eregs->esp_soff, esp->prev_soff); 1692 esp->prev_stp = esp_dev->sync_min_period; 1693 esp_write(eregs->esp_stp, esp->prev_stp); 1694 if(esp->erev > esp100a) { 1695 esp->prev_cfg3 = esp->config3[scmd_id(sp)]; 1696 esp_write(eregs->esp_cfg3, esp->prev_cfg3); 1697 } 1698 } 1699 esp->current_SC = sp; 1700} 1701 1702/* This will place the current working command back into the issue queue 1703 * if we are to receive a reselection amidst a selection attempt. 1704 */ 1705static inline void esp_reconnect(struct NCR_ESP *esp, Scsi_Cmnd *sp) 1706{ 1707 if(!esp->disconnected_SC) 1708 ESPLOG(("esp%d: Weird, being reselected but disconnected " 1709 "command queue is empty.\n", esp->esp_id)); 1710 esp->snip = 0; 1711 esp->current_SC = NULL; 1712 sp->SCp.phase = not_issued; 1713 append_SC(&esp->issue_SC, sp); 1714} 1715 1716/* Begin message in phase. */ 1717static int esp_do_msgin(struct NCR_ESP *esp, struct ESP_regs *eregs) 1718{ 1719 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 1720 esp_maybe_nop(esp, eregs); 1721 esp_cmd(esp, eregs, ESP_CMD_TI); 1722 esp->msgin_len = 1; 1723 esp->msgin_ctr = 0; 1724 esp_advance_phase(esp->current_SC, in_msgindone); 1725 return do_work_bus; 1726} 1727 1728static inline void advance_sg(struct NCR_ESP *esp, Scsi_Cmnd *sp) 1729{ 1730 ++sp->SCp.buffer; 1731 --sp->SCp.buffers_residual; 1732 sp->SCp.this_residual = sp->SCp.buffer->length; 1733 if (esp->dma_advance_sg) 1734 esp->dma_advance_sg (sp); 1735 else 1736 sp->SCp.ptr = (char *) virt_to_phys((page_address(sp->SCp.buffer->page) + sp->SCp.buffer->offset)); 1737 1738} 1739 1740/* Please note that the way I've coded these routines is that I _always_ 1741 * check for a disconnect during any and all information transfer 1742 * phases. The SCSI standard states that the target _can_ cause a BUS 1743 * FREE condition by dropping all MSG/CD/IO/BSY signals. Also note 1744 * that during information transfer phases the target controls every 1745 * change in phase, the only thing the initiator can do is "ask" for 1746 * a message out phase by driving ATN true. The target can, and sometimes 1747 * will, completely ignore this request so we cannot assume anything when 1748 * we try to force a message out phase to abort/reset a target. Most of 1749 * the time the target will eventually be nice and go to message out, so 1750 * we may have to hold on to our state about what we want to tell the target 1751 * for some period of time. 1752 */ 1753 1754/* I think I have things working here correctly. Even partial transfers 1755 * within a buffer or sub-buffer should not upset us at all no matter 1756 * how bad the target and/or ESP fucks things up. 1757 */ 1758static int esp_do_data(struct NCR_ESP *esp, struct ESP_regs *eregs) 1759{ 1760 Scsi_Cmnd *SCptr = esp->current_SC; 1761 int thisphase, hmuch; 1762 1763 ESPDATA(("esp_do_data: ")); 1764 esp_maybe_nop(esp, eregs); 1765 thisphase = sreg_to_dataphase(esp->sreg); 1766 esp_advance_phase(SCptr, thisphase); 1767 ESPDATA(("newphase<%s> ", (thisphase == in_datain) ? "DATAIN" : "DATAOUT")); 1768 hmuch = esp->dma_can_transfer(esp, SCptr); 1769 1770 if (hmuch) { /* DMA */ 1771 /* 1772 * DMA 1773 */ 1774 ESPDATA(("hmuch<%d> ", hmuch)); 1775 esp->current_transfer_size = hmuch; 1776 esp_setcount(eregs, (esp->fas_premature_intr_workaround ? 1777 (hmuch + 0x40) : hmuch)); 1778 esp->dma_setup(esp, (__u32)((unsigned long)SCptr->SCp.ptr), 1779 hmuch, (thisphase == in_datain)); 1780 ESPDATA(("DMA|TI --> do_intr_end\n")); 1781 esp_cmd(esp, eregs, ESP_CMD_DMA | ESP_CMD_TI); 1782 return do_intr_end; 1783 /* 1784 * end DMA 1785 */ 1786 } else { 1787 /* 1788 * PIO 1789 */ 1790 int oldphase, i = 0; /* or where we left off last time ?? esp->current_data ?? */ 1791 int fifocnt = 0; 1792 unsigned char *p = phys_to_virt((unsigned long)SCptr->SCp.ptr); 1793 1794 oldphase = esp_read(eregs->esp_status) & ESP_STAT_PMASK; 1795 1796 /* 1797 * polled transfer; ugly, can we make this happen in a DRQ 1798 * interrupt handler ?? 1799 * requires keeping track of state information in host or 1800 * command struct! 1801 * Problem: I've never seen a DRQ happen on Mac, not even 1802 * with ESP_CMD_DMA ... 1803 */ 1804 1805 /* figure out how much needs to be transferred */ 1806 hmuch = SCptr->SCp.this_residual; 1807 ESPDATA(("hmuch<%d> pio ", hmuch)); 1808 esp->current_transfer_size = hmuch; 1809 1810 /* tell the ESP ... */ 1811 esp_setcount(eregs, hmuch); 1812 1813 /* loop */ 1814 while (hmuch) { 1815 int j, fifo_stuck = 0, newphase; 1816 unsigned long timeout; 1817 if(thisphase == in_datain) { 1818 /* 'go' ... */ 1819 esp_cmd(esp, eregs, ESP_CMD_TI); 1820 1821 /* wait for data */ 1822 timeout = 1000000; 1823 while (!((esp->sreg=esp_read(eregs->esp_status)) & ESP_STAT_INTR) && --timeout) 1824 udelay(2); 1825 if (timeout == 0) 1826 printk("DRQ datain timeout! \n"); 1827 1828 newphase = esp->sreg & ESP_STAT_PMASK; 1829 1830 /* see how much we got ... */ 1831 fifocnt = (esp_read(eregs->esp_fflags) & ESP_FF_FBYTES); 1832 1833 if (!fifocnt) 1834 fifo_stuck++; 1835 else 1836 fifo_stuck = 0; 1837 1838 ESPDATA(("\rgot %d st %x ph %x", fifocnt, esp->sreg, newphase)); 1839 1840 /* read fifo */ 1841 for(j=0;j<fifocnt;j++) 1842 p[i++] = esp_read(eregs->esp_fdata); 1843 1844 ESPDATA(("(%d) ", i)); 1845 1846 /* how many to go ?? */ 1847 hmuch -= fifocnt; 1848 1849 /* break if status phase !! */ 1850 if(newphase == ESP_STATP) { 1851 /* clear int. */ 1852 esp->ireg = esp_read(eregs->esp_intrpt); 1853 break; 1854 } 1855 } else { 1856#define MAX_FIFO 8 1857 /* how much will fit ? */ 1858 int this_count = MAX_FIFO - fifocnt; 1859 if (this_count > hmuch) 1860 this_count = hmuch; 1861 1862 /* fill fifo */ 1863 for(j=0;j<this_count;j++) 1864 esp_write(eregs->esp_fdata, p[i++]); 1865 1866 /* how many left if this goes out ?? */ 1867 hmuch -= this_count; 1868 1869 /* 'go' ... */ 1870 esp_cmd(esp, eregs, ESP_CMD_TI); 1871 1872 /* wait for 'got it' */ 1873 timeout = 1000000; 1874 while (!((esp->sreg=esp_read(eregs->esp_status)) & ESP_STAT_INTR) && --timeout) 1875 udelay(2); 1876 if (timeout == 0) 1877 printk("DRQ dataout timeout! \n"); 1878 1879 newphase = esp->sreg & ESP_STAT_PMASK; 1880 1881 /* need to check how much was sent ?? */ 1882 fifocnt = (esp_read(eregs->esp_fflags) & ESP_FF_FBYTES); 1883 1884 ESPDATA(("\rsent %d st %x ph %x", this_count - fifocnt, esp->sreg, newphase)); 1885 1886 ESPDATA(("(%d) ", i)); 1887 1888 /* break if status phase !! */ 1889 if(newphase == ESP_STATP) { 1890 /* clear int. */ 1891 esp->ireg = esp_read(eregs->esp_intrpt); 1892 break; 1893 } 1894 1895 } 1896 1897 /* clear int. */ 1898 esp->ireg = esp_read(eregs->esp_intrpt); 1899 1900 ESPDATA(("ir %x ... ", esp->ireg)); 1901 1902 if (hmuch == 0) 1903 ESPDATA(("done! \n")); 1904 1905 1906 /* check new bus phase */ 1907 if (newphase != oldphase && i < esp->current_transfer_size) { 1908 /* something happened; disconnect ?? */ 1909 ESPDATA(("phase change, dropped out with %d done ... ", i)); 1910 break; 1911 } 1912 1913 /* check int. status */ 1914 if (esp->ireg & ESP_INTR_DC) { 1915 /* disconnect */ 1916 ESPDATA(("disconnect; %d transferred ... ", i)); 1917 break; 1918 } else if (esp->ireg & ESP_INTR_FDONE) { 1919 /* function done */ 1920 ESPDATA(("function done; %d transferred ... ", i)); 1921 break; 1922 } 1923 1924 if (fifo_stuck > 10) { 1925 /* we're stuck */ 1926 ESPDATA(("fifo stall; %d transferred ... ", i)); 1927 break; 1928 } 1929 } 1930 1931 ESPDATA(("\n")); 1932 /* check successful completion ?? */ 1933 1934 if (thisphase == in_dataout) 1935 hmuch += fifocnt; /* stuck?? adjust data pointer ...*/ 1936 1937 /* tell do_data_finale how much was transferred */ 1938 esp->current_transfer_size -= hmuch; 1939 1940 /* still not completely sure on this one ... */ 1941 return /*do_intr_end*/ do_work_bus /*do_phase_determine*/ ; 1942 1943 /* 1944 * end PIO 1945 */ 1946 } 1947 return do_intr_end; 1948} 1949 1950/* See how successful the data transfer was. */ 1951static int esp_do_data_finale(struct NCR_ESP *esp, 1952 struct ESP_regs *eregs) 1953{ 1954 Scsi_Cmnd *SCptr = esp->current_SC; 1955 struct esp_device *esp_dev = SCptr->device->hostdata; 1956 int bogus_data = 0, bytes_sent = 0, fifocnt, ecount = 0; 1957 1958 if(esp->dma_led_off) 1959 esp->dma_led_off(esp); 1960 1961 ESPDATA(("esp_do_data_finale: ")); 1962 1963 if(SCptr->SCp.phase == in_datain) { 1964 if(esp->sreg & ESP_STAT_PERR) { 1965 /* Yuck, parity error. The ESP asserts ATN 1966 * so that we can go to message out phase 1967 * immediately and inform the target that 1968 * something bad happened. 1969 */ 1970 ESPLOG(("esp%d: data bad parity detected.\n", 1971 esp->esp_id)); 1972 esp->cur_msgout[0] = INITIATOR_ERROR; 1973 esp->msgout_len = 1; 1974 } 1975 if(esp->dma_drain) 1976 esp->dma_drain(esp); 1977 } 1978 if(esp->dma_invalidate) 1979 esp->dma_invalidate(esp); 1980 1981 /* This could happen for the above parity error case. */ 1982 if(!(esp->ireg == ESP_INTR_BSERV)) { 1983 /* Please go to msgout phase, please please please... */ 1984 ESPLOG(("esp%d: !BSERV after data, probably to msgout\n", 1985 esp->esp_id)); 1986 return esp_do_phase_determine(esp, eregs); 1987 } 1988 1989 /* Check for partial transfers and other horrible events. */ 1990 fifocnt = (esp_read(eregs->esp_fflags) & ESP_FF_FBYTES); 1991 ecount = esp_getcount(eregs); 1992 if(esp->fas_premature_intr_workaround) 1993 ecount -= 0x40; 1994 bytes_sent = esp->current_transfer_size; 1995 1996 ESPDATA(("trans_sz=%d, ", bytes_sent)); 1997 if(!(esp->sreg & ESP_STAT_TCNT)) 1998 bytes_sent -= ecount; 1999 if(SCptr->SCp.phase == in_dataout) 2000 bytes_sent -= fifocnt; 2001 2002 ESPDATA(("bytes_sent=%d (ecount=%d, fifocnt=%d), ", bytes_sent, 2003 ecount, fifocnt)); 2004 2005 /* If we were in synchronous mode, check for peculiarities. */ 2006 if(esp_dev->sync_max_offset) 2007 bogus_data = esp100_sync_hwbug(esp, eregs, SCptr, fifocnt); 2008 else 2009 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 2010 2011 /* Until we are sure of what has happened, we are certainly 2012 * in the dark. 2013 */ 2014 esp_advance_phase(SCptr, in_the_dark); 2015 2016 if(!esp->fas_premature_intr_workaround && (fifocnt == 1) && 2017 sreg_dataoutp(esp->sreg)) { 2018 ESPLOG(("esp%d: Premature interrupt, enabling workaround\n", 2019 esp->esp_id)); 2020 /* Just set the disconnected bit. That's what appears to 2021 * happen anyway. The state machine will pick it up when 2022 * we return. 2023 */ 2024 esp->ireg |= ESP_INTR_DC; 2025 } 2026 2027 if(bytes_sent < 0) { 2028 /* I've seen this happen due to lost state in this 2029 * driver. No idea why it happened, but allowing 2030 * this value to be negative caused things to 2031 * lock up. This allows greater chance of recovery. 2032 * In fact every time I've seen this, it has been 2033 * a driver bug without question. 2034 */ 2035 ESPLOG(("esp%d: yieee, bytes_sent < 0!\n", esp->esp_id)); 2036 ESPLOG(("esp%d: csz=%d fifocount=%d ecount=%d\n", 2037 esp->esp_id, 2038 esp->current_transfer_size, fifocnt, ecount)); 2039 ESPLOG(("esp%d: use_sg=%d ptr=%p this_residual=%d\n", 2040 esp->esp_id, 2041 SCptr->use_sg, SCptr->SCp.ptr, SCptr->SCp.this_residual)); 2042 ESPLOG(("esp%d: Forcing async for target %d\n", esp->esp_id, 2043 SCptr->device->id)); 2044 SCptr->device->borken = 1; 2045 esp_dev->sync = 0; 2046 bytes_sent = 0; 2047 } 2048 2049 /* Update the state of our transfer. */ 2050 SCptr->SCp.ptr += bytes_sent; 2051 SCptr->SCp.this_residual -= bytes_sent; 2052 if(SCptr->SCp.this_residual < 0) { 2053 /* shit */ 2054 ESPLOG(("esp%d: Data transfer overrun.\n", esp->esp_id)); 2055 SCptr->SCp.this_residual = 0; 2056 } 2057 2058 /* Maybe continue. */ 2059 if(!bogus_data) { 2060 ESPDATA(("!bogus_data, ")); 2061 /* NO MATTER WHAT, we advance the scatterlist, 2062 * if the target should decide to disconnect 2063 * in between scatter chunks (which is common) 2064 * we could die horribly! I used to have the sg 2065 * advance occur only if we are going back into 2066 * (or are staying in) a data phase, you can 2067 * imagine the hell I went through trying to 2068 * figure this out. 2069 */ 2070 if(!SCptr->SCp.this_residual && SCptr->SCp.buffers_residual) 2071 advance_sg(esp, SCptr); 2072#ifdef DEBUG_ESP_DATA 2073 if(sreg_datainp(esp->sreg) || sreg_dataoutp(esp->sreg)) { 2074 ESPDATA(("to more data\n")); 2075 } else { 2076 ESPDATA(("to new phase\n")); 2077 } 2078#endif 2079 return esp_do_phase_determine(esp, eregs); 2080 } 2081 /* Bogus data, just wait for next interrupt. */ 2082 ESPLOG(("esp%d: bogus_data during end of data phase\n", 2083 esp->esp_id)); 2084 return do_intr_end; 2085} 2086 2087/* We received a non-good status return at the end of 2088 * running a SCSI command. This is used to decide if 2089 * we should clear our synchronous transfer state for 2090 * such a device when that happens. 2091 * 2092 * The idea is that when spinning up a disk or rewinding 2093 * a tape, we don't want to go into a loop re-negotiating 2094 * synchronous capabilities over and over. 2095 */ 2096static int esp_should_clear_sync(Scsi_Cmnd *sp) 2097{ 2098 unchar cmd = sp->cmnd[0]; 2099 2100 /* These cases are for spinning up a disk and 2101 * waiting for that spinup to complete. 2102 */ 2103 if(cmd == START_STOP) 2104 return 0; 2105 2106 if(cmd == TEST_UNIT_READY) 2107 return 0; 2108 2109 /* One more special case for SCSI tape drives, 2110 * this is what is used to probe the device for 2111 * completion of a rewind or tape load operation. 2112 */ 2113 if(sp->device->type == TYPE_TAPE && cmd == MODE_SENSE) 2114 return 0; 2115 2116 return 1; 2117} 2118 2119/* Either a command is completing or a target is dropping off the bus 2120 * to continue the command in the background so we can do other work. 2121 */ 2122static int esp_do_freebus(struct NCR_ESP *esp, struct ESP_regs *eregs) 2123{ 2124 Scsi_Cmnd *SCptr = esp->current_SC; 2125 int rval; 2126 2127 rval = skipahead2(esp, eregs, SCptr, in_status, in_msgindone, in_freeing); 2128 if(rval) 2129 return rval; 2130 2131 if(esp->ireg != ESP_INTR_DC) { 2132 ESPLOG(("esp%d: Target will not disconnect\n", esp->esp_id)); 2133 return do_reset_bus; /* target will not drop BSY... */ 2134 } 2135 esp->msgout_len = 0; 2136 esp->prevmsgout = NOP; 2137 if(esp->prevmsgin == COMMAND_COMPLETE) { 2138 struct esp_device *esp_dev = SCptr->device->hostdata; 2139 /* Normal end of nexus. */ 2140 if(esp->disconnected_SC) 2141 esp_cmd(esp, eregs, ESP_CMD_ESEL); 2142 2143 if(SCptr->SCp.Status != GOOD && 2144 SCptr->SCp.Status != CONDITION_GOOD && 2145 ((1<<scmd_id(SCptr)) & esp->targets_present) && 2146 esp_dev->sync && esp_dev->sync_max_offset) { 2147 /* SCSI standard says that the synchronous capabilities 2148 * should be renegotiated at this point. Most likely 2149 * we are about to request sense from this target 2150 * in which case we want to avoid using sync 2151 * transfers until we are sure of the current target 2152 * state. 2153 */ 2154 ESPMISC(("esp: Status <%d> for target %d lun %d\n", 2155 SCptr->SCp.Status, SCptr->device->id, SCptr->device->lun)); 2156 2157 /* But don't do this when spinning up a disk at 2158 * boot time while we poll for completion as it 2159 * fills up the console with messages. Also, tapes 2160 * can report not ready many times right after 2161 * loading up a tape. 2162 */ 2163 if(esp_should_clear_sync(SCptr) != 0) 2164 esp_dev->sync = 0; 2165 } 2166 ESPDISC(("F<%02x,%02x>", SCptr->device->id, SCptr->device->lun)); 2167 esp_done(esp, ((SCptr->SCp.Status & 0xff) | 2168 ((SCptr->SCp.Message & 0xff)<<8) | 2169 (DID_OK << 16))); 2170 } else if(esp->prevmsgin == DISCONNECT) { 2171 /* Normal disconnect. */ 2172 esp_cmd(esp, eregs, ESP_CMD_ESEL); 2173 ESPDISC(("D<%02x,%02x>", SCptr->device->id, SCptr->device->lun)); 2174 append_SC(&esp->disconnected_SC, SCptr); 2175 esp->current_SC = NULL; 2176 if(esp->issue_SC) 2177 esp_exec_cmd(esp); 2178 } else { 2179 /* Driver bug, we do not expect a disconnect here 2180 * and should not have advanced the state engine 2181 * to in_freeing. 2182 */ 2183 ESPLOG(("esp%d: last msg not disc and not cmd cmplt.\n", 2184 esp->esp_id)); 2185 return do_reset_bus; 2186 } 2187 return do_intr_end; 2188} 2189 2190/* When a reselect occurs, and we cannot find the command to 2191 * reconnect to in our queues, we do this. 2192 */ 2193static int esp_bad_reconnect(struct NCR_ESP *esp) 2194{ 2195 Scsi_Cmnd *sp; 2196 2197 ESPLOG(("esp%d: Eieeee, reconnecting unknown command!\n", 2198 esp->esp_id)); 2199 ESPLOG(("QUEUE DUMP\n")); 2200 sp = esp->issue_SC; 2201 ESPLOG(("esp%d: issue_SC[", esp->esp_id)); 2202 while(sp) { 2203 ESPLOG(("<%02x,%02x>", sp->device->id, sp->device->lun)); 2204 sp = (Scsi_Cmnd *) sp->host_scribble; 2205 } 2206 ESPLOG(("]\n")); 2207 sp = esp->current_SC; 2208 ESPLOG(("esp%d: current_SC[", esp->esp_id)); 2209 while(sp) { 2210 ESPLOG(("<%02x,%02x>", sp->device->id, sp->device->lun)); 2211 sp = (Scsi_Cmnd *) sp->host_scribble; 2212 } 2213 ESPLOG(("]\n")); 2214 sp = esp->disconnected_SC; 2215 ESPLOG(("esp%d: disconnected_SC[", esp->esp_id)); 2216 while(sp) { 2217 ESPLOG(("<%02x,%02x>", sp->device->id, sp->device->lun)); 2218 sp = (Scsi_Cmnd *) sp->host_scribble; 2219 } 2220 ESPLOG(("]\n")); 2221 return do_reset_bus; 2222} 2223 2224/* Do the needy when a target tries to reconnect to us. */ 2225static int esp_do_reconnect(struct NCR_ESP *esp, 2226 struct ESP_regs *eregs) 2227{ 2228 int lun, target; 2229 Scsi_Cmnd *SCptr; 2230 2231 /* Check for all bogus conditions first. */ 2232 target = reconnect_target(esp, eregs); 2233 if(target < 0) { 2234 ESPDISC(("bad bus bits\n")); 2235 return do_reset_bus; 2236 } 2237 lun = reconnect_lun(esp, eregs); 2238 if(lun < 0) { 2239 ESPDISC(("target=%2x, bad identify msg\n", target)); 2240 return do_reset_bus; 2241 } 2242 2243 /* Things look ok... */ 2244 ESPDISC(("R<%02x,%02x>", target, lun)); 2245 2246 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 2247 if(esp100_reconnect_hwbug(esp, eregs)) 2248 return do_reset_bus; 2249 esp_cmd(esp, eregs, ESP_CMD_NULL); 2250 2251 SCptr = remove_SC(&esp->disconnected_SC, (unchar) target, (unchar) lun); 2252 if(!SCptr) 2253 return esp_bad_reconnect(esp); 2254 2255 esp_connect(esp, eregs, SCptr); 2256 esp_cmd(esp, eregs, ESP_CMD_MOK); 2257 2258 /* Reconnect implies a restore pointers operation. */ 2259 esp_restore_pointers(esp, SCptr); 2260 2261 esp->snip = 0; 2262 esp_advance_phase(SCptr, in_the_dark); 2263 return do_intr_end; 2264} 2265 2266/* End of NEXUS (hopefully), pick up status + message byte then leave if 2267 * all goes well. 2268 */ 2269static int esp_do_status(struct NCR_ESP *esp, struct ESP_regs *eregs) 2270{ 2271 Scsi_Cmnd *SCptr = esp->current_SC; 2272 int intr, rval; 2273 2274 rval = skipahead1(esp, eregs, SCptr, in_the_dark, in_status); 2275 if(rval) 2276 return rval; 2277 2278 intr = esp->ireg; 2279 ESPSTAT(("esp_do_status: ")); 2280 if(intr != ESP_INTR_DC) { 2281 int message_out = 0; /* for parity problems */ 2282 2283 /* Ack the message. */ 2284 ESPSTAT(("ack msg, ")); 2285 esp_cmd(esp, eregs, ESP_CMD_MOK); 2286 2287 if(esp->dma_poll) 2288 esp->dma_poll(esp, (unsigned char *) esp->esp_command); 2289 2290 ESPSTAT(("got something, ")); 2291 /* ESP chimes in with one of 2292 * 2293 * 1) function done interrupt: 2294 * both status and message in bytes 2295 * are available 2296 * 2297 * 2) bus service interrupt: 2298 * only status byte was acquired 2299 * 2300 * 3) Anything else: 2301 * can't happen, but we test for it 2302 * anyways 2303 * 2304 * ALSO: If bad parity was detected on either 2305 * the status _or_ the message byte then 2306 * the ESP has asserted ATN on the bus 2307 * and we must therefore wait for the 2308 * next phase change. 2309 */ 2310 if(intr & ESP_INTR_FDONE) { 2311 /* We got it all, hallejulia. */ 2312 ESPSTAT(("got both, ")); 2313 SCptr->SCp.Status = esp->esp_command[0]; 2314 SCptr->SCp.Message = esp->esp_command[1]; 2315 esp->prevmsgin = SCptr->SCp.Message; 2316 esp->cur_msgin[0] = SCptr->SCp.Message; 2317 if(esp->sreg & ESP_STAT_PERR) { 2318 /* There was bad parity for the 2319 * message byte, the status byte 2320 * was ok. 2321 */ 2322 message_out = MSG_PARITY_ERROR; 2323 } 2324 } else if(intr == ESP_INTR_BSERV) { 2325 /* Only got status byte. */ 2326 ESPLOG(("esp%d: got status only, ", esp->esp_id)); 2327 if(!(esp->sreg & ESP_STAT_PERR)) { 2328 SCptr->SCp.Status = esp->esp_command[0]; 2329 SCptr->SCp.Message = 0xff; 2330 } else { 2331 /* The status byte had bad parity. 2332 * we leave the scsi_pointer Status 2333 * field alone as we set it to a default 2334 * of CHECK_CONDITION in esp_queue. 2335 */ 2336 message_out = INITIATOR_ERROR; 2337 } 2338 } else { 2339 /* This shouldn't happen ever. */ 2340 ESPSTAT(("got bolixed\n")); 2341 esp_advance_phase(SCptr, in_the_dark); 2342 return esp_do_phase_determine(esp, eregs); 2343 } 2344 2345 if(!message_out) { 2346 ESPSTAT(("status=%2x msg=%2x, ", SCptr->SCp.Status, 2347 SCptr->SCp.Message)); 2348 if(SCptr->SCp.Message == COMMAND_COMPLETE) { 2349 ESPSTAT(("and was COMMAND_COMPLETE\n")); 2350 esp_advance_phase(SCptr, in_freeing); 2351 return esp_do_freebus(esp, eregs); 2352 } else { 2353 ESPLOG(("esp%d: and _not_ COMMAND_COMPLETE\n", 2354 esp->esp_id)); 2355 esp->msgin_len = esp->msgin_ctr = 1; 2356 esp_advance_phase(SCptr, in_msgindone); 2357 return esp_do_msgindone(esp, eregs); 2358 } 2359 } else { 2360 /* With luck we'll be able to let the target 2361 * know that bad parity happened, it will know 2362 * which byte caused the problems and send it 2363 * again. For the case where the status byte 2364 * receives bad parity, I do not believe most 2365 * targets recover very well. We'll see. 2366 */ 2367 ESPLOG(("esp%d: bad parity somewhere mout=%2x\n", 2368 esp->esp_id, message_out)); 2369 esp->cur_msgout[0] = message_out; 2370 esp->msgout_len = esp->msgout_ctr = 1; 2371 esp_advance_phase(SCptr, in_the_dark); 2372 return esp_do_phase_determine(esp, eregs); 2373 } 2374 } else { 2375 /* If we disconnect now, all hell breaks loose. */ 2376 ESPLOG(("esp%d: whoops, disconnect\n", esp->esp_id)); 2377 esp_advance_phase(SCptr, in_the_dark); 2378 return esp_do_phase_determine(esp, eregs); 2379 } 2380} 2381 2382static int esp_enter_status(struct NCR_ESP *esp, 2383 struct ESP_regs *eregs) 2384{ 2385 unchar thecmd = ESP_CMD_ICCSEQ; 2386 2387 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 2388 2389 if(esp->do_pio_cmds) { 2390 esp_advance_phase(esp->current_SC, in_status); 2391 esp_cmd(esp, eregs, thecmd); 2392 while(!(esp_read(esp->eregs->esp_status) & ESP_STAT_INTR)); 2393 esp->esp_command[0] = esp_read(eregs->esp_fdata); 2394 while(!(esp_read(esp->eregs->esp_status) & ESP_STAT_INTR)); 2395 esp->esp_command[1] = esp_read(eregs->esp_fdata); 2396 } else { 2397 esp->esp_command[0] = esp->esp_command[1] = 0xff; 2398 esp_write(eregs->esp_tclow, 2); 2399 esp_write(eregs->esp_tcmed, 0); 2400 esp->dma_init_read(esp, esp->esp_command_dvma, 2); 2401 thecmd |= ESP_CMD_DMA; 2402 esp_cmd(esp, eregs, thecmd); 2403 esp_advance_phase(esp->current_SC, in_status); 2404 } 2405 2406 return esp_do_status(esp, eregs); 2407} 2408 2409static int esp_disconnect_amidst_phases(struct NCR_ESP *esp, 2410 struct ESP_regs *eregs) 2411{ 2412 Scsi_Cmnd *sp = esp->current_SC; 2413 struct esp_device *esp_dev = sp->device->hostdata; 2414 2415 /* This means real problems if we see this 2416 * here. Unless we were actually trying 2417 * to force the device to abort/reset. 2418 */ 2419 ESPLOG(("esp%d: Disconnect amidst phases, ", esp->esp_id)); 2420 ESPLOG(("pphase<%s> cphase<%s>, ", 2421 phase_string(sp->SCp.phase), 2422 phase_string(sp->SCp.sent_command))); 2423 2424 if(esp->disconnected_SC) 2425 esp_cmd(esp, eregs, ESP_CMD_ESEL); 2426 2427 switch(esp->cur_msgout[0]) { 2428 default: 2429 /* We didn't expect this to happen at all. */ 2430 ESPLOG(("device is bolixed\n")); 2431 esp_advance_phase(sp, in_tgterror); 2432 esp_done(esp, (DID_ERROR << 16)); 2433 break; 2434 2435 case BUS_DEVICE_RESET: 2436 ESPLOG(("device reset successful\n")); 2437 esp_dev->sync_max_offset = 0; 2438 esp_dev->sync_min_period = 0; 2439 esp_dev->sync = 0; 2440 esp_advance_phase(sp, in_resetdev); 2441 esp_done(esp, (DID_RESET << 16)); 2442 break; 2443 2444 case ABORT: 2445 ESPLOG(("device abort successful\n")); 2446 esp_advance_phase(sp, in_abortone); 2447 esp_done(esp, (DID_ABORT << 16)); 2448 break; 2449 2450 }; 2451 return do_intr_end; 2452} 2453 2454static int esp_enter_msgout(struct NCR_ESP *esp, 2455 struct ESP_regs *eregs) 2456{ 2457 esp_advance_phase(esp->current_SC, in_msgout); 2458 return esp_do_msgout(esp, eregs); 2459} 2460 2461static int esp_enter_msgin(struct NCR_ESP *esp, 2462 struct ESP_regs *eregs) 2463{ 2464 esp_advance_phase(esp->current_SC, in_msgin); 2465 return esp_do_msgin(esp, eregs); 2466} 2467 2468static int esp_enter_cmd(struct NCR_ESP *esp, 2469 struct ESP_regs *eregs) 2470{ 2471 esp_advance_phase(esp->current_SC, in_cmdbegin); 2472 return esp_do_cmdbegin(esp, eregs); 2473} 2474 2475static int esp_enter_badphase(struct NCR_ESP *esp, 2476 struct ESP_regs *eregs) 2477{ 2478 ESPLOG(("esp%d: Bizarre bus phase %2x.\n", esp->esp_id, 2479 esp->sreg & ESP_STAT_PMASK)); 2480 return do_reset_bus; 2481} 2482 2483typedef int (*espfunc_t)(struct NCR_ESP *, 2484 struct ESP_regs *); 2485 2486static espfunc_t phase_vector[] = { 2487 esp_do_data, /* ESP_DOP */ 2488 esp_do_data, /* ESP_DIP */ 2489 esp_enter_cmd, /* ESP_CMDP */ 2490 esp_enter_status, /* ESP_STATP */ 2491 esp_enter_badphase, /* ESP_STAT_PMSG */ 2492 esp_enter_badphase, /* ESP_STAT_PMSG | ESP_STAT_PIO */ 2493 esp_enter_msgout, /* ESP_MOP */ 2494 esp_enter_msgin, /* ESP_MIP */ 2495}; 2496 2497/* The target has control of the bus and we have to see where it has 2498 * taken us. 2499 */ 2500static int esp_do_phase_determine(struct NCR_ESP *esp, 2501 struct ESP_regs *eregs) 2502{ 2503 if ((esp->ireg & ESP_INTR_DC) != 0) 2504 return esp_disconnect_amidst_phases(esp, eregs); 2505 return phase_vector[esp->sreg & ESP_STAT_PMASK](esp, eregs); 2506} 2507 2508/* First interrupt after exec'ing a cmd comes here. */ 2509static int esp_select_complete(struct NCR_ESP *esp, struct ESP_regs *eregs) 2510{ 2511 Scsi_Cmnd *SCptr = esp->current_SC; 2512 struct esp_device *esp_dev = SCptr->device->hostdata; 2513 int cmd_bytes_sent, fcnt; 2514 2515 fcnt = (esp_read(eregs->esp_fflags) & ESP_FF_FBYTES); 2516 cmd_bytes_sent = esp->dma_bytes_sent(esp, fcnt); 2517 if(esp->dma_invalidate) 2518 esp->dma_invalidate(esp); 2519 2520 /* Let's check to see if a reselect happened 2521 * while we we're trying to select. This must 2522 * be checked first. 2523 */ 2524 if(esp->ireg == (ESP_INTR_RSEL | ESP_INTR_FDONE)) { 2525 esp_reconnect(esp, SCptr); 2526 return esp_do_reconnect(esp, eregs); 2527 } 2528 2529 /* Looks like things worked, we should see a bus service & 2530 * a function complete interrupt at this point. Note we 2531 * are doing a direct comparison because we don't want to 2532 * be fooled into thinking selection was successful if 2533 * ESP_INTR_DC is set, see below. 2534 */ 2535 if(esp->ireg == (ESP_INTR_FDONE | ESP_INTR_BSERV)) { 2536 /* target speaks... */ 2537 esp->targets_present |= (1<<scmd_id(SCptr)); 2538 2539 /* What if the target ignores the sdtr? */ 2540 if(esp->snip) 2541 esp_dev->sync = 1; 2542 2543 /* See how far, if at all, we got in getting 2544 * the information out to the target. 2545 */ 2546 switch(esp->seqreg) { 2547 default: 2548 2549 case ESP_STEP_ASEL: 2550 ESPLOG(("esp%d: STEP_ASEL for tgt %d\n", 2551 esp->esp_id, SCptr->device->id)); 2552 2553 case ESP_STEP_SID: 2554 2555 case ESP_STEP_NCMD: 2556 /* Arbitration won, target selected, maybe 2557 * sent the one message byte in message out 2558 * phase, but we did not go to command phase 2559 * in the end. Actually, we could have sent 2560 * only some of the message bytes if we tried 2561 * to send out the entire identify and tag 2562 * message using ESP_CMD_SA3. 2563 */ 2564 cmd_bytes_sent = 0; 2565 break; 2566 2567 case ESP_STEP_PPC: 2568 2569 case ESP_STEP_FINI4: 2570 case ESP_STEP_FINI5: 2571 case ESP_STEP_FINI6: 2572 case ESP_STEP_FINI7: 2573 /* Account for the identify message */ 2574 if(SCptr->SCp.phase == in_slct_norm) 2575 cmd_bytes_sent -= 1; 2576 }; 2577 esp_cmd(esp, eregs, ESP_CMD_NULL); 2578 2579 /* Be careful, we could really get fucked during synchronous 2580 * data transfers if we try to flush the fifo now. 2581 */ 2582 if(!fcnt && /* Fifo is empty and... */ 2583 /* either we are not doing synchronous transfers or... */ 2584 (!esp_dev->sync_max_offset || 2585 /* We are not going into data in phase. */ 2586 ((esp->sreg & ESP_STAT_PMASK) != ESP_DIP))) 2587 esp_cmd(esp, eregs, ESP_CMD_FLUSH); /* flush is safe */ 2588 2589 /* See how far we got if this is not a slow command. */ 2590 if(!esp->esp_slowcmd) { 2591 if(cmd_bytes_sent < 0) 2592 cmd_bytes_sent = 0; 2593 if(cmd_bytes_sent != SCptr->cmd_len) { 2594 esp->esp_slowcmd = 1; 2595 esp->esp_scmdp = &(SCptr->cmnd[cmd_bytes_sent]); 2596 esp->esp_scmdleft = (SCptr->cmd_len - cmd_bytes_sent); 2597 } 2598 } 2599 2600 /* Now figure out where we went. */ 2601 esp_advance_phase(SCptr, in_the_dark); 2602 return esp_do_phase_determine(esp, eregs); 2603 } 2604 2605 /* Did the target even make it? */ 2606 if(esp->ireg == ESP_INTR_DC) { 2607 /* wheee... nobody there or they didn't like 2608 * what we told it to do, clean up. 2609 */ 2610 2611 /* If anyone is off the bus, but working on 2612 * a command in the background for us, tell 2613 * the ESP to listen for them. 2614 */ 2615 if(esp->disconnected_SC) 2616 esp_cmd(esp, eregs, ESP_CMD_ESEL); 2617 2618 if(((1<<SCptr->device->id) & esp->targets_present) && 2619 esp->seqreg && esp->cur_msgout[0] == EXTENDED_MESSAGE && 2620 (SCptr->SCp.phase == in_slct_msg || 2621 SCptr->SCp.phase == in_slct_stop)) { 2622 /* shit */ 2623 esp->snip = 0; 2624 ESPLOG(("esp%d: Failed synchronous negotiation for target %d " 2625 "lun %d\n", esp->esp_id, SCptr->device->id, SCptr->device->lun)); 2626 esp_dev->sync_max_offset = 0; 2627 esp_dev->sync_min_period = 0; 2628 esp_dev->sync = 1; /* so we don't negotiate again */ 2629 2630 esp->current_SC = NULL; 2631 esp_advance_phase(SCptr, not_issued); 2632 prepend_SC(&esp->issue_SC, SCptr); 2633 esp_exec_cmd(esp); 2634 return do_intr_end; 2635 } 2636 2637 /* Ok, this is normal, this is what we see during boot 2638 * or whenever when we are scanning the bus for targets. 2639 * But first make sure that is really what is happening. 2640 */ 2641 if(((1<<SCptr->device->id) & esp->targets_present)) { 2642 ESPLOG(("esp%d: Warning, live target %d not responding to " 2643 "selection.\n", esp->esp_id, SCptr->device->id)); 2644 2645 /* This _CAN_ happen. The SCSI standard states that 2646 * the target is to _not_ respond to selection if 2647 * _it_ detects bad parity on the bus for any reason. 2648 * Therefore, we assume that if we've talked successfully 2649 * to this target before, bad parity is the problem. 2650 */ 2651 esp_done(esp, (DID_PARITY << 16)); 2652 } else { 2653 /* Else, there really isn't anyone there. */ 2654 ESPMISC(("esp: selection failure, maybe nobody there?\n")); 2655 ESPMISC(("esp: target %d lun %d\n", 2656 SCptr->device->id, SCptr->device->lun)); 2657 esp_done(esp, (DID_BAD_TARGET << 16)); 2658 } 2659 return do_intr_end; 2660 } 2661 2662 2663 ESPLOG(("esp%d: Selection failure.\n", esp->esp_id)); 2664 printk("esp%d: Currently -- ", esp->esp_id); 2665 esp_print_ireg(esp->ireg); 2666 printk(" "); 2667 esp_print_statreg(esp->sreg); 2668 printk(" "); 2669 esp_print_seqreg(esp->seqreg); 2670 printk("\n"); 2671 printk("esp%d: New -- ", esp->esp_id); 2672 esp->sreg = esp_read(eregs->esp_status); 2673 esp->seqreg = esp_read(eregs->esp_sstep); 2674 esp->ireg = esp_read(eregs->esp_intrpt); 2675 esp_print_ireg(esp->ireg); 2676 printk(" "); 2677 esp_print_statreg(esp->sreg); 2678 printk(" "); 2679 esp_print_seqreg(esp->seqreg); 2680 printk("\n"); 2681 ESPLOG(("esp%d: resetting bus\n", esp->esp_id)); 2682 return do_reset_bus; /* ugh... */ 2683} 2684 2685/* Continue reading bytes for msgin phase. */ 2686static int esp_do_msgincont(struct NCR_ESP *esp, struct ESP_regs *eregs) 2687{ 2688 if(esp->ireg & ESP_INTR_BSERV) { 2689 /* in the right phase too? */ 2690 if((esp->sreg & ESP_STAT_PMASK) == ESP_MIP) { 2691 /* phew... */ 2692 esp_cmd(esp, eregs, ESP_CMD_TI); 2693 esp_advance_phase(esp->current_SC, in_msgindone); 2694 return do_intr_end; 2695 } 2696 2697 /* We changed phase but ESP shows bus service, 2698 * in this case it is most likely that we, the 2699 * hacker who has been up for 20hrs straight 2700 * staring at the screen, drowned in coffee 2701 * smelling like retched cigarette ashes 2702 * have miscoded something..... so, try to 2703 * recover as best we can. 2704 */ 2705 ESPLOG(("esp%d: message in mis-carriage.\n", esp->esp_id)); 2706 } 2707 esp_advance_phase(esp->current_SC, in_the_dark); 2708 return do_phase_determine; 2709} 2710 2711static int check_singlebyte_msg(struct NCR_ESP *esp, 2712 struct ESP_regs *eregs) 2713{ 2714 esp->prevmsgin = esp->cur_msgin[0]; 2715 if(esp->cur_msgin[0] & 0x80) { 2716 /* wheee... */ 2717 ESPLOG(("esp%d: target sends identify amidst phases\n", 2718 esp->esp_id)); 2719 esp_advance_phase(esp->current_SC, in_the_dark); 2720 return 0; 2721 } else if(((esp->cur_msgin[0] & 0xf0) == 0x20) || 2722 (esp->cur_msgin[0] == EXTENDED_MESSAGE)) { 2723 esp->msgin_len = 2; 2724 esp_advance_phase(esp->current_SC, in_msgincont); 2725 return 0; 2726 } 2727 esp_advance_phase(esp->current_SC, in_the_dark); 2728 switch(esp->cur_msgin[0]) { 2729 default: 2730 /* We don't want to hear about it. */ 2731 ESPLOG(("esp%d: msg %02x which we don't know about\n", esp->esp_id, 2732 esp->cur_msgin[0])); 2733 return MESSAGE_REJECT; 2734 2735 case NOP: 2736 ESPLOG(("esp%d: target %d sends a nop\n", esp->esp_id, 2737 esp->current_SC->device->id)); 2738 return 0; 2739 2740 case RESTORE_POINTERS: 2741 /* In this case we might also have to backup the 2742 * "slow command" pointer. It is rare to get such 2743 * a save/restore pointer sequence so early in the 2744 * bus transition sequences, but cover it. 2745 */ 2746 if(esp->esp_slowcmd) { 2747 esp->esp_scmdleft = esp->current_SC->cmd_len; 2748 esp->esp_scmdp = &esp->current_SC->cmnd[0]; 2749 } 2750 esp_restore_pointers(esp, esp->current_SC); 2751 return 0; 2752 2753 case SAVE_POINTERS: 2754 esp_save_pointers(esp, esp->current_SC); 2755 return 0; 2756 2757 case COMMAND_COMPLETE: 2758 case DISCONNECT: 2759 /* Freeing the bus, let it go. */ 2760 esp->current_SC->SCp.phase = in_freeing; 2761 return 0; 2762 2763 case MESSAGE_REJECT: 2764 ESPMISC(("msg reject, ")); 2765 if(esp->prevmsgout == EXTENDED_MESSAGE) { 2766 struct esp_device *esp_dev = esp->current_SC->device->hostdata; 2767 2768 /* Doesn't look like this target can 2769 * do synchronous or WIDE transfers. 2770 */ 2771 ESPSDTR(("got reject, was trying nego, clearing sync/WIDE\n")); 2772 esp_dev->sync = 1; 2773 esp_dev->wide = 1; 2774 esp_dev->sync_min_period = 0; 2775 esp_dev->sync_max_offset = 0; 2776 return 0; 2777 } else { 2778 ESPMISC(("not sync nego, sending ABORT\n")); 2779 return ABORT; 2780 } 2781 }; 2782} 2783 2784/* Target negotiates for synchronous transfers before we do, this 2785 * is legal although very strange. What is even funnier is that 2786 * the SCSI2 standard specifically recommends against targets doing 2787 * this because so many initiators cannot cope with this occurring. 2788 */ 2789static int target_with_ants_in_pants(struct NCR_ESP *esp, 2790 Scsi_Cmnd *SCptr, 2791 struct esp_device *esp_dev) 2792{ 2793 if(esp_dev->sync || SCptr->device->borken) { 2794 /* sorry, no can do */ 2795 ESPSDTR(("forcing to async, ")); 2796 build_sync_nego_msg(esp, 0, 0); 2797 esp_dev->sync = 1; 2798 esp->snip = 1; 2799 ESPLOG(("esp%d: hoping for msgout\n", esp->esp_id)); 2800 esp_advance_phase(SCptr, in_the_dark); 2801 return EXTENDED_MESSAGE; 2802 } 2803 2804 /* Ok, we'll check them out... */ 2805 return 0; 2806} 2807 2808static void sync_report(struct NCR_ESP *esp) 2809{ 2810 int msg3, msg4; 2811 char *type; 2812 2813 msg3 = esp->cur_msgin[3]; 2814 msg4 = esp->cur_msgin[4]; 2815 if(msg4) { 2816 int hz = 1000000000 / (msg3 * 4); 2817 int integer = hz / 1000000; 2818 int fraction = (hz - (integer * 1000000)) / 10000; 2819 if((msg3 * 4) < 200) { 2820 type = "FAST"; 2821 } else { 2822 type = "synchronous"; 2823 } 2824 2825 /* Do not transform this back into one big printk 2826 * again, it triggers a bug in our sparc64-gcc272 2827 * sibling call optimization. -DaveM 2828 */ 2829 ESPLOG((KERN_INFO "esp%d: target %d ", 2830 esp->esp_id, esp->current_SC->device->id)); 2831 ESPLOG(("[period %dns offset %d %d.%02dMHz ", 2832 (int) msg3 * 4, (int) msg4, 2833 integer, fraction)); 2834 ESPLOG(("%s SCSI%s]\n", type, 2835 (((msg3 * 4) < 200) ? "-II" : ""))); 2836 } else { 2837 ESPLOG((KERN_INFO "esp%d: target %d asynchronous\n", 2838 esp->esp_id, esp->current_SC->device->id)); 2839 } 2840} 2841 2842static int check_multibyte_msg(struct NCR_ESP *esp, 2843 struct ESP_regs *eregs) 2844{ 2845 Scsi_Cmnd *SCptr = esp->current_SC; 2846 struct esp_device *esp_dev = SCptr->device->hostdata; 2847 unchar regval = 0; 2848 int message_out = 0; 2849 2850 ESPSDTR(("chk multibyte msg: ")); 2851 if(esp->cur_msgin[2] == EXTENDED_SDTR) { 2852 int period = esp->cur_msgin[3]; 2853 int offset = esp->cur_msgin[4]; 2854 2855 ESPSDTR(("is sync nego response, ")); 2856 if(!esp->snip) { 2857 int rval; 2858 2859 /* Target negotiates first! */ 2860 ESPSDTR(("target jumps the gun, ")); 2861 message_out = EXTENDED_MESSAGE; /* we must respond */ 2862 rval = target_with_ants_in_pants(esp, SCptr, esp_dev); 2863 if(rval) 2864 return rval; 2865 } 2866 2867 ESPSDTR(("examining sdtr, ")); 2868 2869 /* Offset cannot be larger than ESP fifo size. */ 2870 if(offset > 15) { 2871 ESPSDTR(("offset too big %2x, ", offset)); 2872 offset = 15; 2873 ESPSDTR(("sending back new offset\n")); 2874 build_sync_nego_msg(esp, period, offset); 2875 return EXTENDED_MESSAGE; 2876 } 2877 2878 if(offset && period > esp->max_period) { 2879 /* Yeee, async for this slow device. */ 2880 ESPSDTR(("period too long %2x, ", period)); 2881 build_sync_nego_msg(esp, 0, 0); 2882 ESPSDTR(("hoping for msgout\n")); 2883 esp_advance_phase(esp->current_SC, in_the_dark); 2884 return EXTENDED_MESSAGE; 2885 } else if (offset && period < esp->min_period) { 2886 ESPSDTR(("period too short %2x, ", period)); 2887 period = esp->min_period; 2888 if(esp->erev > esp236) 2889 regval = 4; 2890 else 2891 regval = 5; 2892 } else if(offset) { 2893 int tmp; 2894 2895 ESPSDTR(("period is ok, ")); 2896 tmp = esp->ccycle / 1000; 2897 regval = (((period << 2) + tmp - 1) / tmp); 2898 if(regval && (esp->erev > esp236)) { 2899 if(period >= 50) 2900 regval--; 2901 } 2902 } 2903 2904 if(offset) { 2905 unchar bit; 2906 2907 esp_dev->sync_min_period = (regval & 0x1f); 2908 esp_dev->sync_max_offset = (offset | esp->radelay); 2909 if(esp->erev > esp236) { 2910 if(esp->erev == fas100a) 2911 bit = ESP_CONFIG3_FAST; 2912 else 2913 bit = ESP_CONFIG3_FSCSI; 2914 if(period < 50) 2915 esp->config3[SCptr->device->id] |= bit; 2916 else 2917 esp->config3[SCptr->device->id] &= ~bit; 2918 esp->prev_cfg3 = esp->config3[SCptr->device->id]; 2919 esp_write(eregs->esp_cfg3, esp->prev_cfg3); 2920 } 2921 esp->prev_soff = esp_dev->sync_min_period; 2922 esp_write(eregs->esp_soff, esp->prev_soff); 2923 esp->prev_stp = esp_dev->sync_max_offset; 2924 esp_write(eregs->esp_stp, esp->prev_stp); 2925 2926 ESPSDTR(("soff=%2x stp=%2x cfg3=%2x\n", 2927 esp_dev->sync_max_offset, 2928 esp_dev->sync_min_period, 2929 esp->config3[scmd_id(SCptr)])); 2930 2931 esp->snip = 0; 2932 } else if(esp_dev->sync_max_offset) { 2933 unchar bit; 2934 2935 /* back to async mode */ 2936 ESPSDTR(("unaccaptable sync nego, forcing async\n")); 2937 esp_dev->sync_max_offset = 0; 2938 esp_dev->sync_min_period = 0; 2939 esp->prev_soff = 0; 2940 esp_write(eregs->esp_soff, 0); 2941 esp->prev_stp = 0; 2942 esp_write(eregs->esp_stp, 0); 2943 if(esp->erev > esp236) { 2944 if(esp->erev == fas100a) 2945 bit = ESP_CONFIG3_FAST; 2946 else 2947 bit = ESP_CONFIG3_FSCSI; 2948 esp->config3[SCptr->device->id] &= ~bit; 2949 esp->prev_cfg3 = esp->config3[SCptr->device->id]; 2950 esp_write(eregs->esp_cfg3, esp->prev_cfg3); 2951 } 2952 } 2953 2954 sync_report(esp); 2955 2956 ESPSDTR(("chk multibyte msg: sync is known, ")); 2957 esp_dev->sync = 1; 2958 2959 if(message_out) { 2960 ESPLOG(("esp%d: sending sdtr back, hoping for msgout\n", 2961 esp->esp_id)); 2962 build_sync_nego_msg(esp, period, offset); 2963 esp_advance_phase(SCptr, in_the_dark); 2964 return EXTENDED_MESSAGE; 2965 } 2966 2967 ESPSDTR(("returning zero\n")); 2968 esp_advance_phase(SCptr, in_the_dark); /* ...or else! */ 2969 return 0; 2970 } else if(esp->cur_msgin[2] == EXTENDED_WDTR) { 2971 ESPLOG(("esp%d: AIEEE wide msg received\n", esp->esp_id)); 2972 message_out = MESSAGE_REJECT; 2973 } else if(esp->cur_msgin[2] == EXTENDED_MODIFY_DATA_POINTER) { 2974 ESPLOG(("esp%d: rejecting modify data ptr msg\n", esp->esp_id)); 2975 message_out = MESSAGE_REJECT; 2976 } 2977 esp_advance_phase(SCptr, in_the_dark); 2978 return message_out; 2979} 2980 2981static int esp_do_msgindone(struct NCR_ESP *esp, struct ESP_regs *eregs) 2982{ 2983 Scsi_Cmnd *SCptr = esp->current_SC; 2984 int message_out = 0, it = 0, rval; 2985 2986 rval = skipahead1(esp, eregs, SCptr, in_msgin, in_msgindone); 2987 if(rval) 2988 return rval; 2989 if(SCptr->SCp.sent_command != in_status) { 2990 if(!(esp->ireg & ESP_INTR_DC)) { 2991 if(esp->msgin_len && (esp->sreg & ESP_STAT_PERR)) { 2992 message_out = MSG_PARITY_ERROR; 2993 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 2994 } else if((it = (esp_read(eregs->esp_fflags) & ESP_FF_FBYTES))!=1) { 2995 /* We certainly dropped the ball somewhere. */ 2996 message_out = INITIATOR_ERROR; 2997 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 2998 } else if(!esp->msgin_len) { 2999 it = esp_read(eregs->esp_fdata); 3000 esp_advance_phase(SCptr, in_msgincont); 3001 } else { 3002 /* it is ok and we want it */ 3003 it = esp->cur_msgin[esp->msgin_ctr] = 3004 esp_read(eregs->esp_fdata); 3005 esp->msgin_ctr++; 3006 } 3007 } else { 3008 esp_advance_phase(SCptr, in_the_dark); 3009 return do_work_bus; 3010 } 3011 } else { 3012 it = esp->cur_msgin[0]; 3013 } 3014 if(!message_out && esp->msgin_len) { 3015 if(esp->msgin_ctr < esp->msgin_len) { 3016 esp_advance_phase(SCptr, in_msgincont); 3017 } else if(esp->msgin_len == 1) { 3018 message_out = check_singlebyte_msg(esp, eregs); 3019 } else if(esp->msgin_len == 2) { 3020 if(esp->cur_msgin[0] == EXTENDED_MESSAGE) { 3021 if((it+2) >= 15) { 3022 message_out = MESSAGE_REJECT; 3023 } else { 3024 esp->msgin_len = (it + 2); 3025 esp_advance_phase(SCptr, in_msgincont); 3026 } 3027 } else { 3028 message_out = MESSAGE_REJECT; /* foo on you */ 3029 } 3030 } else { 3031 message_out = check_multibyte_msg(esp, eregs); 3032 } 3033 } 3034 if(message_out < 0) { 3035 return -message_out; 3036 } else if(message_out) { 3037 if(((message_out != 1) && 3038 ((message_out < 0x20) || (message_out & 0x80)))) 3039 esp->msgout_len = 1; 3040 esp->cur_msgout[0] = message_out; 3041 esp_cmd(esp, eregs, ESP_CMD_SATN); 3042 esp_advance_phase(SCptr, in_the_dark); 3043 esp->msgin_len = 0; 3044 } 3045 esp->sreg = esp_read(eregs->esp_status); 3046 esp->sreg &= ~(ESP_STAT_INTR); 3047 if((esp->sreg & (ESP_STAT_PMSG|ESP_STAT_PCD)) == (ESP_STAT_PMSG|ESP_STAT_PCD)) 3048 esp_cmd(esp, eregs, ESP_CMD_MOK); 3049 if((SCptr->SCp.sent_command == in_msgindone) && 3050 (SCptr->SCp.phase == in_freeing)) 3051 return esp_do_freebus(esp, eregs); 3052 return do_intr_end; 3053} 3054 3055static int esp_do_cmdbegin(struct NCR_ESP *esp, struct ESP_regs *eregs) 3056{ 3057 unsigned char tmp; 3058 Scsi_Cmnd *SCptr = esp->current_SC; 3059 3060 esp_advance_phase(SCptr, in_cmdend); 3061 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 3062 tmp = *esp->esp_scmdp++; 3063 esp->esp_scmdleft--; 3064 esp_write(eregs->esp_fdata, tmp); 3065 esp_cmd(esp, eregs, ESP_CMD_TI); 3066 return do_intr_end; 3067} 3068 3069static int esp_do_cmddone(struct NCR_ESP *esp, struct ESP_regs *eregs) 3070{ 3071 esp_cmd(esp, eregs, ESP_CMD_NULL); 3072 if(esp->ireg & ESP_INTR_BSERV) { 3073 esp_advance_phase(esp->current_SC, in_the_dark); 3074 return esp_do_phase_determine(esp, eregs); 3075 } 3076 ESPLOG(("esp%d: in do_cmddone() but didn't get BSERV interrupt.\n", 3077 esp->esp_id)); 3078 return do_reset_bus; 3079} 3080 3081static int esp_do_msgout(struct NCR_ESP *esp, struct ESP_regs *eregs) 3082{ 3083 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 3084 switch(esp->msgout_len) { 3085 case 1: 3086 esp_write(eregs->esp_fdata, esp->cur_msgout[0]); 3087 esp_cmd(esp, eregs, ESP_CMD_TI); 3088 break; 3089 3090 case 2: 3091 if(esp->do_pio_cmds){ 3092 esp_write(eregs->esp_fdata, esp->cur_msgout[0]); 3093 esp_write(eregs->esp_fdata, esp->cur_msgout[1]); 3094 esp_cmd(esp, eregs, ESP_CMD_TI); 3095 } else { 3096 esp->esp_command[0] = esp->cur_msgout[0]; 3097 esp->esp_command[1] = esp->cur_msgout[1]; 3098 esp->dma_setup(esp, esp->esp_command_dvma, 2, 0); 3099 esp_setcount(eregs, 2); 3100 esp_cmd(esp, eregs, ESP_CMD_DMA | ESP_CMD_TI); 3101 } 3102 break; 3103 3104 case 4: 3105 esp->snip = 1; 3106 if(esp->do_pio_cmds){ 3107 esp_write(eregs->esp_fdata, esp->cur_msgout[0]); 3108 esp_write(eregs->esp_fdata, esp->cur_msgout[1]); 3109 esp_write(eregs->esp_fdata, esp->cur_msgout[2]); 3110 esp_write(eregs->esp_fdata, esp->cur_msgout[3]); 3111 esp_cmd(esp, eregs, ESP_CMD_TI); 3112 } else { 3113 esp->esp_command[0] = esp->cur_msgout[0]; 3114 esp->esp_command[1] = esp->cur_msgout[1]; 3115 esp->esp_command[2] = esp->cur_msgout[2]; 3116 esp->esp_command[3] = esp->cur_msgout[3]; 3117 esp->dma_setup(esp, esp->esp_command_dvma, 4, 0); 3118 esp_setcount(eregs, 4); 3119 esp_cmd(esp, eregs, ESP_CMD_DMA | ESP_CMD_TI); 3120 } 3121 break; 3122 3123 case 5: 3124 esp->snip = 1; 3125 if(esp->do_pio_cmds){ 3126 esp_write(eregs->esp_fdata, esp->cur_msgout[0]); 3127 esp_write(eregs->esp_fdata, esp->cur_msgout[1]); 3128 esp_write(eregs->esp_fdata, esp->cur_msgout[2]); 3129 esp_write(eregs->esp_fdata, esp->cur_msgout[3]); 3130 esp_write(eregs->esp_fdata, esp->cur_msgout[4]); 3131 esp_cmd(esp, eregs, ESP_CMD_TI); 3132 } else { 3133 esp->esp_command[0] = esp->cur_msgout[0]; 3134 esp->esp_command[1] = esp->cur_msgout[1]; 3135 esp->esp_command[2] = esp->cur_msgout[2]; 3136 esp->esp_command[3] = esp->cur_msgout[3]; 3137 esp->esp_command[4] = esp->cur_msgout[4]; 3138 esp->dma_setup(esp, esp->esp_command_dvma, 5, 0); 3139 esp_setcount(eregs, 5); 3140 esp_cmd(esp, eregs, ESP_CMD_DMA | ESP_CMD_TI); 3141 } 3142 break; 3143 3144 default: 3145 /* whoops */ 3146 ESPMISC(("bogus msgout sending NOP\n")); 3147 esp->cur_msgout[0] = NOP; 3148 esp_write(eregs->esp_fdata, esp->cur_msgout[0]); 3149 esp->msgout_len = 1; 3150 esp_cmd(esp, eregs, ESP_CMD_TI); 3151 break; 3152 } 3153 esp_advance_phase(esp->current_SC, in_msgoutdone); 3154 return do_intr_end; 3155} 3156 3157static int esp_do_msgoutdone(struct NCR_ESP *esp, 3158 struct ESP_regs *eregs) 3159{ 3160 if((esp->msgout_len > 1) && esp->dma_barrier) 3161 esp->dma_barrier(esp); 3162 3163 if(!(esp->ireg & ESP_INTR_DC)) { 3164 esp_cmd(esp, eregs, ESP_CMD_NULL); 3165 switch(esp->sreg & ESP_STAT_PMASK) { 3166 case ESP_MOP: 3167 /* whoops, parity error */ 3168 ESPLOG(("esp%d: still in msgout, parity error assumed\n", 3169 esp->esp_id)); 3170 if(esp->msgout_len > 1) 3171 esp_cmd(esp, eregs, ESP_CMD_SATN); 3172 esp_advance_phase(esp->current_SC, in_msgout); 3173 return do_work_bus; 3174 3175 case ESP_DIP: 3176 break; 3177 3178 default: 3179 if(!fcount(esp, eregs) && 3180 !(((struct esp_device *)esp->current_SC->device->hostdata)->sync_max_offset)) 3181 esp_cmd(esp, eregs, ESP_CMD_FLUSH); 3182 break; 3183 3184 }; 3185 } 3186 3187 /* If we sent out a synchronous negotiation message, update 3188 * our state. 3189 */ 3190 if(esp->cur_msgout[2] == EXTENDED_MESSAGE && 3191 esp->cur_msgout[4] == EXTENDED_SDTR) { 3192 esp->snip = 1; /* anal retentiveness... */ 3193 } 3194 3195 esp->prevmsgout = esp->cur_msgout[0]; 3196 esp->msgout_len = 0; 3197 esp_advance_phase(esp->current_SC, in_the_dark); 3198 return esp_do_phase_determine(esp, eregs); 3199} 3200 3201static int esp_bus_unexpected(struct NCR_ESP *esp, struct ESP_regs *eregs) 3202{ 3203 ESPLOG(("esp%d: command in weird state %2x\n", 3204 esp->esp_id, esp->current_SC->SCp.phase)); 3205 return do_reset_bus; 3206} 3207 3208static espfunc_t bus_vector[] = { 3209 esp_do_data_finale, 3210 esp_do_data_finale, 3211 esp_bus_unexpected, 3212 esp_do_msgin, 3213 esp_do_msgincont, 3214 esp_do_msgindone, 3215 esp_do_msgout, 3216 esp_do_msgoutdone, 3217 esp_do_cmdbegin, 3218 esp_do_cmddone, 3219 esp_do_status, 3220 esp_do_freebus, 3221 esp_do_phase_determine, 3222 esp_bus_unexpected, 3223 esp_bus_unexpected, 3224 esp_bus_unexpected, 3225}; 3226 3227/* This is the second tier in our dual-level SCSI state machine. */ 3228static int esp_work_bus(struct NCR_ESP *esp, struct ESP_regs *eregs) 3229{ 3230 Scsi_Cmnd *SCptr = esp->current_SC; 3231 unsigned int phase; 3232 3233 ESPBUS(("esp_work_bus: ")); 3234 if(!SCptr) { 3235 ESPBUS(("reconnect\n")); 3236 return esp_do_reconnect(esp, eregs); 3237 } 3238 phase = SCptr->SCp.phase; 3239 if ((phase & 0xf0) == in_phases_mask) 3240 return bus_vector[(phase & 0x0f)](esp, eregs); 3241 else if((phase & 0xf0) == in_slct_mask) 3242 return esp_select_complete(esp, eregs); 3243 else 3244 return esp_bus_unexpected(esp, eregs); 3245} 3246 3247static espfunc_t isvc_vector[] = { 3248 NULL, 3249 esp_do_phase_determine, 3250 esp_do_resetbus, 3251 esp_finish_reset, 3252 esp_work_bus 3253}; 3254 3255/* Main interrupt handler for an esp adapter. */ 3256void esp_handle(struct NCR_ESP *esp) 3257{ 3258 struct ESP_regs *eregs; 3259 Scsi_Cmnd *SCptr; 3260 int what_next = do_intr_end; 3261 eregs = esp->eregs; 3262 SCptr = esp->current_SC; 3263 3264 if(esp->dma_irq_entry) 3265 esp->dma_irq_entry(esp); 3266 3267 /* Check for errors. */ 3268 esp->sreg = esp_read(eregs->esp_status); 3269 esp->sreg &= (~ESP_STAT_INTR); 3270 esp->seqreg = (esp_read(eregs->esp_sstep) & ESP_STEP_VBITS); 3271 esp->ireg = esp_read(eregs->esp_intrpt); /* Unlatch intr and stat regs */ 3272 ESPIRQ(("handle_irq: [sreg<%02x> sstep<%02x> ireg<%02x>]\n", 3273 esp->sreg, esp->seqreg, esp->ireg)); 3274 if(esp->sreg & (ESP_STAT_SPAM)) { 3275 /* Gross error, could be due to one of: 3276 * 3277 * - top of fifo overwritten, could be because 3278 * we tried to do a synchronous transfer with 3279 * an offset greater than ESP fifo size 3280 * 3281 * - top of command register overwritten 3282 * 3283 * - DMA setup to go in one direction, SCSI 3284 * bus points in the other, whoops 3285 * 3286 * - weird phase change during asynchronous 3287 * data phase while we are initiator 3288 */ 3289 ESPLOG(("esp%d: Gross error sreg=%2x\n", esp->esp_id, esp->sreg)); 3290 3291 /* If a command is live on the bus we cannot safely 3292 * reset the bus, so we'll just let the pieces fall 3293 * where they may. Here we are hoping that the 3294 * target will be able to cleanly go away soon 3295 * so we can safely reset things. 3296 */ 3297 if(!SCptr) { 3298 ESPLOG(("esp%d: No current cmd during gross error, " 3299 "resetting bus\n", esp->esp_id)); 3300 what_next = do_reset_bus; 3301 goto state_machine; 3302 } 3303 } 3304 3305 /* No current cmd is only valid at this point when there are 3306 * commands off the bus or we are trying a reset. 3307 */ 3308 if(!SCptr && !esp->disconnected_SC && !(esp->ireg & ESP_INTR_SR)) { 3309 /* Panic is safe, since current_SC is null. */ 3310 ESPLOG(("esp%d: no command in esp_handle()\n", esp->esp_id)); 3311 panic("esp_handle: current_SC == penguin within interrupt!"); 3312 } 3313 3314 if(esp->ireg & (ESP_INTR_IC)) { 3315 /* Illegal command fed to ESP. Outside of obvious 3316 * software bugs that could cause this, there is 3317 * a condition with ESP100 where we can confuse the 3318 * ESP into an erroneous illegal command interrupt 3319 * because it does not scrape the FIFO properly 3320 * for reselection. See esp100_reconnect_hwbug() 3321 * to see how we try very hard to avoid this. 3322 */ 3323 ESPLOG(("esp%d: invalid command\n", esp->esp_id)); 3324 3325 esp_dump_state(esp, eregs); 3326 3327 if(SCptr) { 3328 /* Devices with very buggy firmware can drop BSY 3329 * during a scatter list interrupt when using sync 3330 * mode transfers. We continue the transfer as 3331 * expected, the target drops the bus, the ESP 3332 * gets confused, and we get a illegal command 3333 * interrupt because the bus is in the disconnected 3334 * state now and ESP_CMD_TI is only allowed when 3335 * a nexus is alive on the bus. 3336 */ 3337 ESPLOG(("esp%d: Forcing async and disabling disconnect for " 3338 "target %d\n", esp->esp_id, SCptr->device->id)); 3339 SCptr->device->borken = 1; /* foo on you */ 3340 } 3341 3342 what_next = do_reset_bus; 3343 } else if(!(esp->ireg & ~(ESP_INTR_FDONE | ESP_INTR_BSERV | ESP_INTR_DC))) { 3344 int phase; 3345 3346 if(SCptr) { 3347 phase = SCptr->SCp.phase; 3348 if(phase & in_phases_mask) { 3349 what_next = esp_work_bus(esp, eregs); 3350 } else if(phase & in_slct_mask) { 3351 what_next = esp_select_complete(esp, eregs); 3352 } else { 3353 ESPLOG(("esp%d: interrupt for no good reason...\n", 3354 esp->esp_id)); 3355 what_next = do_intr_end; 3356 } 3357 } else { 3358 ESPLOG(("esp%d: BSERV or FDONE or DC while SCptr==NULL\n", 3359 esp->esp_id)); 3360 what_next = do_reset_bus; 3361 } 3362 } else if(esp->ireg & ESP_INTR_SR) { 3363 ESPLOG(("esp%d: SCSI bus reset interrupt\n", esp->esp_id)); 3364 what_next = do_reset_complete; 3365 } else if(esp->ireg & (ESP_INTR_S | ESP_INTR_SATN)) { 3366 ESPLOG(("esp%d: AIEEE we have been selected by another initiator!\n", 3367 esp->esp_id)); 3368 what_next = do_reset_bus; 3369 } else if(esp->ireg & ESP_INTR_RSEL) { 3370 if(!SCptr) { 3371 /* This is ok. */ 3372 what_next = esp_do_reconnect(esp, eregs); 3373 } else if(SCptr->SCp.phase & in_slct_mask) { 3374 /* Only selection code knows how to clean 3375 * up properly. 3376 */ 3377 ESPDISC(("Reselected during selection attempt\n")); 3378 what_next = esp_select_complete(esp, eregs); 3379 } else { 3380 ESPLOG(("esp%d: Reselected while bus is busy\n", 3381 esp->esp_id)); 3382 what_next = do_reset_bus; 3383 } 3384 } 3385 3386 /* This is tier-one in our dual level SCSI state machine. */ 3387state_machine: 3388 while(what_next != do_intr_end) { 3389 if (what_next >= do_phase_determine && 3390 what_next < do_intr_end) 3391 what_next = isvc_vector[what_next](esp, eregs); 3392 else { 3393 /* state is completely lost ;-( */ 3394 ESPLOG(("esp%d: interrupt engine loses state, resetting bus\n", 3395 esp->esp_id)); 3396 what_next = do_reset_bus; 3397 } 3398 } 3399 if(esp->dma_irq_exit) 3400 esp->dma_irq_exit(esp); 3401} 3402 3403#ifndef CONFIG_SMP 3404irqreturn_t esp_intr(int irq, void *dev_id) 3405{ 3406 struct NCR_ESP *esp; 3407 unsigned long flags; 3408 int again; 3409 struct Scsi_Host *dev = dev_id; 3410 3411 /* Handle all ESP interrupts showing at this IRQ level. */ 3412 spin_lock_irqsave(dev->host_lock, flags); 3413repeat: 3414 again = 0; 3415 for_each_esp(esp) { 3416#ifndef __mips__ 3417 if(((esp)->irq & 0xff) == irq) { 3418#endif 3419 if(esp->dma_irq_p(esp)) { 3420 again = 1; 3421 3422 esp->dma_ints_off(esp); 3423 3424 ESPIRQ(("I%d(", esp->esp_id)); 3425 esp_handle(esp); 3426 ESPIRQ((")")); 3427 3428 esp->dma_ints_on(esp); 3429 } 3430#ifndef __mips__ 3431 } 3432#endif 3433 } 3434 if(again) 3435 goto repeat; 3436 spin_unlock_irqrestore(dev->host_lock, flags); 3437 return IRQ_HANDLED; 3438} 3439#else 3440/* For SMP we only service one ESP on the list list at our IRQ level! */ 3441irqreturn_t esp_intr(int irq, void *dev_id) 3442{ 3443 struct NCR_ESP *esp; 3444 unsigned long flags; 3445 struct Scsi_Host *dev = dev_id; 3446 3447 /* Handle all ESP interrupts showing at this IRQ level. */ 3448 spin_lock_irqsave(dev->host_lock, flags); 3449 for_each_esp(esp) { 3450 if(((esp)->irq & 0xf) == irq) { 3451 if(esp->dma_irq_p(esp)) { 3452 esp->dma_ints_off(esp); 3453 3454 ESPIRQ(("I[%d:%d](", 3455 smp_processor_id(), esp->esp_id)); 3456 esp_handle(esp); 3457 ESPIRQ((")")); 3458 3459 esp->dma_ints_on(esp); 3460 goto out; 3461 } 3462 } 3463 } 3464out: 3465 spin_unlock_irqrestore(dev->host_lock, flags); 3466 return IRQ_HANDLED; 3467} 3468#endif 3469 3470int esp_slave_alloc(struct scsi_device *SDptr) 3471{ 3472 struct esp_device *esp_dev = 3473 kmalloc(sizeof(struct esp_device), GFP_ATOMIC); 3474 3475 if (!esp_dev) 3476 return -ENOMEM; 3477 memset(esp_dev, 0, sizeof(struct esp_device)); 3478 SDptr->hostdata = esp_dev; 3479 return 0; 3480} 3481 3482void esp_slave_destroy(struct scsi_device *SDptr) 3483{ 3484 struct NCR_ESP *esp = (struct NCR_ESP *) SDptr->host->hostdata; 3485 3486 esp->targets_present &= ~(1 << sdev_id(SDptr)); 3487 kfree(SDptr->hostdata); 3488 SDptr->hostdata = NULL; 3489} 3490 3491#ifdef MODULE 3492int init_module(void) { return 0; } 3493void cleanup_module(void) {} 3494void esp_release(void) 3495{ 3496 esps_in_use--; 3497 esps_running = esps_in_use; 3498} 3499#endif 3500 3501EXPORT_SYMBOL(esp_abort); 3502EXPORT_SYMBOL(esp_allocate); 3503EXPORT_SYMBOL(esp_deallocate); 3504EXPORT_SYMBOL(esp_initialize); 3505EXPORT_SYMBOL(esp_intr); 3506EXPORT_SYMBOL(esp_queue); 3507EXPORT_SYMBOL(esp_reset); 3508EXPORT_SYMBOL(esp_slave_alloc); 3509EXPORT_SYMBOL(esp_slave_destroy); 3510EXPORT_SYMBOL(esps_in_use); 3511 3512MODULE_LICENSE("GPL"); 3513