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