1 /* 2 * Adaptec AIC7xxx device driver for Linux. 3 * 4 * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.c#235 $ 5 * 6 * Copyright (c) 1994 John Aycock 7 * The University of Calgary Department of Computer Science. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2, or (at your option) 12 * any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; see the file COPYING. If not, write to 21 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 22 * 23 * Sources include the Adaptec 1740 driver (aha1740.c), the Ultrastor 24F 24 * driver (ultrastor.c), various Linux kernel source, the Adaptec EISA 25 * config file (!adp7771.cfg), the Adaptec AHA-2740A Series User's Guide, 26 * the Linux Kernel Hacker's Guide, Writing a SCSI Device Driver for Linux, 27 * the Adaptec 1542 driver (aha1542.c), the Adaptec EISA overlay file 28 * (adp7770.ovl), the Adaptec AHA-2740 Series Technical Reference Manual, 29 * the Adaptec AIC-7770 Data Book, the ANSI SCSI specification, the 30 * ANSI SCSI-2 specification (draft 10c), ... 31 * 32 * -------------------------------------------------------------------------- 33 * 34 * Modifications by Daniel M. Eischen (deischen@iworks.InterWorks.org): 35 * 36 * Substantially modified to include support for wide and twin bus 37 * adapters, DMAing of SCBs, tagged queueing, IRQ sharing, bug fixes, 38 * SCB paging, and other rework of the code. 39 * 40 * -------------------------------------------------------------------------- 41 * Copyright (c) 1994-2000 Justin T. Gibbs. 42 * Copyright (c) 2000-2001 Adaptec Inc. 43 * All rights reserved. 44 * 45 * Redistribution and use in source and binary forms, with or without 46 * modification, are permitted provided that the following conditions 47 * are met: 48 * 1. Redistributions of source code must retain the above copyright 49 * notice, this list of conditions, and the following disclaimer, 50 * without modification. 51 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 52 * substantially similar to the "NO WARRANTY" disclaimer below 53 * ("Disclaimer") and any redistribution must be conditioned upon 54 * including a substantially similar Disclaimer requirement for further 55 * binary redistribution. 56 * 3. Neither the names of the above-listed copyright holders nor the names 57 * of any contributors may be used to endorse or promote products derived 58 * from this software without specific prior written permission. 59 * 60 * Alternatively, this software may be distributed under the terms of the 61 * GNU General Public License ("GPL") version 2 as published by the Free 62 * Software Foundation. 63 * 64 * NO WARRANTY 65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 66 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 67 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 68 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 69 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 70 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 71 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 72 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 73 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 74 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 75 * POSSIBILITY OF SUCH DAMAGES. 76 * 77 *--------------------------------------------------------------------------- 78 * 79 * Thanks also go to (in alphabetical order) the following: 80 * 81 * Rory Bolt - Sequencer bug fixes 82 * Jay Estabrook - Initial DEC Alpha support 83 * Doug Ledford - Much needed abort/reset bug fixes 84 * Kai Makisara - DMAing of SCBs 85 * 86 * A Boot time option was also added for not resetting the scsi bus. 87 * 88 * Form: aic7xxx=extended 89 * aic7xxx=no_reset 90 * aic7xxx=verbose 91 * 92 * Daniel M. Eischen, deischen@iworks.InterWorks.org, 1/23/97 93 * 94 * Id: aic7xxx.c,v 4.1 1997/06/12 08:23:42 deang Exp 95 */ 96 97 /* 98 * Further driver modifications made by Doug Ledford <dledford@redhat.com> 99 * 100 * Copyright (c) 1997-1999 Doug Ledford 101 * 102 * These changes are released under the same licensing terms as the FreeBSD 103 * driver written by Justin Gibbs. Please see his Copyright notice above 104 * for the exact terms and conditions covering my changes as well as the 105 * warranty statement. 106 * 107 * Modifications made to the aic7xxx.c,v 4.1 driver from Dan Eischen include 108 * but are not limited to: 109 * 110 * 1: Import of the latest FreeBSD sequencer code for this driver 111 * 2: Modification of kernel code to accommodate different sequencer semantics 112 * 3: Extensive changes throughout kernel portion of driver to improve 113 * abort/reset processing and error hanndling 114 * 4: Other work contributed by various people on the Internet 115 * 5: Changes to printk information and verbosity selection code 116 * 6: General reliability related changes, especially in IRQ management 117 * 7: Modifications to the default probe/attach order for supported cards 118 * 8: SMP friendliness has been improved 119 * 120 */ 121 122 #include "aic7xxx_osm.h" 123 #include "aic7xxx_inline.h" 124 #include <scsi/scsicam.h> 125 126 static struct scsi_transport_template *ahc_linux_transport_template = NULL; 127 128 #include <linux/init.h> /* __setup */ 129 #include <linux/mm.h> /* For fetching system memory size */ 130 #include <linux/blkdev.h> /* For block_size() */ 131 #include <linux/delay.h> /* For ssleep/msleep */ 132 133 134 /* 135 * Set this to the delay in seconds after SCSI bus reset. 136 * Note, we honor this only for the initial bus reset. 137 * The scsi error recovery code performs its own bus settle 138 * delay handling for error recovery actions. 139 */ 140 #ifdef CONFIG_AIC7XXX_RESET_DELAY_MS 141 #define AIC7XXX_RESET_DELAY CONFIG_AIC7XXX_RESET_DELAY_MS 142 #else 143 #define AIC7XXX_RESET_DELAY 5000 144 #endif 145 146 /* 147 * Control collection of SCSI transfer statistics for the /proc filesystem. 148 * 149 * NOTE: Do NOT enable this when running on kernels version 1.2.x and below. 150 * NOTE: This does affect performance since it has to maintain statistics. 151 */ 152 #ifdef CONFIG_AIC7XXX_PROC_STATS 153 #define AIC7XXX_PROC_STATS 154 #endif 155 156 /* 157 * To change the default number of tagged transactions allowed per-device, 158 * add a line to the lilo.conf file like: 159 * append="aic7xxx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}" 160 * which will result in the first four devices on the first two 161 * controllers being set to a tagged queue depth of 32. 162 * 163 * The tag_commands is an array of 16 to allow for wide and twin adapters. 164 * Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15 165 * for channel 1. 166 */ 167 typedef struct { 168 uint8_t tag_commands[16]; /* Allow for wide/twin adapters. */ 169 } adapter_tag_info_t; 170 171 /* 172 * Modify this as you see fit for your system. 173 * 174 * 0 tagged queuing disabled 175 * 1 <= n <= 253 n == max tags ever dispatched. 176 * 177 * The driver will throttle the number of commands dispatched to a 178 * device if it returns queue full. For devices with a fixed maximum 179 * queue depth, the driver will eventually determine this depth and 180 * lock it in (a console message is printed to indicate that a lock 181 * has occurred). On some devices, queue full is returned for a temporary 182 * resource shortage. These devices will return queue full at varying 183 * depths. The driver will throttle back when the queue fulls occur and 184 * attempt to slowly increase the depth over time as the device recovers 185 * from the resource shortage. 186 * 187 * In this example, the first line will disable tagged queueing for all 188 * the devices on the first probed aic7xxx adapter. 189 * 190 * The second line enables tagged queueing with 4 commands/LUN for IDs 191 * (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the 192 * driver to attempt to use up to 64 tags for ID 1. 193 * 194 * The third line is the same as the first line. 195 * 196 * The fourth line disables tagged queueing for devices 0 and 3. It 197 * enables tagged queueing for the other IDs, with 16 commands/LUN 198 * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for 199 * IDs 2, 5-7, and 9-15. 200 */ 201 202 /* 203 * NOTE: The below structure is for reference only, the actual structure 204 * to modify in order to change things is just below this comment block. 205 adapter_tag_info_t aic7xxx_tag_info[] = 206 { 207 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 208 {{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}}, 209 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, 210 {{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}} 211 }; 212 */ 213 214 #ifdef CONFIG_AIC7XXX_CMDS_PER_DEVICE 215 #define AIC7XXX_CMDS_PER_DEVICE CONFIG_AIC7XXX_CMDS_PER_DEVICE 216 #else 217 #define AIC7XXX_CMDS_PER_DEVICE AHC_MAX_QUEUE 218 #endif 219 220 #define AIC7XXX_CONFIGED_TAG_COMMANDS { \ 221 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \ 222 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \ 223 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \ 224 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \ 225 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \ 226 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \ 227 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \ 228 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE \ 229 } 230 231 /* 232 * By default, use the number of commands specified by 233 * the users kernel configuration. 234 */ 235 static adapter_tag_info_t aic7xxx_tag_info[] = 236 { 237 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 238 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 239 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 240 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 241 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 242 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 243 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 244 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 245 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 246 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 247 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 248 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 249 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 250 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 251 {AIC7XXX_CONFIGED_TAG_COMMANDS}, 252 {AIC7XXX_CONFIGED_TAG_COMMANDS} 253 }; 254 255 /* 256 * There should be a specific return value for this in scsi.h, but 257 * it seems that most drivers ignore it. 258 */ 259 #define DID_UNDERFLOW DID_ERROR 260 261 void 262 ahc_print_path(struct ahc_softc *ahc, struct scb *scb) 263 { 264 printk("(scsi%d:%c:%d:%d): ", 265 ahc->platform_data->host->host_no, 266 scb != NULL ? SCB_GET_CHANNEL(ahc, scb) : 'X', 267 scb != NULL ? SCB_GET_TARGET(ahc, scb) : -1, 268 scb != NULL ? SCB_GET_LUN(scb) : -1); 269 } 270 271 /* 272 * XXX - these options apply unilaterally to _all_ 274x/284x/294x 273 * cards in the system. This should be fixed. Exceptions to this 274 * rule are noted in the comments. 275 */ 276 277 /* 278 * Skip the scsi bus reset. Non 0 make us skip the reset at startup. This 279 * has no effect on any later resets that might occur due to things like 280 * SCSI bus timeouts. 281 */ 282 static uint32_t aic7xxx_no_reset; 283 284 /* 285 * Should we force EXTENDED translation on a controller. 286 * 0 == Use whatever is in the SEEPROM or default to off 287 * 1 == Use whatever is in the SEEPROM or default to on 288 */ 289 static uint32_t aic7xxx_extended; 290 291 /* 292 * PCI bus parity checking of the Adaptec controllers. This is somewhat 293 * dubious at best. To my knowledge, this option has never actually 294 * solved a PCI parity problem, but on certain machines with broken PCI 295 * chipset configurations where stray PCI transactions with bad parity are 296 * the norm rather than the exception, the error messages can be overwelming. 297 * It's included in the driver for completeness. 298 * 0 = Shut off PCI parity check 299 * non-0 = reverse polarity pci parity checking 300 */ 301 static uint32_t aic7xxx_pci_parity = ~0; 302 303 /* 304 * There are lots of broken chipsets in the world. Some of them will 305 * violate the PCI spec when we issue byte sized memory writes to our 306 * controller. I/O mapped register access, if allowed by the given 307 * platform, will work in almost all cases. 308 */ 309 uint32_t aic7xxx_allow_memio = ~0; 310 311 /* 312 * So that we can set how long each device is given as a selection timeout. 313 * The table of values goes like this: 314 * 0 - 256ms 315 * 1 - 128ms 316 * 2 - 64ms 317 * 3 - 32ms 318 * We default to 256ms because some older devices need a longer time 319 * to respond to initial selection. 320 */ 321 static uint32_t aic7xxx_seltime; 322 323 /* 324 * Certain devices do not perform any aging on commands. Should the 325 * device be saturated by commands in one portion of the disk, it is 326 * possible for transactions on far away sectors to never be serviced. 327 * To handle these devices, we can periodically send an ordered tag to 328 * force all outstanding transactions to be serviced prior to a new 329 * transaction. 330 */ 331 uint32_t aic7xxx_periodic_otag; 332 333 /* 334 * Module information and settable options. 335 */ 336 static char *aic7xxx = NULL; 337 338 MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>"); 339 MODULE_DESCRIPTION("Adaptec Aic77XX/78XX SCSI Host Bus Adapter driver"); 340 MODULE_LICENSE("Dual BSD/GPL"); 341 MODULE_VERSION(AIC7XXX_DRIVER_VERSION); 342 module_param(aic7xxx, charp, 0444); 343 MODULE_PARM_DESC(aic7xxx, 344 "period delimited, options string.\n" 345 " verbose Enable verbose/diagnostic logging\n" 346 " allow_memio Allow device registers to be memory mapped\n" 347 " debug Bitmask of debug values to enable\n" 348 " no_probe Toggle EISA/VLB controller probing\n" 349 " probe_eisa_vl Toggle EISA/VLB controller probing\n" 350 " no_reset Supress initial bus resets\n" 351 " extended Enable extended geometry on all controllers\n" 352 " periodic_otag Send an ordered tagged transaction\n" 353 " periodically to prevent tag starvation.\n" 354 " This may be required by some older disk\n" 355 " drives or RAID arrays.\n" 356 " reverse_scan Sort PCI devices highest Bus/Slot to lowest\n" 357 " tag_info:<tag_str> Set per-target tag depth\n" 358 " global_tag_depth:<int> Global tag depth for every target\n" 359 " on every bus\n" 360 " seltime:<int> Selection Timeout\n" 361 " (0/256ms,1/128ms,2/64ms,3/32ms)\n" 362 "\n" 363 " Sample /etc/modprobe.conf line:\n" 364 " Toggle EISA/VLB probing\n" 365 " Set tag depth on Controller 1/Target 1 to 10 tags\n" 366 " Shorten the selection timeout to 128ms\n" 367 "\n" 368 " options aic7xxx 'aic7xxx=probe_eisa_vl.tag_info:{{}.{.10}}.seltime:1'\n" 369 ); 370 371 static void ahc_linux_handle_scsi_status(struct ahc_softc *, 372 struct scsi_device *, 373 struct scb *); 374 static void ahc_linux_queue_cmd_complete(struct ahc_softc *ahc, 375 struct scsi_cmnd *cmd); 376 static void ahc_linux_sem_timeout(u_long arg); 377 static void ahc_linux_freeze_simq(struct ahc_softc *ahc); 378 static void ahc_linux_release_simq(u_long arg); 379 static int ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag); 380 static void ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc); 381 static u_int ahc_linux_user_tagdepth(struct ahc_softc *ahc, 382 struct ahc_devinfo *devinfo); 383 static void ahc_linux_device_queue_depth(struct scsi_device *); 384 static int ahc_linux_run_command(struct ahc_softc*, 385 struct ahc_linux_device *, 386 struct scsi_cmnd *); 387 static void ahc_linux_setup_tag_info_global(char *p); 388 static int aic7xxx_setup(char *s); 389 390 static int ahc_linux_unit; 391 392 393 /********************************* Inlines ************************************/ 394 static __inline void ahc_linux_unmap_scb(struct ahc_softc*, struct scb*); 395 396 static __inline int ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb, 397 struct ahc_dma_seg *sg, 398 dma_addr_t addr, bus_size_t len); 399 400 static __inline void 401 ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb) 402 { 403 struct scsi_cmnd *cmd; 404 405 cmd = scb->io_ctx; 406 ahc_sync_sglist(ahc, scb, BUS_DMASYNC_POSTWRITE); 407 if (cmd->use_sg != 0) { 408 struct scatterlist *sg; 409 410 sg = (struct scatterlist *)cmd->request_buffer; 411 pci_unmap_sg(ahc->dev_softc, sg, cmd->use_sg, 412 cmd->sc_data_direction); 413 } else if (cmd->request_bufflen != 0) { 414 pci_unmap_single(ahc->dev_softc, 415 scb->platform_data->buf_busaddr, 416 cmd->request_bufflen, 417 cmd->sc_data_direction); 418 } 419 } 420 421 static __inline int 422 ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb, 423 struct ahc_dma_seg *sg, dma_addr_t addr, bus_size_t len) 424 { 425 int consumed; 426 427 if ((scb->sg_count + 1) > AHC_NSEG) 428 panic("Too few segs for dma mapping. " 429 "Increase AHC_NSEG\n"); 430 431 consumed = 1; 432 sg->addr = ahc_htole32(addr & 0xFFFFFFFF); 433 scb->platform_data->xfer_len += len; 434 435 if (sizeof(dma_addr_t) > 4 436 && (ahc->flags & AHC_39BIT_ADDRESSING) != 0) 437 len |= (addr >> 8) & AHC_SG_HIGH_ADDR_MASK; 438 439 sg->len = ahc_htole32(len); 440 return (consumed); 441 } 442 443 /* 444 * Return a string describing the driver. 445 */ 446 static const char * 447 ahc_linux_info(struct Scsi_Host *host) 448 { 449 static char buffer[512]; 450 char ahc_info[256]; 451 char *bp; 452 struct ahc_softc *ahc; 453 454 bp = &buffer[0]; 455 ahc = *(struct ahc_softc **)host->hostdata; 456 memset(bp, 0, sizeof(buffer)); 457 strcpy(bp, "Adaptec AIC7XXX EISA/VLB/PCI SCSI HBA DRIVER, Rev "); 458 strcat(bp, AIC7XXX_DRIVER_VERSION); 459 strcat(bp, "\n"); 460 strcat(bp, " <"); 461 strcat(bp, ahc->description); 462 strcat(bp, ">\n"); 463 strcat(bp, " "); 464 ahc_controller_info(ahc, ahc_info); 465 strcat(bp, ahc_info); 466 strcat(bp, "\n"); 467 468 return (bp); 469 } 470 471 /* 472 * Queue an SCB to the controller. 473 */ 474 static int 475 ahc_linux_queue(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *)) 476 { 477 struct ahc_softc *ahc; 478 struct ahc_linux_device *dev = scsi_transport_device_data(cmd->device); 479 480 ahc = *(struct ahc_softc **)cmd->device->host->hostdata; 481 482 /* 483 * Save the callback on completion function. 484 */ 485 cmd->scsi_done = scsi_done; 486 487 /* 488 * Close the race of a command that was in the process of 489 * being queued to us just as our simq was frozen. Let 490 * DV commands through so long as we are only frozen to 491 * perform DV. 492 */ 493 if (ahc->platform_data->qfrozen != 0) 494 return SCSI_MLQUEUE_HOST_BUSY; 495 496 cmd->result = CAM_REQ_INPROG << 16; 497 498 return ahc_linux_run_command(ahc, dev, cmd); 499 } 500 501 static inline struct scsi_target ** 502 ahc_linux_target_in_softc(struct scsi_target *starget) 503 { 504 struct ahc_softc *ahc = 505 *((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata); 506 unsigned int target_offset; 507 508 target_offset = starget->id; 509 if (starget->channel != 0) 510 target_offset += 8; 511 512 return &ahc->platform_data->starget[target_offset]; 513 } 514 515 static int 516 ahc_linux_target_alloc(struct scsi_target *starget) 517 { 518 struct ahc_softc *ahc = 519 *((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata); 520 struct seeprom_config *sc = ahc->seep_config; 521 unsigned long flags; 522 struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget); 523 struct ahc_linux_target *targ = scsi_transport_target_data(starget); 524 unsigned short scsirate; 525 struct ahc_devinfo devinfo; 526 struct ahc_initiator_tinfo *tinfo; 527 struct ahc_tmode_tstate *tstate; 528 char channel = starget->channel + 'A'; 529 unsigned int our_id = ahc->our_id; 530 unsigned int target_offset; 531 532 target_offset = starget->id; 533 if (starget->channel != 0) 534 target_offset += 8; 535 536 if (starget->channel) 537 our_id = ahc->our_id_b; 538 539 ahc_lock(ahc, &flags); 540 541 BUG_ON(*ahc_targp != NULL); 542 543 *ahc_targp = starget; 544 memset(targ, 0, sizeof(*targ)); 545 546 if (sc) { 547 int maxsync = AHC_SYNCRATE_DT; 548 int ultra = 0; 549 int flags = sc->device_flags[target_offset]; 550 551 if (ahc->flags & AHC_NEWEEPROM_FMT) { 552 if (flags & CFSYNCHISULTRA) 553 ultra = 1; 554 } else if (flags & CFULTRAEN) 555 ultra = 1; 556 /* AIC nutcase; 10MHz appears as ultra = 1, CFXFER = 0x04 557 * change it to ultra=0, CFXFER = 0 */ 558 if(ultra && (flags & CFXFER) == 0x04) { 559 ultra = 0; 560 flags &= ~CFXFER; 561 } 562 563 if ((ahc->features & AHC_ULTRA2) != 0) { 564 scsirate = (flags & CFXFER) | (ultra ? 0x8 : 0); 565 } else { 566 scsirate = (flags & CFXFER) << 4; 567 maxsync = ultra ? AHC_SYNCRATE_ULTRA : 568 AHC_SYNCRATE_FAST; 569 } 570 spi_max_width(starget) = (flags & CFWIDEB) ? 1 : 0; 571 if (!(flags & CFSYNCH)) 572 spi_max_offset(starget) = 0; 573 spi_min_period(starget) = 574 ahc_find_period(ahc, scsirate, maxsync); 575 576 tinfo = ahc_fetch_transinfo(ahc, channel, ahc->our_id, 577 starget->id, &tstate); 578 } 579 ahc_compile_devinfo(&devinfo, our_id, starget->id, 580 CAM_LUN_WILDCARD, channel, 581 ROLE_INITIATOR); 582 ahc_set_syncrate(ahc, &devinfo, NULL, 0, 0, 0, 583 AHC_TRANS_GOAL, /*paused*/FALSE); 584 ahc_set_width(ahc, &devinfo, MSG_EXT_WDTR_BUS_8_BIT, 585 AHC_TRANS_GOAL, /*paused*/FALSE); 586 ahc_unlock(ahc, &flags); 587 588 return 0; 589 } 590 591 static void 592 ahc_linux_target_destroy(struct scsi_target *starget) 593 { 594 struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget); 595 596 *ahc_targp = NULL; 597 } 598 599 static int 600 ahc_linux_slave_alloc(struct scsi_device *sdev) 601 { 602 struct ahc_softc *ahc = 603 *((struct ahc_softc **)sdev->host->hostdata); 604 struct scsi_target *starget = sdev->sdev_target; 605 struct ahc_linux_target *targ = scsi_transport_target_data(starget); 606 struct ahc_linux_device *dev; 607 608 if (bootverbose) 609 printf("%s: Slave Alloc %d\n", ahc_name(ahc), sdev->id); 610 611 BUG_ON(targ->sdev[sdev->lun] != NULL); 612 613 dev = scsi_transport_device_data(sdev); 614 memset(dev, 0, sizeof(*dev)); 615 616 /* 617 * We start out life using untagged 618 * transactions of which we allow one. 619 */ 620 dev->openings = 1; 621 622 /* 623 * Set maxtags to 0. This will be changed if we 624 * later determine that we are dealing with 625 * a tagged queuing capable device. 626 */ 627 dev->maxtags = 0; 628 629 targ->sdev[sdev->lun] = sdev; 630 631 spi_period(starget) = 0; 632 633 return 0; 634 } 635 636 static int 637 ahc_linux_slave_configure(struct scsi_device *sdev) 638 { 639 struct ahc_softc *ahc; 640 641 ahc = *((struct ahc_softc **)sdev->host->hostdata); 642 643 if (bootverbose) 644 sdev_printk(KERN_INFO, sdev, "Slave Configure\n"); 645 646 ahc_linux_device_queue_depth(sdev); 647 648 /* Initial Domain Validation */ 649 if (!spi_initial_dv(sdev->sdev_target)) 650 spi_dv_device(sdev); 651 652 return 0; 653 } 654 655 static void 656 ahc_linux_slave_destroy(struct scsi_device *sdev) 657 { 658 struct ahc_softc *ahc; 659 struct ahc_linux_device *dev = scsi_transport_device_data(sdev); 660 struct ahc_linux_target *targ = scsi_transport_target_data(sdev->sdev_target); 661 662 ahc = *((struct ahc_softc **)sdev->host->hostdata); 663 if (bootverbose) 664 printf("%s: Slave Destroy %d\n", ahc_name(ahc), sdev->id); 665 666 BUG_ON(dev->active); 667 668 targ->sdev[sdev->lun] = NULL; 669 } 670 671 #if defined(__i386__) 672 /* 673 * Return the disk geometry for the given SCSI device. 674 */ 675 static int 676 ahc_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev, 677 sector_t capacity, int geom[]) 678 { 679 uint8_t *bh; 680 int heads; 681 int sectors; 682 int cylinders; 683 int ret; 684 int extended; 685 struct ahc_softc *ahc; 686 u_int channel; 687 688 ahc = *((struct ahc_softc **)sdev->host->hostdata); 689 channel = sdev_channel(sdev); 690 691 bh = scsi_bios_ptable(bdev); 692 if (bh) { 693 ret = scsi_partsize(bh, capacity, 694 &geom[2], &geom[0], &geom[1]); 695 kfree(bh); 696 if (ret != -1) 697 return (ret); 698 } 699 heads = 64; 700 sectors = 32; 701 cylinders = aic_sector_div(capacity, heads, sectors); 702 703 if (aic7xxx_extended != 0) 704 extended = 1; 705 else if (channel == 0) 706 extended = (ahc->flags & AHC_EXTENDED_TRANS_A) != 0; 707 else 708 extended = (ahc->flags & AHC_EXTENDED_TRANS_B) != 0; 709 if (extended && cylinders >= 1024) { 710 heads = 255; 711 sectors = 63; 712 cylinders = aic_sector_div(capacity, heads, sectors); 713 } 714 geom[0] = heads; 715 geom[1] = sectors; 716 geom[2] = cylinders; 717 return (0); 718 } 719 #endif 720 721 /* 722 * Abort the current SCSI command(s). 723 */ 724 static int 725 ahc_linux_abort(struct scsi_cmnd *cmd) 726 { 727 int error; 728 729 error = ahc_linux_queue_recovery_cmd(cmd, SCB_ABORT); 730 if (error != 0) 731 printf("aic7xxx_abort returns 0x%x\n", error); 732 return (error); 733 } 734 735 /* 736 * Attempt to send a target reset message to the device that timed out. 737 */ 738 static int 739 ahc_linux_dev_reset(struct scsi_cmnd *cmd) 740 { 741 int error; 742 743 error = ahc_linux_queue_recovery_cmd(cmd, SCB_DEVICE_RESET); 744 if (error != 0) 745 printf("aic7xxx_dev_reset returns 0x%x\n", error); 746 return (error); 747 } 748 749 /* 750 * Reset the SCSI bus. 751 */ 752 static int 753 ahc_linux_bus_reset(struct scsi_cmnd *cmd) 754 { 755 struct ahc_softc *ahc; 756 int found; 757 unsigned long flags; 758 759 ahc = *(struct ahc_softc **)cmd->device->host->hostdata; 760 761 ahc_lock(ahc, &flags); 762 found = ahc_reset_channel(ahc, scmd_channel(cmd) + 'A', 763 /*initiate reset*/TRUE); 764 ahc_unlock(ahc, &flags); 765 766 if (bootverbose) 767 printf("%s: SCSI bus reset delivered. " 768 "%d SCBs aborted.\n", ahc_name(ahc), found); 769 770 return SUCCESS; 771 } 772 773 struct scsi_host_template aic7xxx_driver_template = { 774 .module = THIS_MODULE, 775 .name = "aic7xxx", 776 .proc_name = "aic7xxx", 777 .proc_info = ahc_linux_proc_info, 778 .info = ahc_linux_info, 779 .queuecommand = ahc_linux_queue, 780 .eh_abort_handler = ahc_linux_abort, 781 .eh_device_reset_handler = ahc_linux_dev_reset, 782 .eh_bus_reset_handler = ahc_linux_bus_reset, 783 #if defined(__i386__) 784 .bios_param = ahc_linux_biosparam, 785 #endif 786 .can_queue = AHC_MAX_QUEUE, 787 .this_id = -1, 788 .cmd_per_lun = 2, 789 .use_clustering = ENABLE_CLUSTERING, 790 .slave_alloc = ahc_linux_slave_alloc, 791 .slave_configure = ahc_linux_slave_configure, 792 .slave_destroy = ahc_linux_slave_destroy, 793 .target_alloc = ahc_linux_target_alloc, 794 .target_destroy = ahc_linux_target_destroy, 795 }; 796 797 /**************************** Tasklet Handler *********************************/ 798 799 /******************************** Macros **************************************/ 800 #define BUILD_SCSIID(ahc, cmd) \ 801 ((((cmd)->device->id << TID_SHIFT) & TID) \ 802 | (((cmd)->device->channel == 0) ? (ahc)->our_id : (ahc)->our_id_b) \ 803 | (((cmd)->device->channel == 0) ? 0 : TWIN_CHNLB)) 804 805 /******************************** Bus DMA *************************************/ 806 int 807 ahc_dma_tag_create(struct ahc_softc *ahc, bus_dma_tag_t parent, 808 bus_size_t alignment, bus_size_t boundary, 809 dma_addr_t lowaddr, dma_addr_t highaddr, 810 bus_dma_filter_t *filter, void *filterarg, 811 bus_size_t maxsize, int nsegments, 812 bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag) 813 { 814 bus_dma_tag_t dmat; 815 816 dmat = malloc(sizeof(*dmat), M_DEVBUF, M_NOWAIT); 817 if (dmat == NULL) 818 return (ENOMEM); 819 820 /* 821 * Linux is very simplistic about DMA memory. For now don't 822 * maintain all specification information. Once Linux supplies 823 * better facilities for doing these operations, or the 824 * needs of this particular driver change, we might need to do 825 * more here. 826 */ 827 dmat->alignment = alignment; 828 dmat->boundary = boundary; 829 dmat->maxsize = maxsize; 830 *ret_tag = dmat; 831 return (0); 832 } 833 834 void 835 ahc_dma_tag_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat) 836 { 837 free(dmat, M_DEVBUF); 838 } 839 840 int 841 ahc_dmamem_alloc(struct ahc_softc *ahc, bus_dma_tag_t dmat, void** vaddr, 842 int flags, bus_dmamap_t *mapp) 843 { 844 *vaddr = pci_alloc_consistent(ahc->dev_softc, 845 dmat->maxsize, mapp); 846 if (*vaddr == NULL) 847 return ENOMEM; 848 return 0; 849 } 850 851 void 852 ahc_dmamem_free(struct ahc_softc *ahc, bus_dma_tag_t dmat, 853 void* vaddr, bus_dmamap_t map) 854 { 855 pci_free_consistent(ahc->dev_softc, dmat->maxsize, 856 vaddr, map); 857 } 858 859 int 860 ahc_dmamap_load(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map, 861 void *buf, bus_size_t buflen, bus_dmamap_callback_t *cb, 862 void *cb_arg, int flags) 863 { 864 /* 865 * Assume for now that this will only be used during 866 * initialization and not for per-transaction buffer mapping. 867 */ 868 bus_dma_segment_t stack_sg; 869 870 stack_sg.ds_addr = map; 871 stack_sg.ds_len = dmat->maxsize; 872 cb(cb_arg, &stack_sg, /*nseg*/1, /*error*/0); 873 return (0); 874 } 875 876 void 877 ahc_dmamap_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map) 878 { 879 } 880 881 int 882 ahc_dmamap_unload(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map) 883 { 884 /* Nothing to do */ 885 return (0); 886 } 887 888 static void 889 ahc_linux_setup_tag_info_global(char *p) 890 { 891 int tags, i, j; 892 893 tags = simple_strtoul(p + 1, NULL, 0) & 0xff; 894 printf("Setting Global Tags= %d\n", tags); 895 896 for (i = 0; i < NUM_ELEMENTS(aic7xxx_tag_info); i++) { 897 for (j = 0; j < AHC_NUM_TARGETS; j++) { 898 aic7xxx_tag_info[i].tag_commands[j] = tags; 899 } 900 } 901 } 902 903 static void 904 ahc_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value) 905 { 906 907 if ((instance >= 0) && (targ >= 0) 908 && (instance < NUM_ELEMENTS(aic7xxx_tag_info)) 909 && (targ < AHC_NUM_TARGETS)) { 910 aic7xxx_tag_info[instance].tag_commands[targ] = value & 0xff; 911 if (bootverbose) 912 printf("tag_info[%d:%d] = %d\n", instance, targ, value); 913 } 914 } 915 916 static char * 917 ahc_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth, 918 void (*callback)(u_long, int, int, int32_t), 919 u_long callback_arg) 920 { 921 char *tok_end; 922 char *tok_end2; 923 int i; 924 int instance; 925 int targ; 926 int done; 927 char tok_list[] = {'.', ',', '{', '}', '\0'}; 928 929 /* All options use a ':' name/arg separator */ 930 if (*opt_arg != ':') 931 return (opt_arg); 932 opt_arg++; 933 instance = -1; 934 targ = -1; 935 done = FALSE; 936 /* 937 * Restore separator that may be in 938 * the middle of our option argument. 939 */ 940 tok_end = strchr(opt_arg, '\0'); 941 if (tok_end < end) 942 *tok_end = ','; 943 while (!done) { 944 switch (*opt_arg) { 945 case '{': 946 if (instance == -1) { 947 instance = 0; 948 } else { 949 if (depth > 1) { 950 if (targ == -1) 951 targ = 0; 952 } else { 953 printf("Malformed Option %s\n", 954 opt_name); 955 done = TRUE; 956 } 957 } 958 opt_arg++; 959 break; 960 case '}': 961 if (targ != -1) 962 targ = -1; 963 else if (instance != -1) 964 instance = -1; 965 opt_arg++; 966 break; 967 case ',': 968 case '.': 969 if (instance == -1) 970 done = TRUE; 971 else if (targ >= 0) 972 targ++; 973 else if (instance >= 0) 974 instance++; 975 opt_arg++; 976 break; 977 case '\0': 978 done = TRUE; 979 break; 980 default: 981 tok_end = end; 982 for (i = 0; tok_list[i]; i++) { 983 tok_end2 = strchr(opt_arg, tok_list[i]); 984 if ((tok_end2) && (tok_end2 < tok_end)) 985 tok_end = tok_end2; 986 } 987 callback(callback_arg, instance, targ, 988 simple_strtol(opt_arg, NULL, 0)); 989 opt_arg = tok_end; 990 break; 991 } 992 } 993 return (opt_arg); 994 } 995 996 /* 997 * Handle Linux boot parameters. This routine allows for assigning a value 998 * to a parameter with a ':' between the parameter and the value. 999 * ie. aic7xxx=stpwlev:1,extended 1000 */ 1001 static int 1002 aic7xxx_setup(char *s) 1003 { 1004 int i, n; 1005 char *p; 1006 char *end; 1007 1008 static struct { 1009 const char *name; 1010 uint32_t *flag; 1011 } options[] = { 1012 { "extended", &aic7xxx_extended }, 1013 { "no_reset", &aic7xxx_no_reset }, 1014 { "verbose", &aic7xxx_verbose }, 1015 { "allow_memio", &aic7xxx_allow_memio}, 1016 #ifdef AHC_DEBUG 1017 { "debug", &ahc_debug }, 1018 #endif 1019 { "periodic_otag", &aic7xxx_periodic_otag }, 1020 { "pci_parity", &aic7xxx_pci_parity }, 1021 { "seltime", &aic7xxx_seltime }, 1022 { "tag_info", NULL }, 1023 { "global_tag_depth", NULL }, 1024 { "dv", NULL } 1025 }; 1026 1027 end = strchr(s, '\0'); 1028 1029 /* 1030 * XXX ia64 gcc isn't smart enough to know that NUM_ELEMENTS 1031 * will never be 0 in this case. 1032 */ 1033 n = 0; 1034 1035 while ((p = strsep(&s, ",.")) != NULL) { 1036 if (*p == '\0') 1037 continue; 1038 for (i = 0; i < NUM_ELEMENTS(options); i++) { 1039 1040 n = strlen(options[i].name); 1041 if (strncmp(options[i].name, p, n) == 0) 1042 break; 1043 } 1044 if (i == NUM_ELEMENTS(options)) 1045 continue; 1046 1047 if (strncmp(p, "global_tag_depth", n) == 0) { 1048 ahc_linux_setup_tag_info_global(p + n); 1049 } else if (strncmp(p, "tag_info", n) == 0) { 1050 s = ahc_parse_brace_option("tag_info", p + n, end, 1051 2, ahc_linux_setup_tag_info, 0); 1052 } else if (p[n] == ':') { 1053 *(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0); 1054 } else if (strncmp(p, "verbose", n) == 0) { 1055 *(options[i].flag) = 1; 1056 } else { 1057 *(options[i].flag) ^= 0xFFFFFFFF; 1058 } 1059 } 1060 return 1; 1061 } 1062 1063 __setup("aic7xxx=", aic7xxx_setup); 1064 1065 uint32_t aic7xxx_verbose; 1066 1067 int 1068 ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *template) 1069 { 1070 char buf[80]; 1071 struct Scsi_Host *host; 1072 char *new_name; 1073 u_long s; 1074 1075 template->name = ahc->description; 1076 host = scsi_host_alloc(template, sizeof(struct ahc_softc *)); 1077 if (host == NULL) 1078 return (ENOMEM); 1079 1080 *((struct ahc_softc **)host->hostdata) = ahc; 1081 ahc_lock(ahc, &s); 1082 scsi_assign_lock(host, &ahc->platform_data->spin_lock); 1083 ahc->platform_data->host = host; 1084 host->can_queue = AHC_MAX_QUEUE; 1085 host->cmd_per_lun = 2; 1086 /* XXX No way to communicate the ID for multiple channels */ 1087 host->this_id = ahc->our_id; 1088 host->irq = ahc->platform_data->irq; 1089 host->max_id = (ahc->features & AHC_WIDE) ? 16 : 8; 1090 host->max_lun = AHC_NUM_LUNS; 1091 host->max_channel = (ahc->features & AHC_TWIN) ? 1 : 0; 1092 host->sg_tablesize = AHC_NSEG; 1093 ahc_set_unit(ahc, ahc_linux_unit++); 1094 sprintf(buf, "scsi%d", host->host_no); 1095 new_name = malloc(strlen(buf) + 1, M_DEVBUF, M_NOWAIT); 1096 if (new_name != NULL) { 1097 strcpy(new_name, buf); 1098 ahc_set_name(ahc, new_name); 1099 } 1100 host->unique_id = ahc->unit; 1101 ahc_linux_initialize_scsi_bus(ahc); 1102 ahc_intr_enable(ahc, TRUE); 1103 ahc_unlock(ahc, &s); 1104 1105 host->transportt = ahc_linux_transport_template; 1106 1107 scsi_add_host(host, (ahc->dev_softc ? &ahc->dev_softc->dev : NULL)); /* XXX handle failure */ 1108 scsi_scan_host(host); 1109 return (0); 1110 } 1111 1112 /* 1113 * Place the SCSI bus into a known state by either resetting it, 1114 * or forcing transfer negotiations on the next command to any 1115 * target. 1116 */ 1117 void 1118 ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc) 1119 { 1120 int i; 1121 int numtarg; 1122 1123 i = 0; 1124 numtarg = 0; 1125 1126 if (aic7xxx_no_reset != 0) 1127 ahc->flags &= ~(AHC_RESET_BUS_A|AHC_RESET_BUS_B); 1128 1129 if ((ahc->flags & AHC_RESET_BUS_A) != 0) 1130 ahc_reset_channel(ahc, 'A', /*initiate_reset*/TRUE); 1131 else 1132 numtarg = (ahc->features & AHC_WIDE) ? 16 : 8; 1133 1134 if ((ahc->features & AHC_TWIN) != 0) { 1135 1136 if ((ahc->flags & AHC_RESET_BUS_B) != 0) { 1137 ahc_reset_channel(ahc, 'B', /*initiate_reset*/TRUE); 1138 } else { 1139 if (numtarg == 0) 1140 i = 8; 1141 numtarg += 8; 1142 } 1143 } 1144 1145 /* 1146 * Force negotiation to async for all targets that 1147 * will not see an initial bus reset. 1148 */ 1149 for (; i < numtarg; i++) { 1150 struct ahc_devinfo devinfo; 1151 struct ahc_initiator_tinfo *tinfo; 1152 struct ahc_tmode_tstate *tstate; 1153 u_int our_id; 1154 u_int target_id; 1155 char channel; 1156 1157 channel = 'A'; 1158 our_id = ahc->our_id; 1159 target_id = i; 1160 if (i > 7 && (ahc->features & AHC_TWIN) != 0) { 1161 channel = 'B'; 1162 our_id = ahc->our_id_b; 1163 target_id = i % 8; 1164 } 1165 tinfo = ahc_fetch_transinfo(ahc, channel, our_id, 1166 target_id, &tstate); 1167 ahc_compile_devinfo(&devinfo, our_id, target_id, 1168 CAM_LUN_WILDCARD, channel, ROLE_INITIATOR); 1169 ahc_update_neg_request(ahc, &devinfo, tstate, 1170 tinfo, AHC_NEG_ALWAYS); 1171 } 1172 /* Give the bus some time to recover */ 1173 if ((ahc->flags & (AHC_RESET_BUS_A|AHC_RESET_BUS_B)) != 0) { 1174 ahc_linux_freeze_simq(ahc); 1175 init_timer(&ahc->platform_data->reset_timer); 1176 ahc->platform_data->reset_timer.data = (u_long)ahc; 1177 ahc->platform_data->reset_timer.expires = 1178 jiffies + (AIC7XXX_RESET_DELAY * HZ)/1000; 1179 ahc->platform_data->reset_timer.function = 1180 ahc_linux_release_simq; 1181 add_timer(&ahc->platform_data->reset_timer); 1182 } 1183 } 1184 1185 int 1186 ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg) 1187 { 1188 1189 ahc->platform_data = 1190 malloc(sizeof(struct ahc_platform_data), M_DEVBUF, M_NOWAIT); 1191 if (ahc->platform_data == NULL) 1192 return (ENOMEM); 1193 memset(ahc->platform_data, 0, sizeof(struct ahc_platform_data)); 1194 ahc->platform_data->irq = AHC_LINUX_NOIRQ; 1195 ahc_lockinit(ahc); 1196 init_MUTEX_LOCKED(&ahc->platform_data->eh_sem); 1197 ahc->seltime = (aic7xxx_seltime & 0x3) << 4; 1198 ahc->seltime_b = (aic7xxx_seltime & 0x3) << 4; 1199 if (aic7xxx_pci_parity == 0) 1200 ahc->flags |= AHC_DISABLE_PCI_PERR; 1201 1202 return (0); 1203 } 1204 1205 void 1206 ahc_platform_free(struct ahc_softc *ahc) 1207 { 1208 struct scsi_target *starget; 1209 int i, j; 1210 1211 if (ahc->platform_data != NULL) { 1212 /* destroy all of the device and target objects */ 1213 for (i = 0; i < AHC_NUM_TARGETS; i++) { 1214 starget = ahc->platform_data->starget[i]; 1215 if (starget != NULL) { 1216 for (j = 0; j < AHC_NUM_LUNS; j++) { 1217 struct ahc_linux_target *targ = 1218 scsi_transport_target_data(starget); 1219 1220 if (targ->sdev[j] == NULL) 1221 continue; 1222 targ->sdev[j] = NULL; 1223 } 1224 ahc->platform_data->starget[i] = NULL; 1225 } 1226 } 1227 1228 if (ahc->platform_data->irq != AHC_LINUX_NOIRQ) 1229 free_irq(ahc->platform_data->irq, ahc); 1230 if (ahc->tag == BUS_SPACE_PIO 1231 && ahc->bsh.ioport != 0) 1232 release_region(ahc->bsh.ioport, 256); 1233 if (ahc->tag == BUS_SPACE_MEMIO 1234 && ahc->bsh.maddr != NULL) { 1235 iounmap(ahc->bsh.maddr); 1236 release_mem_region(ahc->platform_data->mem_busaddr, 1237 0x1000); 1238 } 1239 1240 if (ahc->platform_data->host) 1241 scsi_host_put(ahc->platform_data->host); 1242 1243 free(ahc->platform_data, M_DEVBUF); 1244 } 1245 } 1246 1247 void 1248 ahc_platform_freeze_devq(struct ahc_softc *ahc, struct scb *scb) 1249 { 1250 ahc_platform_abort_scbs(ahc, SCB_GET_TARGET(ahc, scb), 1251 SCB_GET_CHANNEL(ahc, scb), 1252 SCB_GET_LUN(scb), SCB_LIST_NULL, 1253 ROLE_UNKNOWN, CAM_REQUEUE_REQ); 1254 } 1255 1256 void 1257 ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo, 1258 ahc_queue_alg alg) 1259 { 1260 struct scsi_target *starget; 1261 struct ahc_linux_target *targ; 1262 struct ahc_linux_device *dev; 1263 struct scsi_device *sdev; 1264 u_int target_offset; 1265 int was_queuing; 1266 int now_queuing; 1267 1268 target_offset = devinfo->target; 1269 if (devinfo->channel != 'A') 1270 target_offset += 8; 1271 starget = ahc->platform_data->starget[target_offset]; 1272 targ = scsi_transport_target_data(starget); 1273 BUG_ON(targ == NULL); 1274 sdev = targ->sdev[devinfo->lun]; 1275 if (sdev == NULL) 1276 return; 1277 dev = scsi_transport_device_data(sdev); 1278 1279 was_queuing = dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED); 1280 switch (alg) { 1281 default: 1282 case AHC_QUEUE_NONE: 1283 now_queuing = 0; 1284 break; 1285 case AHC_QUEUE_BASIC: 1286 now_queuing = AHC_DEV_Q_BASIC; 1287 break; 1288 case AHC_QUEUE_TAGGED: 1289 now_queuing = AHC_DEV_Q_TAGGED; 1290 break; 1291 } 1292 if ((dev->flags & AHC_DEV_FREEZE_TIL_EMPTY) == 0 1293 && (was_queuing != now_queuing) 1294 && (dev->active != 0)) { 1295 dev->flags |= AHC_DEV_FREEZE_TIL_EMPTY; 1296 dev->qfrozen++; 1297 } 1298 1299 dev->flags &= ~(AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED|AHC_DEV_PERIODIC_OTAG); 1300 if (now_queuing) { 1301 u_int usertags; 1302 1303 usertags = ahc_linux_user_tagdepth(ahc, devinfo); 1304 if (!was_queuing) { 1305 /* 1306 * Start out agressively and allow our 1307 * dynamic queue depth algorithm to take 1308 * care of the rest. 1309 */ 1310 dev->maxtags = usertags; 1311 dev->openings = dev->maxtags - dev->active; 1312 } 1313 if (dev->maxtags == 0) { 1314 /* 1315 * Queueing is disabled by the user. 1316 */ 1317 dev->openings = 1; 1318 } else if (alg == AHC_QUEUE_TAGGED) { 1319 dev->flags |= AHC_DEV_Q_TAGGED; 1320 if (aic7xxx_periodic_otag != 0) 1321 dev->flags |= AHC_DEV_PERIODIC_OTAG; 1322 } else 1323 dev->flags |= AHC_DEV_Q_BASIC; 1324 } else { 1325 /* We can only have one opening. */ 1326 dev->maxtags = 0; 1327 dev->openings = 1 - dev->active; 1328 } 1329 switch ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED))) { 1330 case AHC_DEV_Q_BASIC: 1331 scsi_set_tag_type(sdev, MSG_SIMPLE_TAG); 1332 scsi_activate_tcq(sdev, dev->openings + dev->active); 1333 break; 1334 case AHC_DEV_Q_TAGGED: 1335 scsi_set_tag_type(sdev, MSG_ORDERED_TAG); 1336 scsi_activate_tcq(sdev, dev->openings + dev->active); 1337 break; 1338 default: 1339 /* 1340 * We allow the OS to queue 2 untagged transactions to 1341 * us at any time even though we can only execute them 1342 * serially on the controller/device. This should 1343 * remove some latency. 1344 */ 1345 scsi_deactivate_tcq(sdev, 2); 1346 break; 1347 } 1348 } 1349 1350 int 1351 ahc_platform_abort_scbs(struct ahc_softc *ahc, int target, char channel, 1352 int lun, u_int tag, role_t role, uint32_t status) 1353 { 1354 return 0; 1355 } 1356 1357 static u_int 1358 ahc_linux_user_tagdepth(struct ahc_softc *ahc, struct ahc_devinfo *devinfo) 1359 { 1360 static int warned_user; 1361 u_int tags; 1362 1363 tags = 0; 1364 if ((ahc->user_discenable & devinfo->target_mask) != 0) { 1365 if (ahc->unit >= NUM_ELEMENTS(aic7xxx_tag_info)) { 1366 if (warned_user == 0) { 1367 1368 printf(KERN_WARNING 1369 "aic7xxx: WARNING: Insufficient tag_info instances\n" 1370 "aic7xxx: for installed controllers. Using defaults\n" 1371 "aic7xxx: Please update the aic7xxx_tag_info array in\n" 1372 "aic7xxx: the aic7xxx_osm..c source file.\n"); 1373 warned_user++; 1374 } 1375 tags = AHC_MAX_QUEUE; 1376 } else { 1377 adapter_tag_info_t *tag_info; 1378 1379 tag_info = &aic7xxx_tag_info[ahc->unit]; 1380 tags = tag_info->tag_commands[devinfo->target_offset]; 1381 if (tags > AHC_MAX_QUEUE) 1382 tags = AHC_MAX_QUEUE; 1383 } 1384 } 1385 return (tags); 1386 } 1387 1388 /* 1389 * Determines the queue depth for a given device. 1390 */ 1391 static void 1392 ahc_linux_device_queue_depth(struct scsi_device *sdev) 1393 { 1394 struct ahc_devinfo devinfo; 1395 u_int tags; 1396 struct ahc_softc *ahc = *((struct ahc_softc **)sdev->host->hostdata); 1397 1398 ahc_compile_devinfo(&devinfo, 1399 sdev->sdev_target->channel == 0 1400 ? ahc->our_id : ahc->our_id_b, 1401 sdev->sdev_target->id, sdev->lun, 1402 sdev->sdev_target->channel == 0 ? 'A' : 'B', 1403 ROLE_INITIATOR); 1404 tags = ahc_linux_user_tagdepth(ahc, &devinfo); 1405 if (tags != 0 && sdev->tagged_supported != 0) { 1406 1407 ahc_set_tags(ahc, &devinfo, AHC_QUEUE_TAGGED); 1408 ahc_print_devinfo(ahc, &devinfo); 1409 printf("Tagged Queuing enabled. Depth %d\n", tags); 1410 } else { 1411 ahc_set_tags(ahc, &devinfo, AHC_QUEUE_NONE); 1412 } 1413 } 1414 1415 static int 1416 ahc_linux_run_command(struct ahc_softc *ahc, struct ahc_linux_device *dev, 1417 struct scsi_cmnd *cmd) 1418 { 1419 struct scb *scb; 1420 struct hardware_scb *hscb; 1421 struct ahc_initiator_tinfo *tinfo; 1422 struct ahc_tmode_tstate *tstate; 1423 uint16_t mask; 1424 struct scb_tailq *untagged_q = NULL; 1425 1426 /* 1427 * Schedule us to run later. The only reason we are not 1428 * running is because the whole controller Q is frozen. 1429 */ 1430 if (ahc->platform_data->qfrozen != 0) 1431 return SCSI_MLQUEUE_HOST_BUSY; 1432 1433 /* 1434 * We only allow one untagged transaction 1435 * per target in the initiator role unless 1436 * we are storing a full busy target *lun* 1437 * table in SCB space. 1438 */ 1439 if (!blk_rq_tagged(cmd->request) 1440 && (ahc->features & AHC_SCB_BTT) == 0) { 1441 int target_offset; 1442 1443 target_offset = cmd->device->id + cmd->device->channel * 8; 1444 untagged_q = &(ahc->untagged_queues[target_offset]); 1445 if (!TAILQ_EMPTY(untagged_q)) 1446 /* if we're already executing an untagged command 1447 * we're busy to another */ 1448 return SCSI_MLQUEUE_DEVICE_BUSY; 1449 } 1450 1451 /* 1452 * Get an scb to use. 1453 */ 1454 scb = ahc_get_scb(ahc); 1455 if (!scb) 1456 return SCSI_MLQUEUE_HOST_BUSY; 1457 1458 scb->io_ctx = cmd; 1459 scb->platform_data->dev = dev; 1460 hscb = scb->hscb; 1461 cmd->host_scribble = (char *)scb; 1462 1463 /* 1464 * Fill out basics of the HSCB. 1465 */ 1466 hscb->control = 0; 1467 hscb->scsiid = BUILD_SCSIID(ahc, cmd); 1468 hscb->lun = cmd->device->lun; 1469 mask = SCB_GET_TARGET_MASK(ahc, scb); 1470 tinfo = ahc_fetch_transinfo(ahc, SCB_GET_CHANNEL(ahc, scb), 1471 SCB_GET_OUR_ID(scb), 1472 SCB_GET_TARGET(ahc, scb), &tstate); 1473 hscb->scsirate = tinfo->scsirate; 1474 hscb->scsioffset = tinfo->curr.offset; 1475 if ((tstate->ultraenb & mask) != 0) 1476 hscb->control |= ULTRAENB; 1477 1478 if ((ahc->user_discenable & mask) != 0) 1479 hscb->control |= DISCENB; 1480 1481 if ((tstate->auto_negotiate & mask) != 0) { 1482 scb->flags |= SCB_AUTO_NEGOTIATE; 1483 scb->hscb->control |= MK_MESSAGE; 1484 } 1485 1486 if ((dev->flags & (AHC_DEV_Q_TAGGED|AHC_DEV_Q_BASIC)) != 0) { 1487 int msg_bytes; 1488 uint8_t tag_msgs[2]; 1489 1490 msg_bytes = scsi_populate_tag_msg(cmd, tag_msgs); 1491 if (msg_bytes && tag_msgs[0] != MSG_SIMPLE_TASK) { 1492 hscb->control |= tag_msgs[0]; 1493 if (tag_msgs[0] == MSG_ORDERED_TASK) 1494 dev->commands_since_idle_or_otag = 0; 1495 } else if (dev->commands_since_idle_or_otag == AHC_OTAG_THRESH 1496 && (dev->flags & AHC_DEV_Q_TAGGED) != 0) { 1497 hscb->control |= MSG_ORDERED_TASK; 1498 dev->commands_since_idle_or_otag = 0; 1499 } else { 1500 hscb->control |= MSG_SIMPLE_TASK; 1501 } 1502 } 1503 1504 hscb->cdb_len = cmd->cmd_len; 1505 if (hscb->cdb_len <= 12) { 1506 memcpy(hscb->shared_data.cdb, cmd->cmnd, hscb->cdb_len); 1507 } else { 1508 memcpy(hscb->cdb32, cmd->cmnd, hscb->cdb_len); 1509 scb->flags |= SCB_CDB32_PTR; 1510 } 1511 1512 scb->platform_data->xfer_len = 0; 1513 ahc_set_residual(scb, 0); 1514 ahc_set_sense_residual(scb, 0); 1515 scb->sg_count = 0; 1516 if (cmd->use_sg != 0) { 1517 struct ahc_dma_seg *sg; 1518 struct scatterlist *cur_seg; 1519 struct scatterlist *end_seg; 1520 int nseg; 1521 1522 cur_seg = (struct scatterlist *)cmd->request_buffer; 1523 nseg = pci_map_sg(ahc->dev_softc, cur_seg, cmd->use_sg, 1524 cmd->sc_data_direction); 1525 end_seg = cur_seg + nseg; 1526 /* Copy the segments into the SG list. */ 1527 sg = scb->sg_list; 1528 /* 1529 * The sg_count may be larger than nseg if 1530 * a transfer crosses a 32bit page. 1531 */ 1532 while (cur_seg < end_seg) { 1533 dma_addr_t addr; 1534 bus_size_t len; 1535 int consumed; 1536 1537 addr = sg_dma_address(cur_seg); 1538 len = sg_dma_len(cur_seg); 1539 consumed = ahc_linux_map_seg(ahc, scb, 1540 sg, addr, len); 1541 sg += consumed; 1542 scb->sg_count += consumed; 1543 cur_seg++; 1544 } 1545 sg--; 1546 sg->len |= ahc_htole32(AHC_DMA_LAST_SEG); 1547 1548 /* 1549 * Reset the sg list pointer. 1550 */ 1551 scb->hscb->sgptr = 1552 ahc_htole32(scb->sg_list_phys | SG_FULL_RESID); 1553 1554 /* 1555 * Copy the first SG into the "current" 1556 * data pointer area. 1557 */ 1558 scb->hscb->dataptr = scb->sg_list->addr; 1559 scb->hscb->datacnt = scb->sg_list->len; 1560 } else if (cmd->request_bufflen != 0) { 1561 struct ahc_dma_seg *sg; 1562 dma_addr_t addr; 1563 1564 sg = scb->sg_list; 1565 addr = pci_map_single(ahc->dev_softc, 1566 cmd->request_buffer, 1567 cmd->request_bufflen, 1568 cmd->sc_data_direction); 1569 scb->platform_data->buf_busaddr = addr; 1570 scb->sg_count = ahc_linux_map_seg(ahc, scb, 1571 sg, addr, 1572 cmd->request_bufflen); 1573 sg->len |= ahc_htole32(AHC_DMA_LAST_SEG); 1574 1575 /* 1576 * Reset the sg list pointer. 1577 */ 1578 scb->hscb->sgptr = 1579 ahc_htole32(scb->sg_list_phys | SG_FULL_RESID); 1580 1581 /* 1582 * Copy the first SG into the "current" 1583 * data pointer area. 1584 */ 1585 scb->hscb->dataptr = sg->addr; 1586 scb->hscb->datacnt = sg->len; 1587 } else { 1588 scb->hscb->sgptr = ahc_htole32(SG_LIST_NULL); 1589 scb->hscb->dataptr = 0; 1590 scb->hscb->datacnt = 0; 1591 scb->sg_count = 0; 1592 } 1593 1594 LIST_INSERT_HEAD(&ahc->pending_scbs, scb, pending_links); 1595 dev->openings--; 1596 dev->active++; 1597 dev->commands_issued++; 1598 if ((dev->flags & AHC_DEV_PERIODIC_OTAG) != 0) 1599 dev->commands_since_idle_or_otag++; 1600 1601 scb->flags |= SCB_ACTIVE; 1602 if (untagged_q) { 1603 TAILQ_INSERT_TAIL(untagged_q, scb, links.tqe); 1604 scb->flags |= SCB_UNTAGGEDQ; 1605 } 1606 ahc_queue_scb(ahc, scb); 1607 return 0; 1608 } 1609 1610 /* 1611 * SCSI controller interrupt handler. 1612 */ 1613 irqreturn_t 1614 ahc_linux_isr(int irq, void *dev_id, struct pt_regs * regs) 1615 { 1616 struct ahc_softc *ahc; 1617 u_long flags; 1618 int ours; 1619 1620 ahc = (struct ahc_softc *) dev_id; 1621 ahc_lock(ahc, &flags); 1622 ours = ahc_intr(ahc); 1623 ahc_unlock(ahc, &flags); 1624 return IRQ_RETVAL(ours); 1625 } 1626 1627 void 1628 ahc_platform_flushwork(struct ahc_softc *ahc) 1629 { 1630 1631 } 1632 1633 void 1634 ahc_send_async(struct ahc_softc *ahc, char channel, 1635 u_int target, u_int lun, ac_code code, void *arg) 1636 { 1637 switch (code) { 1638 case AC_TRANSFER_NEG: 1639 { 1640 char buf[80]; 1641 struct scsi_target *starget; 1642 struct ahc_linux_target *targ; 1643 struct info_str info; 1644 struct ahc_initiator_tinfo *tinfo; 1645 struct ahc_tmode_tstate *tstate; 1646 int target_offset; 1647 unsigned int target_ppr_options; 1648 1649 BUG_ON(target == CAM_TARGET_WILDCARD); 1650 1651 info.buffer = buf; 1652 info.length = sizeof(buf); 1653 info.offset = 0; 1654 info.pos = 0; 1655 tinfo = ahc_fetch_transinfo(ahc, channel, 1656 channel == 'A' ? ahc->our_id 1657 : ahc->our_id_b, 1658 target, &tstate); 1659 1660 /* 1661 * Don't bother reporting results while 1662 * negotiations are still pending. 1663 */ 1664 if (tinfo->curr.period != tinfo->goal.period 1665 || tinfo->curr.width != tinfo->goal.width 1666 || tinfo->curr.offset != tinfo->goal.offset 1667 || tinfo->curr.ppr_options != tinfo->goal.ppr_options) 1668 if (bootverbose == 0) 1669 break; 1670 1671 /* 1672 * Don't bother reporting results that 1673 * are identical to those last reported. 1674 */ 1675 target_offset = target; 1676 if (channel == 'B') 1677 target_offset += 8; 1678 starget = ahc->platform_data->starget[target_offset]; 1679 if (starget == NULL) 1680 break; 1681 targ = scsi_transport_target_data(starget); 1682 1683 target_ppr_options = 1684 (spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : 0) 1685 + (spi_qas(starget) ? MSG_EXT_PPR_QAS_REQ : 0) 1686 + (spi_iu(starget) ? MSG_EXT_PPR_IU_REQ : 0); 1687 1688 if (tinfo->curr.period == spi_period(starget) 1689 && tinfo->curr.width == spi_width(starget) 1690 && tinfo->curr.offset == spi_offset(starget) 1691 && tinfo->curr.ppr_options == target_ppr_options) 1692 if (bootverbose == 0) 1693 break; 1694 1695 spi_period(starget) = tinfo->curr.period; 1696 spi_width(starget) = tinfo->curr.width; 1697 spi_offset(starget) = tinfo->curr.offset; 1698 spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ ? 1 : 0; 1699 spi_qas(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ ? 1 : 0; 1700 spi_iu(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ ? 1 : 0; 1701 spi_display_xfer_agreement(starget); 1702 break; 1703 } 1704 case AC_SENT_BDR: 1705 { 1706 WARN_ON(lun != CAM_LUN_WILDCARD); 1707 scsi_report_device_reset(ahc->platform_data->host, 1708 channel - 'A', target); 1709 break; 1710 } 1711 case AC_BUS_RESET: 1712 if (ahc->platform_data->host != NULL) { 1713 scsi_report_bus_reset(ahc->platform_data->host, 1714 channel - 'A'); 1715 } 1716 break; 1717 default: 1718 panic("ahc_send_async: Unexpected async event"); 1719 } 1720 } 1721 1722 /* 1723 * Calls the higher level scsi done function and frees the scb. 1724 */ 1725 void 1726 ahc_done(struct ahc_softc *ahc, struct scb *scb) 1727 { 1728 struct scsi_cmnd *cmd; 1729 struct ahc_linux_device *dev; 1730 1731 LIST_REMOVE(scb, pending_links); 1732 if ((scb->flags & SCB_UNTAGGEDQ) != 0) { 1733 struct scb_tailq *untagged_q; 1734 int target_offset; 1735 1736 target_offset = SCB_GET_TARGET_OFFSET(ahc, scb); 1737 untagged_q = &(ahc->untagged_queues[target_offset]); 1738 TAILQ_REMOVE(untagged_q, scb, links.tqe); 1739 BUG_ON(!TAILQ_EMPTY(untagged_q)); 1740 } 1741 1742 if ((scb->flags & SCB_ACTIVE) == 0) { 1743 printf("SCB %d done'd twice\n", scb->hscb->tag); 1744 ahc_dump_card_state(ahc); 1745 panic("Stopping for safety"); 1746 } 1747 cmd = scb->io_ctx; 1748 dev = scb->platform_data->dev; 1749 dev->active--; 1750 dev->openings++; 1751 if ((cmd->result & (CAM_DEV_QFRZN << 16)) != 0) { 1752 cmd->result &= ~(CAM_DEV_QFRZN << 16); 1753 dev->qfrozen--; 1754 } 1755 ahc_linux_unmap_scb(ahc, scb); 1756 1757 /* 1758 * Guard against stale sense data. 1759 * The Linux mid-layer assumes that sense 1760 * was retrieved anytime the first byte of 1761 * the sense buffer looks "sane". 1762 */ 1763 cmd->sense_buffer[0] = 0; 1764 if (ahc_get_transaction_status(scb) == CAM_REQ_INPROG) { 1765 uint32_t amount_xferred; 1766 1767 amount_xferred = 1768 ahc_get_transfer_length(scb) - ahc_get_residual(scb); 1769 if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) { 1770 #ifdef AHC_DEBUG 1771 if ((ahc_debug & AHC_SHOW_MISC) != 0) { 1772 ahc_print_path(ahc, scb); 1773 printf("Set CAM_UNCOR_PARITY\n"); 1774 } 1775 #endif 1776 ahc_set_transaction_status(scb, CAM_UNCOR_PARITY); 1777 #ifdef AHC_REPORT_UNDERFLOWS 1778 /* 1779 * This code is disabled by default as some 1780 * clients of the SCSI system do not properly 1781 * initialize the underflow parameter. This 1782 * results in spurious termination of commands 1783 * that complete as expected (e.g. underflow is 1784 * allowed as command can return variable amounts 1785 * of data. 1786 */ 1787 } else if (amount_xferred < scb->io_ctx->underflow) { 1788 u_int i; 1789 1790 ahc_print_path(ahc, scb); 1791 printf("CDB:"); 1792 for (i = 0; i < scb->io_ctx->cmd_len; i++) 1793 printf(" 0x%x", scb->io_ctx->cmnd[i]); 1794 printf("\n"); 1795 ahc_print_path(ahc, scb); 1796 printf("Saw underflow (%ld of %ld bytes). " 1797 "Treated as error\n", 1798 ahc_get_residual(scb), 1799 ahc_get_transfer_length(scb)); 1800 ahc_set_transaction_status(scb, CAM_DATA_RUN_ERR); 1801 #endif 1802 } else { 1803 ahc_set_transaction_status(scb, CAM_REQ_CMP); 1804 } 1805 } else if (ahc_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) { 1806 ahc_linux_handle_scsi_status(ahc, cmd->device, scb); 1807 } 1808 1809 if (dev->openings == 1 1810 && ahc_get_transaction_status(scb) == CAM_REQ_CMP 1811 && ahc_get_scsi_status(scb) != SCSI_STATUS_QUEUE_FULL) 1812 dev->tag_success_count++; 1813 /* 1814 * Some devices deal with temporary internal resource 1815 * shortages by returning queue full. When the queue 1816 * full occurrs, we throttle back. Slowly try to get 1817 * back to our previous queue depth. 1818 */ 1819 if ((dev->openings + dev->active) < dev->maxtags 1820 && dev->tag_success_count > AHC_TAG_SUCCESS_INTERVAL) { 1821 dev->tag_success_count = 0; 1822 dev->openings++; 1823 } 1824 1825 if (dev->active == 0) 1826 dev->commands_since_idle_or_otag = 0; 1827 1828 if ((scb->flags & SCB_RECOVERY_SCB) != 0) { 1829 printf("Recovery SCB completes\n"); 1830 if (ahc_get_transaction_status(scb) == CAM_BDR_SENT 1831 || ahc_get_transaction_status(scb) == CAM_REQ_ABORTED) 1832 ahc_set_transaction_status(scb, CAM_CMD_TIMEOUT); 1833 if ((ahc->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) { 1834 ahc->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE; 1835 up(&ahc->platform_data->eh_sem); 1836 } 1837 } 1838 1839 ahc_free_scb(ahc, scb); 1840 ahc_linux_queue_cmd_complete(ahc, cmd); 1841 } 1842 1843 static void 1844 ahc_linux_handle_scsi_status(struct ahc_softc *ahc, 1845 struct scsi_device *sdev, struct scb *scb) 1846 { 1847 struct ahc_devinfo devinfo; 1848 struct ahc_linux_device *dev = scsi_transport_device_data(sdev); 1849 1850 ahc_compile_devinfo(&devinfo, 1851 ahc->our_id, 1852 sdev->sdev_target->id, sdev->lun, 1853 sdev->sdev_target->channel == 0 ? 'A' : 'B', 1854 ROLE_INITIATOR); 1855 1856 /* 1857 * We don't currently trust the mid-layer to 1858 * properly deal with queue full or busy. So, 1859 * when one occurs, we tell the mid-layer to 1860 * unconditionally requeue the command to us 1861 * so that we can retry it ourselves. We also 1862 * implement our own throttling mechanism so 1863 * we don't clobber the device with too many 1864 * commands. 1865 */ 1866 switch (ahc_get_scsi_status(scb)) { 1867 default: 1868 break; 1869 case SCSI_STATUS_CHECK_COND: 1870 case SCSI_STATUS_CMD_TERMINATED: 1871 { 1872 struct scsi_cmnd *cmd; 1873 1874 /* 1875 * Copy sense information to the OS's cmd 1876 * structure if it is available. 1877 */ 1878 cmd = scb->io_ctx; 1879 if (scb->flags & SCB_SENSE) { 1880 u_int sense_size; 1881 1882 sense_size = MIN(sizeof(struct scsi_sense_data) 1883 - ahc_get_sense_residual(scb), 1884 sizeof(cmd->sense_buffer)); 1885 memcpy(cmd->sense_buffer, 1886 ahc_get_sense_buf(ahc, scb), sense_size); 1887 if (sense_size < sizeof(cmd->sense_buffer)) 1888 memset(&cmd->sense_buffer[sense_size], 0, 1889 sizeof(cmd->sense_buffer) - sense_size); 1890 cmd->result |= (DRIVER_SENSE << 24); 1891 #ifdef AHC_DEBUG 1892 if (ahc_debug & AHC_SHOW_SENSE) { 1893 int i; 1894 1895 printf("Copied %d bytes of sense data:", 1896 sense_size); 1897 for (i = 0; i < sense_size; i++) { 1898 if ((i & 0xF) == 0) 1899 printf("\n"); 1900 printf("0x%x ", cmd->sense_buffer[i]); 1901 } 1902 printf("\n"); 1903 } 1904 #endif 1905 } 1906 break; 1907 } 1908 case SCSI_STATUS_QUEUE_FULL: 1909 { 1910 /* 1911 * By the time the core driver has returned this 1912 * command, all other commands that were queued 1913 * to us but not the device have been returned. 1914 * This ensures that dev->active is equal to 1915 * the number of commands actually queued to 1916 * the device. 1917 */ 1918 dev->tag_success_count = 0; 1919 if (dev->active != 0) { 1920 /* 1921 * Drop our opening count to the number 1922 * of commands currently outstanding. 1923 */ 1924 dev->openings = 0; 1925 /* 1926 ahc_print_path(ahc, scb); 1927 printf("Dropping tag count to %d\n", dev->active); 1928 */ 1929 if (dev->active == dev->tags_on_last_queuefull) { 1930 1931 dev->last_queuefull_same_count++; 1932 /* 1933 * If we repeatedly see a queue full 1934 * at the same queue depth, this 1935 * device has a fixed number of tag 1936 * slots. Lock in this tag depth 1937 * so we stop seeing queue fulls from 1938 * this device. 1939 */ 1940 if (dev->last_queuefull_same_count 1941 == AHC_LOCK_TAGS_COUNT) { 1942 dev->maxtags = dev->active; 1943 ahc_print_path(ahc, scb); 1944 printf("Locking max tag count at %d\n", 1945 dev->active); 1946 } 1947 } else { 1948 dev->tags_on_last_queuefull = dev->active; 1949 dev->last_queuefull_same_count = 0; 1950 } 1951 ahc_set_transaction_status(scb, CAM_REQUEUE_REQ); 1952 ahc_set_scsi_status(scb, SCSI_STATUS_OK); 1953 ahc_platform_set_tags(ahc, &devinfo, 1954 (dev->flags & AHC_DEV_Q_BASIC) 1955 ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED); 1956 break; 1957 } 1958 /* 1959 * Drop down to a single opening, and treat this 1960 * as if the target returned BUSY SCSI status. 1961 */ 1962 dev->openings = 1; 1963 ahc_set_scsi_status(scb, SCSI_STATUS_BUSY); 1964 ahc_platform_set_tags(ahc, &devinfo, 1965 (dev->flags & AHC_DEV_Q_BASIC) 1966 ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED); 1967 break; 1968 } 1969 } 1970 } 1971 1972 static void 1973 ahc_linux_queue_cmd_complete(struct ahc_softc *ahc, struct scsi_cmnd *cmd) 1974 { 1975 /* 1976 * Map CAM error codes into Linux Error codes. We 1977 * avoid the conversion so that the DV code has the 1978 * full error information available when making 1979 * state change decisions. 1980 */ 1981 { 1982 u_int new_status; 1983 1984 switch (ahc_cmd_get_transaction_status(cmd)) { 1985 case CAM_REQ_INPROG: 1986 case CAM_REQ_CMP: 1987 case CAM_SCSI_STATUS_ERROR: 1988 new_status = DID_OK; 1989 break; 1990 case CAM_REQ_ABORTED: 1991 new_status = DID_ABORT; 1992 break; 1993 case CAM_BUSY: 1994 new_status = DID_BUS_BUSY; 1995 break; 1996 case CAM_REQ_INVALID: 1997 case CAM_PATH_INVALID: 1998 new_status = DID_BAD_TARGET; 1999 break; 2000 case CAM_SEL_TIMEOUT: 2001 new_status = DID_NO_CONNECT; 2002 break; 2003 case CAM_SCSI_BUS_RESET: 2004 case CAM_BDR_SENT: 2005 new_status = DID_RESET; 2006 break; 2007 case CAM_UNCOR_PARITY: 2008 new_status = DID_PARITY; 2009 break; 2010 case CAM_CMD_TIMEOUT: 2011 new_status = DID_TIME_OUT; 2012 break; 2013 case CAM_UA_ABORT: 2014 case CAM_REQ_CMP_ERR: 2015 case CAM_AUTOSENSE_FAIL: 2016 case CAM_NO_HBA: 2017 case CAM_DATA_RUN_ERR: 2018 case CAM_UNEXP_BUSFREE: 2019 case CAM_SEQUENCE_FAIL: 2020 case CAM_CCB_LEN_ERR: 2021 case CAM_PROVIDE_FAIL: 2022 case CAM_REQ_TERMIO: 2023 case CAM_UNREC_HBA_ERROR: 2024 case CAM_REQ_TOO_BIG: 2025 new_status = DID_ERROR; 2026 break; 2027 case CAM_REQUEUE_REQ: 2028 new_status = DID_REQUEUE; 2029 break; 2030 default: 2031 /* We should never get here */ 2032 new_status = DID_ERROR; 2033 break; 2034 } 2035 2036 ahc_cmd_set_transaction_status(cmd, new_status); 2037 } 2038 2039 cmd->scsi_done(cmd); 2040 } 2041 2042 static void 2043 ahc_linux_sem_timeout(u_long arg) 2044 { 2045 struct ahc_softc *ahc; 2046 u_long s; 2047 2048 ahc = (struct ahc_softc *)arg; 2049 2050 ahc_lock(ahc, &s); 2051 if ((ahc->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) { 2052 ahc->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE; 2053 up(&ahc->platform_data->eh_sem); 2054 } 2055 ahc_unlock(ahc, &s); 2056 } 2057 2058 static void 2059 ahc_linux_freeze_simq(struct ahc_softc *ahc) 2060 { 2061 ahc->platform_data->qfrozen++; 2062 if (ahc->platform_data->qfrozen == 1) { 2063 scsi_block_requests(ahc->platform_data->host); 2064 2065 /* XXX What about Twin channels? */ 2066 ahc_platform_abort_scbs(ahc, CAM_TARGET_WILDCARD, ALL_CHANNELS, 2067 CAM_LUN_WILDCARD, SCB_LIST_NULL, 2068 ROLE_INITIATOR, CAM_REQUEUE_REQ); 2069 } 2070 } 2071 2072 static void 2073 ahc_linux_release_simq(u_long arg) 2074 { 2075 struct ahc_softc *ahc; 2076 u_long s; 2077 int unblock_reqs; 2078 2079 ahc = (struct ahc_softc *)arg; 2080 2081 unblock_reqs = 0; 2082 ahc_lock(ahc, &s); 2083 if (ahc->platform_data->qfrozen > 0) 2084 ahc->platform_data->qfrozen--; 2085 if (ahc->platform_data->qfrozen == 0) 2086 unblock_reqs = 1; 2087 ahc_unlock(ahc, &s); 2088 /* 2089 * There is still a race here. The mid-layer 2090 * should keep its own freeze count and use 2091 * a bottom half handler to run the queues 2092 * so we can unblock with our own lock held. 2093 */ 2094 if (unblock_reqs) 2095 scsi_unblock_requests(ahc->platform_data->host); 2096 } 2097 2098 static int 2099 ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag) 2100 { 2101 struct ahc_softc *ahc; 2102 struct ahc_linux_device *dev; 2103 struct scb *pending_scb; 2104 u_int saved_scbptr; 2105 u_int active_scb_index; 2106 u_int last_phase; 2107 u_int saved_scsiid; 2108 u_int cdb_byte; 2109 int retval; 2110 int was_paused; 2111 int paused; 2112 int wait; 2113 int disconnected; 2114 2115 pending_scb = NULL; 2116 paused = FALSE; 2117 wait = FALSE; 2118 ahc = *(struct ahc_softc **)cmd->device->host->hostdata; 2119 2120 scmd_printk(KERN_INFO, cmd, "Attempting to queue a%s message\n", 2121 flag == SCB_ABORT ? "n ABORT" : " TARGET RESET"); 2122 2123 printf("CDB:"); 2124 for (cdb_byte = 0; cdb_byte < cmd->cmd_len; cdb_byte++) 2125 printf(" 0x%x", cmd->cmnd[cdb_byte]); 2126 printf("\n"); 2127 2128 spin_lock_irq(&ahc->platform_data->spin_lock); 2129 2130 /* 2131 * First determine if we currently own this command. 2132 * Start by searching the device queue. If not found 2133 * there, check the pending_scb list. If not found 2134 * at all, and the system wanted us to just abort the 2135 * command, return success. 2136 */ 2137 dev = scsi_transport_device_data(cmd->device); 2138 2139 if (dev == NULL) { 2140 /* 2141 * No target device for this command exists, 2142 * so we must not still own the command. 2143 */ 2144 printf("%s:%d:%d:%d: Is not an active device\n", 2145 ahc_name(ahc), cmd->device->channel, cmd->device->id, 2146 cmd->device->lun); 2147 retval = SUCCESS; 2148 goto no_cmd; 2149 } 2150 2151 if ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED)) == 0 2152 && ahc_search_untagged_queues(ahc, cmd, cmd->device->id, 2153 cmd->device->channel + 'A', 2154 cmd->device->lun, 2155 CAM_REQ_ABORTED, SEARCH_COMPLETE) != 0) { 2156 printf("%s:%d:%d:%d: Command found on untagged queue\n", 2157 ahc_name(ahc), cmd->device->channel, cmd->device->id, 2158 cmd->device->lun); 2159 retval = SUCCESS; 2160 goto done; 2161 } 2162 2163 /* 2164 * See if we can find a matching cmd in the pending list. 2165 */ 2166 LIST_FOREACH(pending_scb, &ahc->pending_scbs, pending_links) { 2167 if (pending_scb->io_ctx == cmd) 2168 break; 2169 } 2170 2171 if (pending_scb == NULL && flag == SCB_DEVICE_RESET) { 2172 2173 /* Any SCB for this device will do for a target reset */ 2174 LIST_FOREACH(pending_scb, &ahc->pending_scbs, pending_links) { 2175 if (ahc_match_scb(ahc, pending_scb, scmd_id(cmd), 2176 scmd_channel(cmd) + 'A', 2177 CAM_LUN_WILDCARD, 2178 SCB_LIST_NULL, ROLE_INITIATOR) == 0) 2179 break; 2180 } 2181 } 2182 2183 if (pending_scb == NULL) { 2184 scmd_printk(KERN_INFO, cmd, "Command not found\n"); 2185 goto no_cmd; 2186 } 2187 2188 if ((pending_scb->flags & SCB_RECOVERY_SCB) != 0) { 2189 /* 2190 * We can't queue two recovery actions using the same SCB 2191 */ 2192 retval = FAILED; 2193 goto done; 2194 } 2195 2196 /* 2197 * Ensure that the card doesn't do anything 2198 * behind our back and that we didn't "just" miss 2199 * an interrupt that would affect this cmd. 2200 */ 2201 was_paused = ahc_is_paused(ahc); 2202 ahc_pause_and_flushwork(ahc); 2203 paused = TRUE; 2204 2205 if ((pending_scb->flags & SCB_ACTIVE) == 0) { 2206 scmd_printk(KERN_INFO, cmd, "Command already completed\n"); 2207 goto no_cmd; 2208 } 2209 2210 printf("%s: At time of recovery, card was %spaused\n", 2211 ahc_name(ahc), was_paused ? "" : "not "); 2212 ahc_dump_card_state(ahc); 2213 2214 disconnected = TRUE; 2215 if (flag == SCB_ABORT) { 2216 if (ahc_search_qinfifo(ahc, cmd->device->id, 2217 cmd->device->channel + 'A', 2218 cmd->device->lun, 2219 pending_scb->hscb->tag, 2220 ROLE_INITIATOR, CAM_REQ_ABORTED, 2221 SEARCH_COMPLETE) > 0) { 2222 printf("%s:%d:%d:%d: Cmd aborted from QINFIFO\n", 2223 ahc_name(ahc), cmd->device->channel, 2224 cmd->device->id, cmd->device->lun); 2225 retval = SUCCESS; 2226 goto done; 2227 } 2228 } else if (ahc_search_qinfifo(ahc, cmd->device->id, 2229 cmd->device->channel + 'A', 2230 cmd->device->lun, pending_scb->hscb->tag, 2231 ROLE_INITIATOR, /*status*/0, 2232 SEARCH_COUNT) > 0) { 2233 disconnected = FALSE; 2234 } 2235 2236 if (disconnected && (ahc_inb(ahc, SEQ_FLAGS) & NOT_IDENTIFIED) == 0) { 2237 struct scb *bus_scb; 2238 2239 bus_scb = ahc_lookup_scb(ahc, ahc_inb(ahc, SCB_TAG)); 2240 if (bus_scb == pending_scb) 2241 disconnected = FALSE; 2242 else if (flag != SCB_ABORT 2243 && ahc_inb(ahc, SAVED_SCSIID) == pending_scb->hscb->scsiid 2244 && ahc_inb(ahc, SAVED_LUN) == SCB_GET_LUN(pending_scb)) 2245 disconnected = FALSE; 2246 } 2247 2248 /* 2249 * At this point, pending_scb is the scb associated with the 2250 * passed in command. That command is currently active on the 2251 * bus, is in the disconnected state, or we're hoping to find 2252 * a command for the same target active on the bus to abuse to 2253 * send a BDR. Queue the appropriate message based on which of 2254 * these states we are in. 2255 */ 2256 last_phase = ahc_inb(ahc, LASTPHASE); 2257 saved_scbptr = ahc_inb(ahc, SCBPTR); 2258 active_scb_index = ahc_inb(ahc, SCB_TAG); 2259 saved_scsiid = ahc_inb(ahc, SAVED_SCSIID); 2260 if (last_phase != P_BUSFREE 2261 && (pending_scb->hscb->tag == active_scb_index 2262 || (flag == SCB_DEVICE_RESET 2263 && SCSIID_TARGET(ahc, saved_scsiid) == scmd_id(cmd)))) { 2264 2265 /* 2266 * We're active on the bus, so assert ATN 2267 * and hope that the target responds. 2268 */ 2269 pending_scb = ahc_lookup_scb(ahc, active_scb_index); 2270 pending_scb->flags |= SCB_RECOVERY_SCB|flag; 2271 ahc_outb(ahc, MSG_OUT, HOST_MSG); 2272 ahc_outb(ahc, SCSISIGO, last_phase|ATNO); 2273 scmd_printk(KERN_INFO, cmd, "Device is active, asserting ATN\n"); 2274 wait = TRUE; 2275 } else if (disconnected) { 2276 2277 /* 2278 * Actually re-queue this SCB in an attempt 2279 * to select the device before it reconnects. 2280 * In either case (selection or reselection), 2281 * we will now issue the approprate message 2282 * to the timed-out device. 2283 * 2284 * Set the MK_MESSAGE control bit indicating 2285 * that we desire to send a message. We 2286 * also set the disconnected flag since 2287 * in the paging case there is no guarantee 2288 * that our SCB control byte matches the 2289 * version on the card. We don't want the 2290 * sequencer to abort the command thinking 2291 * an unsolicited reselection occurred. 2292 */ 2293 pending_scb->hscb->control |= MK_MESSAGE|DISCONNECTED; 2294 pending_scb->flags |= SCB_RECOVERY_SCB|flag; 2295 2296 /* 2297 * Remove any cached copy of this SCB in the 2298 * disconnected list in preparation for the 2299 * queuing of our abort SCB. We use the 2300 * same element in the SCB, SCB_NEXT, for 2301 * both the qinfifo and the disconnected list. 2302 */ 2303 ahc_search_disc_list(ahc, cmd->device->id, 2304 cmd->device->channel + 'A', 2305 cmd->device->lun, pending_scb->hscb->tag, 2306 /*stop_on_first*/TRUE, 2307 /*remove*/TRUE, 2308 /*save_state*/FALSE); 2309 2310 /* 2311 * In the non-paging case, the sequencer will 2312 * never re-reference the in-core SCB. 2313 * To make sure we are notified during 2314 * reslection, set the MK_MESSAGE flag in 2315 * the card's copy of the SCB. 2316 */ 2317 if ((ahc->flags & AHC_PAGESCBS) == 0) { 2318 ahc_outb(ahc, SCBPTR, pending_scb->hscb->tag); 2319 ahc_outb(ahc, SCB_CONTROL, 2320 ahc_inb(ahc, SCB_CONTROL)|MK_MESSAGE); 2321 } 2322 2323 /* 2324 * Clear out any entries in the QINFIFO first 2325 * so we are the next SCB for this target 2326 * to run. 2327 */ 2328 ahc_search_qinfifo(ahc, cmd->device->id, 2329 cmd->device->channel + 'A', 2330 cmd->device->lun, SCB_LIST_NULL, 2331 ROLE_INITIATOR, CAM_REQUEUE_REQ, 2332 SEARCH_COMPLETE); 2333 ahc_qinfifo_requeue_tail(ahc, pending_scb); 2334 ahc_outb(ahc, SCBPTR, saved_scbptr); 2335 ahc_print_path(ahc, pending_scb); 2336 printf("Device is disconnected, re-queuing SCB\n"); 2337 wait = TRUE; 2338 } else { 2339 scmd_printk(KERN_INFO, cmd, "Unable to deliver message\n"); 2340 retval = FAILED; 2341 goto done; 2342 } 2343 2344 no_cmd: 2345 /* 2346 * Our assumption is that if we don't have the command, no 2347 * recovery action was required, so we return success. Again, 2348 * the semantics of the mid-layer recovery engine are not 2349 * well defined, so this may change in time. 2350 */ 2351 retval = SUCCESS; 2352 done: 2353 if (paused) 2354 ahc_unpause(ahc); 2355 if (wait) { 2356 struct timer_list timer; 2357 int ret; 2358 2359 ahc->platform_data->flags |= AHC_UP_EH_SEMAPHORE; 2360 spin_unlock_irq(&ahc->platform_data->spin_lock); 2361 init_timer(&timer); 2362 timer.data = (u_long)ahc; 2363 timer.expires = jiffies + (5 * HZ); 2364 timer.function = ahc_linux_sem_timeout; 2365 add_timer(&timer); 2366 printf("Recovery code sleeping\n"); 2367 down(&ahc->platform_data->eh_sem); 2368 printf("Recovery code awake\n"); 2369 ret = del_timer_sync(&timer); 2370 if (ret == 0) { 2371 printf("Timer Expired\n"); 2372 retval = FAILED; 2373 } 2374 spin_lock_irq(&ahc->platform_data->spin_lock); 2375 } 2376 2377 spin_unlock_irq(&ahc->platform_data->spin_lock); 2378 return (retval); 2379 } 2380 2381 void 2382 ahc_platform_dump_card_state(struct ahc_softc *ahc) 2383 { 2384 } 2385 2386 static void ahc_linux_set_width(struct scsi_target *starget, int width) 2387 { 2388 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2389 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata); 2390 struct ahc_devinfo devinfo; 2391 unsigned long flags; 2392 2393 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0, 2394 starget->channel + 'A', ROLE_INITIATOR); 2395 ahc_lock(ahc, &flags); 2396 ahc_set_width(ahc, &devinfo, width, AHC_TRANS_GOAL, FALSE); 2397 ahc_unlock(ahc, &flags); 2398 } 2399 2400 static void ahc_linux_set_period(struct scsi_target *starget, int period) 2401 { 2402 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2403 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata); 2404 struct ahc_tmode_tstate *tstate; 2405 struct ahc_initiator_tinfo *tinfo 2406 = ahc_fetch_transinfo(ahc, 2407 starget->channel + 'A', 2408 shost->this_id, starget->id, &tstate); 2409 struct ahc_devinfo devinfo; 2410 unsigned int ppr_options = tinfo->goal.ppr_options; 2411 unsigned long flags; 2412 unsigned long offset = tinfo->goal.offset; 2413 struct ahc_syncrate *syncrate; 2414 2415 if (offset == 0) 2416 offset = MAX_OFFSET; 2417 2418 if (period < 9) 2419 period = 9; /* 12.5ns is our minimum */ 2420 if (period == 9) 2421 ppr_options |= MSG_EXT_PPR_DT_REQ; 2422 2423 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0, 2424 starget->channel + 'A', ROLE_INITIATOR); 2425 2426 /* all PPR requests apart from QAS require wide transfers */ 2427 if (ppr_options & ~MSG_EXT_PPR_QAS_REQ) { 2428 if (spi_width(starget) == 0) 2429 ppr_options &= MSG_EXT_PPR_QAS_REQ; 2430 } 2431 2432 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT); 2433 ahc_lock(ahc, &flags); 2434 ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset, 2435 ppr_options, AHC_TRANS_GOAL, FALSE); 2436 ahc_unlock(ahc, &flags); 2437 } 2438 2439 static void ahc_linux_set_offset(struct scsi_target *starget, int offset) 2440 { 2441 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2442 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata); 2443 struct ahc_tmode_tstate *tstate; 2444 struct ahc_initiator_tinfo *tinfo 2445 = ahc_fetch_transinfo(ahc, 2446 starget->channel + 'A', 2447 shost->this_id, starget->id, &tstate); 2448 struct ahc_devinfo devinfo; 2449 unsigned int ppr_options = 0; 2450 unsigned int period = 0; 2451 unsigned long flags; 2452 struct ahc_syncrate *syncrate = NULL; 2453 2454 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0, 2455 starget->channel + 'A', ROLE_INITIATOR); 2456 if (offset != 0) { 2457 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT); 2458 period = tinfo->goal.period; 2459 ppr_options = tinfo->goal.ppr_options; 2460 } 2461 ahc_lock(ahc, &flags); 2462 ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset, 2463 ppr_options, AHC_TRANS_GOAL, FALSE); 2464 ahc_unlock(ahc, &flags); 2465 } 2466 2467 static void ahc_linux_set_dt(struct scsi_target *starget, int dt) 2468 { 2469 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2470 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata); 2471 struct ahc_tmode_tstate *tstate; 2472 struct ahc_initiator_tinfo *tinfo 2473 = ahc_fetch_transinfo(ahc, 2474 starget->channel + 'A', 2475 shost->this_id, starget->id, &tstate); 2476 struct ahc_devinfo devinfo; 2477 unsigned int ppr_options = tinfo->goal.ppr_options 2478 & ~MSG_EXT_PPR_DT_REQ; 2479 unsigned int period = tinfo->goal.period; 2480 unsigned int width = tinfo->goal.width; 2481 unsigned long flags; 2482 struct ahc_syncrate *syncrate; 2483 2484 if (dt) { 2485 ppr_options |= MSG_EXT_PPR_DT_REQ; 2486 if (!width) 2487 ahc_linux_set_width(starget, 1); 2488 } else if (period == 9) 2489 period = 10; /* if resetting DT, period must be >= 25ns */ 2490 2491 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0, 2492 starget->channel + 'A', ROLE_INITIATOR); 2493 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,AHC_SYNCRATE_DT); 2494 ahc_lock(ahc, &flags); 2495 ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset, 2496 ppr_options, AHC_TRANS_GOAL, FALSE); 2497 ahc_unlock(ahc, &flags); 2498 } 2499 2500 #if 0 2501 /* FIXME: This code claims to support IU and QAS. However, the actual 2502 * sequencer code and aic7xxx_core have no support for these parameters and 2503 * will get into a bad state if they're negotiated. Do not enable this 2504 * unless you know what you're doing */ 2505 static void ahc_linux_set_qas(struct scsi_target *starget, int qas) 2506 { 2507 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2508 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata); 2509 struct ahc_tmode_tstate *tstate; 2510 struct ahc_initiator_tinfo *tinfo 2511 = ahc_fetch_transinfo(ahc, 2512 starget->channel + 'A', 2513 shost->this_id, starget->id, &tstate); 2514 struct ahc_devinfo devinfo; 2515 unsigned int ppr_options = tinfo->goal.ppr_options 2516 & ~MSG_EXT_PPR_QAS_REQ; 2517 unsigned int period = tinfo->goal.period; 2518 unsigned long flags; 2519 struct ahc_syncrate *syncrate; 2520 2521 if (qas) 2522 ppr_options |= MSG_EXT_PPR_QAS_REQ; 2523 2524 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0, 2525 starget->channel + 'A', ROLE_INITIATOR); 2526 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT); 2527 ahc_lock(ahc, &flags); 2528 ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset, 2529 ppr_options, AHC_TRANS_GOAL, FALSE); 2530 ahc_unlock(ahc, &flags); 2531 } 2532 2533 static void ahc_linux_set_iu(struct scsi_target *starget, int iu) 2534 { 2535 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 2536 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata); 2537 struct ahc_tmode_tstate *tstate; 2538 struct ahc_initiator_tinfo *tinfo 2539 = ahc_fetch_transinfo(ahc, 2540 starget->channel + 'A', 2541 shost->this_id, starget->id, &tstate); 2542 struct ahc_devinfo devinfo; 2543 unsigned int ppr_options = tinfo->goal.ppr_options 2544 & ~MSG_EXT_PPR_IU_REQ; 2545 unsigned int period = tinfo->goal.period; 2546 unsigned long flags; 2547 struct ahc_syncrate *syncrate; 2548 2549 if (iu) 2550 ppr_options |= MSG_EXT_PPR_IU_REQ; 2551 2552 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0, 2553 starget->channel + 'A', ROLE_INITIATOR); 2554 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT); 2555 ahc_lock(ahc, &flags); 2556 ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset, 2557 ppr_options, AHC_TRANS_GOAL, FALSE); 2558 ahc_unlock(ahc, &flags); 2559 } 2560 #endif 2561 2562 static struct spi_function_template ahc_linux_transport_functions = { 2563 .set_offset = ahc_linux_set_offset, 2564 .show_offset = 1, 2565 .set_period = ahc_linux_set_period, 2566 .show_period = 1, 2567 .set_width = ahc_linux_set_width, 2568 .show_width = 1, 2569 .set_dt = ahc_linux_set_dt, 2570 .show_dt = 1, 2571 #if 0 2572 .set_iu = ahc_linux_set_iu, 2573 .show_iu = 1, 2574 .set_qas = ahc_linux_set_qas, 2575 .show_qas = 1, 2576 #endif 2577 }; 2578 2579 2580 2581 static int __init 2582 ahc_linux_init(void) 2583 { 2584 /* 2585 * If we've been passed any parameters, process them now. 2586 */ 2587 if (aic7xxx) 2588 aic7xxx_setup(aic7xxx); 2589 2590 ahc_linux_transport_template = 2591 spi_attach_transport(&ahc_linux_transport_functions); 2592 if (!ahc_linux_transport_template) 2593 return -ENODEV; 2594 2595 scsi_transport_reserve_target(ahc_linux_transport_template, 2596 sizeof(struct ahc_linux_target)); 2597 scsi_transport_reserve_device(ahc_linux_transport_template, 2598 sizeof(struct ahc_linux_device)); 2599 2600 ahc_linux_pci_init(); 2601 ahc_linux_eisa_init(); 2602 return 0; 2603 } 2604 2605 static void 2606 ahc_linux_exit(void) 2607 { 2608 ahc_linux_pci_exit(); 2609 ahc_linux_eisa_exit(); 2610 spi_release_transport(ahc_linux_transport_template); 2611 } 2612 2613 module_init(ahc_linux_init); 2614 module_exit(ahc_linux_exit); 2615