1 /* 2 * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family 3 * of PCI-SCSI IO processors. 4 * 5 * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr> 6 * Copyright (c) 2003-2005 Matthew Wilcox <matthew@wil.cx> 7 * 8 * This driver is derived from the Linux sym53c8xx driver. 9 * Copyright (C) 1998-2000 Gerard Roudier 10 * 11 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been 12 * a port of the FreeBSD ncr driver to Linux-1.2.13. 13 * 14 * The original ncr driver has been written for 386bsd and FreeBSD by 15 * Wolfgang Stanglmeier <wolf@cologne.de> 16 * Stefan Esser <se@mi.Uni-Koeln.de> 17 * Copyright (C) 1994 Wolfgang Stanglmeier 18 * 19 * Other major contributions: 20 * 21 * NVRAM detection and reading. 22 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk> 23 * 24 *----------------------------------------------------------------------------- 25 * 26 * This program is free software; you can redistribute it and/or modify 27 * it under the terms of the GNU General Public License as published by 28 * the Free Software Foundation; either version 2 of the License, or 29 * (at your option) any later version. 30 * 31 * This program is distributed in the hope that it will be useful, 32 * but WITHOUT ANY WARRANTY; without even the implied warranty of 33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 34 * GNU General Public License for more details. 35 * 36 * You should have received a copy of the GNU General Public License 37 * along with this program; if not, write to the Free Software 38 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 39 */ 40 #include <linux/ctype.h> 41 #include <linux/init.h> 42 #include <linux/interrupt.h> 43 #include <linux/module.h> 44 #include <linux/moduleparam.h> 45 #include <linux/spinlock.h> 46 #include <scsi/scsi.h> 47 #include <scsi/scsi_tcq.h> 48 #include <scsi/scsi_device.h> 49 #include <scsi/scsi_transport.h> 50 51 #include "sym_glue.h" 52 #include "sym_nvram.h" 53 54 #define NAME53C "sym53c" 55 #define NAME53C8XX "sym53c8xx" 56 57 /* SPARC just has to be different ... */ 58 #ifdef __sparc__ 59 #define IRQ_FMT "%s" 60 #define IRQ_PRM(x) __irq_itoa(x) 61 #else 62 #define IRQ_FMT "%d" 63 #define IRQ_PRM(x) (x) 64 #endif 65 66 struct sym_driver_setup sym_driver_setup = SYM_LINUX_DRIVER_SETUP; 67 unsigned int sym_debug_flags = 0; 68 69 static char *excl_string; 70 static char *safe_string; 71 module_param_named(cmd_per_lun, sym_driver_setup.max_tag, ushort, 0); 72 module_param_string(tag_ctrl, sym_driver_setup.tag_ctrl, 100, 0); 73 module_param_named(burst, sym_driver_setup.burst_order, byte, 0); 74 module_param_named(led, sym_driver_setup.scsi_led, byte, 0); 75 module_param_named(diff, sym_driver_setup.scsi_diff, byte, 0); 76 module_param_named(irqm, sym_driver_setup.irq_mode, byte, 0); 77 module_param_named(buschk, sym_driver_setup.scsi_bus_check, byte, 0); 78 module_param_named(hostid, sym_driver_setup.host_id, byte, 0); 79 module_param_named(verb, sym_driver_setup.verbose, byte, 0); 80 module_param_named(debug, sym_debug_flags, uint, 0); 81 module_param_named(settle, sym_driver_setup.settle_delay, byte, 0); 82 module_param_named(nvram, sym_driver_setup.use_nvram, byte, 0); 83 module_param_named(excl, excl_string, charp, 0); 84 module_param_named(safe, safe_string, charp, 0); 85 86 MODULE_PARM_DESC(cmd_per_lun, "The maximum number of tags to use by default"); 87 MODULE_PARM_DESC(tag_ctrl, "More detailed control over tags per LUN"); 88 MODULE_PARM_DESC(burst, "Maximum burst. 0 to disable, 255 to read from registers"); 89 MODULE_PARM_DESC(led, "Set to 1 to enable LED support"); 90 MODULE_PARM_DESC(diff, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3"); 91 MODULE_PARM_DESC(irqm, "0 for open drain, 1 to leave alone, 2 for totem pole"); 92 MODULE_PARM_DESC(buschk, "0 to not check, 1 for detach on error, 2 for warn on error"); 93 MODULE_PARM_DESC(hostid, "The SCSI ID to use for the host adapters"); 94 MODULE_PARM_DESC(verb, "0 for minimal verbosity, 1 for normal, 2 for excessive"); 95 MODULE_PARM_DESC(debug, "Set bits to enable debugging"); 96 MODULE_PARM_DESC(settle, "Settle delay in seconds. Default 3"); 97 MODULE_PARM_DESC(nvram, "Option currently not used"); 98 MODULE_PARM_DESC(excl, "List ioport addresses here to prevent controllers from being attached"); 99 MODULE_PARM_DESC(safe, "Set other settings to a \"safe mode\""); 100 101 MODULE_LICENSE("GPL"); 102 MODULE_VERSION(SYM_VERSION); 103 MODULE_AUTHOR("Matthew Wilcox <matthew@wil.cx>"); 104 MODULE_DESCRIPTION("NCR, Symbios and LSI 8xx and 1010 PCI SCSI adapters"); 105 106 static void sym2_setup_params(void) 107 { 108 char *p = excl_string; 109 int xi = 0; 110 111 while (p && (xi < 8)) { 112 char *next_p; 113 int val = (int) simple_strtoul(p, &next_p, 0); 114 sym_driver_setup.excludes[xi++] = val; 115 p = next_p; 116 } 117 118 if (safe_string) { 119 if (*safe_string == 'y') { 120 sym_driver_setup.max_tag = 0; 121 sym_driver_setup.burst_order = 0; 122 sym_driver_setup.scsi_led = 0; 123 sym_driver_setup.scsi_diff = 1; 124 sym_driver_setup.irq_mode = 0; 125 sym_driver_setup.scsi_bus_check = 2; 126 sym_driver_setup.host_id = 7; 127 sym_driver_setup.verbose = 2; 128 sym_driver_setup.settle_delay = 10; 129 sym_driver_setup.use_nvram = 1; 130 } else if (*safe_string != 'n') { 131 printk(KERN_WARNING NAME53C8XX "Ignoring parameter %s" 132 " passed to safe option", safe_string); 133 } 134 } 135 } 136 137 static struct scsi_transport_template *sym2_transport_template = NULL; 138 139 /* 140 * Driver private area in the SCSI command structure. 141 */ 142 struct sym_ucmd { /* Override the SCSI pointer structure */ 143 dma_addr_t data_mapping; 144 unsigned char data_mapped; 145 unsigned char to_do; /* For error handling */ 146 void (*old_done)(struct scsi_cmnd *); /* For error handling */ 147 struct completion *eh_done; /* For error handling */ 148 }; 149 150 #define SYM_UCMD_PTR(cmd) ((struct sym_ucmd *)(&(cmd)->SCp)) 151 #define SYM_SOFTC_PTR(cmd) sym_get_hcb(cmd->device->host) 152 153 static void __unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 154 { 155 int dma_dir = cmd->sc_data_direction; 156 157 switch(SYM_UCMD_PTR(cmd)->data_mapped) { 158 case 2: 159 pci_unmap_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir); 160 break; 161 case 1: 162 pci_unmap_single(pdev, SYM_UCMD_PTR(cmd)->data_mapping, 163 cmd->request_bufflen, dma_dir); 164 break; 165 } 166 SYM_UCMD_PTR(cmd)->data_mapped = 0; 167 } 168 169 static dma_addr_t __map_scsi_single_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 170 { 171 dma_addr_t mapping; 172 int dma_dir = cmd->sc_data_direction; 173 174 mapping = pci_map_single(pdev, cmd->request_buffer, 175 cmd->request_bufflen, dma_dir); 176 if (mapping) { 177 SYM_UCMD_PTR(cmd)->data_mapped = 1; 178 SYM_UCMD_PTR(cmd)->data_mapping = mapping; 179 } 180 181 return mapping; 182 } 183 184 static int __map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 185 { 186 int use_sg; 187 int dma_dir = cmd->sc_data_direction; 188 189 use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir); 190 if (use_sg > 0) { 191 SYM_UCMD_PTR(cmd)->data_mapped = 2; 192 SYM_UCMD_PTR(cmd)->data_mapping = use_sg; 193 } 194 195 return use_sg; 196 } 197 198 #define unmap_scsi_data(np, cmd) \ 199 __unmap_scsi_data(np->s.device, cmd) 200 #define map_scsi_single_data(np, cmd) \ 201 __map_scsi_single_data(np->s.device, cmd) 202 #define map_scsi_sg_data(np, cmd) \ 203 __map_scsi_sg_data(np->s.device, cmd) 204 /* 205 * Complete a pending CAM CCB. 206 */ 207 void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *cmd) 208 { 209 unmap_scsi_data(np, cmd); 210 cmd->scsi_done(cmd); 211 } 212 213 static void sym_xpt_done2(struct sym_hcb *np, struct scsi_cmnd *cmd, int cam_status) 214 { 215 sym_set_cam_status(cmd, cam_status); 216 sym_xpt_done(np, cmd); 217 } 218 219 220 /* 221 * Tell the SCSI layer about a BUS RESET. 222 */ 223 void sym_xpt_async_bus_reset(struct sym_hcb *np) 224 { 225 printf_notice("%s: SCSI BUS has been reset.\n", sym_name(np)); 226 np->s.settle_time = jiffies + sym_driver_setup.settle_delay * HZ; 227 np->s.settle_time_valid = 1; 228 if (sym_verbose >= 2) 229 printf_info("%s: command processing suspended for %d seconds\n", 230 sym_name(np), sym_driver_setup.settle_delay); 231 } 232 233 /* 234 * Tell the SCSI layer about a BUS DEVICE RESET message sent. 235 */ 236 void sym_xpt_async_sent_bdr(struct sym_hcb *np, int target) 237 { 238 printf_notice("%s: TARGET %d has been reset.\n", sym_name(np), target); 239 } 240 241 /* 242 * Choose the more appropriate CAM status if 243 * the IO encountered an extended error. 244 */ 245 static int sym_xerr_cam_status(int cam_status, int x_status) 246 { 247 if (x_status) { 248 if (x_status & XE_PARITY_ERR) 249 cam_status = DID_PARITY; 250 else if (x_status &(XE_EXTRA_DATA|XE_SODL_UNRUN|XE_SWIDE_OVRUN)) 251 cam_status = DID_ERROR; 252 else if (x_status & XE_BAD_PHASE) 253 cam_status = DID_ERROR; 254 else 255 cam_status = DID_ERROR; 256 } 257 return cam_status; 258 } 259 260 /* 261 * Build CAM result for a failed or auto-sensed IO. 262 */ 263 void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid) 264 { 265 struct scsi_cmnd *cmd = cp->cmd; 266 u_int cam_status, scsi_status, drv_status; 267 268 drv_status = 0; 269 cam_status = DID_OK; 270 scsi_status = cp->ssss_status; 271 272 if (cp->host_flags & HF_SENSE) { 273 scsi_status = cp->sv_scsi_status; 274 resid = cp->sv_resid; 275 if (sym_verbose && cp->sv_xerr_status) 276 sym_print_xerr(cmd, cp->sv_xerr_status); 277 if (cp->host_status == HS_COMPLETE && 278 cp->ssss_status == S_GOOD && 279 cp->xerr_status == 0) { 280 cam_status = sym_xerr_cam_status(DID_OK, 281 cp->sv_xerr_status); 282 drv_status = DRIVER_SENSE; 283 /* 284 * Bounce back the sense data to user. 285 */ 286 memset(&cmd->sense_buffer, 0, sizeof(cmd->sense_buffer)); 287 memcpy(cmd->sense_buffer, cp->sns_bbuf, 288 min(sizeof(cmd->sense_buffer), 289 (size_t)SYM_SNS_BBUF_LEN)); 290 #if 0 291 /* 292 * If the device reports a UNIT ATTENTION condition 293 * due to a RESET condition, we should consider all 294 * disconnect CCBs for this unit as aborted. 295 */ 296 if (1) { 297 u_char *p; 298 p = (u_char *) cmd->sense_data; 299 if (p[0]==0x70 && p[2]==0x6 && p[12]==0x29) 300 sym_clear_tasks(np, DID_ABORT, 301 cp->target,cp->lun, -1); 302 } 303 #endif 304 } else { 305 /* 306 * Error return from our internal request sense. This 307 * is bad: we must clear the contingent allegiance 308 * condition otherwise the device will always return 309 * BUSY. Use a big stick. 310 */ 311 sym_reset_scsi_target(np, cmd->device->id); 312 cam_status = DID_ERROR; 313 } 314 } else if (cp->host_status == HS_COMPLETE) /* Bad SCSI status */ 315 cam_status = DID_OK; 316 else if (cp->host_status == HS_SEL_TIMEOUT) /* Selection timeout */ 317 cam_status = DID_NO_CONNECT; 318 else if (cp->host_status == HS_UNEXPECTED) /* Unexpected BUS FREE*/ 319 cam_status = DID_ERROR; 320 else { /* Extended error */ 321 if (sym_verbose) { 322 sym_print_addr(cmd, "COMMAND FAILED (%x %x %x).\n", 323 cp->host_status, cp->ssss_status, 324 cp->xerr_status); 325 } 326 /* 327 * Set the most appropriate value for CAM status. 328 */ 329 cam_status = sym_xerr_cam_status(DID_ERROR, cp->xerr_status); 330 } 331 cmd->resid = resid; 332 cmd->result = (drv_status << 24) + (cam_status << 16) + scsi_status; 333 } 334 335 336 /* 337 * Build the scatter/gather array for an I/O. 338 */ 339 340 static int sym_scatter_no_sglist(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd *cmd) 341 { 342 struct sym_tblmove *data = &cp->phys.data[SYM_CONF_MAX_SG-1]; 343 int segment; 344 unsigned int len = cmd->request_bufflen; 345 346 if (len) { 347 dma_addr_t baddr = map_scsi_single_data(np, cmd); 348 if (baddr) { 349 if (len & 1) { 350 struct sym_tcb *tp = &np->target[cp->target]; 351 if (tp->head.wval & EWS) { 352 len++; 353 cp->odd_byte_adjustment++; 354 } 355 } 356 cp->data_len = len; 357 sym_build_sge(np, data, baddr, len); 358 segment = 1; 359 } else { 360 segment = -2; 361 } 362 } else { 363 segment = 0; 364 } 365 366 return segment; 367 } 368 369 static int sym_scatter(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd *cmd) 370 { 371 int segment; 372 int use_sg = (int) cmd->use_sg; 373 374 cp->data_len = 0; 375 376 if (!use_sg) 377 segment = sym_scatter_no_sglist(np, cp, cmd); 378 else if ((use_sg = map_scsi_sg_data(np, cmd)) > 0) { 379 struct scatterlist *scatter = (struct scatterlist *)cmd->buffer; 380 struct sym_tcb *tp = &np->target[cp->target]; 381 struct sym_tblmove *data; 382 383 if (use_sg > SYM_CONF_MAX_SG) { 384 unmap_scsi_data(np, cmd); 385 return -1; 386 } 387 388 data = &cp->phys.data[SYM_CONF_MAX_SG - use_sg]; 389 390 for (segment = 0; segment < use_sg; segment++) { 391 dma_addr_t baddr = sg_dma_address(&scatter[segment]); 392 unsigned int len = sg_dma_len(&scatter[segment]); 393 394 if ((len & 1) && (tp->head.wval & EWS)) { 395 len++; 396 cp->odd_byte_adjustment++; 397 } 398 399 sym_build_sge(np, &data[segment], baddr, len); 400 cp->data_len += len; 401 } 402 } else { 403 segment = -2; 404 } 405 406 return segment; 407 } 408 409 /* 410 * Queue a SCSI command. 411 */ 412 static int sym_queue_command(struct sym_hcb *np, struct scsi_cmnd *cmd) 413 { 414 struct scsi_device *sdev = cmd->device; 415 struct sym_tcb *tp; 416 struct sym_lcb *lp; 417 struct sym_ccb *cp; 418 int order; 419 420 /* 421 * Minimal checkings, so that we will not 422 * go outside our tables. 423 */ 424 if (sdev->id == np->myaddr) { 425 sym_xpt_done2(np, cmd, DID_NO_CONNECT); 426 return 0; 427 } 428 429 /* 430 * Retrieve the target descriptor. 431 */ 432 tp = &np->target[sdev->id]; 433 434 /* 435 * Select tagged/untagged. 436 */ 437 lp = sym_lp(tp, sdev->lun); 438 order = (lp && lp->s.reqtags) ? M_SIMPLE_TAG : 0; 439 440 /* 441 * Queue the SCSI IO. 442 */ 443 cp = sym_get_ccb(np, cmd, order); 444 if (!cp) 445 return 1; /* Means resource shortage */ 446 sym_queue_scsiio(np, cmd, cp); 447 return 0; 448 } 449 450 /* 451 * Setup buffers and pointers that address the CDB. 452 */ 453 static inline int sym_setup_cdb(struct sym_hcb *np, struct scsi_cmnd *cmd, struct sym_ccb *cp) 454 { 455 memcpy(cp->cdb_buf, cmd->cmnd, cmd->cmd_len); 456 457 cp->phys.cmd.addr = CCB_BA(cp, cdb_buf[0]); 458 cp->phys.cmd.size = cpu_to_scr(cmd->cmd_len); 459 460 return 0; 461 } 462 463 /* 464 * Setup pointers that address the data and start the I/O. 465 */ 466 int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct sym_ccb *cp) 467 { 468 u32 lastp, goalp; 469 int dir; 470 471 /* 472 * Build the CDB. 473 */ 474 if (sym_setup_cdb(np, cmd, cp)) 475 goto out_abort; 476 477 /* 478 * No direction means no data. 479 */ 480 dir = cmd->sc_data_direction; 481 if (dir != DMA_NONE) { 482 cp->segments = sym_scatter(np, cp, cmd); 483 if (cp->segments < 0) { 484 sym_set_cam_status(cmd, DID_ERROR); 485 goto out_abort; 486 } 487 488 /* 489 * No segments means no data. 490 */ 491 if (!cp->segments) 492 dir = DMA_NONE; 493 } else { 494 cp->data_len = 0; 495 cp->segments = 0; 496 } 497 498 /* 499 * Set the data pointer. 500 */ 501 switch (dir) { 502 case DMA_BIDIRECTIONAL: 503 printk("%s: got DMA_BIDIRECTIONAL command", sym_name(np)); 504 sym_set_cam_status(cmd, DID_ERROR); 505 goto out_abort; 506 case DMA_TO_DEVICE: 507 goalp = SCRIPTA_BA(np, data_out2) + 8; 508 lastp = goalp - 8 - (cp->segments * (2*4)); 509 break; 510 case DMA_FROM_DEVICE: 511 cp->host_flags |= HF_DATA_IN; 512 goalp = SCRIPTA_BA(np, data_in2) + 8; 513 lastp = goalp - 8 - (cp->segments * (2*4)); 514 break; 515 case DMA_NONE: 516 default: 517 lastp = goalp = SCRIPTB_BA(np, no_data); 518 break; 519 } 520 521 /* 522 * Set all pointers values needed by SCRIPTS. 523 */ 524 cp->phys.head.lastp = cpu_to_scr(lastp); 525 cp->phys.head.savep = cpu_to_scr(lastp); 526 cp->startp = cp->phys.head.savep; 527 cp->goalp = cpu_to_scr(goalp); 528 529 /* 530 * When `#ifed 1', the code below makes the driver 531 * panic on the first attempt to write to a SCSI device. 532 * It is the first test we want to do after a driver 533 * change that does not seem obviously safe. :) 534 */ 535 #if 0 536 switch (cp->cdb_buf[0]) { 537 case 0x0A: case 0x2A: case 0xAA: 538 panic("XXXXXXXXXXXXX WRITE NOT YET ALLOWED XXXXXXXXXXXXXX\n"); 539 break; 540 default: 541 break; 542 } 543 #endif 544 545 /* 546 * activate this job. 547 */ 548 sym_put_start_queue(np, cp); 549 return 0; 550 551 out_abort: 552 sym_free_ccb(np, cp); 553 sym_xpt_done(np, cmd); 554 return 0; 555 } 556 557 558 /* 559 * timer daemon. 560 * 561 * Misused to keep the driver running when 562 * interrupts are not configured correctly. 563 */ 564 static void sym_timer(struct sym_hcb *np) 565 { 566 unsigned long thistime = jiffies; 567 568 /* 569 * Restart the timer. 570 */ 571 np->s.timer.expires = thistime + SYM_CONF_TIMER_INTERVAL; 572 add_timer(&np->s.timer); 573 574 /* 575 * If we are resetting the ncr, wait for settle_time before 576 * clearing it. Then command processing will be resumed. 577 */ 578 if (np->s.settle_time_valid) { 579 if (time_before_eq(np->s.settle_time, thistime)) { 580 if (sym_verbose >= 2 ) 581 printk("%s: command processing resumed\n", 582 sym_name(np)); 583 np->s.settle_time_valid = 0; 584 } 585 return; 586 } 587 588 /* 589 * Nothing to do for now, but that may come. 590 */ 591 if (np->s.lasttime + 4*HZ < thistime) { 592 np->s.lasttime = thistime; 593 } 594 595 #ifdef SYM_CONF_PCIQ_MAY_MISS_COMPLETIONS 596 /* 597 * Some way-broken PCI bridges may lead to 598 * completions being lost when the clearing 599 * of the INTFLY flag by the CPU occurs 600 * concurrently with the chip raising this flag. 601 * If this ever happen, lost completions will 602 * be reaped here. 603 */ 604 sym_wakeup_done(np); 605 #endif 606 } 607 608 609 /* 610 * PCI BUS error handler. 611 */ 612 void sym_log_bus_error(struct sym_hcb *np) 613 { 614 u_short pci_sts; 615 pci_read_config_word(np->s.device, PCI_STATUS, &pci_sts); 616 if (pci_sts & 0xf900) { 617 pci_write_config_word(np->s.device, PCI_STATUS, pci_sts); 618 printf("%s: PCI STATUS = 0x%04x\n", 619 sym_name(np), pci_sts & 0xf900); 620 } 621 } 622 623 /* 624 * queuecommand method. Entered with the host adapter lock held and 625 * interrupts disabled. 626 */ 627 static int sym53c8xx_queue_command(struct scsi_cmnd *cmd, 628 void (*done)(struct scsi_cmnd *)) 629 { 630 struct sym_hcb *np = SYM_SOFTC_PTR(cmd); 631 struct sym_ucmd *ucp = SYM_UCMD_PTR(cmd); 632 int sts = 0; 633 634 cmd->scsi_done = done; 635 memset(ucp, 0, sizeof(*ucp)); 636 637 /* 638 * Shorten our settle_time if needed for 639 * this command not to time out. 640 */ 641 if (np->s.settle_time_valid && cmd->timeout_per_command) { 642 unsigned long tlimit = jiffies + cmd->timeout_per_command; 643 tlimit -= SYM_CONF_TIMER_INTERVAL*2; 644 if (time_after(np->s.settle_time, tlimit)) { 645 np->s.settle_time = tlimit; 646 } 647 } 648 649 if (np->s.settle_time_valid) 650 return SCSI_MLQUEUE_HOST_BUSY; 651 652 sts = sym_queue_command(np, cmd); 653 if (sts) 654 return SCSI_MLQUEUE_HOST_BUSY; 655 return 0; 656 } 657 658 /* 659 * Linux entry point of the interrupt handler. 660 */ 661 static irqreturn_t sym53c8xx_intr(int irq, void *dev_id, struct pt_regs * regs) 662 { 663 unsigned long flags; 664 struct sym_hcb *np = (struct sym_hcb *)dev_id; 665 666 if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("["); 667 668 spin_lock_irqsave(np->s.host->host_lock, flags); 669 sym_interrupt(np); 670 spin_unlock_irqrestore(np->s.host->host_lock, flags); 671 672 if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("]\n"); 673 674 return IRQ_HANDLED; 675 } 676 677 /* 678 * Linux entry point of the timer handler 679 */ 680 static void sym53c8xx_timer(unsigned long npref) 681 { 682 struct sym_hcb *np = (struct sym_hcb *)npref; 683 unsigned long flags; 684 685 spin_lock_irqsave(np->s.host->host_lock, flags); 686 sym_timer(np); 687 spin_unlock_irqrestore(np->s.host->host_lock, flags); 688 } 689 690 691 /* 692 * What the eh thread wants us to perform. 693 */ 694 #define SYM_EH_ABORT 0 695 #define SYM_EH_DEVICE_RESET 1 696 #define SYM_EH_BUS_RESET 2 697 #define SYM_EH_HOST_RESET 3 698 699 /* 700 * What we will do regarding the involved SCSI command. 701 */ 702 #define SYM_EH_DO_IGNORE 0 703 #define SYM_EH_DO_WAIT 2 704 705 /* 706 * scsi_done() alias when error recovery is in progress. 707 */ 708 static void sym_eh_done(struct scsi_cmnd *cmd) 709 { 710 struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd); 711 BUILD_BUG_ON(sizeof(struct scsi_pointer) < sizeof(struct sym_ucmd)); 712 713 cmd->scsi_done = ucmd->old_done; 714 715 if (ucmd->to_do == SYM_EH_DO_WAIT) 716 complete(ucmd->eh_done); 717 } 718 719 /* 720 * Generic method for our eh processing. 721 * The 'op' argument tells what we have to do. 722 */ 723 static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd) 724 { 725 struct sym_hcb *np = SYM_SOFTC_PTR(cmd); 726 struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd); 727 struct Scsi_Host *host = cmd->device->host; 728 SYM_QUEHEAD *qp; 729 int to_do = SYM_EH_DO_IGNORE; 730 int sts = -1; 731 struct completion eh_done; 732 733 dev_warn(&cmd->device->sdev_gendev, "%s operation started.\n", opname); 734 735 spin_lock_irq(host->host_lock); 736 /* This one is queued in some place -> to wait for completion */ 737 FOR_EACH_QUEUED_ELEMENT(&np->busy_ccbq, qp) { 738 struct sym_ccb *cp = sym_que_entry(qp, struct sym_ccb, link_ccbq); 739 if (cp->cmd == cmd) { 740 to_do = SYM_EH_DO_WAIT; 741 break; 742 } 743 } 744 745 if (to_do == SYM_EH_DO_WAIT) { 746 init_completion(&eh_done); 747 ucmd->old_done = cmd->scsi_done; 748 ucmd->eh_done = &eh_done; 749 wmb(); 750 cmd->scsi_done = sym_eh_done; 751 } 752 753 /* Try to proceed the operation we have been asked for */ 754 sts = -1; 755 switch(op) { 756 case SYM_EH_ABORT: 757 sts = sym_abort_scsiio(np, cmd, 1); 758 break; 759 case SYM_EH_DEVICE_RESET: 760 sts = sym_reset_scsi_target(np, cmd->device->id); 761 break; 762 case SYM_EH_BUS_RESET: 763 sym_reset_scsi_bus(np, 1); 764 sts = 0; 765 break; 766 case SYM_EH_HOST_RESET: 767 sym_reset_scsi_bus(np, 0); 768 sym_start_up (np, 1); 769 sts = 0; 770 break; 771 default: 772 break; 773 } 774 775 /* On error, restore everything and cross fingers :) */ 776 if (sts) { 777 cmd->scsi_done = ucmd->old_done; 778 to_do = SYM_EH_DO_IGNORE; 779 } 780 781 ucmd->to_do = to_do; 782 spin_unlock_irq(host->host_lock); 783 784 if (to_do == SYM_EH_DO_WAIT) { 785 if (!wait_for_completion_timeout(&eh_done, 5*HZ)) { 786 ucmd->to_do = SYM_EH_DO_IGNORE; 787 wmb(); 788 sts = -2; 789 } 790 } 791 dev_warn(&cmd->device->sdev_gendev, "%s operation %s.\n", opname, 792 sts==0 ? "complete" :sts==-2 ? "timed-out" : "failed"); 793 return sts ? SCSI_FAILED : SCSI_SUCCESS; 794 } 795 796 797 /* 798 * Error handlers called from the eh thread (one thread per HBA). 799 */ 800 static int sym53c8xx_eh_abort_handler(struct scsi_cmnd *cmd) 801 { 802 return sym_eh_handler(SYM_EH_ABORT, "ABORT", cmd); 803 } 804 805 static int sym53c8xx_eh_device_reset_handler(struct scsi_cmnd *cmd) 806 { 807 return sym_eh_handler(SYM_EH_DEVICE_RESET, "DEVICE RESET", cmd); 808 } 809 810 static int sym53c8xx_eh_bus_reset_handler(struct scsi_cmnd *cmd) 811 { 812 return sym_eh_handler(SYM_EH_BUS_RESET, "BUS RESET", cmd); 813 } 814 815 static int sym53c8xx_eh_host_reset_handler(struct scsi_cmnd *cmd) 816 { 817 return sym_eh_handler(SYM_EH_HOST_RESET, "HOST RESET", cmd); 818 } 819 820 /* 821 * Tune device queuing depth, according to various limits. 822 */ 823 static void sym_tune_dev_queuing(struct sym_tcb *tp, int lun, u_short reqtags) 824 { 825 struct sym_lcb *lp = sym_lp(tp, lun); 826 u_short oldtags; 827 828 if (!lp) 829 return; 830 831 oldtags = lp->s.reqtags; 832 833 if (reqtags > lp->s.scdev_depth) 834 reqtags = lp->s.scdev_depth; 835 836 lp->s.reqtags = reqtags; 837 838 if (reqtags != oldtags) { 839 dev_info(&tp->starget->dev, 840 "tagged command queuing %s, command queue depth %d.\n", 841 lp->s.reqtags ? "enabled" : "disabled", reqtags); 842 } 843 } 844 845 /* 846 * Linux select queue depths function 847 */ 848 #define DEF_DEPTH (sym_driver_setup.max_tag) 849 #define ALL_TARGETS -2 850 #define NO_TARGET -1 851 #define ALL_LUNS -2 852 #define NO_LUN -1 853 854 static int device_queue_depth(struct sym_hcb *np, int target, int lun) 855 { 856 int c, h, t, u, v; 857 char *p = sym_driver_setup.tag_ctrl; 858 char *ep; 859 860 h = -1; 861 t = NO_TARGET; 862 u = NO_LUN; 863 while ((c = *p++) != 0) { 864 v = simple_strtoul(p, &ep, 0); 865 switch(c) { 866 case '/': 867 ++h; 868 t = ALL_TARGETS; 869 u = ALL_LUNS; 870 break; 871 case 't': 872 if (t != target) 873 t = (target == v) ? v : NO_TARGET; 874 u = ALL_LUNS; 875 break; 876 case 'u': 877 if (u != lun) 878 u = (lun == v) ? v : NO_LUN; 879 break; 880 case 'q': 881 if (h == np->s.unit && 882 (t == ALL_TARGETS || t == target) && 883 (u == ALL_LUNS || u == lun)) 884 return v; 885 break; 886 case '-': 887 t = ALL_TARGETS; 888 u = ALL_LUNS; 889 break; 890 default: 891 break; 892 } 893 p = ep; 894 } 895 return DEF_DEPTH; 896 } 897 898 static int sym53c8xx_slave_alloc(struct scsi_device *sdev) 899 { 900 struct sym_hcb *np = sym_get_hcb(sdev->host); 901 struct sym_tcb *tp = &np->target[sdev->id]; 902 struct sym_lcb *lp; 903 904 if (sdev->id >= SYM_CONF_MAX_TARGET || sdev->lun >= SYM_CONF_MAX_LUN) 905 return -ENXIO; 906 907 tp->starget = sdev->sdev_target; 908 /* 909 * Fail the device init if the device is flagged NOSCAN at BOOT in 910 * the NVRAM. This may speed up boot and maintain coherency with 911 * BIOS device numbering. Clearing the flag allows the user to 912 * rescan skipped devices later. We also return an error for 913 * devices not flagged for SCAN LUNS in the NVRAM since some single 914 * lun devices behave badly when asked for a non zero LUN. 915 */ 916 917 if (tp->usrflags & SYM_SCAN_BOOT_DISABLED) { 918 tp->usrflags &= ~SYM_SCAN_BOOT_DISABLED; 919 starget_printk(KERN_INFO, tp->starget, 920 "Scan at boot disabled in NVRAM\n"); 921 return -ENXIO; 922 } 923 924 if (tp->usrflags & SYM_SCAN_LUNS_DISABLED) { 925 if (sdev->lun != 0) 926 return -ENXIO; 927 starget_printk(KERN_INFO, tp->starget, 928 "Multiple LUNs disabled in NVRAM\n"); 929 } 930 931 lp = sym_alloc_lcb(np, sdev->id, sdev->lun); 932 if (!lp) 933 return -ENOMEM; 934 935 spi_min_period(tp->starget) = tp->usr_period; 936 spi_max_width(tp->starget) = tp->usr_width; 937 938 return 0; 939 } 940 941 /* 942 * Linux entry point for device queue sizing. 943 */ 944 static int sym53c8xx_slave_configure(struct scsi_device *sdev) 945 { 946 struct sym_hcb *np = sym_get_hcb(sdev->host); 947 struct sym_tcb *tp = &np->target[sdev->id]; 948 struct sym_lcb *lp = sym_lp(tp, sdev->lun); 949 int reqtags, depth_to_use; 950 951 /* 952 * Get user flags. 953 */ 954 lp->curr_flags = lp->user_flags; 955 956 /* 957 * Select queue depth from driver setup. 958 * Donnot use more than configured by user. 959 * Use at least 2. 960 * Donnot use more than our maximum. 961 */ 962 reqtags = device_queue_depth(np, sdev->id, sdev->lun); 963 if (reqtags > tp->usrtags) 964 reqtags = tp->usrtags; 965 if (!sdev->tagged_supported) 966 reqtags = 0; 967 #if 1 /* Avoid to locally queue commands for no good reasons */ 968 if (reqtags > SYM_CONF_MAX_TAG) 969 reqtags = SYM_CONF_MAX_TAG; 970 depth_to_use = (reqtags ? reqtags : 2); 971 #else 972 depth_to_use = (reqtags ? SYM_CONF_MAX_TAG : 2); 973 #endif 974 scsi_adjust_queue_depth(sdev, 975 (sdev->tagged_supported ? 976 MSG_SIMPLE_TAG : 0), 977 depth_to_use); 978 lp->s.scdev_depth = depth_to_use; 979 sym_tune_dev_queuing(tp, sdev->lun, reqtags); 980 981 if (!spi_initial_dv(sdev->sdev_target)) 982 spi_dv_device(sdev); 983 984 return 0; 985 } 986 987 static void sym53c8xx_slave_destroy(struct scsi_device *sdev) 988 { 989 struct sym_hcb *np = sym_get_hcb(sdev->host); 990 struct sym_lcb *lp = sym_lp(&np->target[sdev->id], sdev->lun); 991 992 if (lp->itlq_tbl) 993 sym_mfree_dma(lp->itlq_tbl, SYM_CONF_MAX_TASK * 4, "ITLQ_TBL"); 994 kfree(lp->cb_tags); 995 sym_mfree_dma(lp, sizeof(*lp), "LCB"); 996 } 997 998 /* 999 * Linux entry point for info() function 1000 */ 1001 static const char *sym53c8xx_info (struct Scsi_Host *host) 1002 { 1003 return SYM_DRIVER_NAME; 1004 } 1005 1006 1007 #ifdef SYM_LINUX_PROC_INFO_SUPPORT 1008 /* 1009 * Proc file system stuff 1010 * 1011 * A read operation returns adapter information. 1012 * A write operation is a control command. 1013 * The string is parsed in the driver code and the command is passed 1014 * to the sym_usercmd() function. 1015 */ 1016 1017 #ifdef SYM_LINUX_USER_COMMAND_SUPPORT 1018 1019 struct sym_usrcmd { 1020 u_long target; 1021 u_long lun; 1022 u_long data; 1023 u_long cmd; 1024 }; 1025 1026 #define UC_SETSYNC 10 1027 #define UC_SETTAGS 11 1028 #define UC_SETDEBUG 12 1029 #define UC_SETWIDE 14 1030 #define UC_SETFLAG 15 1031 #define UC_SETVERBOSE 17 1032 #define UC_RESETDEV 18 1033 #define UC_CLEARDEV 19 1034 1035 static void sym_exec_user_command (struct sym_hcb *np, struct sym_usrcmd *uc) 1036 { 1037 struct sym_tcb *tp; 1038 int t, l; 1039 1040 switch (uc->cmd) { 1041 case 0: return; 1042 1043 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT 1044 case UC_SETDEBUG: 1045 sym_debug_flags = uc->data; 1046 break; 1047 #endif 1048 case UC_SETVERBOSE: 1049 np->verbose = uc->data; 1050 break; 1051 default: 1052 /* 1053 * We assume that other commands apply to targets. 1054 * This should always be the case and avoid the below 1055 * 4 lines to be repeated 6 times. 1056 */ 1057 for (t = 0; t < SYM_CONF_MAX_TARGET; t++) { 1058 if (!((uc->target >> t) & 1)) 1059 continue; 1060 tp = &np->target[t]; 1061 1062 switch (uc->cmd) { 1063 1064 case UC_SETSYNC: 1065 if (!uc->data || uc->data >= 255) { 1066 tp->tgoal.iu = tp->tgoal.dt = 1067 tp->tgoal.qas = 0; 1068 tp->tgoal.offset = 0; 1069 } else if (uc->data <= 9 && np->minsync_dt) { 1070 if (uc->data < np->minsync_dt) 1071 uc->data = np->minsync_dt; 1072 tp->tgoal.iu = tp->tgoal.dt = 1073 tp->tgoal.qas = 1; 1074 tp->tgoal.width = 1; 1075 tp->tgoal.period = uc->data; 1076 tp->tgoal.offset = np->maxoffs_dt; 1077 } else { 1078 if (uc->data < np->minsync) 1079 uc->data = np->minsync; 1080 tp->tgoal.iu = tp->tgoal.dt = 1081 tp->tgoal.qas = 0; 1082 tp->tgoal.period = uc->data; 1083 tp->tgoal.offset = np->maxoffs; 1084 } 1085 tp->tgoal.check_nego = 1; 1086 break; 1087 case UC_SETWIDE: 1088 tp->tgoal.width = uc->data ? 1 : 0; 1089 tp->tgoal.check_nego = 1; 1090 break; 1091 case UC_SETTAGS: 1092 for (l = 0; l < SYM_CONF_MAX_LUN; l++) 1093 sym_tune_dev_queuing(tp, l, uc->data); 1094 break; 1095 case UC_RESETDEV: 1096 tp->to_reset = 1; 1097 np->istat_sem = SEM; 1098 OUTB(np, nc_istat, SIGP|SEM); 1099 break; 1100 case UC_CLEARDEV: 1101 for (l = 0; l < SYM_CONF_MAX_LUN; l++) { 1102 struct sym_lcb *lp = sym_lp(tp, l); 1103 if (lp) lp->to_clear = 1; 1104 } 1105 np->istat_sem = SEM; 1106 OUTB(np, nc_istat, SIGP|SEM); 1107 break; 1108 case UC_SETFLAG: 1109 tp->usrflags = uc->data; 1110 break; 1111 } 1112 } 1113 break; 1114 } 1115 } 1116 1117 static int skip_spaces(char *ptr, int len) 1118 { 1119 int cnt, c; 1120 1121 for (cnt = len; cnt > 0 && (c = *ptr++) && isspace(c); cnt--); 1122 1123 return (len - cnt); 1124 } 1125 1126 static int get_int_arg(char *ptr, int len, u_long *pv) 1127 { 1128 char *end; 1129 1130 *pv = simple_strtoul(ptr, &end, 10); 1131 return (end - ptr); 1132 } 1133 1134 static int is_keyword(char *ptr, int len, char *verb) 1135 { 1136 int verb_len = strlen(verb); 1137 1138 if (len >= verb_len && !memcmp(verb, ptr, verb_len)) 1139 return verb_len; 1140 else 1141 return 0; 1142 } 1143 1144 #define SKIP_SPACES(ptr, len) \ 1145 if ((arg_len = skip_spaces(ptr, len)) < 1) \ 1146 return -EINVAL; \ 1147 ptr += arg_len; len -= arg_len; 1148 1149 #define GET_INT_ARG(ptr, len, v) \ 1150 if (!(arg_len = get_int_arg(ptr, len, &(v)))) \ 1151 return -EINVAL; \ 1152 ptr += arg_len; len -= arg_len; 1153 1154 1155 /* 1156 * Parse a control command 1157 */ 1158 1159 static int sym_user_command(struct sym_hcb *np, char *buffer, int length) 1160 { 1161 char *ptr = buffer; 1162 int len = length; 1163 struct sym_usrcmd cmd, *uc = &cmd; 1164 int arg_len; 1165 u_long target; 1166 1167 memset(uc, 0, sizeof(*uc)); 1168 1169 if (len > 0 && ptr[len-1] == '\n') 1170 --len; 1171 1172 if ((arg_len = is_keyword(ptr, len, "setsync")) != 0) 1173 uc->cmd = UC_SETSYNC; 1174 else if ((arg_len = is_keyword(ptr, len, "settags")) != 0) 1175 uc->cmd = UC_SETTAGS; 1176 else if ((arg_len = is_keyword(ptr, len, "setverbose")) != 0) 1177 uc->cmd = UC_SETVERBOSE; 1178 else if ((arg_len = is_keyword(ptr, len, "setwide")) != 0) 1179 uc->cmd = UC_SETWIDE; 1180 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT 1181 else if ((arg_len = is_keyword(ptr, len, "setdebug")) != 0) 1182 uc->cmd = UC_SETDEBUG; 1183 #endif 1184 else if ((arg_len = is_keyword(ptr, len, "setflag")) != 0) 1185 uc->cmd = UC_SETFLAG; 1186 else if ((arg_len = is_keyword(ptr, len, "resetdev")) != 0) 1187 uc->cmd = UC_RESETDEV; 1188 else if ((arg_len = is_keyword(ptr, len, "cleardev")) != 0) 1189 uc->cmd = UC_CLEARDEV; 1190 else 1191 arg_len = 0; 1192 1193 #ifdef DEBUG_PROC_INFO 1194 printk("sym_user_command: arg_len=%d, cmd=%ld\n", arg_len, uc->cmd); 1195 #endif 1196 1197 if (!arg_len) 1198 return -EINVAL; 1199 ptr += arg_len; len -= arg_len; 1200 1201 switch(uc->cmd) { 1202 case UC_SETSYNC: 1203 case UC_SETTAGS: 1204 case UC_SETWIDE: 1205 case UC_SETFLAG: 1206 case UC_RESETDEV: 1207 case UC_CLEARDEV: 1208 SKIP_SPACES(ptr, len); 1209 if ((arg_len = is_keyword(ptr, len, "all")) != 0) { 1210 ptr += arg_len; len -= arg_len; 1211 uc->target = ~0; 1212 } else { 1213 GET_INT_ARG(ptr, len, target); 1214 uc->target = (1<<target); 1215 #ifdef DEBUG_PROC_INFO 1216 printk("sym_user_command: target=%ld\n", target); 1217 #endif 1218 } 1219 break; 1220 } 1221 1222 switch(uc->cmd) { 1223 case UC_SETVERBOSE: 1224 case UC_SETSYNC: 1225 case UC_SETTAGS: 1226 case UC_SETWIDE: 1227 SKIP_SPACES(ptr, len); 1228 GET_INT_ARG(ptr, len, uc->data); 1229 #ifdef DEBUG_PROC_INFO 1230 printk("sym_user_command: data=%ld\n", uc->data); 1231 #endif 1232 break; 1233 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT 1234 case UC_SETDEBUG: 1235 while (len > 0) { 1236 SKIP_SPACES(ptr, len); 1237 if ((arg_len = is_keyword(ptr, len, "alloc"))) 1238 uc->data |= DEBUG_ALLOC; 1239 else if ((arg_len = is_keyword(ptr, len, "phase"))) 1240 uc->data |= DEBUG_PHASE; 1241 else if ((arg_len = is_keyword(ptr, len, "queue"))) 1242 uc->data |= DEBUG_QUEUE; 1243 else if ((arg_len = is_keyword(ptr, len, "result"))) 1244 uc->data |= DEBUG_RESULT; 1245 else if ((arg_len = is_keyword(ptr, len, "scatter"))) 1246 uc->data |= DEBUG_SCATTER; 1247 else if ((arg_len = is_keyword(ptr, len, "script"))) 1248 uc->data |= DEBUG_SCRIPT; 1249 else if ((arg_len = is_keyword(ptr, len, "tiny"))) 1250 uc->data |= DEBUG_TINY; 1251 else if ((arg_len = is_keyword(ptr, len, "timing"))) 1252 uc->data |= DEBUG_TIMING; 1253 else if ((arg_len = is_keyword(ptr, len, "nego"))) 1254 uc->data |= DEBUG_NEGO; 1255 else if ((arg_len = is_keyword(ptr, len, "tags"))) 1256 uc->data |= DEBUG_TAGS; 1257 else if ((arg_len = is_keyword(ptr, len, "pointer"))) 1258 uc->data |= DEBUG_POINTER; 1259 else 1260 return -EINVAL; 1261 ptr += arg_len; len -= arg_len; 1262 } 1263 #ifdef DEBUG_PROC_INFO 1264 printk("sym_user_command: data=%ld\n", uc->data); 1265 #endif 1266 break; 1267 #endif /* SYM_LINUX_DEBUG_CONTROL_SUPPORT */ 1268 case UC_SETFLAG: 1269 while (len > 0) { 1270 SKIP_SPACES(ptr, len); 1271 if ((arg_len = is_keyword(ptr, len, "no_disc"))) 1272 uc->data &= ~SYM_DISC_ENABLED; 1273 else 1274 return -EINVAL; 1275 ptr += arg_len; len -= arg_len; 1276 } 1277 break; 1278 default: 1279 break; 1280 } 1281 1282 if (len) 1283 return -EINVAL; 1284 else { 1285 unsigned long flags; 1286 1287 spin_lock_irqsave(np->s.host->host_lock, flags); 1288 sym_exec_user_command (np, uc); 1289 spin_unlock_irqrestore(np->s.host->host_lock, flags); 1290 } 1291 return length; 1292 } 1293 1294 #endif /* SYM_LINUX_USER_COMMAND_SUPPORT */ 1295 1296 1297 #ifdef SYM_LINUX_USER_INFO_SUPPORT 1298 /* 1299 * Informations through the proc file system. 1300 */ 1301 struct info_str { 1302 char *buffer; 1303 int length; 1304 int offset; 1305 int pos; 1306 }; 1307 1308 static void copy_mem_info(struct info_str *info, char *data, int len) 1309 { 1310 if (info->pos + len > info->length) 1311 len = info->length - info->pos; 1312 1313 if (info->pos + len < info->offset) { 1314 info->pos += len; 1315 return; 1316 } 1317 if (info->pos < info->offset) { 1318 data += (info->offset - info->pos); 1319 len -= (info->offset - info->pos); 1320 } 1321 1322 if (len > 0) { 1323 memcpy(info->buffer + info->pos, data, len); 1324 info->pos += len; 1325 } 1326 } 1327 1328 static int copy_info(struct info_str *info, char *fmt, ...) 1329 { 1330 va_list args; 1331 char buf[81]; 1332 int len; 1333 1334 va_start(args, fmt); 1335 len = vsprintf(buf, fmt, args); 1336 va_end(args); 1337 1338 copy_mem_info(info, buf, len); 1339 return len; 1340 } 1341 1342 /* 1343 * Copy formatted information into the input buffer. 1344 */ 1345 static int sym_host_info(struct sym_hcb *np, char *ptr, off_t offset, int len) 1346 { 1347 struct info_str info; 1348 1349 info.buffer = ptr; 1350 info.length = len; 1351 info.offset = offset; 1352 info.pos = 0; 1353 1354 copy_info(&info, "Chip " NAME53C "%s, device id 0x%x, " 1355 "revision id 0x%x\n", 1356 np->s.chip_name, np->device_id, np->revision_id); 1357 copy_info(&info, "At PCI address %s, IRQ " IRQ_FMT "\n", 1358 pci_name(np->s.device), IRQ_PRM(np->s.irq)); 1359 copy_info(&info, "Min. period factor %d, %s SCSI BUS%s\n", 1360 (int) (np->minsync_dt ? np->minsync_dt : np->minsync), 1361 np->maxwide ? "Wide" : "Narrow", 1362 np->minsync_dt ? ", DT capable" : ""); 1363 1364 copy_info(&info, "Max. started commands %d, " 1365 "max. commands per LUN %d\n", 1366 SYM_CONF_MAX_START, SYM_CONF_MAX_TAG); 1367 1368 return info.pos > info.offset? info.pos - info.offset : 0; 1369 } 1370 #endif /* SYM_LINUX_USER_INFO_SUPPORT */ 1371 1372 /* 1373 * Entry point of the scsi proc fs of the driver. 1374 * - func = 0 means read (returns adapter infos) 1375 * - func = 1 means write (not yet merget from sym53c8xx) 1376 */ 1377 static int sym53c8xx_proc_info(struct Scsi_Host *host, char *buffer, 1378 char **start, off_t offset, int length, int func) 1379 { 1380 struct sym_hcb *np = sym_get_hcb(host); 1381 int retv; 1382 1383 if (func) { 1384 #ifdef SYM_LINUX_USER_COMMAND_SUPPORT 1385 retv = sym_user_command(np, buffer, length); 1386 #else 1387 retv = -EINVAL; 1388 #endif 1389 } else { 1390 if (start) 1391 *start = buffer; 1392 #ifdef SYM_LINUX_USER_INFO_SUPPORT 1393 retv = sym_host_info(np, buffer, offset, length); 1394 #else 1395 retv = -EINVAL; 1396 #endif 1397 } 1398 1399 return retv; 1400 } 1401 #endif /* SYM_LINUX_PROC_INFO_SUPPORT */ 1402 1403 /* 1404 * Free controller resources. 1405 */ 1406 static void sym_free_resources(struct sym_hcb *np, struct pci_dev *pdev) 1407 { 1408 /* 1409 * Free O/S specific resources. 1410 */ 1411 if (np->s.irq) 1412 free_irq(np->s.irq, np); 1413 if (np->s.ioaddr) 1414 pci_iounmap(pdev, np->s.ioaddr); 1415 if (np->s.ramaddr) 1416 pci_iounmap(pdev, np->s.ramaddr); 1417 /* 1418 * Free O/S independent resources. 1419 */ 1420 sym_hcb_free(np); 1421 1422 sym_mfree_dma(np, sizeof(*np), "HCB"); 1423 } 1424 1425 /* 1426 * Ask/tell the system about DMA addressing. 1427 */ 1428 static int sym_setup_bus_dma_mask(struct sym_hcb *np) 1429 { 1430 #if SYM_CONF_DMA_ADDRESSING_MODE > 0 1431 #if SYM_CONF_DMA_ADDRESSING_MODE == 1 1432 #define DMA_DAC_MASK DMA_40BIT_MASK 1433 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2 1434 #define DMA_DAC_MASK DMA_64BIT_MASK 1435 #endif 1436 if ((np->features & FE_DAC) && 1437 !pci_set_dma_mask(np->s.device, DMA_DAC_MASK)) { 1438 np->use_dac = 1; 1439 return 0; 1440 } 1441 #endif 1442 1443 if (!pci_set_dma_mask(np->s.device, DMA_32BIT_MASK)) 1444 return 0; 1445 1446 printf_warning("%s: No suitable DMA available\n", sym_name(np)); 1447 return -1; 1448 } 1449 1450 /* 1451 * Host attach and initialisations. 1452 * 1453 * Allocate host data and ncb structure. 1454 * Remap MMIO region. 1455 * Do chip initialization. 1456 * If all is OK, install interrupt handling and 1457 * start the timer daemon. 1458 */ 1459 static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt, 1460 int unit, struct sym_device *dev) 1461 { 1462 struct host_data *host_data; 1463 struct sym_hcb *np = NULL; 1464 struct Scsi_Host *instance = NULL; 1465 struct pci_dev *pdev = dev->pdev; 1466 unsigned long flags; 1467 struct sym_fw *fw; 1468 1469 printk(KERN_INFO 1470 "sym%d: <%s> rev 0x%x at pci %s irq " IRQ_FMT "\n", 1471 unit, dev->chip.name, dev->chip.revision_id, 1472 pci_name(pdev), IRQ_PRM(pdev->irq)); 1473 1474 /* 1475 * Get the firmware for this chip. 1476 */ 1477 fw = sym_find_firmware(&dev->chip); 1478 if (!fw) 1479 goto attach_failed; 1480 1481 /* 1482 * Allocate host_data structure 1483 */ 1484 instance = scsi_host_alloc(tpnt, sizeof(*host_data)); 1485 if (!instance) 1486 goto attach_failed; 1487 host_data = (struct host_data *) instance->hostdata; 1488 1489 /* 1490 * Allocate immediately the host control block, 1491 * since we are only expecting to succeed. :) 1492 * We keep track in the HCB of all the resources that 1493 * are to be released on error. 1494 */ 1495 np = __sym_calloc_dma(&pdev->dev, sizeof(*np), "HCB"); 1496 if (!np) 1497 goto attach_failed; 1498 np->s.device = pdev; 1499 np->bus_dmat = &pdev->dev; /* Result in 1 DMA pool per HBA */ 1500 host_data->ncb = np; 1501 np->s.host = instance; 1502 1503 pci_set_drvdata(pdev, np); 1504 1505 /* 1506 * Copy some useful infos to the HCB. 1507 */ 1508 np->hcb_ba = vtobus(np); 1509 np->verbose = sym_driver_setup.verbose; 1510 np->s.device = pdev; 1511 np->s.unit = unit; 1512 np->device_id = dev->chip.device_id; 1513 np->revision_id = dev->chip.revision_id; 1514 np->features = dev->chip.features; 1515 np->clock_divn = dev->chip.nr_divisor; 1516 np->maxoffs = dev->chip.offset_max; 1517 np->maxburst = dev->chip.burst_max; 1518 np->myaddr = dev->host_id; 1519 1520 /* 1521 * Edit its name. 1522 */ 1523 strlcpy(np->s.chip_name, dev->chip.name, sizeof(np->s.chip_name)); 1524 sprintf(np->s.inst_name, "sym%d", np->s.unit); 1525 1526 if (sym_setup_bus_dma_mask(np)) 1527 goto attach_failed; 1528 1529 /* 1530 * Try to map the controller chip to 1531 * virtual and physical memory. 1532 */ 1533 np->mmio_ba = (u32)dev->mmio_base; 1534 np->s.ioaddr = dev->s.ioaddr; 1535 np->s.ramaddr = dev->s.ramaddr; 1536 np->s.io_ws = (np->features & FE_IO256) ? 256 : 128; 1537 1538 /* 1539 * Map on-chip RAM if present and supported. 1540 */ 1541 if (!(np->features & FE_RAM)) 1542 dev->ram_base = 0; 1543 if (dev->ram_base) { 1544 np->ram_ba = (u32)dev->ram_base; 1545 np->ram_ws = (np->features & FE_RAM8K) ? 8192 : 4096; 1546 } 1547 1548 if (sym_hcb_attach(instance, fw, dev->nvram)) 1549 goto attach_failed; 1550 1551 /* 1552 * Install the interrupt handler. 1553 * If we synchonize the C code with SCRIPTS on interrupt, 1554 * we do not want to share the INTR line at all. 1555 */ 1556 if (request_irq(pdev->irq, sym53c8xx_intr, SA_SHIRQ, NAME53C8XX, np)) { 1557 printf_err("%s: request irq %d failure\n", 1558 sym_name(np), pdev->irq); 1559 goto attach_failed; 1560 } 1561 np->s.irq = pdev->irq; 1562 1563 /* 1564 * After SCSI devices have been opened, we cannot 1565 * reset the bus safely, so we do it here. 1566 */ 1567 spin_lock_irqsave(instance->host_lock, flags); 1568 if (sym_reset_scsi_bus(np, 0)) 1569 goto reset_failed; 1570 1571 /* 1572 * Start the SCRIPTS. 1573 */ 1574 sym_start_up (np, 1); 1575 1576 /* 1577 * Start the timer daemon 1578 */ 1579 init_timer(&np->s.timer); 1580 np->s.timer.data = (unsigned long) np; 1581 np->s.timer.function = sym53c8xx_timer; 1582 np->s.lasttime=0; 1583 sym_timer (np); 1584 1585 /* 1586 * Fill Linux host instance structure 1587 * and return success. 1588 */ 1589 instance->max_channel = 0; 1590 instance->this_id = np->myaddr; 1591 instance->max_id = np->maxwide ? 16 : 8; 1592 instance->max_lun = SYM_CONF_MAX_LUN; 1593 instance->unique_id = pci_resource_start(pdev, 0); 1594 instance->cmd_per_lun = SYM_CONF_MAX_TAG; 1595 instance->can_queue = (SYM_CONF_MAX_START-2); 1596 instance->sg_tablesize = SYM_CONF_MAX_SG; 1597 instance->max_cmd_len = 16; 1598 BUG_ON(sym2_transport_template == NULL); 1599 instance->transportt = sym2_transport_template; 1600 1601 spin_unlock_irqrestore(instance->host_lock, flags); 1602 1603 return instance; 1604 1605 reset_failed: 1606 printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, " 1607 "TERMINATION, DEVICE POWER etc.!\n", sym_name(np)); 1608 spin_unlock_irqrestore(instance->host_lock, flags); 1609 attach_failed: 1610 if (!instance) 1611 return NULL; 1612 printf_info("%s: giving up ...\n", sym_name(np)); 1613 if (np) 1614 sym_free_resources(np, pdev); 1615 scsi_host_put(instance); 1616 1617 return NULL; 1618 } 1619 1620 1621 /* 1622 * Detect and try to read SYMBIOS and TEKRAM NVRAM. 1623 */ 1624 #if SYM_CONF_NVRAM_SUPPORT 1625 static void __devinit sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp) 1626 { 1627 devp->nvram = nvp; 1628 devp->device_id = devp->chip.device_id; 1629 nvp->type = 0; 1630 1631 sym_read_nvram(devp, nvp); 1632 } 1633 #else 1634 static inline void sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp) 1635 { 1636 } 1637 #endif /* SYM_CONF_NVRAM_SUPPORT */ 1638 1639 static int __devinit sym_check_supported(struct sym_device *device) 1640 { 1641 struct sym_chip *chip; 1642 struct pci_dev *pdev = device->pdev; 1643 u_char revision; 1644 unsigned long io_port = pci_resource_start(pdev, 0); 1645 int i; 1646 1647 /* 1648 * If user excluded this chip, do not initialize it. 1649 * I hate this code so much. Must kill it. 1650 */ 1651 if (io_port) { 1652 for (i = 0 ; i < 8 ; i++) { 1653 if (sym_driver_setup.excludes[i] == io_port) 1654 return -ENODEV; 1655 } 1656 } 1657 1658 /* 1659 * Check if the chip is supported. Then copy the chip description 1660 * to our device structure so we can make it match the actual device 1661 * and options. 1662 */ 1663 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision); 1664 chip = sym_lookup_chip_table(pdev->device, revision); 1665 if (!chip) { 1666 dev_info(&pdev->dev, "device not supported\n"); 1667 return -ENODEV; 1668 } 1669 memcpy(&device->chip, chip, sizeof(device->chip)); 1670 device->chip.revision_id = revision; 1671 1672 return 0; 1673 } 1674 1675 /* 1676 * Ignore Symbios chips controlled by various RAID controllers. 1677 * These controllers set value 0x52414944 at RAM end - 16. 1678 */ 1679 static int __devinit sym_check_raid(struct sym_device *device) 1680 { 1681 unsigned int ram_size, ram_val; 1682 1683 if (!device->s.ramaddr) 1684 return 0; 1685 1686 if (device->chip.features & FE_RAM8K) 1687 ram_size = 8192; 1688 else 1689 ram_size = 4096; 1690 1691 ram_val = readl(device->s.ramaddr + ram_size - 16); 1692 if (ram_val != 0x52414944) 1693 return 0; 1694 1695 dev_info(&device->pdev->dev, 1696 "not initializing, driven by RAID controller.\n"); 1697 return -ENODEV; 1698 } 1699 1700 static int __devinit sym_set_workarounds(struct sym_device *device) 1701 { 1702 struct sym_chip *chip = &device->chip; 1703 struct pci_dev *pdev = device->pdev; 1704 u_short status_reg; 1705 1706 /* 1707 * (ITEM 12 of a DEL about the 896 I haven't yet). 1708 * We must ensure the chip will use WRITE AND INVALIDATE. 1709 * The revision number limit is for now arbitrary. 1710 */ 1711 if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && chip->revision_id < 0x4) { 1712 chip->features |= (FE_WRIE | FE_CLSE); 1713 } 1714 1715 /* If the chip can do Memory Write Invalidate, enable it */ 1716 if (chip->features & FE_WRIE) { 1717 if (pci_set_mwi(pdev)) 1718 return -ENODEV; 1719 } 1720 1721 /* 1722 * Work around for errant bit in 895A. The 66Mhz 1723 * capable bit is set erroneously. Clear this bit. 1724 * (Item 1 DEL 533) 1725 * 1726 * Make sure Config space and Features agree. 1727 * 1728 * Recall: writes are not normal to status register - 1729 * write a 1 to clear and a 0 to leave unchanged. 1730 * Can only reset bits. 1731 */ 1732 pci_read_config_word(pdev, PCI_STATUS, &status_reg); 1733 if (chip->features & FE_66MHZ) { 1734 if (!(status_reg & PCI_STATUS_66MHZ)) 1735 chip->features &= ~FE_66MHZ; 1736 } else { 1737 if (status_reg & PCI_STATUS_66MHZ) { 1738 status_reg = PCI_STATUS_66MHZ; 1739 pci_write_config_word(pdev, PCI_STATUS, status_reg); 1740 pci_read_config_word(pdev, PCI_STATUS, &status_reg); 1741 } 1742 } 1743 1744 return 0; 1745 } 1746 1747 /* 1748 * Read and check the PCI configuration for any detected NCR 1749 * boards and save data for attaching after all boards have 1750 * been detected. 1751 */ 1752 static void __devinit 1753 sym_init_device(struct pci_dev *pdev, struct sym_device *device) 1754 { 1755 int i = 2; 1756 struct pci_bus_region bus_addr; 1757 1758 device->host_id = SYM_SETUP_HOST_ID; 1759 device->pdev = pdev; 1760 1761 pcibios_resource_to_bus(pdev, &bus_addr, &pdev->resource[1]); 1762 device->mmio_base = bus_addr.start; 1763 1764 /* 1765 * If the BAR is 64-bit, resource 2 will be occupied by the 1766 * upper 32 bits 1767 */ 1768 if (!pdev->resource[i].flags) 1769 i++; 1770 pcibios_resource_to_bus(pdev, &bus_addr, &pdev->resource[i]); 1771 device->ram_base = bus_addr.start; 1772 1773 #ifdef CONFIG_SCSI_SYM53C8XX_MMIO 1774 if (device->mmio_base) 1775 device->s.ioaddr = pci_iomap(pdev, 1, 1776 pci_resource_len(pdev, 1)); 1777 #endif 1778 if (!device->s.ioaddr) 1779 device->s.ioaddr = pci_iomap(pdev, 0, 1780 pci_resource_len(pdev, 0)); 1781 if (device->ram_base) 1782 device->s.ramaddr = pci_iomap(pdev, i, 1783 pci_resource_len(pdev, i)); 1784 } 1785 1786 /* 1787 * The NCR PQS and PDS cards are constructed as a DEC bridge 1788 * behind which sits a proprietary NCR memory controller and 1789 * either four or two 53c875s as separate devices. We can tell 1790 * if an 875 is part of a PQS/PDS or not since if it is, it will 1791 * be on the same bus as the memory controller. In its usual 1792 * mode of operation, the 875s are slaved to the memory 1793 * controller for all transfers. To operate with the Linux 1794 * driver, the memory controller is disabled and the 875s 1795 * freed to function independently. The only wrinkle is that 1796 * the preset SCSI ID (which may be zero) must be read in from 1797 * a special configuration space register of the 875. 1798 */ 1799 static void sym_config_pqs(struct pci_dev *pdev, struct sym_device *sym_dev) 1800 { 1801 int slot; 1802 u8 tmp; 1803 1804 for (slot = 0; slot < 256; slot++) { 1805 struct pci_dev *memc = pci_get_slot(pdev->bus, slot); 1806 1807 if (!memc || memc->vendor != 0x101a || memc->device == 0x0009) { 1808 pci_dev_put(memc); 1809 continue; 1810 } 1811 1812 /* bit 1: allow individual 875 configuration */ 1813 pci_read_config_byte(memc, 0x44, &tmp); 1814 if ((tmp & 0x2) == 0) { 1815 tmp |= 0x2; 1816 pci_write_config_byte(memc, 0x44, tmp); 1817 } 1818 1819 /* bit 2: drive individual 875 interrupts to the bus */ 1820 pci_read_config_byte(memc, 0x45, &tmp); 1821 if ((tmp & 0x4) == 0) { 1822 tmp |= 0x4; 1823 pci_write_config_byte(memc, 0x45, tmp); 1824 } 1825 1826 pci_dev_put(memc); 1827 break; 1828 } 1829 1830 pci_read_config_byte(pdev, 0x84, &tmp); 1831 sym_dev->host_id = tmp; 1832 } 1833 1834 /* 1835 * Called before unloading the module. 1836 * Detach the host. 1837 * We have to free resources and halt the NCR chip. 1838 */ 1839 static int sym_detach(struct sym_hcb *np, struct pci_dev *pdev) 1840 { 1841 printk("%s: detaching ...\n", sym_name(np)); 1842 1843 del_timer_sync(&np->s.timer); 1844 1845 /* 1846 * Reset NCR chip. 1847 * We should use sym_soft_reset(), but we don't want to do 1848 * so, since we may not be safe if interrupts occur. 1849 */ 1850 printk("%s: resetting chip\n", sym_name(np)); 1851 OUTB(np, nc_istat, SRST); 1852 INB(np, nc_mbox1); 1853 udelay(10); 1854 OUTB(np, nc_istat, 0); 1855 1856 sym_free_resources(np, pdev); 1857 1858 return 1; 1859 } 1860 1861 /* 1862 * Driver host template. 1863 */ 1864 static struct scsi_host_template sym2_template = { 1865 .module = THIS_MODULE, 1866 .name = "sym53c8xx", 1867 .info = sym53c8xx_info, 1868 .queuecommand = sym53c8xx_queue_command, 1869 .slave_alloc = sym53c8xx_slave_alloc, 1870 .slave_configure = sym53c8xx_slave_configure, 1871 .slave_destroy = sym53c8xx_slave_destroy, 1872 .eh_abort_handler = sym53c8xx_eh_abort_handler, 1873 .eh_device_reset_handler = sym53c8xx_eh_device_reset_handler, 1874 .eh_bus_reset_handler = sym53c8xx_eh_bus_reset_handler, 1875 .eh_host_reset_handler = sym53c8xx_eh_host_reset_handler, 1876 .this_id = 7, 1877 .use_clustering = ENABLE_CLUSTERING, 1878 .max_sectors = 0xFFFF, 1879 #ifdef SYM_LINUX_PROC_INFO_SUPPORT 1880 .proc_info = sym53c8xx_proc_info, 1881 .proc_name = NAME53C8XX, 1882 #endif 1883 }; 1884 1885 static int attach_count; 1886 1887 static int __devinit sym2_probe(struct pci_dev *pdev, 1888 const struct pci_device_id *ent) 1889 { 1890 struct sym_device sym_dev; 1891 struct sym_nvram nvram; 1892 struct Scsi_Host *instance; 1893 1894 memset(&sym_dev, 0, sizeof(sym_dev)); 1895 memset(&nvram, 0, sizeof(nvram)); 1896 1897 if (pci_enable_device(pdev)) 1898 goto leave; 1899 1900 pci_set_master(pdev); 1901 1902 if (pci_request_regions(pdev, NAME53C8XX)) 1903 goto disable; 1904 1905 sym_init_device(pdev, &sym_dev); 1906 if (sym_check_supported(&sym_dev)) 1907 goto free; 1908 1909 if (sym_check_raid(&sym_dev)) 1910 goto leave; /* Don't disable the device */ 1911 1912 if (sym_set_workarounds(&sym_dev)) 1913 goto free; 1914 1915 sym_config_pqs(pdev, &sym_dev); 1916 1917 sym_get_nvram(&sym_dev, &nvram); 1918 1919 instance = sym_attach(&sym2_template, attach_count, &sym_dev); 1920 if (!instance) 1921 goto free; 1922 1923 if (scsi_add_host(instance, &pdev->dev)) 1924 goto detach; 1925 scsi_scan_host(instance); 1926 1927 attach_count++; 1928 1929 return 0; 1930 1931 detach: 1932 sym_detach(pci_get_drvdata(pdev), pdev); 1933 free: 1934 pci_release_regions(pdev); 1935 disable: 1936 pci_disable_device(pdev); 1937 leave: 1938 return -ENODEV; 1939 } 1940 1941 static void __devexit sym2_remove(struct pci_dev *pdev) 1942 { 1943 struct sym_hcb *np = pci_get_drvdata(pdev); 1944 struct Scsi_Host *host = np->s.host; 1945 1946 scsi_remove_host(host); 1947 scsi_host_put(host); 1948 1949 sym_detach(np, pdev); 1950 1951 pci_release_regions(pdev); 1952 pci_disable_device(pdev); 1953 1954 attach_count--; 1955 } 1956 1957 static void sym2_get_signalling(struct Scsi_Host *shost) 1958 { 1959 struct sym_hcb *np = sym_get_hcb(shost); 1960 enum spi_signal_type type; 1961 1962 switch (np->scsi_mode) { 1963 case SMODE_SE: 1964 type = SPI_SIGNAL_SE; 1965 break; 1966 case SMODE_LVD: 1967 type = SPI_SIGNAL_LVD; 1968 break; 1969 case SMODE_HVD: 1970 type = SPI_SIGNAL_HVD; 1971 break; 1972 default: 1973 type = SPI_SIGNAL_UNKNOWN; 1974 break; 1975 } 1976 spi_signalling(shost) = type; 1977 } 1978 1979 static void sym2_set_offset(struct scsi_target *starget, int offset) 1980 { 1981 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1982 struct sym_hcb *np = sym_get_hcb(shost); 1983 struct sym_tcb *tp = &np->target[starget->id]; 1984 1985 tp->tgoal.offset = offset; 1986 tp->tgoal.check_nego = 1; 1987 } 1988 1989 static void sym2_set_period(struct scsi_target *starget, int period) 1990 { 1991 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1992 struct sym_hcb *np = sym_get_hcb(shost); 1993 struct sym_tcb *tp = &np->target[starget->id]; 1994 1995 /* have to have DT for these transfers, but DT will also 1996 * set width, so check that this is allowed */ 1997 if (period <= np->minsync && spi_width(starget)) 1998 tp->tgoal.dt = 1; 1999 2000 tp->tgoal.period = period; 2001 tp->tgoal.check_nego = 1; 2002 } 2003 2004 static void sym2_set_width(struct scsi_target *starget, int width) 2005 { 2006 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2007 struct sym_hcb *np = sym_get_hcb(shost); 2008 struct sym_tcb *tp = &np->target[starget->id]; 2009 2010 /* It is illegal to have DT set on narrow transfers. If DT is 2011 * clear, we must also clear IU and QAS. */ 2012 if (width == 0) 2013 tp->tgoal.iu = tp->tgoal.dt = tp->tgoal.qas = 0; 2014 2015 tp->tgoal.width = width; 2016 tp->tgoal.check_nego = 1; 2017 } 2018 2019 static void sym2_set_dt(struct scsi_target *starget, int dt) 2020 { 2021 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2022 struct sym_hcb *np = sym_get_hcb(shost); 2023 struct sym_tcb *tp = &np->target[starget->id]; 2024 2025 /* We must clear QAS and IU if DT is clear */ 2026 if (dt) 2027 tp->tgoal.dt = 1; 2028 else 2029 tp->tgoal.iu = tp->tgoal.dt = tp->tgoal.qas = 0; 2030 tp->tgoal.check_nego = 1; 2031 } 2032 2033 #if 0 2034 static void sym2_set_iu(struct scsi_target *starget, int iu) 2035 { 2036 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2037 struct sym_hcb *np = sym_get_hcb(shost); 2038 struct sym_tcb *tp = &np->target[starget->id]; 2039 2040 if (iu) 2041 tp->tgoal.iu = tp->tgoal.dt = 1; 2042 else 2043 tp->tgoal.iu = 0; 2044 tp->tgoal.check_nego = 1; 2045 } 2046 2047 static void sym2_set_qas(struct scsi_target *starget, int qas) 2048 { 2049 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2050 struct sym_hcb *np = sym_get_hcb(shost); 2051 struct sym_tcb *tp = &np->target[starget->id]; 2052 2053 if (qas) 2054 tp->tgoal.dt = tp->tgoal.qas = 1; 2055 else 2056 tp->tgoal.qas = 0; 2057 tp->tgoal.check_nego = 1; 2058 } 2059 #endif 2060 2061 static struct spi_function_template sym2_transport_functions = { 2062 .set_offset = sym2_set_offset, 2063 .show_offset = 1, 2064 .set_period = sym2_set_period, 2065 .show_period = 1, 2066 .set_width = sym2_set_width, 2067 .show_width = 1, 2068 .set_dt = sym2_set_dt, 2069 .show_dt = 1, 2070 #if 0 2071 .set_iu = sym2_set_iu, 2072 .show_iu = 1, 2073 .set_qas = sym2_set_qas, 2074 .show_qas = 1, 2075 #endif 2076 .get_signalling = sym2_get_signalling, 2077 }; 2078 2079 static struct pci_device_id sym2_id_table[] __devinitdata = { 2080 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C810, 2081 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2082 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C820, 2083 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, /* new */ 2084 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C825, 2085 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2086 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C815, 2087 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2088 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C810AP, 2089 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, /* new */ 2090 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C860, 2091 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2092 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1510, 2093 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2094 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C896, 2095 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2096 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C895, 2097 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2098 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C885, 2099 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2100 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C875, 2101 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2102 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C1510, 2103 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, /* new */ 2104 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C895A, 2105 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2106 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C875A, 2107 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2108 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1010_33, 2109 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2110 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1010_66, 2111 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2112 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C875J, 2113 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 2114 { 0, } 2115 }; 2116 2117 MODULE_DEVICE_TABLE(pci, sym2_id_table); 2118 2119 static struct pci_driver sym2_driver = { 2120 .name = NAME53C8XX, 2121 .id_table = sym2_id_table, 2122 .probe = sym2_probe, 2123 .remove = __devexit_p(sym2_remove), 2124 }; 2125 2126 static int __init sym2_init(void) 2127 { 2128 int error; 2129 2130 sym2_setup_params(); 2131 sym2_transport_template = spi_attach_transport(&sym2_transport_functions); 2132 if (!sym2_transport_template) 2133 return -ENODEV; 2134 2135 error = pci_register_driver(&sym2_driver); 2136 if (error) 2137 spi_release_transport(sym2_transport_template); 2138 return error; 2139 } 2140 2141 static void __exit sym2_exit(void) 2142 { 2143 pci_unregister_driver(&sym2_driver); 2144 spi_release_transport(sym2_transport_template); 2145 } 2146 2147 module_init(sym2_init); 2148 module_exit(sym2_exit); 2149