1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* -*- mode: c; c-basic-offset: 8 -*- */ 3 4 /* NCR (or Symbios) 53c700 and 53c700-66 Driver 5 * 6 * Copyright (C) 2001 by James.Bottomley@HansenPartnership.com 7 **----------------------------------------------------------------------------- 8 ** 9 ** 10 **----------------------------------------------------------------------------- 11 */ 12 13 /* Notes: 14 * 15 * This driver is designed exclusively for these chips (virtually the 16 * earliest of the scripts engine chips). They need their own drivers 17 * because they are missing so many of the scripts and snazzy register 18 * features of their elder brothers (the 710, 720 and 770). 19 * 20 * The 700 is the lowliest of the line, it can only do async SCSI. 21 * The 700-66 can at least do synchronous SCSI up to 10MHz. 22 * 23 * The 700 chip has no host bus interface logic of its own. However, 24 * it is usually mapped to a location with well defined register 25 * offsets. Therefore, if you can determine the base address and the 26 * irq your board incorporating this chip uses, you can probably use 27 * this driver to run it (although you'll probably have to write a 28 * minimal wrapper for the purpose---see the NCR_D700 driver for 29 * details about how to do this). 30 * 31 * 32 * TODO List: 33 * 34 * 1. Better statistics in the proc fs 35 * 36 * 2. Implement message queue (queues SCSI messages like commands) and make 37 * the abort and device reset functions use them. 38 * */ 39 40 /* CHANGELOG 41 * 42 * Version 2.8 43 * 44 * Fixed bad bug affecting tag starvation processing (previously the 45 * driver would hang the system if too many tags starved. Also fixed 46 * bad bug having to do with 10 byte command processing and REQUEST 47 * SENSE (the command would loop forever getting a transfer length 48 * mismatch in the CMD phase). 49 * 50 * Version 2.7 51 * 52 * Fixed scripts problem which caused certain devices (notably CDRWs) 53 * to hang on initial INQUIRY. Updated NCR_700_readl/writel to use 54 * __raw_readl/writel for parisc compatibility (Thomas 55 * Bogendoerfer). Added missing SCp->request_bufflen initialisation 56 * for sense requests (Ryan Bradetich). 57 * 58 * Version 2.6 59 * 60 * Following test of the 64 bit parisc kernel by Richard Hirst, 61 * several problems have now been corrected. Also adds support for 62 * consistent memory allocation. 63 * 64 * Version 2.5 65 * 66 * More Compatibility changes for 710 (now actually works). Enhanced 67 * support for odd clock speeds which constrain SDTR negotiations. 68 * correct cacheline separation for scsi messages and status for 69 * incoherent architectures. Use of the pci mapping functions on 70 * buffers to begin support for 64 bit drivers. 71 * 72 * Version 2.4 73 * 74 * Added support for the 53c710 chip (in 53c700 emulation mode only---no 75 * special 53c710 instructions or registers are used). 76 * 77 * Version 2.3 78 * 79 * More endianness/cache coherency changes. 80 * 81 * Better bad device handling (handles devices lying about tag 82 * queueing support and devices which fail to provide sense data on 83 * contingent allegiance conditions) 84 * 85 * Many thanks to Richard Hirst <rhirst@linuxcare.com> for patiently 86 * debugging this driver on the parisc architecture and suggesting 87 * many improvements and bug fixes. 88 * 89 * Thanks also go to Linuxcare Inc. for providing several PARISC 90 * machines for me to debug the driver on. 91 * 92 * Version 2.2 93 * 94 * Made the driver mem or io mapped; added endian invariance; added 95 * dma cache flushing operations for architectures which need it; 96 * added support for more varied clocking speeds. 97 * 98 * Version 2.1 99 * 100 * Initial modularisation from the D700. See NCR_D700.c for the rest of 101 * the changelog. 102 * */ 103 #define NCR_700_VERSION "2.8" 104 105 #include <linux/kernel.h> 106 #include <linux/types.h> 107 #include <linux/string.h> 108 #include <linux/slab.h> 109 #include <linux/ioport.h> 110 #include <linux/delay.h> 111 #include <linux/spinlock.h> 112 #include <linux/completion.h> 113 #include <linux/init.h> 114 #include <linux/proc_fs.h> 115 #include <linux/blkdev.h> 116 #include <linux/module.h> 117 #include <linux/interrupt.h> 118 #include <linux/device.h> 119 #include <linux/pgtable.h> 120 #include <asm/dma.h> 121 #include <asm/io.h> 122 #include <asm/byteorder.h> 123 124 #include <scsi/scsi.h> 125 #include <scsi/scsi_cmnd.h> 126 #include <scsi/scsi_dbg.h> 127 #include <scsi/scsi_eh.h> 128 #include <scsi/scsi_host.h> 129 #include <scsi/scsi_tcq.h> 130 #include <scsi/scsi_transport.h> 131 #include <scsi/scsi_transport_spi.h> 132 133 #include "53c700.h" 134 135 /* NOTE: For 64 bit drivers there are points in the code where we use 136 * a non dereferenceable pointer to point to a structure in dma-able 137 * memory (which is 32 bits) so that we can use all of the structure 138 * operations but take the address at the end. This macro allows us 139 * to truncate the 64 bit pointer down to 32 bits without the compiler 140 * complaining */ 141 #define to32bit(x) ((__u32)((unsigned long)(x))) 142 143 #ifdef NCR_700_DEBUG 144 #define STATIC 145 #else 146 #define STATIC static 147 #endif 148 149 MODULE_AUTHOR("James Bottomley"); 150 MODULE_DESCRIPTION("53c700 and 53c700-66 Driver"); 151 MODULE_LICENSE("GPL"); 152 153 /* This is the script */ 154 #include "53c700_d.h" 155 156 157 STATIC int NCR_700_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *); 158 STATIC int NCR_700_abort(struct scsi_cmnd * SCpnt); 159 STATIC int NCR_700_host_reset(struct scsi_cmnd * SCpnt); 160 STATIC void NCR_700_chip_setup(struct Scsi_Host *host); 161 STATIC void NCR_700_chip_reset(struct Scsi_Host *host); 162 STATIC int NCR_700_slave_alloc(struct scsi_device *SDpnt); 163 STATIC int NCR_700_slave_configure(struct scsi_device *SDpnt); 164 STATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt); 165 static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth); 166 167 STATIC struct device_attribute *NCR_700_dev_attrs[]; 168 169 STATIC struct scsi_transport_template *NCR_700_transport_template = NULL; 170 171 static char *NCR_700_phase[] = { 172 "", 173 "after selection", 174 "before command phase", 175 "after command phase", 176 "after status phase", 177 "after data in phase", 178 "after data out phase", 179 "during data phase", 180 }; 181 182 static char *NCR_700_condition[] = { 183 "", 184 "NOT MSG_OUT", 185 "UNEXPECTED PHASE", 186 "NOT MSG_IN", 187 "UNEXPECTED MSG", 188 "MSG_IN", 189 "SDTR_MSG RECEIVED", 190 "REJECT_MSG RECEIVED", 191 "DISCONNECT_MSG RECEIVED", 192 "MSG_OUT", 193 "DATA_IN", 194 195 }; 196 197 static char *NCR_700_fatal_messages[] = { 198 "unexpected message after reselection", 199 "still MSG_OUT after message injection", 200 "not MSG_IN after selection", 201 "Illegal message length received", 202 }; 203 204 static char *NCR_700_SBCL_bits[] = { 205 "IO ", 206 "CD ", 207 "MSG ", 208 "ATN ", 209 "SEL ", 210 "BSY ", 211 "ACK ", 212 "REQ ", 213 }; 214 215 static char *NCR_700_SBCL_to_phase[] = { 216 "DATA_OUT", 217 "DATA_IN", 218 "CMD_OUT", 219 "STATE", 220 "ILLEGAL PHASE", 221 "ILLEGAL PHASE", 222 "MSG OUT", 223 "MSG IN", 224 }; 225 226 /* This translates the SDTR message offset and period to a value 227 * which can be loaded into the SXFER_REG. 228 * 229 * NOTE: According to SCSI-2, the true transfer period (in ns) is 230 * actually four times this period value */ 231 static inline __u8 232 NCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters *hostdata, 233 __u8 offset, __u8 period) 234 { 235 int XFERP; 236 237 __u8 min_xferp = (hostdata->chip710 238 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP); 239 __u8 max_offset = (hostdata->chip710 240 ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET); 241 242 if(offset == 0) 243 return 0; 244 245 if(period < hostdata->min_period) { 246 printk(KERN_WARNING "53c700: Period %dns is less than this chip's minimum, setting to %d\n", period*4, NCR_700_MIN_PERIOD*4); 247 period = hostdata->min_period; 248 } 249 XFERP = (period*4 * hostdata->sync_clock)/1000 - 4; 250 if(offset > max_offset) { 251 printk(KERN_WARNING "53c700: Offset %d exceeds chip maximum, setting to %d\n", 252 offset, max_offset); 253 offset = max_offset; 254 } 255 if(XFERP < min_xferp) { 256 XFERP = min_xferp; 257 } 258 return (offset & 0x0f) | (XFERP & 0x07)<<4; 259 } 260 261 static inline __u8 262 NCR_700_get_SXFER(struct scsi_device *SDp) 263 { 264 struct NCR_700_Host_Parameters *hostdata = 265 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0]; 266 267 return NCR_700_offset_period_to_sxfer(hostdata, 268 spi_offset(SDp->sdev_target), 269 spi_period(SDp->sdev_target)); 270 } 271 272 static inline dma_addr_t virt_to_dma(struct NCR_700_Host_Parameters *h, void *p) 273 { 274 return h->pScript + ((uintptr_t)p - (uintptr_t)h->script); 275 } 276 277 static inline void dma_sync_to_dev(struct NCR_700_Host_Parameters *h, 278 void *addr, size_t size) 279 { 280 if (h->noncoherent) 281 dma_sync_single_for_device(h->dev, virt_to_dma(h, addr), 282 size, DMA_BIDIRECTIONAL); 283 } 284 285 static inline void dma_sync_from_dev(struct NCR_700_Host_Parameters *h, 286 void *addr, size_t size) 287 { 288 if (h->noncoherent) 289 dma_sync_single_for_device(h->dev, virt_to_dma(h, addr), size, 290 DMA_BIDIRECTIONAL); 291 } 292 293 struct Scsi_Host * 294 NCR_700_detect(struct scsi_host_template *tpnt, 295 struct NCR_700_Host_Parameters *hostdata, struct device *dev) 296 { 297 dma_addr_t pScript, pSlots; 298 __u8 *memory; 299 __u32 *script; 300 struct Scsi_Host *host; 301 static int banner = 0; 302 int j; 303 304 if(tpnt->sdev_attrs == NULL) 305 tpnt->sdev_attrs = NCR_700_dev_attrs; 306 307 memory = dma_alloc_coherent(dev, TOTAL_MEM_SIZE, &pScript, GFP_KERNEL); 308 if (!memory) { 309 hostdata->noncoherent = 1; 310 memory = dma_alloc_noncoherent(dev, TOTAL_MEM_SIZE, &pScript, 311 DMA_BIDIRECTIONAL, GFP_KERNEL); 312 } 313 if (!memory) { 314 printk(KERN_ERR "53c700: Failed to allocate memory for driver, detaching\n"); 315 return NULL; 316 } 317 318 script = (__u32 *)memory; 319 hostdata->msgin = memory + MSGIN_OFFSET; 320 hostdata->msgout = memory + MSGOUT_OFFSET; 321 hostdata->status = memory + STATUS_OFFSET; 322 hostdata->slots = (struct NCR_700_command_slot *)(memory + SLOTS_OFFSET); 323 hostdata->dev = dev; 324 325 pSlots = pScript + SLOTS_OFFSET; 326 327 /* Fill in the missing routines from the host template */ 328 tpnt->queuecommand = NCR_700_queuecommand; 329 tpnt->eh_abort_handler = NCR_700_abort; 330 tpnt->eh_host_reset_handler = NCR_700_host_reset; 331 tpnt->can_queue = NCR_700_COMMAND_SLOTS_PER_HOST; 332 tpnt->sg_tablesize = NCR_700_SG_SEGMENTS; 333 tpnt->cmd_per_lun = NCR_700_CMD_PER_LUN; 334 tpnt->slave_configure = NCR_700_slave_configure; 335 tpnt->slave_destroy = NCR_700_slave_destroy; 336 tpnt->slave_alloc = NCR_700_slave_alloc; 337 tpnt->change_queue_depth = NCR_700_change_queue_depth; 338 339 if(tpnt->name == NULL) 340 tpnt->name = "53c700"; 341 if(tpnt->proc_name == NULL) 342 tpnt->proc_name = "53c700"; 343 344 host = scsi_host_alloc(tpnt, 4); 345 if (!host) 346 return NULL; 347 memset(hostdata->slots, 0, sizeof(struct NCR_700_command_slot) 348 * NCR_700_COMMAND_SLOTS_PER_HOST); 349 for (j = 0; j < NCR_700_COMMAND_SLOTS_PER_HOST; j++) { 350 dma_addr_t offset = (dma_addr_t)((unsigned long)&hostdata->slots[j].SG[0] 351 - (unsigned long)&hostdata->slots[0].SG[0]); 352 hostdata->slots[j].pSG = (struct NCR_700_SG_List *)((unsigned long)(pSlots + offset)); 353 if(j == 0) 354 hostdata->free_list = &hostdata->slots[j]; 355 else 356 hostdata->slots[j-1].ITL_forw = &hostdata->slots[j]; 357 hostdata->slots[j].state = NCR_700_SLOT_FREE; 358 } 359 360 for (j = 0; j < ARRAY_SIZE(SCRIPT); j++) 361 script[j] = bS_to_host(SCRIPT[j]); 362 363 /* adjust all labels to be bus physical */ 364 for (j = 0; j < PATCHES; j++) 365 script[LABELPATCHES[j]] = bS_to_host(pScript + SCRIPT[LABELPATCHES[j]]); 366 /* now patch up fixed addresses. */ 367 script_patch_32(hostdata, script, MessageLocation, 368 pScript + MSGOUT_OFFSET); 369 script_patch_32(hostdata, script, StatusAddress, 370 pScript + STATUS_OFFSET); 371 script_patch_32(hostdata, script, ReceiveMsgAddress, 372 pScript + MSGIN_OFFSET); 373 374 hostdata->script = script; 375 hostdata->pScript = pScript; 376 dma_sync_single_for_device(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE); 377 hostdata->state = NCR_700_HOST_FREE; 378 hostdata->cmd = NULL; 379 host->max_id = 8; 380 host->max_lun = NCR_700_MAX_LUNS; 381 BUG_ON(NCR_700_transport_template == NULL); 382 host->transportt = NCR_700_transport_template; 383 host->unique_id = (unsigned long)hostdata->base; 384 hostdata->eh_complete = NULL; 385 host->hostdata[0] = (unsigned long)hostdata; 386 /* kick the chip */ 387 NCR_700_writeb(0xff, host, CTEST9_REG); 388 if (hostdata->chip710) 389 hostdata->rev = (NCR_700_readb(host, CTEST8_REG)>>4) & 0x0f; 390 else 391 hostdata->rev = (NCR_700_readb(host, CTEST7_REG)>>4) & 0x0f; 392 hostdata->fast = (NCR_700_readb(host, CTEST9_REG) == 0); 393 if (banner == 0) { 394 printk(KERN_NOTICE "53c700: Version " NCR_700_VERSION " By James.Bottomley@HansenPartnership.com\n"); 395 banner = 1; 396 } 397 printk(KERN_NOTICE "scsi%d: %s rev %d %s\n", host->host_no, 398 hostdata->chip710 ? "53c710" : 399 (hostdata->fast ? "53c700-66" : "53c700"), 400 hostdata->rev, hostdata->differential ? 401 "(Differential)" : ""); 402 /* reset the chip */ 403 NCR_700_chip_reset(host); 404 405 if (scsi_add_host(host, dev)) { 406 dev_printk(KERN_ERR, dev, "53c700: scsi_add_host failed\n"); 407 scsi_host_put(host); 408 return NULL; 409 } 410 411 spi_signalling(host) = hostdata->differential ? SPI_SIGNAL_HVD : 412 SPI_SIGNAL_SE; 413 414 return host; 415 } 416 417 int 418 NCR_700_release(struct Scsi_Host *host) 419 { 420 struct NCR_700_Host_Parameters *hostdata = 421 (struct NCR_700_Host_Parameters *)host->hostdata[0]; 422 423 if (hostdata->noncoherent) 424 dma_free_noncoherent(hostdata->dev, TOTAL_MEM_SIZE, 425 hostdata->script, hostdata->pScript, 426 DMA_BIDIRECTIONAL); 427 else 428 dma_free_coherent(hostdata->dev, TOTAL_MEM_SIZE, 429 hostdata->script, hostdata->pScript); 430 return 1; 431 } 432 433 static inline __u8 434 NCR_700_identify(int can_disconnect, __u8 lun) 435 { 436 return IDENTIFY_BASE | 437 ((can_disconnect) ? 0x40 : 0) | 438 (lun & NCR_700_LUN_MASK); 439 } 440 441 /* 442 * Function : static int data_residual (Scsi_Host *host) 443 * 444 * Purpose : return residual data count of what's in the chip. If you 445 * really want to know what this function is doing, it's almost a 446 * direct transcription of the algorithm described in the 53c710 447 * guide, except that the DBC and DFIFO registers are only 6 bits 448 * wide on a 53c700. 449 * 450 * Inputs : host - SCSI host */ 451 static inline int 452 NCR_700_data_residual (struct Scsi_Host *host) { 453 struct NCR_700_Host_Parameters *hostdata = 454 (struct NCR_700_Host_Parameters *)host->hostdata[0]; 455 int count, synchronous = 0; 456 unsigned int ddir; 457 458 if(hostdata->chip710) { 459 count = ((NCR_700_readb(host, DFIFO_REG) & 0x7f) - 460 (NCR_700_readl(host, DBC_REG) & 0x7f)) & 0x7f; 461 } else { 462 count = ((NCR_700_readb(host, DFIFO_REG) & 0x3f) - 463 (NCR_700_readl(host, DBC_REG) & 0x3f)) & 0x3f; 464 } 465 466 if(hostdata->fast) 467 synchronous = NCR_700_readb(host, SXFER_REG) & 0x0f; 468 469 /* get the data direction */ 470 ddir = NCR_700_readb(host, CTEST0_REG) & 0x01; 471 472 if (ddir) { 473 /* Receive */ 474 if (synchronous) 475 count += (NCR_700_readb(host, SSTAT2_REG) & 0xf0) >> 4; 476 else 477 if (NCR_700_readb(host, SSTAT1_REG) & SIDL_REG_FULL) 478 ++count; 479 } else { 480 /* Send */ 481 __u8 sstat = NCR_700_readb(host, SSTAT1_REG); 482 if (sstat & SODL_REG_FULL) 483 ++count; 484 if (synchronous && (sstat & SODR_REG_FULL)) 485 ++count; 486 } 487 #ifdef NCR_700_DEBUG 488 if(count) 489 printk("RESIDUAL IS %d (ddir %d)\n", count, ddir); 490 #endif 491 return count; 492 } 493 494 /* print out the SCSI wires and corresponding phase from the SBCL register 495 * in the chip */ 496 static inline char * 497 sbcl_to_string(__u8 sbcl) 498 { 499 int i; 500 static char ret[256]; 501 502 ret[0]='\0'; 503 for(i=0; i<8; i++) { 504 if((1<<i) & sbcl) 505 strcat(ret, NCR_700_SBCL_bits[i]); 506 } 507 strcat(ret, NCR_700_SBCL_to_phase[sbcl & 0x07]); 508 return ret; 509 } 510 511 static inline __u8 512 bitmap_to_number(__u8 bitmap) 513 { 514 __u8 i; 515 516 for(i=0; i<8 && !(bitmap &(1<<i)); i++) 517 ; 518 return i; 519 } 520 521 /* Pull a slot off the free list */ 522 STATIC struct NCR_700_command_slot * 523 find_empty_slot(struct NCR_700_Host_Parameters *hostdata) 524 { 525 struct NCR_700_command_slot *slot = hostdata->free_list; 526 527 if(slot == NULL) { 528 /* sanity check */ 529 if(hostdata->command_slot_count != NCR_700_COMMAND_SLOTS_PER_HOST) 530 printk(KERN_ERR "SLOTS FULL, but count is %d, should be %d\n", hostdata->command_slot_count, NCR_700_COMMAND_SLOTS_PER_HOST); 531 return NULL; 532 } 533 534 if(slot->state != NCR_700_SLOT_FREE) 535 /* should panic! */ 536 printk(KERN_ERR "BUSY SLOT ON FREE LIST!!!\n"); 537 538 539 hostdata->free_list = slot->ITL_forw; 540 slot->ITL_forw = NULL; 541 542 543 /* NOTE: set the state to busy here, not queued, since this 544 * indicates the slot is in use and cannot be run by the IRQ 545 * finish routine. If we cannot queue the command when it 546 * is properly build, we then change to NCR_700_SLOT_QUEUED */ 547 slot->state = NCR_700_SLOT_BUSY; 548 slot->flags = 0; 549 hostdata->command_slot_count++; 550 551 return slot; 552 } 553 554 STATIC void 555 free_slot(struct NCR_700_command_slot *slot, 556 struct NCR_700_Host_Parameters *hostdata) 557 { 558 if((slot->state & NCR_700_SLOT_MASK) != NCR_700_SLOT_MAGIC) { 559 printk(KERN_ERR "53c700: SLOT %p is not MAGIC!!!\n", slot); 560 } 561 if(slot->state == NCR_700_SLOT_FREE) { 562 printk(KERN_ERR "53c700: SLOT %p is FREE!!!\n", slot); 563 } 564 565 slot->resume_offset = 0; 566 slot->cmnd = NULL; 567 slot->state = NCR_700_SLOT_FREE; 568 slot->ITL_forw = hostdata->free_list; 569 hostdata->free_list = slot; 570 hostdata->command_slot_count--; 571 } 572 573 574 /* This routine really does very little. The command is indexed on 575 the ITL and (if tagged) the ITLQ lists in _queuecommand */ 576 STATIC void 577 save_for_reselection(struct NCR_700_Host_Parameters *hostdata, 578 struct scsi_cmnd *SCp, __u32 dsp) 579 { 580 /* Its just possible that this gets executed twice */ 581 if(SCp != NULL) { 582 struct NCR_700_command_slot *slot = 583 (struct NCR_700_command_slot *)SCp->host_scribble; 584 585 slot->resume_offset = dsp; 586 } 587 hostdata->state = NCR_700_HOST_FREE; 588 hostdata->cmd = NULL; 589 } 590 591 STATIC inline void 592 NCR_700_unmap(struct NCR_700_Host_Parameters *hostdata, struct scsi_cmnd *SCp, 593 struct NCR_700_command_slot *slot) 594 { 595 if(SCp->sc_data_direction != DMA_NONE && 596 SCp->sc_data_direction != DMA_BIDIRECTIONAL) 597 scsi_dma_unmap(SCp); 598 } 599 600 STATIC inline void 601 NCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata, 602 struct scsi_cmnd *SCp, int result) 603 { 604 hostdata->state = NCR_700_HOST_FREE; 605 hostdata->cmd = NULL; 606 607 if(SCp != NULL) { 608 struct NCR_700_command_slot *slot = 609 (struct NCR_700_command_slot *)SCp->host_scribble; 610 611 dma_unmap_single(hostdata->dev, slot->pCmd, 612 MAX_COMMAND_SIZE, DMA_TO_DEVICE); 613 if (slot->flags == NCR_700_FLAG_AUTOSENSE) { 614 char *cmnd = NCR_700_get_sense_cmnd(SCp->device); 615 616 dma_unmap_single(hostdata->dev, slot->dma_handle, 617 SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE); 618 /* restore the old result if the request sense was 619 * successful */ 620 if (result == 0) 621 result = cmnd[7]; 622 /* restore the original length */ 623 SCp->cmd_len = cmnd[8]; 624 } else 625 NCR_700_unmap(hostdata, SCp, slot); 626 627 free_slot(slot, hostdata); 628 #ifdef NCR_700_DEBUG 629 if(NCR_700_get_depth(SCp->device) == 0 || 630 NCR_700_get_depth(SCp->device) > SCp->device->queue_depth) 631 printk(KERN_ERR "Invalid depth in NCR_700_scsi_done(): %d\n", 632 NCR_700_get_depth(SCp->device)); 633 #endif /* NCR_700_DEBUG */ 634 NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) - 1); 635 636 SCp->host_scribble = NULL; 637 SCp->result = result; 638 SCp->scsi_done(SCp); 639 } else { 640 printk(KERN_ERR "53c700: SCSI DONE HAS NULL SCp\n"); 641 } 642 } 643 644 645 STATIC void 646 NCR_700_internal_bus_reset(struct Scsi_Host *host) 647 { 648 /* Bus reset */ 649 NCR_700_writeb(ASSERT_RST, host, SCNTL1_REG); 650 udelay(50); 651 NCR_700_writeb(0, host, SCNTL1_REG); 652 653 } 654 655 STATIC void 656 NCR_700_chip_setup(struct Scsi_Host *host) 657 { 658 struct NCR_700_Host_Parameters *hostdata = 659 (struct NCR_700_Host_Parameters *)host->hostdata[0]; 660 __u8 min_period; 661 __u8 min_xferp = (hostdata->chip710 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP); 662 663 if(hostdata->chip710) { 664 __u8 burst_disable = 0; 665 __u8 burst_length = 0; 666 667 switch (hostdata->burst_length) { 668 case 1: 669 burst_length = BURST_LENGTH_1; 670 break; 671 case 2: 672 burst_length = BURST_LENGTH_2; 673 break; 674 case 4: 675 burst_length = BURST_LENGTH_4; 676 break; 677 case 8: 678 burst_length = BURST_LENGTH_8; 679 break; 680 default: 681 burst_disable = BURST_DISABLE; 682 break; 683 } 684 hostdata->dcntl_extra |= COMPAT_700_MODE; 685 686 NCR_700_writeb(hostdata->dcntl_extra, host, DCNTL_REG); 687 NCR_700_writeb(burst_length | hostdata->dmode_extra, 688 host, DMODE_710_REG); 689 NCR_700_writeb(burst_disable | hostdata->ctest7_extra | 690 (hostdata->differential ? DIFF : 0), 691 host, CTEST7_REG); 692 NCR_700_writeb(BTB_TIMER_DISABLE, host, CTEST0_REG); 693 NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY | PARITY 694 | AUTO_ATN, host, SCNTL0_REG); 695 } else { 696 NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra, 697 host, DMODE_700_REG); 698 NCR_700_writeb(hostdata->differential ? 699 DIFF : 0, host, CTEST7_REG); 700 if(hostdata->fast) { 701 /* this is for 700-66, does nothing on 700 */ 702 NCR_700_writeb(LAST_DIS_ENBL | ENABLE_ACTIVE_NEGATION 703 | GENERATE_RECEIVE_PARITY, host, 704 CTEST8_REG); 705 } else { 706 NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY 707 | PARITY | AUTO_ATN, host, SCNTL0_REG); 708 } 709 } 710 711 NCR_700_writeb(1 << host->this_id, host, SCID_REG); 712 NCR_700_writeb(0, host, SBCL_REG); 713 NCR_700_writeb(ASYNC_OPERATION, host, SXFER_REG); 714 715 NCR_700_writeb(PHASE_MM_INT | SEL_TIMEOUT_INT | GROSS_ERR_INT | UX_DISC_INT 716 | RST_INT | PAR_ERR_INT | SELECT_INT, host, SIEN_REG); 717 718 NCR_700_writeb(ABORT_INT | INT_INST_INT | ILGL_INST_INT, host, DIEN_REG); 719 NCR_700_writeb(ENABLE_SELECT, host, SCNTL1_REG); 720 if(hostdata->clock > 75) { 721 printk(KERN_ERR "53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven at\n", hostdata->clock); 722 /* do the best we can, but the async clock will be out 723 * of spec: sync divider 2, async divider 3 */ 724 DEBUG(("53c700: sync 2 async 3\n")); 725 NCR_700_writeb(SYNC_DIV_2_0, host, SBCL_REG); 726 NCR_700_writeb(ASYNC_DIV_3_0 | hostdata->dcntl_extra, host, DCNTL_REG); 727 hostdata->sync_clock = hostdata->clock/2; 728 } else if(hostdata->clock > 50 && hostdata->clock <= 75) { 729 /* sync divider 1.5, async divider 3 */ 730 DEBUG(("53c700: sync 1.5 async 3\n")); 731 NCR_700_writeb(SYNC_DIV_1_5, host, SBCL_REG); 732 NCR_700_writeb(ASYNC_DIV_3_0 | hostdata->dcntl_extra, host, DCNTL_REG); 733 hostdata->sync_clock = hostdata->clock*2; 734 hostdata->sync_clock /= 3; 735 736 } else if(hostdata->clock > 37 && hostdata->clock <= 50) { 737 /* sync divider 1, async divider 2 */ 738 DEBUG(("53c700: sync 1 async 2\n")); 739 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG); 740 NCR_700_writeb(ASYNC_DIV_2_0 | hostdata->dcntl_extra, host, DCNTL_REG); 741 hostdata->sync_clock = hostdata->clock; 742 } else if(hostdata->clock > 25 && hostdata->clock <=37) { 743 /* sync divider 1, async divider 1.5 */ 744 DEBUG(("53c700: sync 1 async 1.5\n")); 745 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG); 746 NCR_700_writeb(ASYNC_DIV_1_5 | hostdata->dcntl_extra, host, DCNTL_REG); 747 hostdata->sync_clock = hostdata->clock; 748 } else { 749 DEBUG(("53c700: sync 1 async 1\n")); 750 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG); 751 NCR_700_writeb(ASYNC_DIV_1_0 | hostdata->dcntl_extra, host, DCNTL_REG); 752 /* sync divider 1, async divider 1 */ 753 hostdata->sync_clock = hostdata->clock; 754 } 755 /* Calculate the actual minimum period that can be supported 756 * by our synchronous clock speed. See the 710 manual for 757 * exact details of this calculation which is based on a 758 * setting of the SXFER register */ 759 min_period = 1000*(4+min_xferp)/(4*hostdata->sync_clock); 760 hostdata->min_period = NCR_700_MIN_PERIOD; 761 if(min_period > NCR_700_MIN_PERIOD) 762 hostdata->min_period = min_period; 763 } 764 765 STATIC void 766 NCR_700_chip_reset(struct Scsi_Host *host) 767 { 768 struct NCR_700_Host_Parameters *hostdata = 769 (struct NCR_700_Host_Parameters *)host->hostdata[0]; 770 if(hostdata->chip710) { 771 NCR_700_writeb(SOFTWARE_RESET_710, host, ISTAT_REG); 772 udelay(100); 773 774 NCR_700_writeb(0, host, ISTAT_REG); 775 } else { 776 NCR_700_writeb(SOFTWARE_RESET, host, DCNTL_REG); 777 udelay(100); 778 779 NCR_700_writeb(0, host, DCNTL_REG); 780 } 781 782 mdelay(1000); 783 784 NCR_700_chip_setup(host); 785 } 786 787 /* The heart of the message processing engine is that the instruction 788 * immediately after the INT is the normal case (and so must be CLEAR 789 * ACK). If we want to do something else, we call that routine in 790 * scripts and set temp to be the normal case + 8 (skipping the CLEAR 791 * ACK) so that the routine returns correctly to resume its activity 792 * */ 793 STATIC __u32 794 process_extended_message(struct Scsi_Host *host, 795 struct NCR_700_Host_Parameters *hostdata, 796 struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps) 797 { 798 __u32 resume_offset = dsp, temp = dsp + 8; 799 __u8 pun = 0xff, lun = 0xff; 800 801 if(SCp != NULL) { 802 pun = SCp->device->id; 803 lun = SCp->device->lun; 804 } 805 806 switch(hostdata->msgin[2]) { 807 case A_SDTR_MSG: 808 if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) { 809 struct scsi_target *starget = SCp->device->sdev_target; 810 __u8 period = hostdata->msgin[3]; 811 __u8 offset = hostdata->msgin[4]; 812 813 if(offset == 0 || period == 0) { 814 offset = 0; 815 period = 0; 816 } 817 818 spi_offset(starget) = offset; 819 spi_period(starget) = period; 820 821 if(NCR_700_is_flag_set(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION)) { 822 spi_display_xfer_agreement(starget); 823 NCR_700_clear_flag(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION); 824 } 825 826 NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC); 827 NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 828 829 NCR_700_writeb(NCR_700_get_SXFER(SCp->device), 830 host, SXFER_REG); 831 832 } else { 833 /* SDTR message out of the blue, reject it */ 834 shost_printk(KERN_WARNING, host, 835 "Unexpected SDTR msg\n"); 836 hostdata->msgout[0] = A_REJECT_MSG; 837 dma_sync_to_dev(hostdata, hostdata->msgout, 1); 838 script_patch_16(hostdata, hostdata->script, 839 MessageCount, 1); 840 /* SendMsgOut returns, so set up the return 841 * address */ 842 resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 843 } 844 break; 845 846 case A_WDTR_MSG: 847 printk(KERN_INFO "scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejecting\n", 848 host->host_no, pun, lun); 849 hostdata->msgout[0] = A_REJECT_MSG; 850 dma_sync_to_dev(hostdata, hostdata->msgout, 1); 851 script_patch_16(hostdata, hostdata->script, MessageCount, 1); 852 resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 853 854 break; 855 856 default: 857 printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ", 858 host->host_no, pun, lun, 859 NCR_700_phase[(dsps & 0xf00) >> 8]); 860 spi_print_msg(hostdata->msgin); 861 printk("\n"); 862 /* just reject it */ 863 hostdata->msgout[0] = A_REJECT_MSG; 864 dma_sync_to_dev(hostdata, hostdata->msgout, 1); 865 script_patch_16(hostdata, hostdata->script, MessageCount, 1); 866 /* SendMsgOut returns, so set up the return 867 * address */ 868 resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 869 } 870 NCR_700_writel(temp, host, TEMP_REG); 871 return resume_offset; 872 } 873 874 STATIC __u32 875 process_message(struct Scsi_Host *host, struct NCR_700_Host_Parameters *hostdata, 876 struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps) 877 { 878 /* work out where to return to */ 879 __u32 temp = dsp + 8, resume_offset = dsp; 880 __u8 pun = 0xff, lun = 0xff; 881 882 if(SCp != NULL) { 883 pun = SCp->device->id; 884 lun = SCp->device->lun; 885 } 886 887 #ifdef NCR_700_DEBUG 888 printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun, 889 NCR_700_phase[(dsps & 0xf00) >> 8]); 890 spi_print_msg(hostdata->msgin); 891 printk("\n"); 892 #endif 893 894 switch(hostdata->msgin[0]) { 895 896 case A_EXTENDED_MSG: 897 resume_offset = process_extended_message(host, hostdata, SCp, 898 dsp, dsps); 899 break; 900 901 case A_REJECT_MSG: 902 if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) { 903 /* Rejected our sync negotiation attempt */ 904 spi_period(SCp->device->sdev_target) = 905 spi_offset(SCp->device->sdev_target) = 0; 906 NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC); 907 NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 908 } else if(SCp != NULL && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) { 909 /* rejected our first simple tag message */ 910 scmd_printk(KERN_WARNING, SCp, 911 "Rejected first tag queue attempt, turning off tag queueing\n"); 912 /* we're done negotiating */ 913 NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION); 914 hostdata->tag_negotiated &= ~(1<<scmd_id(SCp)); 915 916 SCp->device->tagged_supported = 0; 917 SCp->device->simple_tags = 0; 918 scsi_change_queue_depth(SCp->device, host->cmd_per_lun); 919 } else { 920 shost_printk(KERN_WARNING, host, 921 "(%d:%d) Unexpected REJECT Message %s\n", 922 pun, lun, 923 NCR_700_phase[(dsps & 0xf00) >> 8]); 924 /* however, just ignore it */ 925 } 926 break; 927 928 case A_PARITY_ERROR_MSG: 929 printk(KERN_ERR "scsi%d (%d:%d) Parity Error!\n", host->host_no, 930 pun, lun); 931 NCR_700_internal_bus_reset(host); 932 break; 933 case A_SIMPLE_TAG_MSG: 934 printk(KERN_INFO "scsi%d (%d:%d) SIMPLE TAG %d %s\n", host->host_no, 935 pun, lun, hostdata->msgin[1], 936 NCR_700_phase[(dsps & 0xf00) >> 8]); 937 /* just ignore it */ 938 break; 939 default: 940 printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ", 941 host->host_no, pun, lun, 942 NCR_700_phase[(dsps & 0xf00) >> 8]); 943 944 spi_print_msg(hostdata->msgin); 945 printk("\n"); 946 /* just reject it */ 947 hostdata->msgout[0] = A_REJECT_MSG; 948 dma_sync_to_dev(hostdata, hostdata->msgout, 1); 949 script_patch_16(hostdata, hostdata->script, MessageCount, 1); 950 /* SendMsgOut returns, so set up the return 951 * address */ 952 resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 953 954 break; 955 } 956 NCR_700_writel(temp, host, TEMP_REG); 957 /* set us up to receive another message */ 958 dma_sync_from_dev(hostdata, hostdata->msgin, MSG_ARRAY_SIZE); 959 return resume_offset; 960 } 961 962 STATIC __u32 963 process_script_interrupt(__u32 dsps, __u32 dsp, struct scsi_cmnd *SCp, 964 struct Scsi_Host *host, 965 struct NCR_700_Host_Parameters *hostdata) 966 { 967 __u32 resume_offset = 0; 968 __u8 pun = 0xff, lun=0xff; 969 970 if(SCp != NULL) { 971 pun = SCp->device->id; 972 lun = SCp->device->lun; 973 } 974 975 if(dsps == A_GOOD_STATUS_AFTER_STATUS) { 976 DEBUG((" COMMAND COMPLETE, status=%02x\n", 977 hostdata->status[0])); 978 /* OK, if TCQ still under negotiation, we now know it works */ 979 if (NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) 980 NCR_700_set_tag_neg_state(SCp->device, 981 NCR_700_FINISHED_TAG_NEGOTIATION); 982 983 /* check for contingent allegiance contitions */ 984 if(status_byte(hostdata->status[0]) == CHECK_CONDITION || 985 status_byte(hostdata->status[0]) == COMMAND_TERMINATED) { 986 struct NCR_700_command_slot *slot = 987 (struct NCR_700_command_slot *)SCp->host_scribble; 988 if(slot->flags == NCR_700_FLAG_AUTOSENSE) { 989 /* OOPS: bad device, returning another 990 * contingent allegiance condition */ 991 scmd_printk(KERN_ERR, SCp, 992 "broken device is looping in contingent allegiance: ignoring\n"); 993 NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]); 994 } else { 995 char *cmnd = 996 NCR_700_get_sense_cmnd(SCp->device); 997 #ifdef NCR_DEBUG 998 scsi_print_command(SCp); 999 printk(" cmd %p has status %d, requesting sense\n", 1000 SCp, hostdata->status[0]); 1001 #endif 1002 /* we can destroy the command here 1003 * because the contingent allegiance 1004 * condition will cause a retry which 1005 * will re-copy the command from the 1006 * saved data_cmnd. We also unmap any 1007 * data associated with the command 1008 * here */ 1009 NCR_700_unmap(hostdata, SCp, slot); 1010 dma_unmap_single(hostdata->dev, slot->pCmd, 1011 MAX_COMMAND_SIZE, 1012 DMA_TO_DEVICE); 1013 1014 cmnd[0] = REQUEST_SENSE; 1015 cmnd[1] = (lun & 0x7) << 5; 1016 cmnd[2] = 0; 1017 cmnd[3] = 0; 1018 cmnd[4] = SCSI_SENSE_BUFFERSIZE; 1019 cmnd[5] = 0; 1020 /* Here's a quiet hack: the 1021 * REQUEST_SENSE command is six bytes, 1022 * so store a flag indicating that 1023 * this was an internal sense request 1024 * and the original status at the end 1025 * of the command */ 1026 cmnd[6] = NCR_700_INTERNAL_SENSE_MAGIC; 1027 cmnd[7] = hostdata->status[0]; 1028 cmnd[8] = SCp->cmd_len; 1029 SCp->cmd_len = 6; /* command length for 1030 * REQUEST_SENSE */ 1031 slot->pCmd = dma_map_single(hostdata->dev, cmnd, MAX_COMMAND_SIZE, DMA_TO_DEVICE); 1032 slot->dma_handle = dma_map_single(hostdata->dev, SCp->sense_buffer, SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE); 1033 slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | SCSI_SENSE_BUFFERSIZE); 1034 slot->SG[0].pAddr = bS_to_host(slot->dma_handle); 1035 slot->SG[1].ins = bS_to_host(SCRIPT_RETURN); 1036 slot->SG[1].pAddr = 0; 1037 slot->resume_offset = hostdata->pScript; 1038 dma_sync_to_dev(hostdata, slot->SG, sizeof(slot->SG[0])*2); 1039 dma_sync_from_dev(hostdata, SCp->sense_buffer, SCSI_SENSE_BUFFERSIZE); 1040 1041 /* queue the command for reissue */ 1042 slot->state = NCR_700_SLOT_QUEUED; 1043 slot->flags = NCR_700_FLAG_AUTOSENSE; 1044 hostdata->state = NCR_700_HOST_FREE; 1045 hostdata->cmd = NULL; 1046 } 1047 } else { 1048 // Currently rely on the mid layer evaluation 1049 // of the tag queuing capability 1050 // 1051 //if(status_byte(hostdata->status[0]) == GOOD && 1052 // SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) { 1053 // /* Piggy back the tag queueing support 1054 // * on this command */ 1055 // dma_sync_single_for_cpu(hostdata->dev, 1056 // slot->dma_handle, 1057 // SCp->request_bufflen, 1058 // DMA_FROM_DEVICE); 1059 // if(((char *)SCp->request_buffer)[7] & 0x02) { 1060 // scmd_printk(KERN_INFO, SCp, 1061 // "Enabling Tag Command Queuing\n"); 1062 // hostdata->tag_negotiated |= (1<<scmd_id(SCp)); 1063 // NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING); 1064 // } else { 1065 // NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING); 1066 // hostdata->tag_negotiated &= ~(1<<scmd_id(SCp)); 1067 // } 1068 //} 1069 NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]); 1070 } 1071 } else if((dsps & 0xfffff0f0) == A_UNEXPECTED_PHASE) { 1072 __u8 i = (dsps & 0xf00) >> 8; 1073 1074 scmd_printk(KERN_ERR, SCp, "UNEXPECTED PHASE %s (%s)\n", 1075 NCR_700_phase[i], 1076 sbcl_to_string(NCR_700_readb(host, SBCL_REG))); 1077 scmd_printk(KERN_ERR, SCp, " len = %d, cmd =", 1078 SCp->cmd_len); 1079 scsi_print_command(SCp); 1080 1081 NCR_700_internal_bus_reset(host); 1082 } else if((dsps & 0xfffff000) == A_FATAL) { 1083 int i = (dsps & 0xfff); 1084 1085 printk(KERN_ERR "scsi%d: (%d:%d) FATAL ERROR: %s\n", 1086 host->host_no, pun, lun, NCR_700_fatal_messages[i]); 1087 if(dsps == A_FATAL_ILLEGAL_MSG_LENGTH) { 1088 printk(KERN_ERR " msg begins %02x %02x\n", 1089 hostdata->msgin[0], hostdata->msgin[1]); 1090 } 1091 NCR_700_internal_bus_reset(host); 1092 } else if((dsps & 0xfffff0f0) == A_DISCONNECT) { 1093 #ifdef NCR_700_DEBUG 1094 __u8 i = (dsps & 0xf00) >> 8; 1095 1096 printk("scsi%d: (%d:%d), DISCONNECTED (%d) %s\n", 1097 host->host_no, pun, lun, 1098 i, NCR_700_phase[i]); 1099 #endif 1100 save_for_reselection(hostdata, SCp, dsp); 1101 1102 } else if(dsps == A_RESELECTION_IDENTIFIED) { 1103 __u8 lun; 1104 struct NCR_700_command_slot *slot; 1105 __u8 reselection_id = hostdata->reselection_id; 1106 struct scsi_device *SDp; 1107 1108 lun = hostdata->msgin[0] & 0x1f; 1109 1110 hostdata->reselection_id = 0xff; 1111 DEBUG(("scsi%d: (%d:%d) RESELECTED!\n", 1112 host->host_no, reselection_id, lun)); 1113 /* clear the reselection indicator */ 1114 SDp = __scsi_device_lookup(host, 0, reselection_id, lun); 1115 if(unlikely(SDp == NULL)) { 1116 printk(KERN_ERR "scsi%d: (%d:%d) HAS NO device\n", 1117 host->host_no, reselection_id, lun); 1118 BUG(); 1119 } 1120 if(hostdata->msgin[1] == A_SIMPLE_TAG_MSG) { 1121 struct scsi_cmnd *SCp; 1122 1123 SCp = scsi_host_find_tag(SDp->host, hostdata->msgin[2]); 1124 if(unlikely(SCp == NULL)) { 1125 printk(KERN_ERR "scsi%d: (%d:%d) no saved request for tag %d\n", 1126 host->host_no, reselection_id, lun, hostdata->msgin[2]); 1127 BUG(); 1128 } 1129 1130 slot = (struct NCR_700_command_slot *)SCp->host_scribble; 1131 DDEBUG(KERN_DEBUG, SDp, 1132 "reselection is tag %d, slot %p(%d)\n", 1133 hostdata->msgin[2], slot, slot->tag); 1134 } else { 1135 struct NCR_700_Device_Parameters *p = SDp->hostdata; 1136 struct scsi_cmnd *SCp = p->current_cmnd; 1137 1138 if(unlikely(SCp == NULL)) { 1139 sdev_printk(KERN_ERR, SDp, 1140 "no saved request for untagged cmd\n"); 1141 BUG(); 1142 } 1143 slot = (struct NCR_700_command_slot *)SCp->host_scribble; 1144 } 1145 1146 if(slot == NULL) { 1147 printk(KERN_ERR "scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!\n", 1148 host->host_no, reselection_id, lun, 1149 hostdata->msgin[0], hostdata->msgin[1], 1150 hostdata->msgin[2]); 1151 } else { 1152 if(hostdata->state != NCR_700_HOST_BUSY) 1153 printk(KERN_ERR "scsi%d: FATAL, host not busy during valid reselection!\n", 1154 host->host_no); 1155 resume_offset = slot->resume_offset; 1156 hostdata->cmd = slot->cmnd; 1157 1158 /* re-patch for this command */ 1159 script_patch_32_abs(hostdata, hostdata->script, 1160 CommandAddress, slot->pCmd); 1161 script_patch_16(hostdata, hostdata->script, 1162 CommandCount, slot->cmnd->cmd_len); 1163 script_patch_32_abs(hostdata, hostdata->script, 1164 SGScriptStartAddress, 1165 to32bit(&slot->pSG[0].ins)); 1166 1167 /* Note: setting SXFER only works if we're 1168 * still in the MESSAGE phase, so it is vital 1169 * that ACK is still asserted when we process 1170 * the reselection message. The resume offset 1171 * should therefore always clear ACK */ 1172 NCR_700_writeb(NCR_700_get_SXFER(hostdata->cmd->device), 1173 host, SXFER_REG); 1174 dma_sync_from_dev(hostdata, hostdata->msgin, 1175 MSG_ARRAY_SIZE); 1176 dma_sync_to_dev(hostdata, hostdata->msgout, 1177 MSG_ARRAY_SIZE); 1178 /* I'm just being paranoid here, the command should 1179 * already have been flushed from the cache */ 1180 dma_sync_to_dev(hostdata, slot->cmnd->cmnd, 1181 slot->cmnd->cmd_len); 1182 1183 1184 1185 } 1186 } else if(dsps == A_RESELECTED_DURING_SELECTION) { 1187 1188 /* This section is full of debugging code because I've 1189 * never managed to reach it. I think what happens is 1190 * that, because the 700 runs with selection 1191 * interrupts enabled the whole time that we take a 1192 * selection interrupt before we manage to get to the 1193 * reselected script interrupt */ 1194 1195 __u8 reselection_id = NCR_700_readb(host, SFBR_REG); 1196 struct NCR_700_command_slot *slot; 1197 1198 /* Take out our own ID */ 1199 reselection_id &= ~(1<<host->this_id); 1200 1201 /* I've never seen this happen, so keep this as a printk rather 1202 * than a debug */ 1203 printk(KERN_INFO "scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%d\n", 1204 host->host_no, reselection_id, lun, dsp, dsp - hostdata->pScript, hostdata->state, hostdata->command_slot_count); 1205 1206 { 1207 /* FIXME: DEBUGGING CODE */ 1208 __u32 SG = (__u32)bS_to_cpu(hostdata->script[A_SGScriptStartAddress_used[0]]); 1209 int i; 1210 1211 for(i=0; i< NCR_700_COMMAND_SLOTS_PER_HOST; i++) { 1212 if(SG >= to32bit(&hostdata->slots[i].pSG[0]) 1213 && SG <= to32bit(&hostdata->slots[i].pSG[NCR_700_SG_SEGMENTS])) 1214 break; 1215 } 1216 printk(KERN_INFO "IDENTIFIED SG segment as being %08x in slot %p, cmd %p, slot->resume_offset=%08x\n", SG, &hostdata->slots[i], hostdata->slots[i].cmnd, hostdata->slots[i].resume_offset); 1217 SCp = hostdata->slots[i].cmnd; 1218 } 1219 1220 if(SCp != NULL) { 1221 slot = (struct NCR_700_command_slot *)SCp->host_scribble; 1222 /* change slot from busy to queued to redo command */ 1223 slot->state = NCR_700_SLOT_QUEUED; 1224 } 1225 hostdata->cmd = NULL; 1226 1227 if(reselection_id == 0) { 1228 if(hostdata->reselection_id == 0xff) { 1229 printk(KERN_ERR "scsi%d: Invalid reselection during selection!!\n", host->host_no); 1230 return 0; 1231 } else { 1232 printk(KERN_ERR "scsi%d: script reselected and we took a selection interrupt\n", 1233 host->host_no); 1234 reselection_id = hostdata->reselection_id; 1235 } 1236 } else { 1237 1238 /* convert to real ID */ 1239 reselection_id = bitmap_to_number(reselection_id); 1240 } 1241 hostdata->reselection_id = reselection_id; 1242 /* just in case we have a stale simple tag message, clear it */ 1243 hostdata->msgin[1] = 0; 1244 dma_sync_to_dev(hostdata, hostdata->msgin, MSG_ARRAY_SIZE); 1245 if(hostdata->tag_negotiated & (1<<reselection_id)) { 1246 resume_offset = hostdata->pScript + Ent_GetReselectionWithTag; 1247 } else { 1248 resume_offset = hostdata->pScript + Ent_GetReselectionData; 1249 } 1250 } else if(dsps == A_COMPLETED_SELECTION_AS_TARGET) { 1251 /* we've just disconnected from the bus, do nothing since 1252 * a return here will re-run the queued command slot 1253 * that may have been interrupted by the initial selection */ 1254 DEBUG((" SELECTION COMPLETED\n")); 1255 } else if((dsps & 0xfffff0f0) == A_MSG_IN) { 1256 resume_offset = process_message(host, hostdata, SCp, 1257 dsp, dsps); 1258 } else if((dsps & 0xfffff000) == 0) { 1259 __u8 i = (dsps & 0xf0) >> 4, j = (dsps & 0xf00) >> 8; 1260 printk(KERN_ERR "scsi%d: (%d:%d), unhandled script condition %s %s at %04x\n", 1261 host->host_no, pun, lun, NCR_700_condition[i], 1262 NCR_700_phase[j], dsp - hostdata->pScript); 1263 if(SCp != NULL) { 1264 struct scatterlist *sg; 1265 1266 scsi_print_command(SCp); 1267 scsi_for_each_sg(SCp, sg, scsi_sg_count(SCp) + 1, i) { 1268 printk(KERN_INFO " SG[%d].length = %d, move_insn=%08x, addr %08x\n", i, sg->length, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].ins, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].pAddr); 1269 } 1270 } 1271 NCR_700_internal_bus_reset(host); 1272 } else if((dsps & 0xfffff000) == A_DEBUG_INTERRUPT) { 1273 printk(KERN_NOTICE "scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuing\n", 1274 host->host_no, pun, lun, dsps & 0xfff, dsp, dsp - hostdata->pScript); 1275 resume_offset = dsp; 1276 } else { 1277 printk(KERN_ERR "scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04x\n", 1278 host->host_no, pun, lun, dsps, dsp - hostdata->pScript); 1279 NCR_700_internal_bus_reset(host); 1280 } 1281 return resume_offset; 1282 } 1283 1284 /* We run the 53c700 with selection interrupts always enabled. This 1285 * means that the chip may be selected as soon as the bus frees. On a 1286 * busy bus, this can be before the scripts engine finishes its 1287 * processing. Therefore, part of the selection processing has to be 1288 * to find out what the scripts engine is doing and complete the 1289 * function if necessary (i.e. process the pending disconnect or save 1290 * the interrupted initial selection */ 1291 STATIC inline __u32 1292 process_selection(struct Scsi_Host *host, __u32 dsp) 1293 { 1294 __u8 id = 0; /* Squash compiler warning */ 1295 int count = 0; 1296 __u32 resume_offset = 0; 1297 struct NCR_700_Host_Parameters *hostdata = 1298 (struct NCR_700_Host_Parameters *)host->hostdata[0]; 1299 struct scsi_cmnd *SCp = hostdata->cmd; 1300 __u8 sbcl; 1301 1302 for(count = 0; count < 5; count++) { 1303 id = NCR_700_readb(host, hostdata->chip710 ? 1304 CTEST9_REG : SFBR_REG); 1305 1306 /* Take out our own ID */ 1307 id &= ~(1<<host->this_id); 1308 if(id != 0) 1309 break; 1310 udelay(5); 1311 } 1312 sbcl = NCR_700_readb(host, SBCL_REG); 1313 if((sbcl & SBCL_IO) == 0) { 1314 /* mark as having been selected rather than reselected */ 1315 id = 0xff; 1316 } else { 1317 /* convert to real ID */ 1318 hostdata->reselection_id = id = bitmap_to_number(id); 1319 DEBUG(("scsi%d: Reselected by %d\n", 1320 host->host_no, id)); 1321 } 1322 if(hostdata->state == NCR_700_HOST_BUSY && SCp != NULL) { 1323 struct NCR_700_command_slot *slot = 1324 (struct NCR_700_command_slot *)SCp->host_scribble; 1325 DEBUG((" ID %d WARNING: RESELECTION OF BUSY HOST, saving cmd %p, slot %p, addr %x [%04x], resume %x!\n", id, hostdata->cmd, slot, dsp, dsp - hostdata->pScript, resume_offset)); 1326 1327 switch(dsp - hostdata->pScript) { 1328 case Ent_Disconnect1: 1329 case Ent_Disconnect2: 1330 save_for_reselection(hostdata, SCp, Ent_Disconnect2 + hostdata->pScript); 1331 break; 1332 case Ent_Disconnect3: 1333 case Ent_Disconnect4: 1334 save_for_reselection(hostdata, SCp, Ent_Disconnect4 + hostdata->pScript); 1335 break; 1336 case Ent_Disconnect5: 1337 case Ent_Disconnect6: 1338 save_for_reselection(hostdata, SCp, Ent_Disconnect6 + hostdata->pScript); 1339 break; 1340 case Ent_Disconnect7: 1341 case Ent_Disconnect8: 1342 save_for_reselection(hostdata, SCp, Ent_Disconnect8 + hostdata->pScript); 1343 break; 1344 case Ent_Finish1: 1345 case Ent_Finish2: 1346 process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS, dsp, SCp, host, hostdata); 1347 break; 1348 1349 default: 1350 slot->state = NCR_700_SLOT_QUEUED; 1351 break; 1352 } 1353 } 1354 hostdata->state = NCR_700_HOST_BUSY; 1355 hostdata->cmd = NULL; 1356 /* clear any stale simple tag message */ 1357 hostdata->msgin[1] = 0; 1358 dma_sync_to_dev(hostdata, hostdata->msgin, MSG_ARRAY_SIZE); 1359 1360 if(id == 0xff) { 1361 /* Selected as target, Ignore */ 1362 resume_offset = hostdata->pScript + Ent_SelectedAsTarget; 1363 } else if(hostdata->tag_negotiated & (1<<id)) { 1364 resume_offset = hostdata->pScript + Ent_GetReselectionWithTag; 1365 } else { 1366 resume_offset = hostdata->pScript + Ent_GetReselectionData; 1367 } 1368 return resume_offset; 1369 } 1370 1371 static inline void 1372 NCR_700_clear_fifo(struct Scsi_Host *host) { 1373 const struct NCR_700_Host_Parameters *hostdata 1374 = (struct NCR_700_Host_Parameters *)host->hostdata[0]; 1375 if(hostdata->chip710) { 1376 NCR_700_writeb(CLR_FIFO_710, host, CTEST8_REG); 1377 } else { 1378 NCR_700_writeb(CLR_FIFO, host, DFIFO_REG); 1379 } 1380 } 1381 1382 static inline void 1383 NCR_700_flush_fifo(struct Scsi_Host *host) { 1384 const struct NCR_700_Host_Parameters *hostdata 1385 = (struct NCR_700_Host_Parameters *)host->hostdata[0]; 1386 if(hostdata->chip710) { 1387 NCR_700_writeb(FLUSH_DMA_FIFO_710, host, CTEST8_REG); 1388 udelay(10); 1389 NCR_700_writeb(0, host, CTEST8_REG); 1390 } else { 1391 NCR_700_writeb(FLUSH_DMA_FIFO, host, DFIFO_REG); 1392 udelay(10); 1393 NCR_700_writeb(0, host, DFIFO_REG); 1394 } 1395 } 1396 1397 1398 /* The queue lock with interrupts disabled must be held on entry to 1399 * this function */ 1400 STATIC int 1401 NCR_700_start_command(struct scsi_cmnd *SCp) 1402 { 1403 struct NCR_700_command_slot *slot = 1404 (struct NCR_700_command_slot *)SCp->host_scribble; 1405 struct NCR_700_Host_Parameters *hostdata = 1406 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0]; 1407 __u16 count = 1; /* for IDENTIFY message */ 1408 u8 lun = SCp->device->lun; 1409 1410 if(hostdata->state != NCR_700_HOST_FREE) { 1411 /* keep this inside the lock to close the race window where 1412 * the running command finishes on another CPU while we don't 1413 * change the state to queued on this one */ 1414 slot->state = NCR_700_SLOT_QUEUED; 1415 1416 DEBUG(("scsi%d: host busy, queueing command %p, slot %p\n", 1417 SCp->device->host->host_no, slot->cmnd, slot)); 1418 return 0; 1419 } 1420 hostdata->state = NCR_700_HOST_BUSY; 1421 hostdata->cmd = SCp; 1422 slot->state = NCR_700_SLOT_BUSY; 1423 /* keep interrupts disabled until we have the command correctly 1424 * set up so we cannot take a selection interrupt */ 1425 1426 hostdata->msgout[0] = NCR_700_identify((SCp->cmnd[0] != REQUEST_SENSE && 1427 slot->flags != NCR_700_FLAG_AUTOSENSE), 1428 lun); 1429 /* for INQUIRY or REQUEST_SENSE commands, we cannot be sure 1430 * if the negotiated transfer parameters still hold, so 1431 * always renegotiate them */ 1432 if(SCp->cmnd[0] == INQUIRY || SCp->cmnd[0] == REQUEST_SENSE || 1433 slot->flags == NCR_700_FLAG_AUTOSENSE) { 1434 NCR_700_clear_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC); 1435 } 1436 1437 /* REQUEST_SENSE is asking for contingent I_T_L(_Q) status. 1438 * If a contingent allegiance condition exists, the device 1439 * will refuse all tags, so send the request sense as untagged 1440 * */ 1441 if((hostdata->tag_negotiated & (1<<scmd_id(SCp))) 1442 && (slot->tag != SCSI_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE && 1443 slot->flags != NCR_700_FLAG_AUTOSENSE)) { 1444 count += spi_populate_tag_msg(&hostdata->msgout[count], SCp); 1445 } 1446 1447 if(hostdata->fast && 1448 NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC)) { 1449 count += spi_populate_sync_msg(&hostdata->msgout[count], 1450 spi_period(SCp->device->sdev_target), 1451 spi_offset(SCp->device->sdev_target)); 1452 NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 1453 } 1454 1455 script_patch_16(hostdata, hostdata->script, MessageCount, count); 1456 1457 script_patch_ID(hostdata, hostdata->script, Device_ID, 1<<scmd_id(SCp)); 1458 1459 script_patch_32_abs(hostdata, hostdata->script, CommandAddress, 1460 slot->pCmd); 1461 script_patch_16(hostdata, hostdata->script, CommandCount, SCp->cmd_len); 1462 /* finally plumb the beginning of the SG list into the script 1463 * */ 1464 script_patch_32_abs(hostdata, hostdata->script, 1465 SGScriptStartAddress, to32bit(&slot->pSG[0].ins)); 1466 NCR_700_clear_fifo(SCp->device->host); 1467 1468 if(slot->resume_offset == 0) 1469 slot->resume_offset = hostdata->pScript; 1470 /* now perform all the writebacks and invalidates */ 1471 dma_sync_to_dev(hostdata, hostdata->msgout, count); 1472 dma_sync_from_dev(hostdata, hostdata->msgin, MSG_ARRAY_SIZE); 1473 dma_sync_to_dev(hostdata, SCp->cmnd, SCp->cmd_len); 1474 dma_sync_from_dev(hostdata, hostdata->status, 1); 1475 1476 /* set the synchronous period/offset */ 1477 NCR_700_writeb(NCR_700_get_SXFER(SCp->device), 1478 SCp->device->host, SXFER_REG); 1479 NCR_700_writel(slot->temp, SCp->device->host, TEMP_REG); 1480 NCR_700_writel(slot->resume_offset, SCp->device->host, DSP_REG); 1481 1482 return 1; 1483 } 1484 1485 irqreturn_t 1486 NCR_700_intr(int irq, void *dev_id) 1487 { 1488 struct Scsi_Host *host = (struct Scsi_Host *)dev_id; 1489 struct NCR_700_Host_Parameters *hostdata = 1490 (struct NCR_700_Host_Parameters *)host->hostdata[0]; 1491 __u8 istat; 1492 __u32 resume_offset = 0; 1493 __u8 pun = 0xff, lun = 0xff; 1494 unsigned long flags; 1495 int handled = 0; 1496 1497 /* Use the host lock to serialise access to the 53c700 1498 * hardware. Note: In future, we may need to take the queue 1499 * lock to enter the done routines. When that happens, we 1500 * need to ensure that for this driver, the host lock and the 1501 * queue lock point to the same thing. */ 1502 spin_lock_irqsave(host->host_lock, flags); 1503 if((istat = NCR_700_readb(host, ISTAT_REG)) 1504 & (SCSI_INT_PENDING | DMA_INT_PENDING)) { 1505 __u32 dsps; 1506 __u8 sstat0 = 0, dstat = 0; 1507 __u32 dsp; 1508 struct scsi_cmnd *SCp = hostdata->cmd; 1509 enum NCR_700_Host_State state; 1510 1511 handled = 1; 1512 state = hostdata->state; 1513 SCp = hostdata->cmd; 1514 1515 if(istat & SCSI_INT_PENDING) { 1516 udelay(10); 1517 1518 sstat0 = NCR_700_readb(host, SSTAT0_REG); 1519 } 1520 1521 if(istat & DMA_INT_PENDING) { 1522 udelay(10); 1523 1524 dstat = NCR_700_readb(host, DSTAT_REG); 1525 } 1526 1527 dsps = NCR_700_readl(host, DSPS_REG); 1528 dsp = NCR_700_readl(host, DSP_REG); 1529 1530 DEBUG(("scsi%d: istat %02x sstat0 %02x dstat %02x dsp %04x[%08x] dsps 0x%x\n", 1531 host->host_no, istat, sstat0, dstat, 1532 (dsp - (__u32)(hostdata->pScript))/4, 1533 dsp, dsps)); 1534 1535 if(SCp != NULL) { 1536 pun = SCp->device->id; 1537 lun = SCp->device->lun; 1538 } 1539 1540 if(sstat0 & SCSI_RESET_DETECTED) { 1541 struct scsi_device *SDp; 1542 int i; 1543 1544 hostdata->state = NCR_700_HOST_BUSY; 1545 1546 printk(KERN_ERR "scsi%d: Bus Reset detected, executing command %p, slot %p, dsp %08x[%04x]\n", 1547 host->host_no, SCp, SCp == NULL ? NULL : SCp->host_scribble, dsp, dsp - hostdata->pScript); 1548 1549 scsi_report_bus_reset(host, 0); 1550 1551 /* clear all the negotiated parameters */ 1552 __shost_for_each_device(SDp, host) 1553 NCR_700_clear_flag(SDp, ~0); 1554 1555 /* clear all the slots and their pending commands */ 1556 for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) { 1557 struct scsi_cmnd *SCp; 1558 struct NCR_700_command_slot *slot = 1559 &hostdata->slots[i]; 1560 1561 if(slot->state == NCR_700_SLOT_FREE) 1562 continue; 1563 1564 SCp = slot->cmnd; 1565 printk(KERN_ERR " failing command because of reset, slot %p, cmnd %p\n", 1566 slot, SCp); 1567 free_slot(slot, hostdata); 1568 SCp->host_scribble = NULL; 1569 NCR_700_set_depth(SCp->device, 0); 1570 /* NOTE: deadlock potential here: we 1571 * rely on mid-layer guarantees that 1572 * scsi_done won't try to issue the 1573 * command again otherwise we'll 1574 * deadlock on the 1575 * hostdata->state_lock */ 1576 SCp->result = DID_RESET << 16; 1577 SCp->scsi_done(SCp); 1578 } 1579 mdelay(25); 1580 NCR_700_chip_setup(host); 1581 1582 hostdata->state = NCR_700_HOST_FREE; 1583 hostdata->cmd = NULL; 1584 /* signal back if this was an eh induced reset */ 1585 if(hostdata->eh_complete != NULL) 1586 complete(hostdata->eh_complete); 1587 goto out_unlock; 1588 } else if(sstat0 & SELECTION_TIMEOUT) { 1589 DEBUG(("scsi%d: (%d:%d) selection timeout\n", 1590 host->host_no, pun, lun)); 1591 NCR_700_scsi_done(hostdata, SCp, DID_NO_CONNECT<<16); 1592 } else if(sstat0 & PHASE_MISMATCH) { 1593 struct NCR_700_command_slot *slot = (SCp == NULL) ? NULL : 1594 (struct NCR_700_command_slot *)SCp->host_scribble; 1595 1596 if(dsp == Ent_SendMessage + 8 + hostdata->pScript) { 1597 /* It wants to reply to some part of 1598 * our message */ 1599 #ifdef NCR_700_DEBUG 1600 __u32 temp = NCR_700_readl(host, TEMP_REG); 1601 int count = (hostdata->script[Ent_SendMessage/4] & 0xffffff) - ((NCR_700_readl(host, DBC_REG) & 0xffffff) + NCR_700_data_residual(host)); 1602 printk("scsi%d (%d:%d) PHASE MISMATCH IN SEND MESSAGE %d remain, return %p[%04x], phase %s\n", host->host_no, pun, lun, count, (void *)temp, temp - hostdata->pScript, sbcl_to_string(NCR_700_readb(host, SBCL_REG))); 1603 #endif 1604 resume_offset = hostdata->pScript + Ent_SendMessagePhaseMismatch; 1605 } else if(dsp >= to32bit(&slot->pSG[0].ins) && 1606 dsp <= to32bit(&slot->pSG[NCR_700_SG_SEGMENTS].ins)) { 1607 int data_transfer = NCR_700_readl(host, DBC_REG) & 0xffffff; 1608 int SGcount = (dsp - to32bit(&slot->pSG[0].ins))/sizeof(struct NCR_700_SG_List); 1609 int residual = NCR_700_data_residual(host); 1610 int i; 1611 #ifdef NCR_700_DEBUG 1612 __u32 naddr = NCR_700_readl(host, DNAD_REG); 1613 1614 printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x\n", 1615 host->host_no, pun, lun, 1616 SGcount, data_transfer); 1617 scsi_print_command(SCp); 1618 if(residual) { 1619 printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x, residual %d\n", 1620 host->host_no, pun, lun, 1621 SGcount, data_transfer, residual); 1622 } 1623 #endif 1624 data_transfer += residual; 1625 1626 if(data_transfer != 0) { 1627 int count; 1628 __u32 pAddr; 1629 1630 SGcount--; 1631 1632 count = (bS_to_cpu(slot->SG[SGcount].ins) & 0x00ffffff); 1633 DEBUG(("DATA TRANSFER MISMATCH, count = %d, transferred %d\n", count, count-data_transfer)); 1634 slot->SG[SGcount].ins &= bS_to_host(0xff000000); 1635 slot->SG[SGcount].ins |= bS_to_host(data_transfer); 1636 pAddr = bS_to_cpu(slot->SG[SGcount].pAddr); 1637 pAddr += (count - data_transfer); 1638 #ifdef NCR_700_DEBUG 1639 if(pAddr != naddr) { 1640 printk("scsi%d (%d:%d) transfer mismatch pAddr=%lx, naddr=%lx, data_transfer=%d, residual=%d\n", host->host_no, pun, lun, (unsigned long)pAddr, (unsigned long)naddr, data_transfer, residual); 1641 } 1642 #endif 1643 slot->SG[SGcount].pAddr = bS_to_host(pAddr); 1644 } 1645 /* set the executed moves to nops */ 1646 for(i=0; i<SGcount; i++) { 1647 slot->SG[i].ins = bS_to_host(SCRIPT_NOP); 1648 slot->SG[i].pAddr = 0; 1649 } 1650 dma_sync_to_dev(hostdata, slot->SG, sizeof(slot->SG)); 1651 /* and pretend we disconnected after 1652 * the command phase */ 1653 resume_offset = hostdata->pScript + Ent_MsgInDuringData; 1654 /* make sure all the data is flushed */ 1655 NCR_700_flush_fifo(host); 1656 } else { 1657 __u8 sbcl = NCR_700_readb(host, SBCL_REG); 1658 printk(KERN_ERR "scsi%d: (%d:%d) phase mismatch at %04x, phase %s\n", 1659 host->host_no, pun, lun, dsp - hostdata->pScript, sbcl_to_string(sbcl)); 1660 NCR_700_internal_bus_reset(host); 1661 } 1662 1663 } else if(sstat0 & SCSI_GROSS_ERROR) { 1664 printk(KERN_ERR "scsi%d: (%d:%d) GROSS ERROR\n", 1665 host->host_no, pun, lun); 1666 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 1667 } else if(sstat0 & PARITY_ERROR) { 1668 printk(KERN_ERR "scsi%d: (%d:%d) PARITY ERROR\n", 1669 host->host_no, pun, lun); 1670 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 1671 } else if(dstat & SCRIPT_INT_RECEIVED) { 1672 DEBUG(("scsi%d: (%d:%d) ====>SCRIPT INTERRUPT<====\n", 1673 host->host_no, pun, lun)); 1674 resume_offset = process_script_interrupt(dsps, dsp, SCp, host, hostdata); 1675 } else if(dstat & (ILGL_INST_DETECTED)) { 1676 printk(KERN_ERR "scsi%d: (%d:%d) Illegal Instruction detected at 0x%08x[0x%x]!!!\n" 1677 " Please email James.Bottomley@HansenPartnership.com with the details\n", 1678 host->host_no, pun, lun, 1679 dsp, dsp - hostdata->pScript); 1680 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 1681 } else if(dstat & (WATCH_DOG_INTERRUPT|ABORTED)) { 1682 printk(KERN_ERR "scsi%d: (%d:%d) serious DMA problem, dstat=%02x\n", 1683 host->host_no, pun, lun, dstat); 1684 NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 1685 } 1686 1687 1688 /* NOTE: selection interrupt processing MUST occur 1689 * after script interrupt processing to correctly cope 1690 * with the case where we process a disconnect and 1691 * then get reselected before we process the 1692 * disconnection */ 1693 if(sstat0 & SELECTED) { 1694 /* FIXME: It currently takes at least FOUR 1695 * interrupts to complete a command that 1696 * disconnects: one for the disconnect, one 1697 * for the reselection, one to get the 1698 * reselection data and one to complete the 1699 * command. If we guess the reselected 1700 * command here and prepare it, we only need 1701 * to get a reselection data interrupt if we 1702 * guessed wrongly. Since the interrupt 1703 * overhead is much greater than the command 1704 * setup, this would be an efficient 1705 * optimisation particularly as we probably 1706 * only have one outstanding command on a 1707 * target most of the time */ 1708 1709 resume_offset = process_selection(host, dsp); 1710 1711 } 1712 1713 } 1714 1715 if(resume_offset) { 1716 if(hostdata->state != NCR_700_HOST_BUSY) { 1717 printk(KERN_ERR "scsi%d: Driver error: resume at 0x%08x [0x%04x] with non busy host!\n", 1718 host->host_no, resume_offset, resume_offset - hostdata->pScript); 1719 hostdata->state = NCR_700_HOST_BUSY; 1720 } 1721 1722 DEBUG(("Attempting to resume at %x\n", resume_offset)); 1723 NCR_700_clear_fifo(host); 1724 NCR_700_writel(resume_offset, host, DSP_REG); 1725 } 1726 /* There is probably a technical no-no about this: If we're a 1727 * shared interrupt and we got this interrupt because the 1728 * other device needs servicing not us, we're still going to 1729 * check our queued commands here---of course, there shouldn't 1730 * be any outstanding.... */ 1731 if(hostdata->state == NCR_700_HOST_FREE) { 1732 int i; 1733 1734 for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) { 1735 /* fairness: always run the queue from the last 1736 * position we left off */ 1737 int j = (i + hostdata->saved_slot_position) 1738 % NCR_700_COMMAND_SLOTS_PER_HOST; 1739 1740 if(hostdata->slots[j].state != NCR_700_SLOT_QUEUED) 1741 continue; 1742 if(NCR_700_start_command(hostdata->slots[j].cmnd)) { 1743 DEBUG(("scsi%d: Issuing saved command slot %p, cmd %p\t\n", 1744 host->host_no, &hostdata->slots[j], 1745 hostdata->slots[j].cmnd)); 1746 hostdata->saved_slot_position = j + 1; 1747 } 1748 1749 break; 1750 } 1751 } 1752 out_unlock: 1753 spin_unlock_irqrestore(host->host_lock, flags); 1754 return IRQ_RETVAL(handled); 1755 } 1756 1757 static int 1758 NCR_700_queuecommand_lck(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *)) 1759 { 1760 struct NCR_700_Host_Parameters *hostdata = 1761 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0]; 1762 __u32 move_ins; 1763 enum dma_data_direction direction; 1764 struct NCR_700_command_slot *slot; 1765 1766 if(hostdata->command_slot_count >= NCR_700_COMMAND_SLOTS_PER_HOST) { 1767 /* We're over our allocation, this should never happen 1768 * since we report the max allocation to the mid layer */ 1769 printk(KERN_WARNING "scsi%d: Command depth has gone over queue depth\n", SCp->device->host->host_no); 1770 return 1; 1771 } 1772 /* check for untagged commands. We cannot have any outstanding 1773 * commands if we accept them. Commands could be untagged because: 1774 * 1775 * - The tag negotiated bitmap is clear 1776 * - The blk layer sent and untagged command 1777 */ 1778 if(NCR_700_get_depth(SCp->device) != 0 1779 && (!(hostdata->tag_negotiated & (1<<scmd_id(SCp))) 1780 || !(SCp->flags & SCMD_TAGGED))) { 1781 CDEBUG(KERN_ERR, SCp, "has non zero depth %d\n", 1782 NCR_700_get_depth(SCp->device)); 1783 return SCSI_MLQUEUE_DEVICE_BUSY; 1784 } 1785 if(NCR_700_get_depth(SCp->device) >= SCp->device->queue_depth) { 1786 CDEBUG(KERN_ERR, SCp, "has max tag depth %d\n", 1787 NCR_700_get_depth(SCp->device)); 1788 return SCSI_MLQUEUE_DEVICE_BUSY; 1789 } 1790 NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) + 1); 1791 1792 /* begin the command here */ 1793 /* no need to check for NULL, test for command_slot_count above 1794 * ensures a slot is free */ 1795 slot = find_empty_slot(hostdata); 1796 1797 slot->cmnd = SCp; 1798 1799 SCp->scsi_done = done; 1800 SCp->host_scribble = (unsigned char *)slot; 1801 SCp->SCp.ptr = NULL; 1802 SCp->SCp.buffer = NULL; 1803 1804 #ifdef NCR_700_DEBUG 1805 printk("53c700: scsi%d, command ", SCp->device->host->host_no); 1806 scsi_print_command(SCp); 1807 #endif 1808 if ((SCp->flags & SCMD_TAGGED) 1809 && (hostdata->tag_negotiated &(1<<scmd_id(SCp))) == 0 1810 && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_START_TAG_NEGOTIATION) { 1811 scmd_printk(KERN_ERR, SCp, "Enabling Tag Command Queuing\n"); 1812 hostdata->tag_negotiated |= (1<<scmd_id(SCp)); 1813 NCR_700_set_tag_neg_state(SCp->device, NCR_700_DURING_TAG_NEGOTIATION); 1814 } 1815 1816 /* here we may have to process an untagged command. The gate 1817 * above ensures that this will be the only one outstanding, 1818 * so clear the tag negotiated bit. 1819 * 1820 * FIXME: This will royally screw up on multiple LUN devices 1821 * */ 1822 if (!(SCp->flags & SCMD_TAGGED) 1823 && (hostdata->tag_negotiated &(1<<scmd_id(SCp)))) { 1824 scmd_printk(KERN_INFO, SCp, "Disabling Tag Command Queuing\n"); 1825 hostdata->tag_negotiated &= ~(1<<scmd_id(SCp)); 1826 } 1827 1828 if ((hostdata->tag_negotiated & (1<<scmd_id(SCp))) && 1829 SCp->device->simple_tags) { 1830 slot->tag = SCp->request->tag; 1831 CDEBUG(KERN_DEBUG, SCp, "sending out tag %d, slot %p\n", 1832 slot->tag, slot); 1833 } else { 1834 struct NCR_700_Device_Parameters *p = SCp->device->hostdata; 1835 1836 slot->tag = SCSI_NO_TAG; 1837 /* save current command for reselection */ 1838 p->current_cmnd = SCp; 1839 } 1840 /* sanity check: some of the commands generated by the mid-layer 1841 * have an eccentric idea of their sc_data_direction */ 1842 if(!scsi_sg_count(SCp) && !scsi_bufflen(SCp) && 1843 SCp->sc_data_direction != DMA_NONE) { 1844 #ifdef NCR_700_DEBUG 1845 printk("53c700: Command"); 1846 scsi_print_command(SCp); 1847 printk("Has wrong data direction %d\n", SCp->sc_data_direction); 1848 #endif 1849 SCp->sc_data_direction = DMA_NONE; 1850 } 1851 1852 switch (SCp->cmnd[0]) { 1853 case REQUEST_SENSE: 1854 /* clear the internal sense magic */ 1855 SCp->cmnd[6] = 0; 1856 fallthrough; 1857 default: 1858 /* OK, get it from the command */ 1859 switch(SCp->sc_data_direction) { 1860 case DMA_BIDIRECTIONAL: 1861 default: 1862 printk(KERN_ERR "53c700: Unknown command for data direction "); 1863 scsi_print_command(SCp); 1864 1865 move_ins = 0; 1866 break; 1867 case DMA_NONE: 1868 move_ins = 0; 1869 break; 1870 case DMA_FROM_DEVICE: 1871 move_ins = SCRIPT_MOVE_DATA_IN; 1872 break; 1873 case DMA_TO_DEVICE: 1874 move_ins = SCRIPT_MOVE_DATA_OUT; 1875 break; 1876 } 1877 } 1878 1879 /* now build the scatter gather list */ 1880 direction = SCp->sc_data_direction; 1881 if(move_ins != 0) { 1882 int i; 1883 int sg_count; 1884 dma_addr_t vPtr = 0; 1885 struct scatterlist *sg; 1886 __u32 count = 0; 1887 1888 sg_count = scsi_dma_map(SCp); 1889 BUG_ON(sg_count < 0); 1890 1891 scsi_for_each_sg(SCp, sg, sg_count, i) { 1892 vPtr = sg_dma_address(sg); 1893 count = sg_dma_len(sg); 1894 1895 slot->SG[i].ins = bS_to_host(move_ins | count); 1896 DEBUG((" scatter block %d: move %d[%08x] from 0x%lx\n", 1897 i, count, slot->SG[i].ins, (unsigned long)vPtr)); 1898 slot->SG[i].pAddr = bS_to_host(vPtr); 1899 } 1900 slot->SG[i].ins = bS_to_host(SCRIPT_RETURN); 1901 slot->SG[i].pAddr = 0; 1902 dma_sync_to_dev(hostdata, slot->SG, sizeof(slot->SG)); 1903 DEBUG((" SETTING %p to %x\n", 1904 (&slot->pSG[i].ins), 1905 slot->SG[i].ins)); 1906 } 1907 slot->resume_offset = 0; 1908 slot->pCmd = dma_map_single(hostdata->dev, SCp->cmnd, 1909 MAX_COMMAND_SIZE, DMA_TO_DEVICE); 1910 NCR_700_start_command(SCp); 1911 return 0; 1912 } 1913 1914 STATIC DEF_SCSI_QCMD(NCR_700_queuecommand) 1915 1916 STATIC int 1917 NCR_700_abort(struct scsi_cmnd * SCp) 1918 { 1919 struct NCR_700_command_slot *slot; 1920 1921 scmd_printk(KERN_INFO, SCp, "abort command\n"); 1922 1923 slot = (struct NCR_700_command_slot *)SCp->host_scribble; 1924 1925 if(slot == NULL) 1926 /* no outstanding command to abort */ 1927 return SUCCESS; 1928 if(SCp->cmnd[0] == TEST_UNIT_READY) { 1929 /* FIXME: This is because of a problem in the new 1930 * error handler. When it is in error recovery, it 1931 * will send a TUR to a device it thinks may still be 1932 * showing a problem. If the TUR isn't responded to, 1933 * it will abort it and mark the device off line. 1934 * Unfortunately, it does no other error recovery, so 1935 * this would leave us with an outstanding command 1936 * occupying a slot. Rather than allow this to 1937 * happen, we issue a bus reset to force all 1938 * outstanding commands to terminate here. */ 1939 NCR_700_internal_bus_reset(SCp->device->host); 1940 /* still drop through and return failed */ 1941 } 1942 return FAILED; 1943 1944 } 1945 1946 STATIC int 1947 NCR_700_host_reset(struct scsi_cmnd * SCp) 1948 { 1949 DECLARE_COMPLETION_ONSTACK(complete); 1950 struct NCR_700_Host_Parameters *hostdata = 1951 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0]; 1952 1953 scmd_printk(KERN_INFO, SCp, 1954 "New error handler wants HOST reset, cmd %p\n\t", SCp); 1955 scsi_print_command(SCp); 1956 1957 /* In theory, eh_complete should always be null because the 1958 * eh is single threaded, but just in case we're handling a 1959 * reset via sg or something */ 1960 spin_lock_irq(SCp->device->host->host_lock); 1961 while (hostdata->eh_complete != NULL) { 1962 spin_unlock_irq(SCp->device->host->host_lock); 1963 msleep_interruptible(100); 1964 spin_lock_irq(SCp->device->host->host_lock); 1965 } 1966 1967 hostdata->eh_complete = &complete; 1968 NCR_700_internal_bus_reset(SCp->device->host); 1969 NCR_700_chip_reset(SCp->device->host); 1970 1971 spin_unlock_irq(SCp->device->host->host_lock); 1972 wait_for_completion(&complete); 1973 spin_lock_irq(SCp->device->host->host_lock); 1974 1975 hostdata->eh_complete = NULL; 1976 /* Revalidate the transport parameters of the failing device */ 1977 if(hostdata->fast) 1978 spi_schedule_dv_device(SCp->device); 1979 1980 spin_unlock_irq(SCp->device->host->host_lock); 1981 return SUCCESS; 1982 } 1983 1984 STATIC void 1985 NCR_700_set_period(struct scsi_target *STp, int period) 1986 { 1987 struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent); 1988 struct NCR_700_Host_Parameters *hostdata = 1989 (struct NCR_700_Host_Parameters *)SHp->hostdata[0]; 1990 1991 if(!hostdata->fast) 1992 return; 1993 1994 if(period < hostdata->min_period) 1995 period = hostdata->min_period; 1996 1997 spi_period(STp) = period; 1998 spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC | 1999 NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 2000 spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION; 2001 } 2002 2003 STATIC void 2004 NCR_700_set_offset(struct scsi_target *STp, int offset) 2005 { 2006 struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent); 2007 struct NCR_700_Host_Parameters *hostdata = 2008 (struct NCR_700_Host_Parameters *)SHp->hostdata[0]; 2009 int max_offset = hostdata->chip710 2010 ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET; 2011 2012 if(!hostdata->fast) 2013 return; 2014 2015 if(offset > max_offset) 2016 offset = max_offset; 2017 2018 /* if we're currently async, make sure the period is reasonable */ 2019 if(spi_offset(STp) == 0 && (spi_period(STp) < hostdata->min_period || 2020 spi_period(STp) > 0xff)) 2021 spi_period(STp) = hostdata->min_period; 2022 2023 spi_offset(STp) = offset; 2024 spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC | 2025 NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 2026 spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION; 2027 } 2028 2029 STATIC int 2030 NCR_700_slave_alloc(struct scsi_device *SDp) 2031 { 2032 SDp->hostdata = kzalloc(sizeof(struct NCR_700_Device_Parameters), 2033 GFP_KERNEL); 2034 2035 if (!SDp->hostdata) 2036 return -ENOMEM; 2037 2038 return 0; 2039 } 2040 2041 STATIC int 2042 NCR_700_slave_configure(struct scsi_device *SDp) 2043 { 2044 struct NCR_700_Host_Parameters *hostdata = 2045 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0]; 2046 2047 /* to do here: allocate memory; build a queue_full list */ 2048 if(SDp->tagged_supported) { 2049 scsi_change_queue_depth(SDp, NCR_700_DEFAULT_TAGS); 2050 NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION); 2051 } 2052 2053 if(hostdata->fast) { 2054 /* Find the correct offset and period via domain validation */ 2055 if (!spi_initial_dv(SDp->sdev_target)) 2056 spi_dv_device(SDp); 2057 } else { 2058 spi_offset(SDp->sdev_target) = 0; 2059 spi_period(SDp->sdev_target) = 0; 2060 } 2061 return 0; 2062 } 2063 2064 STATIC void 2065 NCR_700_slave_destroy(struct scsi_device *SDp) 2066 { 2067 kfree(SDp->hostdata); 2068 SDp->hostdata = NULL; 2069 } 2070 2071 static int 2072 NCR_700_change_queue_depth(struct scsi_device *SDp, int depth) 2073 { 2074 if (depth > NCR_700_MAX_TAGS) 2075 depth = NCR_700_MAX_TAGS; 2076 return scsi_change_queue_depth(SDp, depth); 2077 } 2078 2079 static ssize_t 2080 NCR_700_show_active_tags(struct device *dev, struct device_attribute *attr, char *buf) 2081 { 2082 struct scsi_device *SDp = to_scsi_device(dev); 2083 2084 return snprintf(buf, 20, "%d\n", NCR_700_get_depth(SDp)); 2085 } 2086 2087 static struct device_attribute NCR_700_active_tags_attr = { 2088 .attr = { 2089 .name = "active_tags", 2090 .mode = S_IRUGO, 2091 }, 2092 .show = NCR_700_show_active_tags, 2093 }; 2094 2095 STATIC struct device_attribute *NCR_700_dev_attrs[] = { 2096 &NCR_700_active_tags_attr, 2097 NULL, 2098 }; 2099 2100 EXPORT_SYMBOL(NCR_700_detect); 2101 EXPORT_SYMBOL(NCR_700_release); 2102 EXPORT_SYMBOL(NCR_700_intr); 2103 2104 static struct spi_function_template NCR_700_transport_functions = { 2105 .set_period = NCR_700_set_period, 2106 .show_period = 1, 2107 .set_offset = NCR_700_set_offset, 2108 .show_offset = 1, 2109 }; 2110 2111 static int __init NCR_700_init(void) 2112 { 2113 NCR_700_transport_template = spi_attach_transport(&NCR_700_transport_functions); 2114 if(!NCR_700_transport_template) 2115 return -ENODEV; 2116 return 0; 2117 } 2118 2119 static void __exit NCR_700_exit(void) 2120 { 2121 spi_release_transport(NCR_700_transport_template); 2122 } 2123 2124 module_init(NCR_700_init); 2125 module_exit(NCR_700_exit); 2126 2127