![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aic7xxx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi|
Return to aic7xxx.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 ! root 1: /*+M************************************************************************* ! 2: * Adaptec AIC7xxx device driver for Linux. ! 3: * ! 4: * Copyright (c) 1994 John Aycock ! 5: * The University of Calgary Department of Computer Science. ! 6: * ! 7: * This program is free software; you can redistribute it and/or modify ! 8: * it under the terms of the GNU General Public License as published by ! 9: * the Free Software Foundation; either version 2, or (at your option) ! 10: * any later version. ! 11: * ! 12: * This program is distributed in the hope that it will be useful, ! 13: * but WITHOUT ANY WARRANTY; without even the implied warranty of ! 14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 15: * GNU General Public License for more details. ! 16: * ! 17: * You should have received a copy of the GNU General Public License ! 18: * along with this program; see the file COPYING. If not, write to ! 19: * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. ! 20: * ! 21: * Sources include the Adaptec 1740 driver (aha1740.c), the Ultrastor 24F ! 22: * driver (ultrastor.c), various Linux kernel source, the Adaptec EISA ! 23: * config file (!adp7771.cfg), the Adaptec AHA-2740A Series User's Guide, ! 24: * the Linux Kernel Hacker's Guide, Writing a SCSI Device Driver for Linux, ! 25: * the Adaptec 1542 driver (aha1542.c), the Adaptec EISA overlay file ! 26: * (adp7770.ovl), the Adaptec AHA-2740 Series Technical Reference Manual, ! 27: * the Adaptec AIC-7770 Data Book, the ANSI SCSI specification, the ! 28: * ANSI SCSI-2 specification (draft 10c), ... ! 29: * ! 30: * -------------------------------------------------------------------------- ! 31: * ! 32: * Modifications by Daniel M. Eischen ([email protected]): ! 33: * ! 34: * Substantially modified to include support for wide and twin bus ! 35: * adapters, DMAing of SCBs, tagged queueing, IRQ sharing, bug fixes, ! 36: * SCB paging, and other rework of the code. ! 37: * ! 38: * Parts of this driver were also based on the FreeBSD driver by ! 39: * Justin T. Gibbs. His copyright follows: ! 40: * ! 41: * -------------------------------------------------------------------------- ! 42: * Copyright (c) 1994-1997 Justin Gibbs. ! 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, immediately at the beginning of the file. ! 51: * 2. Redistributions in binary form must reproduce the above copyright ! 52: * notice, this list of conditions and the following disclaimer in the ! 53: * documentation and/or other materials provided with the distribution. ! 54: * 3. The name of the author may not be used to endorse or promote products ! 55: * derived from this software without specific prior written permission. ! 56: * ! 57: * Where this Software is combined with software released under the terms of ! 58: * the GNU Public License ("GPL") and the terms of the GPL would require the ! 59: * combined work to also be released under the terms of the GPL, the terms ! 60: * and conditions of this License will apply in addition to those of the ! 61: * GPL with the exception of any terms or conditions of this License that ! 62: * conflict with, or are expressly prohibited by, the GPL. ! 63: * ! 64: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ! 65: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 66: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 67: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ! 68: * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 69: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 70: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 71: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 72: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 73: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 74: * SUCH DAMAGE. ! 75: * ! 76: * $Id: aic7xxx.c,v 1.1 1999/04/26 05:54:15 tb Exp $ ! 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=ultra ! 91: * aic7xxx=irq_trigger:[0,1] # 0 edge, 1 level ! 92: * aic7xxx=verbose ! 93: * ! 94: * Daniel M. Eischen, [email protected], 1/23/97 ! 95: * ! 96: * $Id: aic7xxx.c,v 1.1 1999/04/26 05:54:15 tb Exp $ ! 97: *-M*************************************************************************/ ! 98: ! 99: /*+M************************************************************************** ! 100: * ! 101: * Further driver modifications made by Doug Ledford <[email protected]> ! 102: * ! 103: * Copyright (c) 1997-1998 Doug Ledford ! 104: * ! 105: * These changes are released under the same licensing terms as the FreeBSD ! 106: * driver written by Justin Gibbs. Please see his Copyright notice above ! 107: * for the exact terms and conditions covering my changes as well as the ! 108: * warranty statement. ! 109: * ! 110: * Modifications made to the aic7xxx.c,v 4.1 driver from Dan Eischen include ! 111: * but are not limited to: ! 112: * ! 113: * 1: Import of the latest FreeBSD sequencer code for this driver ! 114: * 2: Modification of kernel code to accomodate different sequencer semantics ! 115: * 3: Extensive changes throughout kernel portion of driver to improve ! 116: * abort/reset processing and error hanndling ! 117: * 4: Other work contributed by various people on the Internet ! 118: * 5: Changes to printk information and verbosity selection code ! 119: * 6: General reliability related changes, especially in IRQ management ! 120: * 7: Modifications to the default probe/attach order for supported cards ! 121: * 8: SMP friendliness has been improved ! 122: * ! 123: * Overall, this driver represents a significant departure from the official ! 124: * aic7xxx driver released by Dan Eischen in two ways. First, in the code ! 125: * itself. A diff between the two version of the driver is now a several ! 126: * thousand line diff. Second, in approach to solving the same problem. The ! 127: * problem is importing the FreeBSD aic7xxx driver code to linux can be a ! 128: * difficult and time consuming process, that also can be error prone. Dan ! 129: * Eischen's official driver uses the approach that the linux and FreeBSD ! 130: * drivers should be as identical as possible. To that end, his next version ! 131: * of this driver will be using a mid-layer code library that he is developing ! 132: * to moderate communications between the linux mid-level SCSI code and the ! 133: * low level FreeBSD driver. He intends to be able to essentially drop the ! 134: * FreeBSD driver into the linux kernel with only a few minor tweaks to some ! 135: * include files and the like and get things working, making for fast easy ! 136: * imports of the FreeBSD code into linux. ! 137: * ! 138: * I disagree with Dan's approach. Not that I don't think his way of doing ! 139: * things would be nice, easy to maintain, and create a more uniform driver ! 140: * between FreeBSD and Linux. I have no objection to those issues. My ! 141: * disagreement is on the needed functionality. There simply are certain ! 142: * things that are done differently in FreeBSD than linux that will cause ! 143: * problems for this driver regardless of any middle ware Dan implements. ! 144: * The biggest example of this at the moment is interrupt semantics. Linux ! 145: * doesn't provide the same protection techniques as FreeBSD does, nor can ! 146: * they be easily implemented in any middle ware code since they would truly ! 147: * belong in the kernel proper and would effect all drivers. For the time ! 148: * being, I see issues such as these as major stumbling blocks to the ! 149: * reliability of code based upon such middle ware. Therefore, I choose to ! 150: * use a different approach to importing the FreeBSD code that doesn't ! 151: * involve any middle ware type code. My approach is to import the sequencer ! 152: * code from FreeBSD wholesale. Then, to only make changes in the kernel ! 153: * portion of the driver as they are needed for the new sequencer semantics. ! 154: * In this way, the portion of the driver that speaks to the rest of the ! 155: * linux kernel is fairly static and can be changed/modified to solve ! 156: * any problems one might encounter without concern for the FreeBSD driver. ! 157: * ! 158: * Note: If time and experience should prove me wrong that the middle ware ! 159: * code Dan writes is reliable in its operation, then I'll retract my above ! 160: * statements. But, for those that don't know, I'm from Missouri (in the US) ! 161: * and our state motto is "The Show-Me State". Well, before I will put ! 162: * faith into it, you'll have to show me that it works :) ! 163: * ! 164: *_M*************************************************************************/ ! 165: ! 166: /* ! 167: * The next three defines are user configurable. These should be the only ! 168: * defines a user might need to get in here and change. There are other ! 169: * defines buried deeper in the code, but those really shouldn't need touched ! 170: * under normal conditions. ! 171: */ ! 172: ! 173: /* ! 174: * AIC7XXX_FAKE_NEGOTIATION_CMDS ! 175: * We now have two distinctly different methods of device negotiation ! 176: * in this code. The two methods are selected by either defining or not ! 177: * defining this option. The difference is as follows: ! 178: * ! 179: * With AIC7XXX_FAKE_NEGOTIATION_CMDS not set (commented out) ! 180: * When the driver is in need of issuing a negotiation command for any ! 181: * given device, it will add the negotiation message on to part of a ! 182: * regular SCSI command for the device. In the process, if the device ! 183: * is configured for and using tagged queueing, then the code will ! 184: * also issue that single command as a non-tagged command, attach the ! 185: * negotiation message to that one command, and use a temporary ! 186: * queue depth of one to keep the untagged and tagged commands from ! 187: * overlapping. ! 188: * Pros: This doesn't use any extra SCB structures, it's simple, it ! 189: * works most of the time (if not all of the time now), and ! 190: * since we get the device capability info frmo the INQUIRY data ! 191: * now, shouldn't cause any problems. ! 192: * Cons: When we need to send a negotiation command to a device, we ! 193: * must use a command that is being sent to LUN 0 of the device. ! 194: * If we try sending one to high LUN numbers, then some devices ! 195: * get noticeably upset. Since we have to wait for a command with ! 196: * LUN == 0 to come along, we may not be able to renegotiate when ! 197: * we want if the user is actually using say LUN 1 of a CD Changer ! 198: * instead of using LUN 0 for an extended period of time. ! 199: * ! 200: * With AIC7XXX_FAKE_NEGOTIATION_CMDS defined ! 201: * When we need to negotiate with a device, instead of attaching our ! 202: * negotiation message to an existing command, we insert our own ! 203: * fictional Scsi_Cmnd into the chain that has the negotiation message ! 204: * attached to it. We send this one command as untagged regardless ! 205: * of the device type, and we fiddle with the queue depth the same as ! 206: * we would with the option unset to avoid overlapping commands. The ! 207: * primary difference between this and the unset option is that the ! 208: * negotiation message is no longer attached to a specific command, ! 209: * instead it is its own command and is merely triggered by a ! 210: * combination of both A) We need to negotiate and B) The mid level ! 211: * SCSI code has sent us a command. We still don't do any negotiation ! 212: * unless there is a valid SCSI command to be processed. ! 213: * Pros: This fixes the problem above in the Cons section. Since we ! 214: * issue our own fake command, we can set the LUN to 0 regardless ! 215: * of what the LUN is in the real command. It also means that if ! 216: * the device get's nasty over negotiation issues, it won't be ! 217: * showing up on a regular command, so we won't get any SENSE buffer ! 218: * data or STATUS_BYTE returns to the mid level code that are caused ! 219: * by snits in the negotiation code. ! 220: * Cons: We add more code, and more complexity. This means more ways ! 221: * in which things could break. It means a larger driver. It means ! 222: * more resource consumption for the fake commands. However, the ! 223: * biggest problem is this. Take a system where there is a CD-ROM ! 224: * on the SCSI bus. Someone has a CD in the CD-ROM and is using it. ! 225: * For some reason the SCSI bus gets reset. We don't touch the ! 226: * CD-ROM again for quite a period of time (so we don't renegotiate ! 227: * after the reset until we do touch the CD-ROM again). In the ! 228: * time while we aren't using the CD-ROM, the current disc is ! 229: * removed and a new one put in. When we go to check that disc, we ! 230: * will first have to renegotiate. In so doing, we issue our fake ! 231: * SCSI command, which happens to be TEST_UNIT_READY. The CD-ROM ! 232: * negotiates with us, then responds to our fake command with a ! 233: * CHECK_CONDITION status. We REQUEST_SENSE from the CD-ROM, it ! 234: * then sends the SENSE data to our fake command to tell it that ! 235: * it has been through a disc change. There, now we've cleared out ! 236: * the SENSE data along with our negotiation command, and when the ! 237: * real command executes, it won't pick up that the CD was changed. ! 238: * That's the biggest Con to this approach. In the future, I could ! 239: * probably code around this problem though, so this option is still ! 240: * viable. ! 241: * ! 242: * So, which command style should you use? I would appreciate it if people ! 243: * could try out both types. I want to know about any cases where one ! 244: * method works and the other doesn't. If one method works on significantly ! 245: * more systems than another, then it will become the default. If the second ! 246: * option turns out to work best, then I'll find a way to work around that ! 247: * big con I listed. ! 248: * ! 249: * -- July 7, 02:33 ! 250: * OK...I just added some code that should make the Con listed for the ! 251: * fake commands a non issue now. However, it needs testing. For now, ! 252: * I'm going to make the default to use the fake commands, we'll see how ! 253: * it goes. ! 254: */ ! 255: ! 256: #define AIC7XXX_FAKE_NEGOTIATION_CMDS ! 257: ! 258: /* ! 259: * AIC7XXX_STRICT_PCI_SETUP ! 260: * Should we assume the PCI config options on our controllers are set with ! 261: * sane and proper values, or should we be anal about our PCI config ! 262: * registers and force them to what we want? The main advantage to ! 263: * defining this option is on non-Intel hardware where the BIOS may not ! 264: * have been run to set things up, or if you have one of the BIOSless ! 265: * Adaptec controllers, such as a 2910, that don't get set up by the ! 266: * BIOS. However, keep in mind that we really do set the most important ! 267: * items in the driver regardless of this setting, this only controls some ! 268: * of the more esoteric PCI options on these cards. In that sense, I ! 269: * would default to leaving this off. However, if people wish to try ! 270: * things both ways, that would also help me to know if there are some ! 271: * machines where it works one way but not another. ! 272: * ! 273: * -- July 7, 17:09 ! 274: * OK...I need this on my machine for testing, so the default is to ! 275: * leave it defined. ! 276: * ! 277: * -- July 7, 18:49 ! 278: * I needed it for testing, but it didn't make any difference, so back ! 279: * off she goes. ! 280: * ! 281: * -- July 16, 23:04 ! 282: * I turned it back on to try and compensate for the 2.1.x PCI code ! 283: * which no longer relies solely on the BIOS and now tries to set ! 284: * things itself. ! 285: */ ! 286: ! 287: #define AIC7XXX_STRICT_PCI_SETUP ! 288: ! 289: /* ! 290: * AIC7XXX_VERBOSE_DEBUGGING ! 291: * This option enables a lot of extra printk();s in the code, surrounded ! 292: * by if (aic7xxx_verbose ...) statements. Executing all of those if ! 293: * statements and the extra checks can get to where it actually does have ! 294: * an impact on CPU usage and such, as well as code size. Disabling this ! 295: * define will keep some of those from becoming part of the code. ! 296: * ! 297: * NOTE: Currently, this option has no real effect, I will be adding the ! 298: * various #ifdef's in the code later when I've decided a section is ! 299: * complete and no longer needs debugging. OK...a lot of things are now ! 300: * surrounded by this define, so turning this off does have an impact. ! 301: */ ! 302: ! 303: /* ! 304: * #define AIC7XXX_VERBOSE_DEBUGGING ! 305: */ ! 306: ! 307: #if defined(MODULE) || defined(PCMCIA) ! 308: #include <linux/module.h> ! 309: #endif ! 310: ! 311: #if defined(PCMCIA) ! 312: # undef MODULE ! 313: #endif ! 314: ! 315: #include <stdarg.h> ! 316: #include <asm/io.h> ! 317: #include <asm/irq.h> ! 318: #include <asm/byteorder.h> ! 319: #include <linux/version.h> ! 320: #include <linux/string.h> ! 321: #include <linux/errno.h> ! 322: #include <linux/kernel.h> ! 323: #include <linux/ioport.h> ! 324: #include <linux/delay.h> ! 325: #include <linux/sched.h> ! 326: #include <linux/pci.h> ! 327: #include <linux/proc_fs.h> ! 328: #include <linux/blk.h> ! 329: #include <linux/tqueue.h> ! 330: #include <linux/tasks.h> ! 331: #include "sd.h" ! 332: #include "scsi.h" ! 333: #include "hosts.h" ! 334: #include "aic7xxx.h" ! 335: ! 336: #include "aic7xxx/sequencer.h" ! 337: #include "aic7xxx/scsi_message.h" ! 338: #include "aic7xxx_reg.h" ! 339: ! 340: #include <linux/stat.h> ! 341: #include <linux/malloc.h> /* for kmalloc() */ ! 342: ! 343: #include <linux/config.h> /* for CONFIG_PCI */ ! 344: ! 345: /* ! 346: * To generate the correct addresses for the controller to issue ! 347: * on the bus. Originally added for DEC Alpha support. ! 348: */ ! 349: #define VIRT_TO_BUS(a) (unsigned int)virt_to_bus((void *)(a)) ! 350: ! 351: struct proc_dir_entry proc_scsi_aic7xxx = { ! 352: PROC_SCSI_AIC7XXX, 7, "aic7xxx", ! 353: S_IFDIR | S_IRUGO | S_IXUGO, 2, ! 354: 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL ! 355: }; ! 356: ! 357: #define AIC7XXX_C_VERSION "5.1.4" ! 358: ! 359: #define NUMBER(arr) (sizeof(arr) / sizeof(arr[0])) ! 360: #define MIN(a,b) (((a) < (b)) ? (a) : (b)) ! 361: #define MAX(a,b) (((a) > (b)) ? (a) : (b)) ! 362: #define ALL_TARGETS -1 ! 363: #define ALL_CHANNELS -1 ! 364: #define ALL_LUNS -1 ! 365: #define MAX_TARGETS 16 ! 366: #define MAX_LUNS 8 ! 367: #ifndef TRUE ! 368: # define TRUE 1 ! 369: #endif ! 370: #ifndef FALSE ! 371: # define FALSE 0 ! 372: #endif ! 373: ! 374: #ifndef KERNEL_VERSION ! 375: # define KERNEL_VERSION(x,y,z) (((x)<<16)+((y)<<8)+(z)) ! 376: #endif ! 377: ! 378: /* ! 379: * We need the bios32.h file if we are kernel version 2.1.92 or less. The ! 380: * full set of pci_* changes wasn't in place until 2.1.93 ! 381: */ ! 382: ! 383: #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,1,92) ! 384: # if defined(__sparc_v9__) || defined(__powerpc__) ! 385: # error "PPC and Sparc platforms are only support under 2.1.92 and above" ! 386: # endif ! 387: # include <linux/bios32.h> ! 388: #endif ! 389: ! 390: #if defined(__powerpc__) ! 391: # define MMAPIO ! 392: # ifdef mb ! 393: # undef mb ! 394: # endif ! 395: # define mb() \ ! 396: __asm__ __volatile__("eieio" ::: "memory") ! 397: #elif defined(__i386__) ! 398: # define MMAPIO ! 399: # ifdef mb ! 400: # undef mb ! 401: # endif ! 402: # define mb() \ ! 403: __asm__ __volatile__("lock ; addl $0,0(%%esp)": : :"memory") ! 404: #elif defined(__alpha__) ! 405: # ifdef mb ! 406: # undef mb ! 407: # endif ! 408: # define mb() \ ! 409: __asm__ __volatile__("mb": : :"memory") ! 410: #endif ! 411: ! 412: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,0) ! 413: # include <asm/spinlock.h> ! 414: # include <linux/smp.h> ! 415: # define cpuid smp_processor_id() ! 416: # if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 417: # define DRIVER_LOCK_INIT \ ! 418: spin_lock_init(&p->spin_lock); ! 419: # define DRIVER_LOCK \ ! 420: if(!p->cpu_lock_count[cpuid]) { \ ! 421: spin_lock_irqsave(&p->spin_lock, cpu_flags); \ ! 422: p->cpu_lock_count[cpuid]++; \ ! 423: } else { \ ! 424: p->cpu_lock_count[cpuid]++; \ ! 425: } ! 426: # define DRIVER_UNLOCK \ ! 427: if(--p->cpu_lock_count[cpuid] == 0) \ ! 428: spin_unlock_irqrestore(&p->spin_lock, cpu_flags); ! 429: # else ! 430: # define DRIVER_LOCK_INIT ! 431: # define DRIVER_LOCK ! 432: # define DRIVER_UNLOCK ! 433: # endif ! 434: #else ! 435: # define cpuid 0 ! 436: # define DRIVER_LOCK_INIT ! 437: # define DRIVER_LOCK \ ! 438: save_flags(cpu_flags); \ ! 439: cli(); ! 440: # define DRIVER_UNLOCK \ ! 441: restore_flags(cpu_flags); ! 442: # define le32_to_cpu(x) (x) ! 443: # define cpu_to_le32(x) (x) ! 444: #endif ! 445: ! 446: /* ! 447: * You can try raising me if tagged queueing is enabled, or lowering ! 448: * me if you only have 4 SCBs. ! 449: */ ! 450: #ifdef CONFIG_AIC7XXX_CMDS_PER_LUN ! 451: #define AIC7XXX_CMDS_PER_LUN CONFIG_AIC7XXX_CMDS_PER_LUN ! 452: #endif ! 453: ! 454: /* Set this to the delay in seconds after SCSI bus reset. */ ! 455: #ifdef CONFIG_AIC7XXX_RESET_DELAY ! 456: #define AIC7XXX_RESET_DELAY CONFIG_AIC7XXX_RESET_DELAY ! 457: #else ! 458: #define AIC7XXX_RESET_DELAY 5 ! 459: #endif ! 460: ! 461: /* ! 462: * Control collection of SCSI transfer statistics for the /proc filesystem. ! 463: * ! 464: * NOTE: Do NOT enable this when running on kernels version 1.2.x and below. ! 465: * NOTE: This does affect performance since it has to maintain statistics. ! 466: */ ! 467: #ifdef CONFIG_AIC7XXX_PROC_STATS ! 468: #define AIC7XXX_PROC_STATS ! 469: #endif ! 470: ! 471: /* ! 472: * NOTE: Uncommenting the define below no longer has any effect, the ! 473: * tagged queue value array is always active now. I've added ! 474: * a setup option to set this particular array and I'm hoping ! 475: * insmod will be smart enough to set it properly as well. It's ! 476: * by use of this array that a person can enable tagged queueing. ! 477: * The DEFAULT_TAG_COMMANDS define has been changed to disable ! 478: * tagged queueing by default, so if your devices can handle tagged ! 479: * queueing you will need to add a line to their lilo.conf file like: ! 480: * append="aic7xxx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}" ! 481: * which will result in the first four devices on the first two ! 482: * controllers being set to a tagged queue depth of 32. ! 483: * ! 484: * Set this for defining the number of tagged commands on a device ! 485: * by device, and controller by controller basis. The first set ! 486: * of tagged commands will be used for the first detected aic7xxx ! 487: * controller, the second set will be used for the second detected ! 488: * aic7xxx controller, and so on. These values will *only* be used ! 489: * for targets that are tagged queueing capable; these values will ! 490: * be ignored in all other cases. The tag_commands is an array of ! 491: * 16 to allow for wide and twin adapters. Twin adapters will use ! 492: * indexes 0-7 for channel 0, and indexes 8-15 for channel 1. ! 493: * ! 494: * *** Determining commands per LUN *** ! 495: * ! 496: * When AIC7XXX_CMDS_PER_LUN is not defined, the driver will use its ! 497: * own algorithm to determine the commands/LUN. If SCB paging is ! 498: * enabled, which is always now, the default is 8 commands per lun ! 499: * that indicates it supports tagged queueing. All non-tagged devices ! 500: * use an internal queue depth of 3, with no more than one of those ! 501: * three commands active at one time. ! 502: */ ! 503: /* #define AIC7XXX_TAGGED_QUEUEING_BY_DEVICE */ ! 504: ! 505: typedef struct ! 506: { ! 507: unsigned char tag_commands[16]; /* Allow for wide/twin adapters. */ ! 508: } adapter_tag_info_t; ! 509: ! 510: /* ! 511: * Make a define that will tell the driver not to use tagged queueing ! 512: * by default. ! 513: */ ! 514: #define DEFAULT_TAG_COMMANDS {255, 255, 255, 255, 255, 255, 255, 255,\ ! 515: 255, 255, 255, 255, 255, 255, 255, 255} ! 516: ! 517: /* ! 518: * Modify this as you see fit for your system. By setting tag_commands ! 519: * to 0, the driver will use it's own algorithm for determining the ! 520: * number of commands to use (see above). When 255, the driver will ! 521: * not enable tagged queueing for that particular device. When positive ! 522: * (> 0) and (< 255) the values in the array are used for the queue_depth. ! 523: * Note that the maximum value for an entry is 254, but you're insane if ! 524: * you try to use that many commands on one device. ! 525: * ! 526: * In this example, the first line will disable tagged queueing for all ! 527: * the devices on the first probed aic7xxx adapter. ! 528: * ! 529: * The second line enables tagged queueing with 4 commands/LUN for IDs ! 530: * (1, 2-11, 13-15), disables tagged queueing for ID 12, and tells the ! 531: * driver to use its own algorithm for ID 1. ! 532: * ! 533: * The third line is the same as the first line. ! 534: * ! 535: * The fourth line disables tagged queueing for devices 0 and 3. It ! 536: * enables tagged queueing for the other IDs, with 16 commands/LUN ! 537: * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for ! 538: * IDs 2, 5-7, and 9-15. ! 539: */ ! 540: ! 541: /* ! 542: * NOTE: The below structure is for reference only, the actual structure ! 543: * to modify in order to change things is located around line ! 544: * number 1305 ! 545: adapter_tag_info_t aic7xxx_tag_info[] = ! 546: { ! 547: {DEFAULT_TAG_COMMANDS}, ! 548: {{4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 255, 4, 4, 4}}, ! 549: {DEFAULT_TAG_COMMANDS}, ! 550: {{255, 16, 4, 255, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}} ! 551: }; ! 552: */ ! 553: ! 554: /* ! 555: * Define an array of board names that can be indexed by aha_type. ! 556: * Don't forget to change this when changing the types! ! 557: */ ! 558: static const char *board_names[] = { ! 559: "AIC-7xxx Unknown", /* AIC_NONE */ ! 560: "Adaptec AIC-7810 Hardware RAID Controller", /* AIC_7810 */ ! 561: "Adaptec AIC-7770 SCSI host adapter", /* AIC_7770 */ ! 562: "Adaptec AHA-274X SCSI host adapter", /* AIC_7771 */ ! 563: "Adaptec AHA-284X SCSI host adapter", /* AIC_284x */ ! 564: "Adaptec AIC-7850 SCSI host adapter", /* AIC_7850 */ ! 565: "Adaptec AIC-7855 SCSI host adapter", /* AIC_7855 */ ! 566: "Adaptec AIC-7860 Ultra SCSI host adapter", /* AIC_7860 */ ! 567: "Adaptec AHA-2940A Ultra SCSI host adapter", /* AIC_7861 */ ! 568: "Adaptec AIC-7870 SCSI host adapter", /* AIC_7870 */ ! 569: "Adaptec AHA-294X SCSI host adapter", /* AIC_7871 */ ! 570: "Adaptec AHA-394X SCSI host adapter", /* AIC_7872 */ ! 571: "Adaptec AHA-398X SCSI host adapter", /* AIC_7873 */ ! 572: "Adaptec AHA-2944 SCSI host adapter", /* AIC_7874 */ ! 573: "Adaptec AIC-7880 Ultra SCSI host adapter", /* AIC_7880 */ ! 574: "Adaptec AHA-294X Ultra SCSI host adapter", /* AIC_7881 */ ! 575: "Adaptec AHA-394X Ultra SCSI host adapter", /* AIC_7882 */ ! 576: "Adaptec AHA-398X Ultra SCSI host adapter", /* AIC_7883 */ ! 577: "Adaptec AHA-2944 Ultra SCSI host adapter", /* AIC_7884 */ ! 578: "Adaptec AIC-7895 Ultra SCSI host adapter", /* AIC_7895 */ ! 579: "Adaptec AIC-7890/1 Ultra2 SCSI host adapter", /* AIC_7890 */ ! 580: "Adaptec AHA-294X Ultra2 SCSI host adapter", /* AIC_7890 */ ! 581: "Adaptec AIC-7896/7 Ultra2 SCSI host adapter", /* AIC_7896 */ ! 582: "Adaptec AHA-394X Ultra2 SCSI host adapter" /* AIC_7897 */ ! 583: }; ! 584: ! 585: /* ! 586: * There should be a specific return value for this in scsi.h, but ! 587: * it seems that most drivers ignore it. ! 588: */ ! 589: #define DID_UNDERFLOW DID_ERROR ! 590: ! 591: /* ! 592: * What we want to do is have the higher level scsi driver requeue ! 593: * the command to us. There is no specific driver status for this ! 594: * condition, but the higher level scsi driver will requeue the ! 595: * command on a DID_BUS_BUSY error. ! 596: * ! 597: * Upon further inspection and testing, it seems that DID_BUS_BUSY ! 598: * will *always* retry the command. We can get into an infinite loop ! 599: * if this happens when we really want some sort of counter that ! 600: * will automatically abort/reset the command after so many retries. ! 601: * Using DID_ERROR will do just that. (Made by a suggestion by ! 602: * Doug Ledford 8/1/96) ! 603: */ ! 604: #define DID_RETRY_COMMAND DID_ERROR ! 605: ! 606: #define HSCSIID 0x07 ! 607: #define SCSI_RESET 0x040 ! 608: ! 609: /* ! 610: * EISA/VL-bus stuff ! 611: */ ! 612: #define MINSLOT 1 ! 613: #define MAXSLOT 15 ! 614: #define SLOTBASE(x) ((x) << 12) ! 615: #define BASE_TO_SLOT(x) ((x) >> 12) ! 616: ! 617: /* ! 618: * Standard EISA Host ID regs (Offset from slot base) ! 619: */ ! 620: #define AHC_HID0 0x80 /* 0,1: msb of ID2, 2-7: ID1 */ ! 621: #define AHC_HID1 0x81 /* 0-4: ID3, 5-7: LSB ID2 */ ! 622: #define AHC_HID2 0x82 /* product */ ! 623: #define AHC_HID3 0x83 /* firmware revision */ ! 624: ! 625: /* ! 626: * AIC-7770 I/O range to reserve for a card ! 627: */ ! 628: #define MINREG 0xC00 ! 629: #define MAXREG 0xCBF ! 630: ! 631: #define INTDEF 0x5C /* Interrupt Definition Register */ ! 632: ! 633: /* ! 634: * AIC-78X0 PCI registers ! 635: */ ! 636: #define CLASS_PROGIF_REVID 0x08 ! 637: #define DEVREVID 0x000000FFul ! 638: #define PROGINFC 0x0000FF00ul ! 639: #define SUBCLASS 0x00FF0000ul ! 640: #define BASECLASS 0xFF000000ul ! 641: ! 642: #define CSIZE_LATTIME 0x0C ! 643: #define CACHESIZE 0x0000003Ful /* only 5 bits */ ! 644: #define LATTIME 0x0000FF00ul ! 645: ! 646: #define DEVCONFIG 0x40 ! 647: #define SCBSIZE32 0x00010000ul /* aic789X only */ ! 648: #define MPORTMODE 0x00000400ul /* aic7870 only */ ! 649: #define RAMPSM 0x00000200ul /* aic7870 only */ ! 650: #define RAMPSM_ULTRA2 0x00000004 ! 651: #define VOLSENSE 0x00000100ul ! 652: #define SCBRAMSEL 0x00000080ul ! 653: #define SCBRAMSEL_ULTRA2 0x00000008 ! 654: #define MRDCEN 0x00000040ul ! 655: #define EXTSCBTIME 0x00000020ul /* aic7870 only */ ! 656: #define EXTSCBPEN 0x00000010ul /* aic7870 only */ ! 657: #define BERREN 0x00000008ul ! 658: #define DACEN 0x00000004ul ! 659: #define STPWLEVEL 0x00000002ul ! 660: #define DIFACTNEGEN 0x00000001ul /* aic7870 only */ ! 661: ! 662: #define SCAMCTL 0x1a /* Ultra2 only */ ! 663: #define CCSCBBADDR 0xf0 /* aic7895/6/7 */ ! 664: ! 665: /* ! 666: * Define the different types of SEEPROMs on aic7xxx adapters ! 667: * and make it also represent the address size used in accessing ! 668: * its registers. The 93C46 chips have 1024 bits organized into ! 669: * 64 16-bit words, while the 93C56 chips have 2048 bits organized ! 670: * into 128 16-bit words. The C46 chips use 6 bits to address ! 671: * each word, while the C56 and C66 (4096 bits) use 8 bits to ! 672: * address each word. ! 673: */ ! 674: typedef enum {C46 = 6, C56_66 = 8} seeprom_chip_type; ! 675: ! 676: /* ! 677: * ! 678: * Define the format of the SEEPROM registers (16 bits). ! 679: * ! 680: */ ! 681: struct seeprom_config { ! 682: ! 683: /* ! 684: * SCSI ID Configuration Flags ! 685: */ ! 686: #define CFXFER 0x0007 /* synchronous transfer rate */ ! 687: #define CFSYNCH 0x0008 /* enable synchronous transfer */ ! 688: #define CFDISC 0x0010 /* enable disconnection */ ! 689: #define CFWIDEB 0x0020 /* wide bus device (wide card) */ ! 690: #define CFSYNCHISULTRA 0x0040 /* CFSYNC is an ultra offset */ ! 691: #define CFNEWULTRAFORMAT 0x0080 /* Use the Ultra2 SEEPROM format */ ! 692: #define CFSTART 0x0100 /* send start unit SCSI command */ ! 693: #define CFINCBIOS 0x0200 /* include in BIOS scan */ ! 694: #define CFRNFOUND 0x0400 /* report even if not found */ ! 695: #define CFMULTILUN 0x0800 /* probe mult luns in BIOS scan */ ! 696: #define CFWBCACHEYES 0x4000 /* Enable W-Behind Cache on drive */ ! 697: #define CFWBCACHENC 0xc000 /* Don't change W-Behind Cache */ ! 698: /* UNUSED 0x3000 */ ! 699: unsigned short device_flags[16]; /* words 0-15 */ ! 700: ! 701: /* ! 702: * BIOS Control Bits ! 703: */ ! 704: #define CFSUPREM 0x0001 /* support all removable drives */ ! 705: #define CFSUPREMB 0x0002 /* support removable drives for boot only */ ! 706: #define CFBIOSEN 0x0004 /* BIOS enabled */ ! 707: /* UNUSED 0x0008 */ ! 708: #define CFSM2DRV 0x0010 /* support more than two drives */ ! 709: #define CF284XEXTEND 0x0020 /* extended translation (284x cards) */ ! 710: /* UNUSED 0x0040 */ ! 711: #define CFEXTEND 0x0080 /* extended translation enabled */ ! 712: /* UNUSED 0xFF00 */ ! 713: unsigned short bios_control; /* word 16 */ ! 714: ! 715: /* ! 716: * Host Adapter Control Bits ! 717: */ ! 718: #define CFAUTOTERM 0x0001 /* Perform Auto termination */ ! 719: #define CFULTRAEN 0x0002 /* Ultra SCSI speed enable (Ultra cards) */ ! 720: #define CF284XSELTO 0x0003 /* Selection timeout (284x cards) */ ! 721: #define CF284XFIFO 0x000C /* FIFO Threshold (284x cards) */ ! 722: #define CFSTERM 0x0004 /* SCSI low byte termination */ ! 723: #define CFWSTERM 0x0008 /* SCSI high byte termination (wide card) */ ! 724: #define CFSPARITY 0x0010 /* SCSI parity */ ! 725: #define CF284XSTERM 0x0020 /* SCSI low byte termination (284x cards) */ ! 726: #define CFRESETB 0x0040 /* reset SCSI bus at boot */ ! 727: #define CFBPRIMARY 0x0100 /* Channel B primary on 7895 chipsets */ ! 728: #define CFSEAUTOTERM 0x0400 /* aic7890 Perform SE Auto Term */ ! 729: #define CFLVDSTERM 0x0800 /* aic7890 LVD Termination */ ! 730: /* UNUSED 0xF280 */ ! 731: unsigned short adapter_control; /* word 17 */ ! 732: ! 733: /* ! 734: * Bus Release, Host Adapter ID ! 735: */ ! 736: #define CFSCSIID 0x000F /* host adapter SCSI ID */ ! 737: /* UNUSED 0x00F0 */ ! 738: #define CFBRTIME 0xFF00 /* bus release time */ ! 739: unsigned short brtime_id; /* word 18 */ ! 740: ! 741: /* ! 742: * Maximum targets ! 743: */ ! 744: #define CFMAXTARG 0x00FF /* maximum targets */ ! 745: /* UNUSED 0xFF00 */ ! 746: unsigned short max_targets; /* word 19 */ ! 747: ! 748: unsigned short res_1[11]; /* words 20-30 */ ! 749: unsigned short checksum; /* word 31 */ ! 750: }; ! 751: ! 752: #define SELBUS_MASK 0x0a ! 753: #define SELNARROW 0x00 ! 754: #define SELBUSB 0x08 ! 755: #define SINGLE_BUS 0x00 ! 756: ! 757: #define SCB_TARGET(scb) \ ! 758: (((scb)->hscb->target_channel_lun & TID) >> 4) ! 759: #define SCB_LUN(scb) \ ! 760: ((scb)->hscb->target_channel_lun & LID) ! 761: #define SCB_IS_SCSIBUS_B(scb) \ ! 762: (((scb)->hscb->target_channel_lun & SELBUSB) != 0) ! 763: ! 764: /* ! 765: * If an error occurs during a data transfer phase, run the command ! 766: * to completion - it's easier that way - making a note of the error ! 767: * condition in this location. This then will modify a DID_OK status ! 768: * into an appropriate error for the higher-level SCSI code. ! 769: */ ! 770: #define aic7xxx_error(cmd) ((cmd)->SCp.Status) ! 771: ! 772: /* ! 773: * Keep track of the targets returned status. ! 774: */ ! 775: #define aic7xxx_status(cmd) ((cmd)->SCp.sent_command) ! 776: ! 777: /* ! 778: * The position of the SCSI commands scb within the scb array. ! 779: */ ! 780: #define aic7xxx_position(cmd) ((cmd)->SCp.have_data_in) ! 781: ! 782: /* ! 783: * So we can keep track of our host structs ! 784: */ ! 785: static struct aic7xxx_host *first_aic7xxx = NULL; ! 786: ! 787: /* ! 788: * As of Linux 2.1, the mid-level SCSI code uses virtual addresses ! 789: * in the scatter-gather lists. We need to convert the virtual ! 790: * addresses to physical addresses. ! 791: */ ! 792: struct hw_scatterlist { ! 793: unsigned int address; ! 794: unsigned int length; ! 795: }; ! 796: ! 797: /* ! 798: * Maximum number of SG segments these cards can support. ! 799: */ ! 800: #define AIC7XXX_MAX_SG 128 ! 801: ! 802: /* ! 803: * The maximum number of SCBs we could have for ANY type ! 804: * of card. DON'T FORGET TO CHANGE THE SCB MASK IN THE ! 805: * SEQUENCER CODE IF THIS IS MODIFIED! ! 806: */ ! 807: #define AIC7XXX_MAXSCB 255 ! 808: ! 809: ! 810: struct aic7xxx_hwscb { ! 811: /* ------------ Begin hardware supported fields ---------------- */ ! 812: /* 0*/ unsigned char control; ! 813: /* 1*/ unsigned char target_channel_lun; /* 4/1/3 bits */ ! 814: /* 2*/ unsigned char target_status; ! 815: /* 3*/ unsigned char SG_segment_count; ! 816: /* 4*/ unsigned int SG_list_pointer; ! 817: /* 8*/ unsigned char residual_SG_segment_count; ! 818: /* 9*/ unsigned char residual_data_count[3]; ! 819: /*12*/ unsigned int data_pointer; ! 820: /*16*/ unsigned int data_count; ! 821: /*20*/ unsigned int SCSI_cmd_pointer; ! 822: /*24*/ unsigned char SCSI_cmd_length; ! 823: /*25*/ unsigned char tag; /* Index into our kernel SCB array. ! 824: * Also used as the tag for tagged I/O ! 825: */ ! 826: #define SCB_PIO_TRANSFER_SIZE 26 /* amount we need to upload/download ! 827: * via PIO to initialize a transaction. ! 828: */ ! 829: /*26*/ unsigned char next; /* Used to thread SCBs awaiting selection ! 830: * or disconnected down in the sequencer. ! 831: */ ! 832: /*27*/ unsigned char prev; ! 833: /*28*/ unsigned int pad; /* ! 834: * Unused by the kernel, but we require ! 835: * the padding so that the array of ! 836: * hardware SCBs is alligned on 32 byte ! 837: * boundaries so the sequencer can index ! 838: */ ! 839: }; ! 840: ! 841: typedef enum { ! 842: SCB_FREE = 0x0000, ! 843: SCB_WAITINGQ = 0x0002, ! 844: SCB_ACTIVE = 0x0004, ! 845: SCB_SENSE = 0x0008, ! 846: SCB_ABORT = 0x0010, ! 847: SCB_DEVICE_RESET = 0x0020, ! 848: SCB_RESET = 0x0040, ! 849: SCB_RECOVERY_SCB = 0x0080, ! 850: SCB_WAS_BUSY = 0x0100, ! 851: SCB_MSGOUT_SENT = 0x0200, ! 852: SCB_MSGOUT_SDTR = 0x0400, ! 853: SCB_MSGOUT_WDTR = 0x0800, ! 854: SCB_MSGOUT_BITS = SCB_MSGOUT_SENT | ! 855: SCB_MSGOUT_SDTR | ! 856: SCB_MSGOUT_WDTR, ! 857: SCB_QUEUED_ABORT = 0x1000, ! 858: SCB_QUEUED_FOR_DONE = 0x2000 ! 859: } scb_flag_type; ! 860: ! 861: typedef enum { ! 862: AHC_FNONE = 0x00000000, ! 863: AHC_PAGESCBS = 0x00000001, ! 864: AHC_CHANNEL_B_PRIMARY = 0x00000002, ! 865: AHC_USEDEFAULTS = 0x00000004, ! 866: AHC_INDIRECT_PAGING = 0x00000008, ! 867: AHC_CHNLB = 0x00000020, ! 868: AHC_CHNLC = 0x00000040, ! 869: AHC_EXTEND_TRANS_A = 0x00000100, ! 870: AHC_EXTEND_TRANS_B = 0x00000200, ! 871: AHC_TERM_ENB_A = 0x00000400, ! 872: AHC_TERM_ENB_SE_LOW = 0x00000400, ! 873: AHC_TERM_ENB_B = 0x00000800, ! 874: AHC_TERM_ENB_SE_HIGH = 0x00000800, ! 875: AHC_HANDLING_REQINITS = 0x00001000, ! 876: AHC_TARGETMODE = 0x00002000, ! 877: AHC_NEWEEPROM_FMT = 0x00004000, ! 878: /* ! 879: * Here ends the FreeBSD defined flags and here begins the linux defined ! 880: * flags. NOTE: I did not preserve the old flag name during this change ! 881: * specifically to force me to evaluate what flags were being used properly ! 882: * and what flags weren't. This way, I could clean up the flag usage on ! 883: * a use by use basis. Doug Ledford ! 884: */ ! 885: AHC_A_SCANNED = 0x00100000, ! 886: AHC_B_SCANNED = 0x00200000, ! 887: AHC_MULTI_CHANNEL = 0x00400000, ! 888: AHC_BIOS_ENABLED = 0x00800000, ! 889: AHC_SEEPROM_FOUND = 0x01000000, ! 890: AHC_TERM_ENB_LVD = 0x02000000, ! 891: AHC_ABORT_PENDING = 0x04000000, ! 892: AHC_RESET_PENDING = 0x08000000, ! 893: #define AHC_IN_ISR_BIT 28 ! 894: AHC_IN_ISR = 0x10000000, ! 895: AHC_IN_ABORT = 0x20000000, ! 896: AHC_IN_RESET = 0x40000000, ! 897: AHC_EXTERNAL_SRAM = 0x80000000 ! 898: } ahc_flag_type; ! 899: ! 900: typedef enum { ! 901: AHC_NONE = 0x0000, ! 902: AHC_CHIPID_MASK = 0x00ff, ! 903: AHC_AIC7770 = 0x0001, ! 904: AHC_AIC7850 = 0x0002, ! 905: AHC_AIC7860 = 0x0003, ! 906: AHC_AIC7870 = 0x0004, ! 907: AHC_AIC7880 = 0x0005, ! 908: AHC_AIC7890 = 0x0006, ! 909: AHC_AIC7895 = 0x0007, ! 910: AHC_AIC7896 = 0x0008, ! 911: AHC_VL = 0x0100, ! 912: AHC_EISA = 0x0200, ! 913: AHC_PCI = 0x0400, ! 914: } ahc_chip; ! 915: ! 916: typedef enum { ! 917: AHC_FENONE = 0x0000, ! 918: AHC_ULTRA = 0x0001, ! 919: AHC_ULTRA2 = 0x0002, ! 920: AHC_WIDE = 0x0004, ! 921: AHC_TWIN = 0x0008, ! 922: AHC_MORE_SRAM = 0x0010, ! 923: AHC_CMD_CHAN = 0x0020, ! 924: AHC_QUEUE_REGS = 0x0040, ! 925: AHC_SG_PRELOAD = 0x0080, ! 926: AHC_SPIOCAP = 0x0100, ! 927: AHC_AIC7770_FE = AHC_FENONE, ! 928: AHC_AIC7850_FE = AHC_SPIOCAP, ! 929: AHC_AIC7860_FE = AHC_ULTRA|AHC_SPIOCAP, ! 930: AHC_AIC7870_FE = AHC_FENONE, ! 931: AHC_AIC7880_FE = AHC_ULTRA, ! 932: AHC_AIC7890_FE = AHC_MORE_SRAM|AHC_CMD_CHAN|AHC_ULTRA2| ! 933: AHC_QUEUE_REGS|AHC_SG_PRELOAD, ! 934: AHC_AIC7895_FE = AHC_MORE_SRAM|AHC_CMD_CHAN|AHC_ULTRA, ! 935: AHC_AIC7896_FE = AHC_AIC7890_FE, ! 936: } ahc_feature; ! 937: ! 938: struct aic7xxx_scb { ! 939: struct aic7xxx_hwscb *hscb; /* corresponding hardware scb */ ! 940: Scsi_Cmnd *cmd; /* Scsi_Cmnd for this scb */ ! 941: struct aic7xxx_scb *q_next; /* next scb in queue */ ! 942: volatile scb_flag_type flags; /* current state of scb */ ! 943: struct hw_scatterlist *sg_list; /* SG list in adapter format */ ! 944: void *kmalloc_ptr; ! 945: unsigned char tag_action; ! 946: unsigned char sg_count; ! 947: unsigned char sense_cmd[6]; /* ! 948: * Allocate 6 characters for ! 949: * sense command. ! 950: */ ! 951: unsigned int sg_length; /* We init this during buildscb so we ! 952: * don't have to calculate anything ! 953: * during underflow/overflow/stat code ! 954: */ ! 955: }; ! 956: ! 957: /* ! 958: * Define a linked list of SCBs. ! 959: */ ! 960: typedef struct { ! 961: struct aic7xxx_scb *head; ! 962: struct aic7xxx_scb *tail; ! 963: } scb_queue_type; ! 964: ! 965: static struct { ! 966: unsigned char errno; ! 967: const char *errmesg; ! 968: } hard_error[] = { ! 969: { ILLHADDR, "Illegal Host Access" }, ! 970: { ILLSADDR, "Illegal Sequencer Address referenced" }, ! 971: { ILLOPCODE, "Illegal Opcode in sequencer program" }, ! 972: { SQPARERR, "Sequencer Ram Parity Error" }, ! 973: { DPARERR, "Data-Path Ram Parity Error" }, ! 974: { MPARERR, "Scratch Ram/SCB Array Ram Parity Error" }, ! 975: { PCIERRSTAT,"PCI Error detected" }, ! 976: { CIOPARERR, "CIOBUS Parity Error" } ! 977: }; ! 978: ! 979: static unsigned char ! 980: generic_sense[] = { REQUEST_SENSE, 0, 0, 0, 255, 0 }; ! 981: ! 982: typedef struct { ! 983: scb_queue_type free_scbs; /* ! 984: * SCBs assigned to free slot on ! 985: * card (no paging required) ! 986: */ ! 987: struct aic7xxx_scb *scb_array[AIC7XXX_MAXSCB]; ! 988: struct aic7xxx_hwscb *hscbs; ! 989: unsigned char numscbs; /* current number of scbs */ ! 990: unsigned char maxhscbs; /* hardware scbs */ ! 991: unsigned char maxscbs; /* max scbs including pageable scbs */ ! 992: void *hscb_kmalloc_ptr; ! 993: } scb_data_type; ! 994: ! 995: struct target_cmd { ! 996: unsigned char mesg_bytes[4]; ! 997: unsigned char command[28]; ! 998: }; ! 999: ! 1000: #define AHC_TRANS_CUR 0x0001 ! 1001: #define AHC_TRANS_ACTIVE 0x0002 ! 1002: #define AHC_TRANS_GOAL 0x0004 ! 1003: #define AHC_TRANS_USER 0x0008 ! 1004: #define AHC_TRANS_QUITE 0x0010 ! 1005: typedef struct { ! 1006: unsigned char cur_width; ! 1007: unsigned char goal_width; ! 1008: unsigned char cur_period; ! 1009: unsigned char goal_period; ! 1010: unsigned char cur_offset; ! 1011: unsigned char goal_offset; ! 1012: unsigned char user_width; ! 1013: unsigned char user_period; ! 1014: unsigned char user_offset; ! 1015: } transinfo_type; ! 1016: ! 1017: /* ! 1018: * Define a structure used for each host adapter. Note, in order to avoid ! 1019: * problems with architectures I can't test on (because I don't have one, ! 1020: * such as the Alpha based systems) which happen to give faults for ! 1021: * non-aligned memory accesses, care was taken to align this structure ! 1022: * in a way that gauranteed all accesses larger than 8 bits were aligned ! 1023: * on the appropriate boundary. It's also organized to try and be more ! 1024: * cache line efficient. Be careful when changing this lest you might hurt ! 1025: * overall performance and bring down the wrath of the masses. ! 1026: */ ! 1027: struct aic7xxx_host { ! 1028: /* ! 1029: * This is the first 64 bytes in the host struct ! 1030: */ ! 1031: ! 1032: struct Scsi_Host *host; /* pointer to scsi host */ ! 1033: struct aic7xxx_host *next; /* allow for multiple IRQs */ ! 1034: int host_no; /* SCSI host number */ ! 1035: unsigned long base; /* card base address */ ! 1036: volatile unsigned char *maddr; /* memory mapped address */ ! 1037: unsigned long mbase; /* I/O memory address */ ! 1038: volatile ahc_flag_type flags; ! 1039: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,0) ! 1040: spinlock_t spin_lock; ! 1041: #endif ! 1042: volatile unsigned char cpu_lock_count[NR_CPUS]; ! 1043: ahc_chip chip; /* chip type */ ! 1044: ahc_feature features; /* chip features */ ! 1045: unsigned long last_reset; ! 1046: unsigned long isr_count; /* Interrupt count */ ! 1047: unsigned long spurious_int; ! 1048: struct target_cmd *targetcmds; ! 1049: unsigned int num_targetcmds; ! 1050: unsigned short discenable; /* Targets allowed to disconnect */ ! 1051: unsigned short tagenable; /* Targets using tagged I/O */ ! 1052: unsigned short orderedtag; /* Ordered Q tags allowed */ ! 1053: volatile unsigned char activescbs; /* active scbs */ ! 1054: volatile unsigned char max_activescbs; ! 1055: unsigned char unpause; /* unpause value for HCNTRL */ ! 1056: unsigned char pause; /* pause value for HCNTRL */ ! 1057: volatile unsigned char qoutfifonext; ! 1058: volatile unsigned char qinfifonext; ! 1059: ! 1060: /* ! 1061: * MAX_TARGETS is currently == 16, so that makes these entries the next ! 1062: * 64 bytes ! 1063: */ ! 1064: ! 1065: #define DEVICE_PRESENT 0x01 ! 1066: #define BUS_DEVICE_RESET_PENDING 0x02 ! 1067: #define DEVICE_TIMEOUT 0x04 ! 1068: #define DEVICE_PRINT_SDTR 0x08 ! 1069: #define DEVICE_PRINT_WDTR 0x10 ! 1070: #define DEVICE_SUCCESS 0x20 ! 1071: #define DEVICE_TAGGED_SUCCESS 0x40 ! 1072: #define DEVICE_SCANNED 0x80 ! 1073: volatile unsigned char dev_flags[MAX_TARGETS]; ! 1074: volatile unsigned char dev_active_cmds[MAX_TARGETS]; ! 1075: volatile unsigned char dev_temp_queue_depth[MAX_TARGETS]; ! 1076: unsigned char dev_commands_sent[MAX_TARGETS]; ! 1077: ! 1078: /* ! 1079: * The next 128 (or 256 on 64 bit machines).... ! 1080: */ ! 1081: Scsi_Cmnd *dev_wdtr_cmnd[MAX_TARGETS]; ! 1082: Scsi_Cmnd *dev_sdtr_cmnd[MAX_TARGETS]; ! 1083: ! 1084: /* ! 1085: * The next 64.... ! 1086: */ ! 1087: ! 1088: long dev_last_reset[MAX_TARGETS]; ! 1089: ! 1090: /* ! 1091: * The next 64.... ! 1092: */ ! 1093: ! 1094: unsigned char dev_mid_level_queue_depth[MAX_TARGETS]; ! 1095: unsigned char dev_last_queue_full[MAX_TARGETS]; ! 1096: unsigned char dev_last_queue_full_count[MAX_TARGETS]; ! 1097: unsigned char dev_max_queue_depth[MAX_TARGETS]; ! 1098: ! 1099: /* ! 1100: * The next 128.... ! 1101: */ ! 1102: ! 1103: volatile scb_queue_type delayed_scbs[MAX_TARGETS]; ! 1104: ! 1105: /* ! 1106: * ! 1107: */ ! 1108: ! 1109: struct timer_list dev_timer[MAX_TARGETS]; ! 1110: ! 1111: /* ! 1112: * The next 64.... ! 1113: */ ! 1114: ! 1115: unsigned char msg_buf[9]; /* The message for the target */ ! 1116: unsigned char msg_type; ! 1117: #define MSG_TYPE_NONE 0x00 ! 1118: #define MSG_TYPE_INITIATOR_MSGOUT 0x01 ! 1119: #define MSG_TYPE_INITIATOR_MSGIN 0x02 ! 1120: unsigned char msg_len; /* Length of message */ ! 1121: unsigned char msg_index; /* Index into msg_buf array */ ! 1122: transinfo_type transinfo[MAX_TARGETS]; ! 1123: volatile scb_queue_type waiting_scbs; /* ! 1124: * SCBs waiting for space in ! 1125: * the QINFIFO. ! 1126: */ ! 1127: scb_data_type *scb_data; ! 1128: ! 1129: struct aic7xxx_cmd_queue { ! 1130: Scsi_Cmnd *head; ! 1131: Scsi_Cmnd *tail; ! 1132: } completeq; ! 1133: ! 1134: ! 1135: /* ! 1136: * We put the less frequently used host structure items after the more ! 1137: * frequently used items to try and ease the burden on the cache subsystem. ! 1138: * These entries are not *commonly* accessed, whereas the preceding entries ! 1139: * are accessed very often. The only exceptions are the qinfifo, qoutfifo, ! 1140: * and untagged_scbs array. But, they are often accessed only once and each ! 1141: * access into these arrays is likely to blow a cache line, so they are put ! 1142: * down here so we can minimize the number of cache lines required to hold ! 1143: * the preceeding entries. ! 1144: */ ! 1145: ! 1146: volatile unsigned char untagged_scbs[256]; ! 1147: volatile unsigned char qoutfifo[256]; ! 1148: volatile unsigned char qinfifo[256]; ! 1149: unsigned int irq; /* IRQ for this adapter */ ! 1150: volatile unsigned short needsdtr; ! 1151: volatile unsigned short sdtr_pending; ! 1152: volatile unsigned short needwdtr; ! 1153: volatile unsigned short wdtr_pending; ! 1154: int instance; /* aic7xxx instance number */ ! 1155: int scsi_id; /* host adapter SCSI ID */ ! 1156: int scsi_id_b; /* channel B for twin adapters */ ! 1157: unsigned int bios_address; ! 1158: int board_name_index; ! 1159: unsigned long reset_start; ! 1160: unsigned short needsdtr_copy; /* default config */ ! 1161: unsigned short needwdtr_copy; /* default config */ ! 1162: unsigned short ultraenb; /* Ultra mode target list */ ! 1163: unsigned short bios_control; /* bios control - SEEPROM */ ! 1164: unsigned short adapter_control; /* adapter control - SEEPROM */ ! 1165: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 1166: struct pci_dev *pdev; ! 1167: #endif ! 1168: unsigned char pci_bus; ! 1169: unsigned char pci_device_fn; ! 1170: struct seeprom_config sc; ! 1171: unsigned short sc_type; ! 1172: unsigned short sc_size; ! 1173: ! 1174: /* ! 1175: * Statistics Kept: ! 1176: * ! 1177: * Total Xfers (count for each command that has a data xfer), ! 1178: * broken down further by reads && writes. ! 1179: * ! 1180: * Binned sizes, writes && reads: ! 1181: * < 512, 512, 1-2K, 2-4K, 4-8K, 8-16K, 16-32K, 32-64K, 64K-128K, > 128K ! 1182: * ! 1183: * Total amounts read/written above 512 bytes (amts under ignored) ! 1184: * ! 1185: * NOTE: Enabling this feature is likely to cause a noticeable performance ! 1186: * decrease as the accesses into the stats structures blows apart multiple ! 1187: * cache lines and is CPU time consuming. We keep the xfer count always ! 1188: * for use by the aic7xxx_proc.c code, but only do the bins if the ! 1189: * proc stats code is enabled. ! 1190: */ ! 1191: struct aic7xxx_xferstats { ! 1192: long xfers; /* total xfer count */ ! 1193: long w_total; /* total writes */ ! 1194: long w_total512; /* 512 byte blocks written */ ! 1195: long r_total; /* total reads */ ! 1196: long r_total512; /* 512 byte blocks read */ ! 1197: #ifdef AIC7XXX_PROC_STATS ! 1198: long w_bins[10]; /* binned write */ ! 1199: long r_bins[10]; /* binned reads */ ! 1200: #endif /* AIC7XXX_PROC_STATS */ ! 1201: } stats[MAX_TARGETS][MAX_LUNS]; /* [(channel << 3)|target][lun] */ ! 1202: }; ! 1203: ! 1204: /* ! 1205: * Valid SCSIRATE values. (p. 3-17) ! 1206: * Provides a mapping of transfer periods in ns/4 to the proper value to ! 1207: * stick in the SCSIRATE reg to use that transfer rate. ! 1208: */ ! 1209: #define AHC_SYNCRATE_ULTRA2 0 ! 1210: #define AHC_SYNCRATE_ULTRA 2 ! 1211: #define AHC_SYNCRATE_FAST 5 ! 1212: static struct aic7xxx_syncrate { ! 1213: /* Rates in Ultra mode have bit 8 of sxfr set */ ! 1214: #define ULTRA_SXFR 0x100 ! 1215: int sxfr_ultra2; ! 1216: int sxfr; ! 1217: unsigned char period; ! 1218: const char *rate[2]; ! 1219: } aic7xxx_syncrates[] = { ! 1220: { 0x13, 0x000, 10, {"40.0", "80.0"} }, ! 1221: { 0x14, 0x000, 11, {"33.0", "66.6"} }, ! 1222: { 0x15, 0x100, 12, {"20.0", "40.0"} }, ! 1223: { 0x16, 0x110, 15, {"16.0", "32.0"} }, ! 1224: { 0x17, 0x120, 18, {"13.4", "26.8"} }, ! 1225: { 0x18, 0x000, 25, {"10.0", "20.0"} }, ! 1226: { 0x19, 0x010, 31, {"8.0", "16.0"} }, ! 1227: { 0x1a, 0x020, 37, {"6.67", "13.3"} }, ! 1228: { 0x1b, 0x030, 43, {"5.7", "11.4"} }, ! 1229: { 0x10, 0x040, 50, {"5.0", "10.0"} }, ! 1230: { 0x00, 0x050, 56, {"4.4", "8.8" } }, ! 1231: { 0x00, 0x060, 62, {"4.0", "8.0" } }, ! 1232: { 0x00, 0x070, 68, {"3.6", "7.2" } }, ! 1233: { 0x00, 0x000, 0, {NULL, NULL} }, ! 1234: }; ! 1235: ! 1236: #define CTL_OF_SCB(scb) (((scb->hscb)->target_channel_lun >> 3) & 0x1), \ ! 1237: (((scb->hscb)->target_channel_lun >> 4) & 0xf), \ ! 1238: ((scb->hscb)->target_channel_lun & 0x07) ! 1239: ! 1240: #define CTL_OF_CMD(cmd) ((cmd->channel) & 0x01), \ ! 1241: ((cmd->target) & 0x0f), \ ! 1242: ((cmd->lun) & 0x07) ! 1243: ! 1244: #define TARGET_INDEX(cmd) ((cmd)->target | ((cmd)->channel << 3)) ! 1245: ! 1246: /* ! 1247: * A nice little define to make doing our printks a little easier ! 1248: */ ! 1249: ! 1250: #define WARN_LEAD KERN_WARNING "(scsi%d:%d:%d:%d) " ! 1251: #define INFO_LEAD KERN_INFO "(scsi%d:%d:%d:%d) " ! 1252: ! 1253: /* ! 1254: * XXX - these options apply unilaterally to _all_ 274x/284x/294x ! 1255: * cards in the system. This should be fixed. Exceptions to this ! 1256: * rule are noted in the comments. ! 1257: */ ! 1258: ! 1259: ! 1260: /* ! 1261: * Skip the scsi bus reset. Non 0 make us skip the reset at startup. This ! 1262: * has no effect on any later resets that might occur due to things like ! 1263: * SCSI bus timeouts. ! 1264: */ ! 1265: static unsigned int aic7xxx_no_reset = 0; ! 1266: /* ! 1267: * Certain PCI motherboards will scan PCI devices from highest to lowest, ! 1268: * others scan from lowest to highest, and they tend to do all kinds of ! 1269: * strange things when they come into contact with PCI bridge chips. The ! 1270: * net result of all this is that the PCI card that is actually used to boot ! 1271: * the machine is very hard to detect. Most motherboards go from lowest ! 1272: * PCI slot number to highest, and the first SCSI controller found is the ! 1273: * one you boot from. The only exceptions to this are when a controller ! 1274: * has its BIOS disabled. So, we by default sort all of our SCSI controllers ! 1275: * from lowest PCI slot number to highest PCI slot number. We also force ! 1276: * all controllers with their BIOS disabled to the end of the list. This ! 1277: * works on *almost* all computers. Where it doesn't work, we have this ! 1278: * option. Setting this option to non-0 will reverse the order of the sort ! 1279: * to highest first, then lowest, but will still leave cards with their BIOS ! 1280: * disabled at the very end. That should fix everyone up unless there are ! 1281: * really strange cirumstances. ! 1282: */ ! 1283: static int aic7xxx_reverse_scan = 0; ! 1284: /* ! 1285: * This setting enables a hack to fix the IRQ settings on buggy 7895 ! 1286: * MB controller setups: ! 1287: * -1 == Disable this hack ! 1288: * 0 == Use the Channel A IRQ for both channels ! 1289: * 1 == Use the Channel B IRQ for both channels ! 1290: */ ! 1291: static unsigned int aic7xxx_extended = 0; ! 1292: /* ! 1293: * The IRQ trigger method used on EISA controllers. Does not effect PCI cards. ! 1294: * -1 = Use detected settings. ! 1295: * 0 = Force Edge triggered mode. ! 1296: * 1 = Force Level triggered mode. ! 1297: */ ! 1298: static int aic7xxx_irq_trigger = -1; ! 1299: /* ! 1300: * This variable is used to override the termination settings on a controller. ! 1301: * This should not be used under normal conditions. However, in the case ! 1302: * that a controller does not have a readable SEEPROM (so that we can't ! 1303: * read the SEEPROM settings directly) and that a controller has a buggered ! 1304: * version of the cable detection logic, this can be used to force the ! 1305: * correct termination. It is preferable to use the manual termination ! 1306: * settings in the BIOS if possible, but some motherboard controllers store ! 1307: * those settings in a format we can't read. In other cases, auto term ! 1308: * should also work, but the chipset was put together with no auto term ! 1309: * logic (common on motherboard controllers). In those cases, we have ! 1310: * 32 bits here to work with. That's good for 8 controllers/channels. The ! 1311: * bits are organized as 4 bits per channel, with scsi0 getting the lowest ! 1312: * 4 bits in the int. A 1 in a bit position indicates the termination setting ! 1313: * that corresponds to that bit should be enabled, a 0 is disabled. ! 1314: * It looks something like this: ! 1315: * ! 1316: * 0x0f = 1111-Single Ended Low Byte Termination on/off ! 1317: * ||\-Single Ended High Byte Termination on/off ! 1318: * |\-LVD Low Byte Termination on/off ! 1319: * \-LVD High Byte Termination on/off ! 1320: * ! 1321: * For non-Ultra2 controllers, the upper 2 bits are not important. So, to ! 1322: * enable both high byte and low byte termination on scsi0, I would need to ! 1323: * make sure that the override_term variable was set to 0x03 (bits 0011). ! 1324: * To make sure that all termination is enabled on an Ultra2 controller at ! 1325: * scsi2 and only high byte termination on scsi1 and high and low byte ! 1326: * termination on scsi0, I would set override_term=0xf23 (bits 1111 0010 0011) ! 1327: * ! 1328: * For the most part, users should never have to use this, that's why I ! 1329: * left it fairly cryptic instead of easy to understand. If you need it, ! 1330: * most likely someone will be telling you what your's needs to be set to. ! 1331: */ ! 1332: static int aic7xxx_override_term = -1; ! 1333: /* ! 1334: * Certain motherboard chipset controllers tend to screw ! 1335: * up the polarity of the term enable output pin. Use this variable ! 1336: * to force the correct polarity for your system. This is a bitfield variable ! 1337: * similar to the previous one, but this one has one bit per channel instead ! 1338: * of four. ! 1339: * 0 = Force the setting to active low. ! 1340: * 1 = Force setting to active high. ! 1341: * Most Adaptec cards are active high, several motherboards are active low. ! 1342: * To force a 2940 card at SCSI 0 to active high and a motherboard 7895 ! 1343: * controller at scsi1 and scsi2 to active low, and a 2910 card at scsi3 ! 1344: * to active high, you would need to set stpwlev=0x9 (bits 1001). ! 1345: * ! 1346: * People shouldn't need to use this, but if you are experiencing lots of ! 1347: * SCSI timeout problems, this may help. There is one sure way to test what ! 1348: * this option needs to be. Using a boot floppy to boot the system, configure ! 1349: * your system to enable all SCSI termination (in the Adaptec SCSI BIOS) and ! 1350: * if needed then also pass a value to override_term to make sure that the ! 1351: * driver is enabling SCSI termination, then set this variable to either 0 ! 1352: * or 1. When the driver boots, make sure there are *NO* SCSI cables ! 1353: * connected to your controller. If it finds and inits the controller ! 1354: * without problem, then the setting you passed to stpwlev was correct. If ! 1355: * the driver goes into a reset loop and hangs the system, then you need the ! 1356: * other setting for this variable. If neither setting lets the machine ! 1357: * boot then you have definite termination problems that may not be fixable. ! 1358: */ ! 1359: static int aic7xxx_stpwlev = -1; ! 1360: /* ! 1361: * Set this to non-0 in order to force the driver to panic the kernel ! 1362: * and print out debugging info on a SCSI abort or reset cycle. ! 1363: */ ! 1364: static int aic7xxx_panic_on_abort = 0; ! 1365: /* ! 1366: * PCI bus parity checking of the Adaptec controllers. This is somewhat ! 1367: * dubious at best. To my knowledge, this option has never actually ! 1368: * solved a PCI parity problem, but on certain machines with broken PCI ! 1369: * chipset configurations, it can generate tons of false error messages. ! 1370: * It's included in the driver for completeness. ! 1371: * 0 = Shut off PCI parity check ! 1372: * -1 = Normal polarity pci parity checking ! 1373: * 1 = reverse polarity pci parity checking ! 1374: * ! 1375: * NOTE: you can't actually pass -1 on the lilo prompt. So, to set this ! 1376: * variable to -1 you would actually want to simply pass the variable ! 1377: * name without a number. That will invert the 0 which will result in ! 1378: * -1. ! 1379: */ ! 1380: static int aic7xxx_pci_parity = 0; ! 1381: /* ! 1382: * Set this to any non-0 value to cause us to dump the contents of all ! 1383: * the card's registers in a hex dump format tailored to each model of ! 1384: * controller. ! 1385: * ! 1386: * NOTE: THE CONTROLLER IS LEFT IN AN UNUSEABLE STATE BY THIS OPTION. ! 1387: * YOU CANNOT BOOT UP WITH THIS OPTION, IT IS FOR DEBUGGING PURPOSES ! 1388: * ONLY ! 1389: */ ! 1390: static int aic7xxx_dump_card = 0; ! 1391: /* ! 1392: * Set this to a non-0 value to make us dump out the 32 bit instruction ! 1393: * registers on the card after completing the sequencer download. This ! 1394: * allows the actual sequencer download to be verified. It is possible ! 1395: * to use this option and still boot up and run your system. This is ! 1396: * only intended for debugging purposes. ! 1397: */ ! 1398: static int aic7xxx_dump_sequencer = 0; ! 1399: /* ! 1400: * Certain newer motherboards have put new PCI based devices into the ! 1401: * IO spaces that used to typically be occupied by VLB or EISA cards. ! 1402: * This overlap can cause these newer motherboards to lock up when scanned ! 1403: * for older EISA and VLB devices. Setting this option to non-0 will ! 1404: * cause the driver to skip scanning for any VLB or EISA controllers and ! 1405: * only support the PCI controllers. NOTE: this means that if the kernel ! 1406: * os compiled with PCI support disabled, then setting this to non-0 ! 1407: * would result in never finding any devices :) ! 1408: */ ! 1409: static int aic7xxx_no_probe = 0; ! 1410: ! 1411: /* ! 1412: * So that insmod can find the variable and make it point to something ! 1413: */ ! 1414: #ifdef MODULE ! 1415: static char * aic7xxx = NULL; ! 1416: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,18) ! 1417: MODULE_PARM(aic7xxx, "s"); ! 1418: #endif ! 1419: ! 1420: /* ! 1421: * Just in case someone uses commas to separate items on the insmod ! 1422: * command line, we define a dummy buffer here to avoid having insmod ! 1423: * write wild stuff into our code segment ! 1424: */ ! 1425: static char dummy_buffer[60] = "Please don't trounce on me insmod!!\n"; ! 1426: ! 1427: #endif ! 1428: ! 1429: /* ! 1430: * See the comments earlier in the file for what this item is all about ! 1431: * If you have more than 4 controllers, you will need to increase the ! 1432: * the number of items in the array below. Additionally, if you don't ! 1433: * want to have lilo pass a humongous config line to the aic7xxx driver, ! 1434: * then you can get in and manually adjust these instead of leaving them ! 1435: * at the default. Pay attention to the comments earlier in this file ! 1436: * concerning this array if you are going to hand modify these values. ! 1437: */ ! 1438: static adapter_tag_info_t aic7xxx_tag_info[] = ! 1439: { ! 1440: {DEFAULT_TAG_COMMANDS}, ! 1441: {DEFAULT_TAG_COMMANDS}, ! 1442: {DEFAULT_TAG_COMMANDS}, ! 1443: {DEFAULT_TAG_COMMANDS}, ! 1444: {DEFAULT_TAG_COMMANDS}, ! 1445: {DEFAULT_TAG_COMMANDS}, ! 1446: {DEFAULT_TAG_COMMANDS}, ! 1447: {DEFAULT_TAG_COMMANDS}, ! 1448: {DEFAULT_TAG_COMMANDS}, ! 1449: {DEFAULT_TAG_COMMANDS}, ! 1450: {DEFAULT_TAG_COMMANDS}, ! 1451: {DEFAULT_TAG_COMMANDS}, ! 1452: {DEFAULT_TAG_COMMANDS}, ! 1453: {DEFAULT_TAG_COMMANDS}, ! 1454: {DEFAULT_TAG_COMMANDS}, ! 1455: {DEFAULT_TAG_COMMANDS} ! 1456: }; ! 1457: ! 1458: #define VERBOSE_NORMAL 0x0000 ! 1459: #define VERBOSE_NEGOTIATION 0x0001 ! 1460: #define VERBOSE_SEQINT 0x0002 ! 1461: #define VERBOSE_SCSIINT 0x0004 ! 1462: #define VERBOSE_PROBE 0x0008 ! 1463: #define VERBOSE_PROBE2 0x0010 ! 1464: #define VERBOSE_NEGOTIATION2 0x0020 ! 1465: #define VERBOSE_MINOR_ERROR 0x0040 ! 1466: #define VERBOSE_TRACING 0x0080 ! 1467: #define VERBOSE_ABORT 0x0f00 ! 1468: #define VERBOSE_ABORT_MID 0x0100 ! 1469: #define VERBOSE_ABORT_FIND 0x0200 ! 1470: #define VERBOSE_ABORT_PROCESS 0x0400 ! 1471: #define VERBOSE_ABORT_RETURN 0x0800 ! 1472: #define VERBOSE_RESET 0xf000 ! 1473: #define VERBOSE_RESET_MID 0x1000 ! 1474: #define VERBOSE_RESET_FIND 0x2000 ! 1475: #define VERBOSE_RESET_PROCESS 0x4000 ! 1476: #define VERBOSE_RESET_RETURN 0x8000 ! 1477: static int aic7xxx_verbose = VERBOSE_NORMAL | VERBOSE_NEGOTIATION | ! 1478: VERBOSE_PROBE; /* verbose messages */ ! 1479: ! 1480: ! 1481: /**************************************************************************** ! 1482: * ! 1483: * We're going to start putting in function declarations so that order of ! 1484: * functions is no longer important. As needed, they are added here. ! 1485: * ! 1486: ***************************************************************************/ ! 1487: ! 1488: static void aic7xxx_panic_abort(struct aic7xxx_host *p, Scsi_Cmnd *cmd); ! 1489: static void aic7xxx_print_card(struct aic7xxx_host *p); ! 1490: static void aic7xxx_print_scratch_ram(struct aic7xxx_host *p); ! 1491: static void aic7xxx_print_sequencer(struct aic7xxx_host *p, int downloaded); ! 1492: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 1493: static void aic7xxx_check_scbs(struct aic7xxx_host *p, char *buffer); ! 1494: #endif ! 1495: ! 1496: /**************************************************************************** ! 1497: * ! 1498: * These functions are now used. They happen to be wrapped in useless ! 1499: * inb/outb port read/writes around the real reads and writes because it ! 1500: * seems that certain very fast CPUs have a problem dealing with us when ! 1501: * going at full speed. ! 1502: * ! 1503: ***************************************************************************/ ! 1504: ! 1505: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) ! 1506: static inline void ! 1507: mdelay(int milliseconds) ! 1508: { ! 1509: int i; ! 1510: ! 1511: for(i=0; i<milliseconds; i++) ! 1512: udelay(1000); ! 1513: } ! 1514: #endif ! 1515: ! 1516: static inline unsigned char ! 1517: aic_inb(struct aic7xxx_host *p, long port) ! 1518: { ! 1519: #ifdef MMAPIO ! 1520: unsigned char x; ! 1521: if(p->maddr) ! 1522: { ! 1523: x = p->maddr[port]; ! 1524: } ! 1525: else ! 1526: { ! 1527: x = inb(p->base + port); ! 1528: } ! 1529: mb(); ! 1530: return(x); ! 1531: #else ! 1532: return(inb(p->base + port)); ! 1533: #endif ! 1534: } ! 1535: ! 1536: static inline void ! 1537: aic_outb(struct aic7xxx_host *p, unsigned char val, long port) ! 1538: { ! 1539: #ifdef MMAPIO ! 1540: if(p->maddr) ! 1541: { ! 1542: p->maddr[port] = val; ! 1543: } ! 1544: else ! 1545: { ! 1546: outb(val, p->base + port); ! 1547: } ! 1548: mb(); ! 1549: #else ! 1550: outb(val, p->base + port); ! 1551: #endif ! 1552: } ! 1553: ! 1554: /*+F************************************************************************* ! 1555: * Function: ! 1556: * aic7xxx_setup ! 1557: * ! 1558: * Description: ! 1559: * Handle Linux boot parameters. This routine allows for assigning a value ! 1560: * to a parameter with a ':' between the parameter and the value. ! 1561: * ie. aic7xxx=unpause:0x0A,extended ! 1562: *-F*************************************************************************/ ! 1563: void ! 1564: aic7xxx_setup(char *s, int *dummy) ! 1565: { ! 1566: int i, n; ! 1567: char *p; ! 1568: char *end; ! 1569: ! 1570: static struct { ! 1571: const char *name; ! 1572: unsigned int *flag; ! 1573: } options[] = { ! 1574: { "extended", &aic7xxx_extended }, ! 1575: { "no_reset", &aic7xxx_no_reset }, ! 1576: { "irq_trigger", &aic7xxx_irq_trigger }, ! 1577: { "verbose", &aic7xxx_verbose }, ! 1578: { "reverse_scan",&aic7xxx_reverse_scan }, ! 1579: { "override_term", &aic7xxx_override_term }, ! 1580: { "stpwlev", &aic7xxx_stpwlev }, ! 1581: { "no_probe", &aic7xxx_no_probe }, ! 1582: { "panic_on_abort", &aic7xxx_panic_on_abort }, ! 1583: { "pci_parity", &aic7xxx_pci_parity }, ! 1584: { "dump_card", &aic7xxx_dump_card }, ! 1585: { "dump_sequencer", &aic7xxx_dump_sequencer }, ! 1586: { "tag_info", NULL } ! 1587: }; ! 1588: ! 1589: end = strchr(s, '\0'); ! 1590: ! 1591: for (p = strtok(s, ",."); p; p = strtok(NULL, ",.")) ! 1592: { ! 1593: for (i = 0; i < NUMBER(options); i++) ! 1594: { ! 1595: n = strlen(options[i].name); ! 1596: if (!strncmp(options[i].name, p, n)) ! 1597: { ! 1598: if (!strncmp(p, "tag_info", n)) ! 1599: { ! 1600: if (p[n] == ':') ! 1601: { ! 1602: char *base; ! 1603: char *tok, *tok_end, *tok_end2; ! 1604: char tok_list[] = { '.', ',', '{', '}', '\0' }; ! 1605: int i, instance = -1, device = -1; ! 1606: unsigned char done = FALSE; ! 1607: ! 1608: base = p; ! 1609: tok = base + n + 1; /* Forward us just past the ':' */ ! 1610: tok_end = strchr(tok, '\0'); ! 1611: if (tok_end < end) ! 1612: *tok_end = ','; ! 1613: while(!done) ! 1614: { ! 1615: switch(*tok) ! 1616: { ! 1617: case '{': ! 1618: if (instance == -1) ! 1619: instance = 0; ! 1620: else if (device == -1) ! 1621: device = 0; ! 1622: tok++; ! 1623: break; ! 1624: case '}': ! 1625: if (device != -1) ! 1626: device = -1; ! 1627: else if (instance != -1) ! 1628: instance = -1; ! 1629: tok++; ! 1630: break; ! 1631: case ',': ! 1632: case '.': ! 1633: if (instance == -1) ! 1634: done = TRUE; ! 1635: else if (device >= 0) ! 1636: device++; ! 1637: else if (instance >= 0) ! 1638: instance++; ! 1639: if ( (device >= MAX_TARGETS) || ! 1640: (instance >= NUMBER(aic7xxx_tag_info)) ) ! 1641: done = TRUE; ! 1642: tok++; ! 1643: if (!done) ! 1644: { ! 1645: base = tok; ! 1646: } ! 1647: break; ! 1648: case '\0': ! 1649: done = TRUE; ! 1650: break; ! 1651: default: ! 1652: done = TRUE; ! 1653: tok_end = strchr(tok, '\0'); ! 1654: for(i=0; tok_list[i]; i++) ! 1655: { ! 1656: tok_end2 = strchr(tok, tok_list[i]); ! 1657: if ( (tok_end2) && (tok_end2 < tok_end) ) ! 1658: { ! 1659: tok_end = tok_end2; ! 1660: done = FALSE; ! 1661: } ! 1662: } ! 1663: if ( (instance >= 0) && (device >= 0) && ! 1664: (instance < NUMBER(aic7xxx_tag_info)) && ! 1665: (device < MAX_TARGETS) ) ! 1666: aic7xxx_tag_info[instance].tag_commands[device] = ! 1667: simple_strtoul(tok, NULL, 0) & 0xff; ! 1668: tok = tok_end; ! 1669: break; ! 1670: } ! 1671: } ! 1672: while((p != base) && (p != NULL)) ! 1673: p = strtok(NULL, ",."); ! 1674: } ! 1675: } ! 1676: else if (p[n] == ':') ! 1677: { ! 1678: *(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0); ! 1679: } ! 1680: else if (!strncmp(p, "verbose", n)) ! 1681: { ! 1682: *(options[i].flag) = 0xff09; ! 1683: } ! 1684: else ! 1685: { ! 1686: *(options[i].flag) = ~(*(options[i].flag)); ! 1687: } ! 1688: } ! 1689: } ! 1690: } ! 1691: } ! 1692: ! 1693: /*+F************************************************************************* ! 1694: * Function: ! 1695: * pause_sequencer ! 1696: * ! 1697: * Description: ! 1698: * Pause the sequencer and wait for it to actually stop - this ! 1699: * is important since the sequencer can disable pausing for critical ! 1700: * sections. ! 1701: *-F*************************************************************************/ ! 1702: static inline void ! 1703: pause_sequencer(struct aic7xxx_host *p) ! 1704: { ! 1705: aic_outb(p, p->pause, HCNTRL); ! 1706: while ((aic_inb(p, HCNTRL) & PAUSE) == 0) ! 1707: { ! 1708: ; ! 1709: } ! 1710: } ! 1711: ! 1712: /*+F************************************************************************* ! 1713: * Function: ! 1714: * unpause_sequencer ! 1715: * ! 1716: * Description: ! 1717: * Unpause the sequencer. Unremarkable, yet done often enough to ! 1718: * warrant an easy way to do it. ! 1719: *-F*************************************************************************/ ! 1720: static inline void ! 1721: unpause_sequencer(struct aic7xxx_host *p, int unpause_always) ! 1722: { ! 1723: if (unpause_always || ! 1724: ( !(aic_inb(p, INTSTAT) & (SCSIINT | SEQINT | BRKADRINT)) && ! 1725: !(p->flags & AHC_HANDLING_REQINITS) ) ) ! 1726: { ! 1727: aic_outb(p, p->unpause, HCNTRL); ! 1728: } ! 1729: } ! 1730: ! 1731: /*+F************************************************************************* ! 1732: * Function: ! 1733: * restart_sequencer ! 1734: * ! 1735: * Description: ! 1736: * Restart the sequencer program from address zero. This assumes ! 1737: * that the sequencer is already paused. ! 1738: *-F*************************************************************************/ ! 1739: static inline void ! 1740: restart_sequencer(struct aic7xxx_host *p) ! 1741: { ! 1742: aic_outb(p, 0, SEQADDR0); ! 1743: aic_outb(p, 0, SEQADDR1); ! 1744: aic_outb(p, FASTMODE, SEQCTL); ! 1745: } ! 1746: ! 1747: /* ! 1748: * We include the aic7xxx_seq.c file here so that the other defines have ! 1749: * already been made, and so that it comes before the code that actually ! 1750: * downloads the instructions (since we don't typically use function ! 1751: * prototype, our code has to be ordered that way, it's a left-over from ! 1752: * the original driver days.....I should fix it some time DL). ! 1753: */ ! 1754: #include "aic7xxx_seq.c" ! 1755: ! 1756: /*+F************************************************************************* ! 1757: * Function: ! 1758: * aic7xxx_check_patch ! 1759: * ! 1760: * Description: ! 1761: * See if the next patch to download should be downloaded. ! 1762: *-F*************************************************************************/ ! 1763: static int ! 1764: aic7xxx_check_patch(struct aic7xxx_host *p, ! 1765: struct sequencer_patch **start_patch, int start_instr, int *skip_addr) ! 1766: { ! 1767: struct sequencer_patch *cur_patch; ! 1768: struct sequencer_patch *last_patch; ! 1769: int num_patches; ! 1770: ! 1771: num_patches = sizeof(sequencer_patches)/sizeof(struct sequencer_patch); ! 1772: last_patch = &sequencer_patches[num_patches]; ! 1773: cur_patch = *start_patch; ! 1774: ! 1775: while ((cur_patch < last_patch) && (start_instr == cur_patch->begin)) ! 1776: { ! 1777: if (cur_patch->patch_func(p) == 0) ! 1778: { ! 1779: /* ! 1780: * Start rejecting code. ! 1781: */ ! 1782: *skip_addr = start_instr + cur_patch->skip_instr; ! 1783: cur_patch += cur_patch->skip_patch; ! 1784: } ! 1785: else ! 1786: { ! 1787: /* ! 1788: * Found an OK patch. Advance the patch pointer to the next patch ! 1789: * and wait for our instruction pointer to get here. ! 1790: */ ! 1791: cur_patch++; ! 1792: } ! 1793: } ! 1794: ! 1795: *start_patch = cur_patch; ! 1796: if (start_instr < *skip_addr) ! 1797: /* ! 1798: * Still skipping ! 1799: */ ! 1800: return (0); ! 1801: return(1); ! 1802: } ! 1803: ! 1804: ! 1805: /*+F************************************************************************* ! 1806: * Function: ! 1807: * aic7xxx_download_instr ! 1808: * ! 1809: * Description: ! 1810: * Find the next patch to download. ! 1811: *-F*************************************************************************/ ! 1812: static void ! 1813: aic7xxx_download_instr(struct aic7xxx_host *p, int instrptr, ! 1814: unsigned char *dconsts) ! 1815: { ! 1816: union ins_formats instr; ! 1817: struct ins_format1 *fmt1_ins; ! 1818: struct ins_format3 *fmt3_ins; ! 1819: unsigned char opcode; ! 1820: ! 1821: instr = *(union ins_formats*) &seqprog[instrptr * 4]; ! 1822: ! 1823: instr.integer = le32_to_cpu(instr.integer); ! 1824: ! 1825: fmt1_ins = &instr.format1; ! 1826: fmt3_ins = NULL; ! 1827: ! 1828: /* Pull the opcode */ ! 1829: opcode = instr.format1.opcode; ! 1830: switch (opcode) ! 1831: { ! 1832: case AIC_OP_JMP: ! 1833: case AIC_OP_JC: ! 1834: case AIC_OP_JNC: ! 1835: case AIC_OP_CALL: ! 1836: case AIC_OP_JNE: ! 1837: case AIC_OP_JNZ: ! 1838: case AIC_OP_JE: ! 1839: case AIC_OP_JZ: ! 1840: { ! 1841: struct sequencer_patch *cur_patch; ! 1842: int address_offset; ! 1843: unsigned int address; ! 1844: int skip_addr; ! 1845: int i; ! 1846: ! 1847: fmt3_ins = &instr.format3; ! 1848: address_offset = 0; ! 1849: address = fmt3_ins->address; ! 1850: cur_patch = sequencer_patches; ! 1851: skip_addr = 0; ! 1852: ! 1853: for (i = 0; i < address;) ! 1854: { ! 1855: aic7xxx_check_patch(p, &cur_patch, i, &skip_addr); ! 1856: if (skip_addr > i) ! 1857: { ! 1858: int end_addr; ! 1859: ! 1860: end_addr = MIN(address, skip_addr); ! 1861: address_offset += end_addr - i; ! 1862: i = skip_addr; ! 1863: } ! 1864: else ! 1865: { ! 1866: i++; ! 1867: } ! 1868: } ! 1869: address -= address_offset; ! 1870: fmt3_ins->address = address; ! 1871: /* Fall Through to the next code section */ ! 1872: } ! 1873: case AIC_OP_OR: ! 1874: case AIC_OP_AND: ! 1875: case AIC_OP_XOR: ! 1876: case AIC_OP_ADD: ! 1877: case AIC_OP_ADC: ! 1878: case AIC_OP_BMOV: ! 1879: if (fmt1_ins->parity != 0) ! 1880: { ! 1881: fmt1_ins->immediate = dconsts[fmt1_ins->immediate]; ! 1882: } ! 1883: fmt1_ins->parity = 0; ! 1884: /* Fall Through to the next code section */ ! 1885: case AIC_OP_ROL: ! 1886: if ((p->features & AHC_ULTRA2) != 0) ! 1887: { ! 1888: int i, count; ! 1889: ! 1890: /* Calculate odd parity for the instruction */ ! 1891: for ( i=0, count=0; i < 31; i++) ! 1892: { ! 1893: unsigned int mask; ! 1894: ! 1895: mask = 0x01 << i; ! 1896: if ((instr.integer & mask) != 0) ! 1897: count++; ! 1898: } ! 1899: if (!(count & 0x01)) ! 1900: instr.format1.parity = 1; ! 1901: } ! 1902: else ! 1903: { ! 1904: if (fmt3_ins != NULL) ! 1905: { ! 1906: instr.integer = fmt3_ins->immediate | ! 1907: (fmt3_ins->source << 8) | ! 1908: (fmt3_ins->address << 16) | ! 1909: (fmt3_ins->opcode << 25); ! 1910: } ! 1911: else ! 1912: { ! 1913: instr.integer = fmt1_ins->immediate | ! 1914: (fmt1_ins->source << 8) | ! 1915: (fmt1_ins->destination << 16) | ! 1916: (fmt1_ins->ret << 24) | ! 1917: (fmt1_ins->opcode << 25); ! 1918: } ! 1919: } ! 1920: aic_outb(p, (instr.integer & 0xff), SEQRAM); ! 1921: aic_outb(p, ((instr.integer >> 8) & 0xff), SEQRAM); ! 1922: aic_outb(p, ((instr.integer >> 16) & 0xff), SEQRAM); ! 1923: aic_outb(p, ((instr.integer >> 24) & 0xff), SEQRAM); ! 1924: break; ! 1925: ! 1926: default: ! 1927: panic("aic7xxx: Unknown opcode encountered in sequencer program."); ! 1928: break; ! 1929: } ! 1930: } ! 1931: ! 1932: ! 1933: /*+F************************************************************************* ! 1934: * Function: ! 1935: * aic7xxx_loadseq ! 1936: * ! 1937: * Description: ! 1938: * Load the sequencer code into the controller memory. ! 1939: *-F*************************************************************************/ ! 1940: static void ! 1941: aic7xxx_loadseq(struct aic7xxx_host *p) ! 1942: { ! 1943: struct sequencer_patch *cur_patch; ! 1944: int i; ! 1945: int downloaded; ! 1946: int skip_addr; ! 1947: unsigned char download_consts[4] = {0, 0, 0, 0}; ! 1948: ! 1949: if (aic7xxx_verbose & VERBOSE_PROBE) ! 1950: { ! 1951: printk(KERN_INFO "(scsi%d) Downloading sequencer code...", p->host_no); ! 1952: } ! 1953: download_consts[TMODE_NUMCMDS] = p->num_targetcmds; ! 1954: cur_patch = &sequencer_patches[0]; ! 1955: downloaded = 0; ! 1956: skip_addr = 0; ! 1957: ! 1958: aic_outb(p, PERRORDIS|LOADRAM|FAILDIS|FASTMODE, SEQCTL); ! 1959: aic_outb(p, 0, SEQADDR0); ! 1960: aic_outb(p, 0, SEQADDR1); ! 1961: ! 1962: for (i = 0; i < sizeof(seqprog) / 4; i++) ! 1963: { ! 1964: if (aic7xxx_check_patch(p, &cur_patch, i, &skip_addr) == 0) ! 1965: { ! 1966: /* Skip this instruction for this configuration. */ ! 1967: continue; ! 1968: } ! 1969: aic7xxx_download_instr(p, i, &download_consts[0]); ! 1970: downloaded++; ! 1971: } ! 1972: ! 1973: aic_outb(p, 0, SEQADDR0); ! 1974: aic_outb(p, 0, SEQADDR1); ! 1975: aic_outb(p, FASTMODE | FAILDIS, SEQCTL); ! 1976: unpause_sequencer(p, TRUE); ! 1977: mdelay(1); ! 1978: pause_sequencer(p); ! 1979: aic_outb(p, FASTMODE, SEQCTL); ! 1980: if (aic7xxx_verbose & VERBOSE_PROBE) ! 1981: { ! 1982: printk(" %d instructions downloaded\n", downloaded); ! 1983: } ! 1984: if (aic7xxx_dump_sequencer) ! 1985: aic7xxx_print_sequencer(p, downloaded); ! 1986: } ! 1987: ! 1988: /*+F************************************************************************* ! 1989: * Function: ! 1990: * aic7xxx_print_sequencer ! 1991: * ! 1992: * Description: ! 1993: * Print the contents of the sequencer memory to the screen. ! 1994: *-F*************************************************************************/ ! 1995: static void ! 1996: aic7xxx_print_sequencer(struct aic7xxx_host *p, int downloaded) ! 1997: { ! 1998: int i, k, temp; ! 1999: ! 2000: aic_outb(p, PERRORDIS|LOADRAM|FAILDIS|FASTMODE, SEQCTL); ! 2001: aic_outb(p, 0, SEQADDR0); ! 2002: aic_outb(p, 0, SEQADDR1); ! 2003: ! 2004: k = 0; ! 2005: for (i=0; i < downloaded; i++) ! 2006: { ! 2007: if ( k == 0 ) ! 2008: printk("%03x: ", i); ! 2009: temp = aic_inb(p, SEQRAM); ! 2010: temp |= (aic_inb(p, SEQRAM) << 8); ! 2011: temp |= (aic_inb(p, SEQRAM) << 16); ! 2012: temp |= (aic_inb(p, SEQRAM) << 24); ! 2013: printk("%08x", temp); ! 2014: if ( ++k == 8 ) ! 2015: { ! 2016: printk("\n"); ! 2017: k = 0; ! 2018: } ! 2019: else ! 2020: printk(" "); ! 2021: } ! 2022: aic_outb(p, 0, SEQADDR0); ! 2023: aic_outb(p, 0, SEQADDR1); ! 2024: aic_outb(p, FASTMODE | FAILDIS, SEQCTL); ! 2025: unpause_sequencer(p, TRUE); ! 2026: mdelay(1); ! 2027: pause_sequencer(p); ! 2028: aic_outb(p, FASTMODE, SEQCTL); ! 2029: printk("\n"); ! 2030: } ! 2031: ! 2032: /*+F************************************************************************* ! 2033: * Function: ! 2034: * aic7xxx_delay ! 2035: * ! 2036: * Description: ! 2037: * Delay for specified amount of time. We use mdelay because the timer ! 2038: * interrupt is not guaranteed to be enabled. This will cause an ! 2039: * infinite loop since jiffies (clock ticks) is not updated. ! 2040: *-F*************************************************************************/ ! 2041: static void ! 2042: aic7xxx_delay(int seconds) ! 2043: { ! 2044: mdelay(seconds * 1000); ! 2045: } ! 2046: ! 2047: /*+F************************************************************************* ! 2048: * Function: ! 2049: * aic7xxx_info ! 2050: * ! 2051: * Description: ! 2052: * Return a string describing the driver. ! 2053: *-F*************************************************************************/ ! 2054: const char * ! 2055: aic7xxx_info(struct Scsi_Host *dooh) ! 2056: { ! 2057: static char buffer[256]; ! 2058: char *bp; ! 2059: struct aic7xxx_host *p; ! 2060: ! 2061: bp = &buffer[0]; ! 2062: p = (struct aic7xxx_host *)dooh->hostdata; ! 2063: memset(bp, 0, sizeof(buffer)); ! 2064: strcpy(bp, "Adaptec AHA274x/284x/294x (EISA/VLB/PCI-Fast SCSI) "); ! 2065: strcat(bp, AIC7XXX_C_VERSION); ! 2066: strcat(bp, "/"); ! 2067: strcat(bp, AIC7XXX_H_VERSION); ! 2068: strcat(bp, "\n"); ! 2069: strcat(bp, " <"); ! 2070: strcat(bp, board_names[p->board_name_index]); ! 2071: strcat(bp, ">"); ! 2072: ! 2073: return(bp); ! 2074: } ! 2075: ! 2076: /*+F************************************************************************* ! 2077: * Function: ! 2078: * aic7xxx_find_syncrate ! 2079: * ! 2080: * Description: ! 2081: * Look up the valid period to SCSIRATE conversion in our table ! 2082: *-F*************************************************************************/ ! 2083: static struct aic7xxx_syncrate * ! 2084: aic7xxx_find_syncrate(struct aic7xxx_host *p, unsigned int *period, ! 2085: unsigned int maxsync) ! 2086: { ! 2087: struct aic7xxx_syncrate *syncrate; ! 2088: ! 2089: syncrate = &aic7xxx_syncrates[maxsync]; ! 2090: while ( (syncrate->rate[0] != NULL) && ! 2091: (!(p->features & AHC_ULTRA2) || syncrate->sxfr_ultra2) ) ! 2092: { ! 2093: if ( *period <= syncrate->period ) ! 2094: { ! 2095: /* ! 2096: * When responding to a target that requests sync, the requested rate ! 2097: * may fall between two rates that we can output, but still be a rate ! 2098: * that we can receive. Because of this, we want to respond with the ! 2099: * same rate that it sent to us even if the persiod we use to send ! 2100: * data to it is lower. Only lower the response period if we must. ! 2101: */ ! 2102: if(syncrate == &aic7xxx_syncrates[maxsync]) ! 2103: { ! 2104: *period = syncrate->period; ! 2105: } ! 2106: break; ! 2107: } ! 2108: syncrate++; ! 2109: } ! 2110: if ( (*period == 0) || (syncrate->rate[0] == NULL) || ! 2111: ((p->features & AHC_ULTRA2) && (syncrate->sxfr_ultra2 == 0)) ) ! 2112: { ! 2113: /* ! 2114: * Use async transfers for this target ! 2115: */ ! 2116: *period = 0; ! 2117: syncrate = NULL; ! 2118: } ! 2119: return (syncrate); ! 2120: } ! 2121: ! 2122: ! 2123: /*+F************************************************************************* ! 2124: * Function: ! 2125: * aic7xxx_find_period ! 2126: * ! 2127: * Description: ! 2128: * Look up the valid SCSIRATE to period conversion in our table ! 2129: *-F*************************************************************************/ ! 2130: static unsigned int ! 2131: aic7xxx_find_period(struct aic7xxx_host *p, unsigned int scsirate, ! 2132: unsigned int maxsync) ! 2133: { ! 2134: struct aic7xxx_syncrate *syncrate; ! 2135: ! 2136: if ((p->features & AHC_ULTRA2) != 0) ! 2137: { ! 2138: scsirate &= SXFR_ULTRA2; ! 2139: } ! 2140: else ! 2141: { ! 2142: scsirate &= SXFR; ! 2143: } ! 2144: ! 2145: syncrate = &aic7xxx_syncrates[maxsync]; ! 2146: while (syncrate->rate[0] != NULL) ! 2147: { ! 2148: if ((p->features & AHC_ULTRA2) != 0) ! 2149: { ! 2150: if (syncrate->sxfr_ultra2 == 0) ! 2151: break; ! 2152: else if (scsirate == syncrate->sxfr_ultra2) ! 2153: return (syncrate->period); ! 2154: } ! 2155: else if (scsirate == (syncrate->sxfr & ~ULTRA_SXFR)) ! 2156: { ! 2157: return (syncrate->period); ! 2158: } ! 2159: syncrate++; ! 2160: } ! 2161: return (0); /* async */ ! 2162: } ! 2163: ! 2164: /*+F************************************************************************* ! 2165: * Function: ! 2166: * aic7xxx_validate_offset ! 2167: * ! 2168: * Description: ! 2169: * Set a valid offset value for a particular card in use and transfer ! 2170: * settings in use. ! 2171: *-F*************************************************************************/ ! 2172: static void ! 2173: aic7xxx_validate_offset(struct aic7xxx_host *p, ! 2174: struct aic7xxx_syncrate *syncrate, unsigned int *offset, int wide) ! 2175: { ! 2176: unsigned int maxoffset; ! 2177: ! 2178: /* Limit offset to what the card (and device) can do */ ! 2179: if (syncrate == NULL) ! 2180: { ! 2181: maxoffset = 0; ! 2182: } ! 2183: else if (p->features & AHC_ULTRA2) ! 2184: { ! 2185: maxoffset = MAX_OFFSET_ULTRA2; ! 2186: } ! 2187: else ! 2188: { ! 2189: if (wide) ! 2190: maxoffset = MAX_OFFSET_16BIT; ! 2191: else ! 2192: maxoffset = MAX_OFFSET_8BIT; ! 2193: } ! 2194: *offset = MIN(*offset, maxoffset); ! 2195: } ! 2196: ! 2197: /*+F************************************************************************* ! 2198: * Function: ! 2199: * aic7xxx_set_syncrate ! 2200: * ! 2201: * Description: ! 2202: * Set the actual syncrate down in the card and in our host structs ! 2203: *-F*************************************************************************/ ! 2204: static void ! 2205: aic7xxx_set_syncrate(struct aic7xxx_host *p, struct aic7xxx_syncrate *syncrate, ! 2206: int target, int channel, unsigned int period, unsigned int offset, ! 2207: unsigned int type) ! 2208: { ! 2209: unsigned char tindex; ! 2210: unsigned short target_mask; ! 2211: unsigned char lun; ! 2212: unsigned int old_period, old_offset; ! 2213: ! 2214: tindex = target | (channel << 3); ! 2215: target_mask = 0x01 << tindex; ! 2216: lun = aic_inb(p, SCB_TCL) & 0x07; ! 2217: ! 2218: if (syncrate == NULL) ! 2219: { ! 2220: period = 0; ! 2221: offset = 0; ! 2222: } ! 2223: ! 2224: old_period = p->transinfo[tindex].cur_period; ! 2225: old_offset = p->transinfo[tindex].cur_offset; ! 2226: ! 2227: ! 2228: if (type & AHC_TRANS_CUR) ! 2229: { ! 2230: unsigned int scsirate; ! 2231: ! 2232: scsirate = aic_inb(p, TARG_SCSIRATE + tindex); ! 2233: if (p->features & AHC_ULTRA2) ! 2234: { ! 2235: scsirate &= ~SXFR_ULTRA2; ! 2236: if (syncrate != NULL) ! 2237: { ! 2238: scsirate |= syncrate->sxfr_ultra2; ! 2239: } ! 2240: if (type & AHC_TRANS_ACTIVE) ! 2241: { ! 2242: aic_outb(p, offset, SCSIOFFSET); ! 2243: } ! 2244: aic_outb(p, offset, TARG_OFFSET + tindex); ! 2245: } ! 2246: else /* Not an Ultra2 controller */ ! 2247: { ! 2248: scsirate &= ~(SXFR|SOFS); ! 2249: p->ultraenb &= ~target_mask; ! 2250: if (syncrate != NULL) ! 2251: { ! 2252: if (syncrate->sxfr & ULTRA_SXFR) ! 2253: { ! 2254: p->ultraenb |= target_mask; ! 2255: } ! 2256: scsirate |= (syncrate->sxfr & SXFR); ! 2257: scsirate |= (offset & SOFS); ! 2258: } ! 2259: if (type & AHC_TRANS_ACTIVE) ! 2260: { ! 2261: unsigned char sxfrctl0; ! 2262: ! 2263: sxfrctl0 = aic_inb(p, SXFRCTL0); ! 2264: sxfrctl0 &= ~FAST20; ! 2265: if (p->ultraenb & target_mask) ! 2266: sxfrctl0 |= FAST20; ! 2267: aic_outb(p, sxfrctl0, SXFRCTL0); ! 2268: } ! 2269: aic_outb(p, p->ultraenb & 0xff, ULTRA_ENB); ! 2270: aic_outb(p, (p->ultraenb >> 8) & 0xff, ULTRA_ENB + 1 ); ! 2271: } ! 2272: if (type & AHC_TRANS_ACTIVE) ! 2273: { ! 2274: aic_outb(p, scsirate, SCSIRATE); ! 2275: } ! 2276: aic_outb(p, scsirate, TARG_SCSIRATE + tindex); ! 2277: p->transinfo[tindex].cur_period = period; ! 2278: p->transinfo[tindex].cur_offset = offset; ! 2279: if ( !(type & AHC_TRANS_QUITE) && ! 2280: (aic7xxx_verbose & VERBOSE_NEGOTIATION) && ! 2281: (p->dev_flags[tindex] & DEVICE_PRINT_SDTR) ) ! 2282: { ! 2283: if (offset) ! 2284: { ! 2285: int rate_mod = (scsirate & WIDEXFER) ? 1 : 0; ! 2286: ! 2287: printk(INFO_LEAD "Synchronous at %s Mbyte/sec, " ! 2288: "offset %d.\n", p->host_no, channel, target, lun, ! 2289: syncrate->rate[rate_mod], offset); ! 2290: } ! 2291: else ! 2292: { ! 2293: printk(INFO_LEAD "Using asynchronous transfers.\n", ! 2294: p->host_no, channel, target, lun); ! 2295: } ! 2296: p->dev_flags[tindex] &= ~DEVICE_PRINT_SDTR; ! 2297: } ! 2298: } ! 2299: ! 2300: if (type & AHC_TRANS_GOAL) ! 2301: { ! 2302: p->transinfo[tindex].goal_period = period; ! 2303: p->transinfo[tindex].goal_offset = offset; ! 2304: } ! 2305: ! 2306: if (type & AHC_TRANS_USER) ! 2307: { ! 2308: p->transinfo[tindex].user_period = period; ! 2309: p->transinfo[tindex].user_offset = offset; ! 2310: } ! 2311: } ! 2312: ! 2313: /*+F************************************************************************* ! 2314: * Function: ! 2315: * aic7xxx_set_width ! 2316: * ! 2317: * Description: ! 2318: * Set the actual width down in the card and in our host structs ! 2319: *-F*************************************************************************/ ! 2320: static void ! 2321: aic7xxx_set_width(struct aic7xxx_host *p, int target, int channel, int lun, ! 2322: unsigned int width, unsigned int type) ! 2323: { ! 2324: unsigned char tindex; ! 2325: unsigned short target_mask; ! 2326: unsigned int old_width, new_offset; ! 2327: ! 2328: tindex = target | (channel << 3); ! 2329: target_mask = 1 << tindex; ! 2330: ! 2331: old_width = p->transinfo[tindex].cur_width; ! 2332: ! 2333: if (p->features & AHC_ULTRA2) ! 2334: new_offset = MAX_OFFSET_ULTRA2; ! 2335: else if (width == MSG_EXT_WDTR_BUS_16_BIT) ! 2336: new_offset = MAX_OFFSET_16BIT; ! 2337: else ! 2338: new_offset = MAX_OFFSET_8BIT; ! 2339: ! 2340: if (type & AHC_TRANS_CUR) ! 2341: { ! 2342: unsigned char scsirate; ! 2343: ! 2344: scsirate = aic_inb(p, TARG_SCSIRATE + tindex); ! 2345: ! 2346: scsirate &= ~WIDEXFER; ! 2347: if (width == MSG_EXT_WDTR_BUS_16_BIT) ! 2348: scsirate |= WIDEXFER; ! 2349: ! 2350: aic_outb(p, scsirate, TARG_SCSIRATE + tindex); ! 2351: ! 2352: if (type & AHC_TRANS_ACTIVE) ! 2353: aic_outb(p, scsirate, SCSIRATE); ! 2354: ! 2355: p->transinfo[tindex].cur_width = width; ! 2356: ! 2357: if ((aic7xxx_verbose & VERBOSE_NEGOTIATION2) && ! 2358: (p->dev_flags[tindex] & DEVICE_PRINT_WDTR)) ! 2359: { ! 2360: printk(INFO_LEAD "Using %s transfers\n", p->host_no, channel, target, ! 2361: lun, (scsirate & WIDEXFER) ? "Wide(16bit)" : "Narrow(8bit)" ); ! 2362: p->dev_flags[tindex] &= ~DEVICE_PRINT_WDTR; ! 2363: } ! 2364: } ! 2365: ! 2366: if (type & AHC_TRANS_GOAL) ! 2367: p->transinfo[tindex].goal_width = width; ! 2368: if (type & AHC_TRANS_USER) ! 2369: p->transinfo[tindex].user_width = width; ! 2370: ! 2371: /* ! 2372: * Having just set the width, the SDTR should come next, and we need a valid ! 2373: * offset for the SDTR. So, we make sure we put a valid one in here now as ! 2374: * the goal_offset. ! 2375: */ ! 2376: if (p->transinfo[tindex].goal_offset) ! 2377: p->transinfo[tindex].goal_offset = new_offset; ! 2378: ! 2379: } ! 2380: ! 2381: /*+F************************************************************************* ! 2382: * Function: ! 2383: * scbq_init ! 2384: * ! 2385: * Description: ! 2386: * SCB queue initialization. ! 2387: * ! 2388: *-F*************************************************************************/ ! 2389: static void ! 2390: scbq_init(volatile scb_queue_type *queue) ! 2391: { ! 2392: queue->head = NULL; ! 2393: queue->tail = NULL; ! 2394: } ! 2395: ! 2396: /*+F************************************************************************* ! 2397: * Function: ! 2398: * scbq_insert_head ! 2399: * ! 2400: * Description: ! 2401: * Add an SCB to the head of the list. ! 2402: * ! 2403: *-F*************************************************************************/ ! 2404: static inline void ! 2405: scbq_insert_head(volatile scb_queue_type *queue, struct aic7xxx_scb *scb) ! 2406: { ! 2407: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 2408: unsigned long cpu_flags; ! 2409: #endif ! 2410: ! 2411: DRIVER_LOCK ! 2412: scb->q_next = queue->head; ! 2413: queue->head = scb; ! 2414: if (queue->tail == NULL) /* If list was empty, update tail. */ ! 2415: queue->tail = queue->head; ! 2416: DRIVER_UNLOCK ! 2417: } ! 2418: ! 2419: /*+F************************************************************************* ! 2420: * Function: ! 2421: * scbq_remove_head ! 2422: * ! 2423: * Description: ! 2424: * Remove an SCB from the head of the list. ! 2425: * ! 2426: *-F*************************************************************************/ ! 2427: static inline struct aic7xxx_scb * ! 2428: scbq_remove_head(volatile scb_queue_type *queue) ! 2429: { ! 2430: struct aic7xxx_scb * scbp; ! 2431: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 2432: unsigned long cpu_flags; ! 2433: #endif ! 2434: ! 2435: DRIVER_LOCK ! 2436: scbp = queue->head; ! 2437: if (queue->head != NULL) ! 2438: queue->head = queue->head->q_next; ! 2439: if (queue->head == NULL) /* If list is now empty, update tail. */ ! 2440: queue->tail = NULL; ! 2441: DRIVER_UNLOCK ! 2442: return(scbp); ! 2443: } ! 2444: ! 2445: /*+F************************************************************************* ! 2446: * Function: ! 2447: * scbq_remove ! 2448: * ! 2449: * Description: ! 2450: * Removes an SCB from the list. ! 2451: * ! 2452: *-F*************************************************************************/ ! 2453: static inline void ! 2454: scbq_remove(volatile scb_queue_type *queue, struct aic7xxx_scb *scb) ! 2455: { ! 2456: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 2457: unsigned long cpu_flags; ! 2458: #endif ! 2459: ! 2460: DRIVER_LOCK ! 2461: if (queue->head == scb) ! 2462: { ! 2463: /* At beginning of queue, remove from head. */ ! 2464: scbq_remove_head(queue); ! 2465: } ! 2466: else ! 2467: { ! 2468: struct aic7xxx_scb *curscb = queue->head; ! 2469: ! 2470: /* ! 2471: * Search until the next scb is the one we're looking for, or ! 2472: * we run out of queue. ! 2473: */ ! 2474: while ((curscb != NULL) && (curscb->q_next != scb)) ! 2475: { ! 2476: curscb = curscb->q_next; ! 2477: } ! 2478: if (curscb != NULL) ! 2479: { ! 2480: /* Found it. */ ! 2481: curscb->q_next = scb->q_next; ! 2482: if (scb->q_next == NULL) ! 2483: { ! 2484: /* Update the tail when removing the tail. */ ! 2485: queue->tail = curscb; ! 2486: } ! 2487: } ! 2488: } ! 2489: DRIVER_UNLOCK ! 2490: } ! 2491: ! 2492: /*+F************************************************************************* ! 2493: * Function: ! 2494: * scbq_insert_tail ! 2495: * ! 2496: * Description: ! 2497: * Add an SCB at the tail of the list. ! 2498: * ! 2499: *-F*************************************************************************/ ! 2500: static inline void ! 2501: scbq_insert_tail(volatile scb_queue_type *queue, struct aic7xxx_scb *scb) ! 2502: { ! 2503: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 2504: unsigned long cpu_flags; ! 2505: #endif ! 2506: ! 2507: DRIVER_LOCK ! 2508: scb->q_next = NULL; ! 2509: if (queue->tail != NULL) /* Add the scb at the end of the list. */ ! 2510: queue->tail->q_next = scb; ! 2511: queue->tail = scb; /* Update the tail. */ ! 2512: if (queue->head == NULL) /* If list was empty, update head. */ ! 2513: queue->head = queue->tail; ! 2514: DRIVER_UNLOCK ! 2515: } ! 2516: ! 2517: /*+F************************************************************************* ! 2518: * Function: ! 2519: * aic7xxx_match_scb ! 2520: * ! 2521: * Description: ! 2522: * Checks to see if an scb matches the target/channel as specified. ! 2523: * If target is ALL_TARGETS (-1), then we're looking for any device ! 2524: * on the specified channel; this happens when a channel is going ! 2525: * to be reset and all devices on that channel must be aborted. ! 2526: *-F*************************************************************************/ ! 2527: static int ! 2528: aic7xxx_match_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb, ! 2529: int target, int channel, int lun, unsigned char tag) ! 2530: { ! 2531: int targ = (scb->hscb->target_channel_lun >> 4) & 0x0F; ! 2532: int chan = (scb->hscb->target_channel_lun >> 3) & 0x01; ! 2533: int slun = scb->hscb->target_channel_lun & 0x07; ! 2534: int match; ! 2535: ! 2536: match = ((chan == channel) || (channel == ALL_CHANNELS)); ! 2537: if (match != 0) ! 2538: match = ((targ == target) || (target == ALL_TARGETS)); ! 2539: if (match != 0) ! 2540: match = ((lun == slun) || (lun == ALL_LUNS)); ! 2541: if (match != 0) ! 2542: match = ((tag == scb->hscb->tag) || (tag == SCB_LIST_NULL)); ! 2543: ! 2544: if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS)) ! 2545: { ! 2546: printk(KERN_INFO "(scsi%d:%d:%d:%d:tag%d) %s search criteria" ! 2547: " (scsi%d:%d:%d:%d:tag%d)\n", p->host_no, CTL_OF_SCB(scb), ! 2548: scb->hscb->tag, (match) ? "matches" : "doesn't match", ! 2549: p->host_no, channel, target, lun, tag); ! 2550: } ! 2551: ! 2552: return (match); ! 2553: } ! 2554: ! 2555: /*+F************************************************************************* ! 2556: * Function: ! 2557: * aic7xxx_add_curscb_to_free_list ! 2558: * ! 2559: * Description: ! 2560: * Adds the current scb (in SCBPTR) to the list of free SCBs. ! 2561: *-F*************************************************************************/ ! 2562: static void ! 2563: aic7xxx_add_curscb_to_free_list(struct aic7xxx_host *p) ! 2564: { ! 2565: /* ! 2566: * Invalidate the tag so that aic7xxx_find_scb doesn't think ! 2567: * it's active ! 2568: */ ! 2569: aic_outb(p, SCB_LIST_NULL, SCB_TAG); ! 2570: aic_outb(p, 0, SCB_CONTROL); ! 2571: ! 2572: aic_outb(p, aic_inb(p, FREE_SCBH), SCB_NEXT); ! 2573: aic_outb(p, aic_inb(p, SCBPTR), FREE_SCBH); ! 2574: } ! 2575: ! 2576: /*+F************************************************************************* ! 2577: * Function: ! 2578: * aic7xxx_rem_scb_from_disc_list ! 2579: * ! 2580: * Description: ! 2581: * Removes the current SCB from the disconnected list and adds it ! 2582: * to the free list. ! 2583: *-F*************************************************************************/ ! 2584: static unsigned char ! 2585: aic7xxx_rem_scb_from_disc_list(struct aic7xxx_host *p, unsigned char scbptr) ! 2586: { ! 2587: unsigned char next; ! 2588: unsigned char prev; ! 2589: ! 2590: aic_outb(p, scbptr, SCBPTR); ! 2591: next = aic_inb(p, SCB_NEXT); ! 2592: prev = aic_inb(p, SCB_PREV); ! 2593: aic7xxx_add_curscb_to_free_list(p); ! 2594: ! 2595: if (prev != SCB_LIST_NULL) ! 2596: { ! 2597: aic_outb(p, prev, SCBPTR); ! 2598: aic_outb(p, next, SCB_NEXT); ! 2599: } ! 2600: else ! 2601: { ! 2602: aic_outb(p, next, DISCONNECTED_SCBH); ! 2603: } ! 2604: ! 2605: if (next != SCB_LIST_NULL) ! 2606: { ! 2607: aic_outb(p, next, SCBPTR); ! 2608: aic_outb(p, prev, SCB_PREV); ! 2609: } ! 2610: return next; ! 2611: } ! 2612: ! 2613: /*+F************************************************************************* ! 2614: * Function: ! 2615: * aic7xxx_busy_target ! 2616: * ! 2617: * Description: ! 2618: * Set the specified target busy. ! 2619: *-F*************************************************************************/ ! 2620: static inline void ! 2621: aic7xxx_busy_target(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 2622: { ! 2623: p->untagged_scbs[scb->hscb->target_channel_lun] = scb->hscb->tag; ! 2624: } ! 2625: ! 2626: /*+F************************************************************************* ! 2627: * Function: ! 2628: * aic7xxx_index_busy_target ! 2629: * ! 2630: * Description: ! 2631: * Returns the index of the busy target, and optionally sets the ! 2632: * target inactive. ! 2633: *-F*************************************************************************/ ! 2634: static inline unsigned char ! 2635: aic7xxx_index_busy_target(struct aic7xxx_host *p, unsigned char tcl, ! 2636: int unbusy) ! 2637: { ! 2638: unsigned char busy_scbid; ! 2639: ! 2640: busy_scbid = p->untagged_scbs[tcl]; ! 2641: if (unbusy) ! 2642: { ! 2643: p->untagged_scbs[tcl] = SCB_LIST_NULL; ! 2644: } ! 2645: return (busy_scbid); ! 2646: } ! 2647: ! 2648: /*+F************************************************************************* ! 2649: * Function: ! 2650: * aic7xxx_find_scb ! 2651: * ! 2652: * Description: ! 2653: * Look through the SCB array of the card and attempt to find the ! 2654: * hardware SCB that corresponds to the passed in SCB. Return ! 2655: * SCB_LIST_NULL if unsuccessful. This routine assumes that the ! 2656: * card is already paused. ! 2657: *-F*************************************************************************/ ! 2658: static unsigned char ! 2659: aic7xxx_find_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 2660: { ! 2661: unsigned char saved_scbptr; ! 2662: unsigned char curindex; ! 2663: ! 2664: saved_scbptr = aic_inb(p, SCBPTR); ! 2665: curindex = 0; ! 2666: for (curindex = 0; curindex < p->scb_data->maxhscbs; curindex++) ! 2667: { ! 2668: aic_outb(p, curindex, SCBPTR); ! 2669: if (aic_inb(p, SCB_TAG) == scb->hscb->tag) ! 2670: { ! 2671: break; ! 2672: } ! 2673: } ! 2674: aic_outb(p, saved_scbptr, SCBPTR); ! 2675: if (curindex >= p->scb_data->maxhscbs) ! 2676: { ! 2677: curindex = SCB_LIST_NULL; ! 2678: } ! 2679: ! 2680: return (curindex); ! 2681: } ! 2682: ! 2683: /*+F************************************************************************* ! 2684: * Function: ! 2685: * aic7xxx_allocate_scb ! 2686: * ! 2687: * Description: ! 2688: * Get an SCB from the free list or by allocating a new one. ! 2689: *-F*************************************************************************/ ! 2690: static int ! 2691: aic7xxx_allocate_scb(struct aic7xxx_host *p) ! 2692: { ! 2693: struct aic7xxx_scb *scbp = NULL; ! 2694: int scb_size = sizeof(struct aic7xxx_scb) + ! 2695: sizeof (struct hw_scatterlist) * AIC7XXX_MAX_SG; ! 2696: int i; ! 2697: int step = PAGE_SIZE / 1024; ! 2698: unsigned long scb_count = 0; ! 2699: struct hw_scatterlist *hsgp; ! 2700: struct aic7xxx_scb *scb_ap; ! 2701: unsigned long temp; ! 2702: ! 2703: ! 2704: if (p->scb_data->numscbs < p->scb_data->maxscbs) ! 2705: { ! 2706: /* ! 2707: * Calculate the optimal number of SCBs to allocate. ! 2708: * ! 2709: * NOTE: This formula works because the sizeof(sg_array) is always ! 2710: * 1024. Therefore, scb_size * i would always be > PAGE_SIZE * ! 2711: * (i/step). The (i-1) allows the left hand side of the equation ! 2712: * to grow into the right hand side to a point of near perfect ! 2713: * efficiency since scb_size * (i -1) is growing slightly faster ! 2714: * than the right hand side. If the number of SG array elements ! 2715: * is changed, this function may not be near so efficient any more. ! 2716: */ ! 2717: for ( i=step;; i *= 2 ) ! 2718: { ! 2719: if ( (scb_size * (i-1)) >= ( (PAGE_SIZE * (i/step)) - 64 ) ) ! 2720: { ! 2721: i /= 2; ! 2722: break; ! 2723: } ! 2724: } ! 2725: scb_count = MIN( (i-1), p->scb_data->maxscbs - p->scb_data->numscbs); ! 2726: scb_ap = (struct aic7xxx_scb *)kmalloc(scb_size * scb_count, GFP_ATOMIC); ! 2727: if (scb_ap != NULL) ! 2728: { ! 2729: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 2730: if (aic7xxx_verbose > 0xffff) ! 2731: { ! 2732: if (p->scb_data->numscbs == 0) ! 2733: printk(INFO_LEAD "Allocating initial %ld SCB structures.\n", ! 2734: p->host_no, -1, -1, -1, scb_count); ! 2735: else ! 2736: printk(INFO_LEAD "Allocating %ld additional SCB structures.\n", ! 2737: p->host_no, -1, -1, -1, scb_count); ! 2738: } ! 2739: #endif ! 2740: memset(scb_ap, 0, scb_count * scb_size); ! 2741: temp = (unsigned long) &scb_ap[scb_count]; ! 2742: temp += 1023; ! 2743: temp &= ~1023; ! 2744: hsgp = (struct hw_scatterlist *)temp; ! 2745: for (i=0; i < scb_count; i++) ! 2746: { ! 2747: scbp = &scb_ap[i]; ! 2748: scbp->hscb = &p->scb_data->hscbs[p->scb_data->numscbs]; ! 2749: scbp->sg_list = &hsgp[i * AIC7XXX_MAX_SG]; ! 2750: memset(scbp->hscb, 0, sizeof(struct aic7xxx_hwscb)); ! 2751: scbp->hscb->tag = p->scb_data->numscbs; ! 2752: /* ! 2753: * Place in the scb array; never is removed ! 2754: */ ! 2755: p->scb_data->scb_array[p->scb_data->numscbs++] = scbp; ! 2756: scbq_insert_head(&p->scb_data->free_scbs, scbp); ! 2757: } ! 2758: scbp->kmalloc_ptr = scb_ap; ! 2759: } ! 2760: else ! 2761: { ! 2762: return(0); ! 2763: } ! 2764: } ! 2765: return(scb_count); ! 2766: } ! 2767: ! 2768: /*+F************************************************************************* ! 2769: * Function: ! 2770: * aic7xxx_queue_cmd_complete ! 2771: * ! 2772: * Description: ! 2773: * Due to race conditions present in the SCSI subsystem, it is easier ! 2774: * to queue completed commands, then call scsi_done() on them when ! 2775: * we're finished. This function queues the completed commands. ! 2776: *-F*************************************************************************/ ! 2777: static void ! 2778: aic7xxx_queue_cmd_complete(struct aic7xxx_host *p, Scsi_Cmnd *cmd) ! 2779: { ! 2780: cmd->host_scribble = (char *)p->completeq.head; ! 2781: p->completeq.head = cmd; ! 2782: } ! 2783: ! 2784: /*+F************************************************************************* ! 2785: * Function: ! 2786: * aic7xxx_done_cmds_complete ! 2787: * ! 2788: * Description: ! 2789: * Process the completed command queue. ! 2790: *-F*************************************************************************/ ! 2791: static void ! 2792: aic7xxx_done_cmds_complete(struct aic7xxx_host *p) ! 2793: { ! 2794: Scsi_Cmnd *cmd; ! 2795: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 2796: unsigned int cpu_flags = 0; ! 2797: ! 2798: DRIVER_LOCK ! 2799: while (p->completeq.head != NULL) ! 2800: { ! 2801: cmd = p->completeq.head; ! 2802: p->completeq.head = (Scsi_Cmnd *)cmd->host_scribble; ! 2803: cmd->host_scribble = NULL; ! 2804: sti(); ! 2805: cmd->scsi_done(cmd); ! 2806: cli(); ! 2807: } ! 2808: DRIVER_UNLOCK ! 2809: #else ! 2810: while (p->completeq.head != NULL) ! 2811: { ! 2812: cmd = p->completeq.head; ! 2813: p->completeq.head = (Scsi_Cmnd *)cmd->host_scribble; ! 2814: cmd->host_scribble = NULL; ! 2815: cmd->scsi_done(cmd); ! 2816: } ! 2817: #endif ! 2818: } ! 2819: ! 2820: /*+F************************************************************************* ! 2821: * Function: ! 2822: * aic7xxx_free_scb ! 2823: * ! 2824: * Description: ! 2825: * Free the scb and insert into the free scb list. ! 2826: *-F*************************************************************************/ ! 2827: static void ! 2828: aic7xxx_free_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 2829: { ! 2830: ! 2831: scb->flags = SCB_FREE; ! 2832: scb->cmd = NULL; ! 2833: scb->sg_count = 0; ! 2834: scb->sg_length = 0; ! 2835: scb->tag_action = 0; ! 2836: scb->hscb->control = 0; ! 2837: scb->hscb->target_status = 0; ! 2838: scb->hscb->target_channel_lun = SCB_LIST_NULL; ! 2839: ! 2840: scbq_insert_head(&p->scb_data->free_scbs, scb); ! 2841: } ! 2842: ! 2843: /*+F************************************************************************* ! 2844: * Function: ! 2845: * aic7xxx_done ! 2846: * ! 2847: * Description: ! 2848: * Calls the higher level scsi done function and frees the scb. ! 2849: *-F*************************************************************************/ ! 2850: static void ! 2851: aic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 2852: { ! 2853: Scsi_Cmnd *cmd = scb->cmd; ! 2854: int tindex = TARGET_INDEX(cmd); ! 2855: struct aic7xxx_scb *scbp; ! 2856: unsigned char queue_depth; ! 2857: ! 2858: if (scb->flags & SCB_RECOVERY_SCB) ! 2859: { ! 2860: p->flags &= ~AHC_ABORT_PENDING; ! 2861: } ! 2862: if (scb->flags & SCB_RESET) ! 2863: { ! 2864: cmd->result = (DID_RESET << 16) | (cmd->result & 0xffff); ! 2865: } ! 2866: else if (scb->flags & SCB_ABORT) ! 2867: { ! 2868: cmd->result = (DID_RESET << 16) | (cmd->result & 0xffff); ! 2869: } ! 2870: else if (!(p->dev_flags[tindex] & DEVICE_SCANNED)) ! 2871: { ! 2872: if ( (cmd->cmnd[0] == INQUIRY) && (cmd->result == DID_OK) ) ! 2873: { ! 2874: char *buffer; ! 2875: ! 2876: if(cmd->use_sg) ! 2877: { ! 2878: struct scatterlist *sg; ! 2879: ! 2880: sg = (struct scatterlist *)cmd->request_buffer; ! 2881: buffer = (char *)sg[0].address; ! 2882: } ! 2883: else ! 2884: { ! 2885: buffer = (char *)cmd->request_buffer; ! 2886: } ! 2887: #define WIDE_INQUIRY_BITS 0x60 ! 2888: #define SYNC_INQUIRY_BITS 0x10 ! 2889: if ( (buffer[7] & WIDE_INQUIRY_BITS) && ! 2890: (p->features & AHC_WIDE) ) ! 2891: { ! 2892: p->needwdtr |= (1<<tindex); ! 2893: p->needwdtr_copy |= (1<<tindex); ! 2894: if ( (p->flags & AHC_SEEPROM_FOUND) && ! 2895: (p->transinfo[tindex].user_width != MSG_EXT_WDTR_BUS_16_BIT) ) ! 2896: p->transinfo[tindex].goal_width = MSG_EXT_WDTR_BUS_8_BIT; ! 2897: else ! 2898: p->transinfo[tindex].goal_width = MSG_EXT_WDTR_BUS_16_BIT; ! 2899: } ! 2900: else ! 2901: { ! 2902: p->needwdtr &= ~(1<<tindex); ! 2903: p->needwdtr_copy &= ~(1<<tindex); ! 2904: pause_sequencer(p); ! 2905: aic7xxx_set_width(p, cmd->target, cmd->channel, cmd->lun, ! 2906: MSG_EXT_WDTR_BUS_8_BIT, (AHC_TRANS_ACTIVE | ! 2907: AHC_TRANS_GOAL | ! 2908: AHC_TRANS_CUR) ); ! 2909: unpause_sequencer(p, FALSE); ! 2910: } ! 2911: if (buffer[7] & SYNC_INQUIRY_BITS) ! 2912: { ! 2913: p->needsdtr |= (1<<tindex); ! 2914: p->needsdtr_copy |= (1<<tindex); ! 2915: ! 2916: if (p->flags & AHC_SEEPROM_FOUND) ! 2917: p->transinfo[tindex].goal_period = p->transinfo[tindex].user_period; ! 2918: else if (p->features & AHC_ULTRA2) ! 2919: p->transinfo[tindex].goal_period = ! 2920: aic7xxx_syncrates[AHC_SYNCRATE_ULTRA2].period; ! 2921: else if (p->features & AHC_ULTRA) ! 2922: p->transinfo[tindex].goal_period = ! 2923: aic7xxx_syncrates[AHC_SYNCRATE_ULTRA].period; ! 2924: else ! 2925: p->transinfo[tindex].goal_period = ! 2926: aic7xxx_syncrates[AHC_SYNCRATE_FAST].period; ! 2927: ! 2928: if (p->features & AHC_ULTRA2) ! 2929: p->transinfo[tindex].goal_offset = MAX_OFFSET_ULTRA2; ! 2930: else if (p->transinfo[tindex].goal_width == MSG_EXT_WDTR_BUS_16_BIT) ! 2931: p->transinfo[tindex].goal_offset = MAX_OFFSET_16BIT; ! 2932: else ! 2933: p->transinfo[tindex].goal_offset = MAX_OFFSET_8BIT; ! 2934: } ! 2935: else ! 2936: { ! 2937: p->needsdtr &= ~(1<<tindex); ! 2938: p->needsdtr_copy &= ~(1<<tindex); ! 2939: p->transinfo[tindex].goal_period = 0; ! 2940: p->transinfo[tindex].goal_offset = 0; ! 2941: } ! 2942: p->dev_flags[tindex] |= DEVICE_SCANNED; ! 2943: p->dev_flags[tindex] |= DEVICE_PRINT_WDTR | DEVICE_PRINT_SDTR; ! 2944: #undef WIDE_INQUIRY_BITS ! 2945: #undef SYNC_INQUIRY_BITS ! 2946: } ! 2947: } ! 2948: else if ((scb->flags & (SCB_MSGOUT_WDTR | SCB_MSGOUT_SDTR)) != 0) ! 2949: { ! 2950: unsigned short mask; ! 2951: int message_error = FALSE; ! 2952: ! 2953: mask = 0x01 << tindex; ! 2954: ! 2955: /* ! 2956: * Check to see if we get an invalid message or a message error ! 2957: * after failing to negotiate a wide or sync transfer message. ! 2958: */ ! 2959: if ((scb->flags & SCB_SENSE) && ! 2960: ((scb->cmd->sense_buffer[12] == 0x43) || /* INVALID_MESSAGE */ ! 2961: (scb->cmd->sense_buffer[12] == 0x49))) /* MESSAGE_ERROR */ ! 2962: { ! 2963: message_error = TRUE; ! 2964: } ! 2965: ! 2966: if (scb->flags & SCB_MSGOUT_WDTR) ! 2967: { ! 2968: p->wdtr_pending &= ~mask; ! 2969: if (message_error) ! 2970: { ! 2971: if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) && ! 2972: (p->dev_flags[tindex] & DEVICE_PRINT_WDTR) ) ! 2973: { ! 2974: printk(INFO_LEAD "Device failed to complete Wide Negotiation " ! 2975: "processing and\n", p->host_no, CTL_OF_SCB(scb)); ! 2976: printk(INFO_LEAD "returned a sense error code for invalid message, " ! 2977: "disabling future\n", p->host_no, CTL_OF_SCB(scb)); ! 2978: printk(INFO_LEAD "Wide negotiation to this device.\n", p->host_no, ! 2979: CTL_OF_SCB(scb)); ! 2980: p->dev_flags[tindex] &= ~DEVICE_PRINT_WDTR; ! 2981: } ! 2982: p->needwdtr &= ~mask; ! 2983: p->needwdtr_copy &= ~mask; ! 2984: } ! 2985: } ! 2986: if (scb->flags & SCB_MSGOUT_SDTR) ! 2987: { ! 2988: p->sdtr_pending &= ~mask; ! 2989: if (message_error) ! 2990: { ! 2991: if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) && ! 2992: (p->dev_flags[tindex] & DEVICE_PRINT_SDTR) ) ! 2993: { ! 2994: printk(INFO_LEAD "Device failed to complete Sync Negotiation " ! 2995: "processing and\n", p->host_no, CTL_OF_SCB(scb)); ! 2996: printk(INFO_LEAD "returned a sense error code for invalid message, " ! 2997: "disabling future\n", p->host_no, CTL_OF_SCB(scb)); ! 2998: printk(INFO_LEAD "Sync negotiation to this device.\n", p->host_no, ! 2999: CTL_OF_SCB(scb)); ! 3000: p->dev_flags[tindex] &= ~DEVICE_PRINT_SDTR; ! 3001: } ! 3002: p->needsdtr &= ~mask; ! 3003: p->needsdtr_copy &= ~mask; ! 3004: } ! 3005: } ! 3006: } ! 3007: queue_depth = p->dev_temp_queue_depth[tindex]; ! 3008: if (queue_depth >= p->dev_active_cmds[tindex]) ! 3009: { ! 3010: scbp = scbq_remove_head(&p->delayed_scbs[tindex]); ! 3011: if (scbp) ! 3012: { ! 3013: if (queue_depth == 1) ! 3014: { ! 3015: /* ! 3016: * Give extra preference to untagged devices, such as CD-R devices ! 3017: * This makes it more likely that a drive *won't* stuff up while ! 3018: * waiting on data at a critical time, such as CD-R writing and ! 3019: * audio CD ripping operations. Should also benefit tape drives. ! 3020: */ ! 3021: scbq_insert_head(&p->waiting_scbs, scbp); ! 3022: } ! 3023: else ! 3024: { ! 3025: scbq_insert_tail(&p->waiting_scbs, scbp); ! 3026: } ! 3027: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 3028: if (aic7xxx_verbose > 0xffff) ! 3029: printk(INFO_LEAD "Moving SCB from delayed to waiting queue.\n", ! 3030: p->host_no, CTL_OF_SCB(scbp)); ! 3031: #endif ! 3032: if (queue_depth > p->dev_active_cmds[tindex]) ! 3033: { ! 3034: scbp = scbq_remove_head(&p->delayed_scbs[tindex]); ! 3035: if (scbp) ! 3036: scbq_insert_tail(&p->waiting_scbs, scbp); ! 3037: } ! 3038: } ! 3039: } ! 3040: if ( !(scb->tag_action) && (p->tagenable & (1<<tindex)) ) ! 3041: { ! 3042: p->dev_temp_queue_depth[tindex] = p->dev_max_queue_depth[tindex]; ! 3043: } ! 3044: p->dev_active_cmds[tindex]--; ! 3045: p->activescbs--; ! 3046: ! 3047: /* ! 3048: * If this was an untagged I/O, unbusy the target so the sequencer won't ! 3049: * mistake things later ! 3050: */ ! 3051: if (aic7xxx_index_busy_target(p, scb->hscb->target_channel_lun, FALSE) == ! 3052: scb->hscb->tag) ! 3053: { ! 3054: aic7xxx_index_busy_target(p, scb->hscb->target_channel_lun, TRUE); ! 3055: } ! 3056: ! 3057: { ! 3058: int actual; ! 3059: ! 3060: /* ! 3061: * XXX: we should actually know how much actually transferred ! 3062: * XXX: for each command, but apparently that's too difficult. ! 3063: * ! 3064: * We set a lower limit of 512 bytes on the transfer length. We ! 3065: * ignore anything less than this because we don't have a real ! 3066: * reason to count it. Read/Writes to tapes are usually about 20K ! 3067: * and disks are a minimum of 512 bytes unless you want to count ! 3068: * non-read/write commands (such as TEST_UNIT_READY) which we don't ! 3069: */ ! 3070: actual = scb->sg_length; ! 3071: if ((actual >= 512) && (((cmd->result >> 16) & 0xf) == DID_OK)) ! 3072: { ! 3073: struct aic7xxx_xferstats *sp; ! 3074: #ifdef AIC7XXX_PROC_STATS ! 3075: long *ptr; ! 3076: int x; ! 3077: #endif /* AIC7XXX_PROC_STATS */ ! 3078: ! 3079: sp = &p->stats[TARGET_INDEX(cmd)][cmd->lun & 0x7]; ! 3080: sp->xfers++; ! 3081: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 3082: if ( (sp->xfers > 16) && (aic7xxx_verbose > 0xffff) ) ! 3083: aic7xxx_verbose &= 0xffff; ! 3084: #endif ! 3085: ! 3086: /* ! 3087: * For block devices, cmd->request.cmd is always == either READ or ! 3088: * WRITE. For character devices, this isn't always set properly, so ! 3089: * we check data_cmnd[0]. This catches the conditions for st.c, but ! 3090: * I'm still not sure if request.cmd is valid for sg devices. ! 3091: */ ! 3092: if ( (cmd->request.cmd == WRITE) || (cmd->data_cmnd[0] == WRITE_6) || ! 3093: (cmd->data_cmnd[0] == WRITE_FILEMARKS) ) ! 3094: { ! 3095: sp->w_total++; ! 3096: sp->w_total512 += (actual >> 9); ! 3097: #ifdef AIC7XXX_PROC_STATS ! 3098: ptr = sp->w_bins; ! 3099: #endif /* AIC7XXX_PROC_STATS */ ! 3100: } ! 3101: else ! 3102: { ! 3103: sp->r_total++; ! 3104: sp->r_total512 += (actual >> 9); ! 3105: #ifdef AIC7XXX_PROC_STATS ! 3106: ptr = sp->r_bins; ! 3107: #endif /* AIC7XXX_PROC_STATS */ ! 3108: } ! 3109: #ifdef AIC7XXX_PROC_STATS ! 3110: for (x = 9; x <= 17; x++) ! 3111: { ! 3112: if (actual < (1 << x)) ! 3113: { ! 3114: ptr[x - 9]++; ! 3115: break; ! 3116: } ! 3117: } ! 3118: if (x > 17) ! 3119: { ! 3120: ptr[x - 9]++; ! 3121: } ! 3122: #endif /* AIC7XXX_PROC_STATS */ ! 3123: } ! 3124: } ! 3125: aic7xxx_free_scb(p, scb); ! 3126: aic7xxx_queue_cmd_complete(p, cmd); ! 3127: ! 3128: } ! 3129: ! 3130: /*+F************************************************************************* ! 3131: * Function: ! 3132: * aic7xxx_run_done_queue ! 3133: * ! 3134: * Description: ! 3135: * Calls the aic7xxx_done() for the Scsi_Cmnd of each scb in the ! 3136: * aborted list, and adds each scb to the free list. If complete ! 3137: * is TRUE, we also process the commands complete list. ! 3138: *-F*************************************************************************/ ! 3139: static void ! 3140: aic7xxx_run_done_queue(struct aic7xxx_host *p, /*complete*/ int complete) ! 3141: { ! 3142: struct aic7xxx_scb *scb; ! 3143: int i, found = 0; ! 3144: ! 3145: for (i = 0; i < p->scb_data->numscbs; i++) ! 3146: { ! 3147: scb = p->scb_data->scb_array[i]; ! 3148: if (scb->flags & SCB_QUEUED_FOR_DONE) ! 3149: { ! 3150: if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS)) ! 3151: printk(INFO_LEAD "Aborting scb %d\n", ! 3152: p->host_no, CTL_OF_SCB(scb), scb->hscb->tag); ! 3153: found++; ! 3154: aic7xxx_done(p, scb); ! 3155: } ! 3156: } ! 3157: if (aic7xxx_verbose & (VERBOSE_ABORT_RETURN | VERBOSE_RESET_RETURN)) ! 3158: { ! 3159: printk(INFO_LEAD "%d commands found and queued for " ! 3160: "completion.\n", p->host_no, -1, -1, -1, found); ! 3161: } ! 3162: if (complete) ! 3163: { ! 3164: aic7xxx_done_cmds_complete(p); ! 3165: } ! 3166: } ! 3167: ! 3168: /*+F************************************************************************* ! 3169: * Function: ! 3170: * aic7xxx_abort_waiting_scb ! 3171: * ! 3172: * Description: ! 3173: * Manipulate the waiting for selection list and return the ! 3174: * scb that follows the one that we remove. ! 3175: *-F*************************************************************************/ ! 3176: static unsigned char ! 3177: aic7xxx_abort_waiting_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb, ! 3178: unsigned char scbpos, unsigned char prev) ! 3179: { ! 3180: unsigned char curscb, next; ! 3181: ! 3182: /* ! 3183: * Select the SCB we want to abort and pull the next pointer out of it. ! 3184: */ ! 3185: curscb = aic_inb(p, SCBPTR); ! 3186: aic_outb(p, scbpos, SCBPTR); ! 3187: next = aic_inb(p, SCB_NEXT); ! 3188: ! 3189: aic7xxx_add_curscb_to_free_list(p); ! 3190: ! 3191: /* ! 3192: * Update the waiting list ! 3193: */ ! 3194: if (prev == SCB_LIST_NULL) ! 3195: { ! 3196: /* ! 3197: * First in the list ! 3198: */ ! 3199: aic_outb(p, next, WAITING_SCBH); ! 3200: } ! 3201: else ! 3202: { ! 3203: /* ! 3204: * Select the scb that pointed to us and update its next pointer. ! 3205: */ ! 3206: aic_outb(p, prev, SCBPTR); ! 3207: aic_outb(p, next, SCB_NEXT); ! 3208: } ! 3209: /* ! 3210: * Point us back at the original scb position and inform the SCSI ! 3211: * system that the command has been aborted. ! 3212: */ ! 3213: aic_outb(p, curscb, SCBPTR); ! 3214: return (next); ! 3215: } ! 3216: ! 3217: /*+F************************************************************************* ! 3218: * Function: ! 3219: * aic7xxx_search_qinfifo ! 3220: * ! 3221: * Description: ! 3222: * Search the queue-in FIFO for matching SCBs and conditionally ! 3223: * requeue. Returns the number of matching SCBs. ! 3224: *-F*************************************************************************/ ! 3225: static int ! 3226: aic7xxx_search_qinfifo(struct aic7xxx_host *p, int target, int channel, ! 3227: int lun, unsigned char tag, int flags, int requeue, ! 3228: volatile scb_queue_type *queue) ! 3229: { ! 3230: int found; ! 3231: unsigned char qinpos, qintail; ! 3232: struct aic7xxx_scb *scbp; ! 3233: ! 3234: found = 0; ! 3235: qinpos = aic_inb(p, QINPOS); ! 3236: qintail = p->qinfifonext; ! 3237: ! 3238: p->qinfifonext = qinpos; ! 3239: ! 3240: while (qinpos != qintail) ! 3241: { ! 3242: scbp = p->scb_data->scb_array[p->qinfifo[qinpos++]]; ! 3243: if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag)) ! 3244: { ! 3245: /* ! 3246: * We found an scb that needs to be removed. ! 3247: */ ! 3248: if (requeue && (queue != NULL)) ! 3249: { ! 3250: if (scbp->flags & SCB_WAITINGQ) ! 3251: { ! 3252: scbq_remove(queue, scbp); ! 3253: scbq_remove(&p->waiting_scbs, scbp); ! 3254: scbq_remove(&p->delayed_scbs[TARGET_INDEX(scbp->cmd)], scbp); ! 3255: p->dev_active_cmds[TARGET_INDEX(scbp->cmd)]++; ! 3256: p->activescbs++; ! 3257: } ! 3258: scbq_insert_tail(queue, scbp); ! 3259: p->dev_active_cmds[TARGET_INDEX(scbp->cmd)]--; ! 3260: p->activescbs--; ! 3261: scbp->flags |= SCB_WAITINGQ; ! 3262: if ( !(scbp->tag_action & TAG_ENB) ) ! 3263: { ! 3264: aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun, ! 3265: TRUE); ! 3266: } ! 3267: } ! 3268: else if (requeue) ! 3269: { ! 3270: p->qinfifo[p->qinfifonext++] = scbp->hscb->tag; ! 3271: } ! 3272: else ! 3273: { ! 3274: /* ! 3275: * Preserve any SCB_RECOVERY_SCB flags on this scb then set the ! 3276: * flags we were called with, presumeably so aic7xxx_run_done_queue ! 3277: * can find this scb ! 3278: */ ! 3279: scbp->flags = flags | (scbp->flags & SCB_RECOVERY_SCB); ! 3280: if (aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun, ! 3281: FALSE) == scbp->hscb->tag) ! 3282: { ! 3283: aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun, ! 3284: TRUE); ! 3285: } ! 3286: } ! 3287: found++; ! 3288: } ! 3289: else ! 3290: { ! 3291: p->qinfifo[p->qinfifonext++] = scbp->hscb->tag; ! 3292: } ! 3293: } ! 3294: /* ! 3295: * Now that we've done the work, clear out any left over commands in the ! 3296: * qinfifo and update the KERNEL_QINPOS down on the card. ! 3297: * ! 3298: * NOTE: This routine expect the sequencer to already be paused when ! 3299: * it is run....make sure it's that way! ! 3300: */ ! 3301: qinpos = p->qinfifonext; ! 3302: while(qinpos != qintail) ! 3303: { ! 3304: p->qinfifo[qinpos++] = SCB_LIST_NULL; ! 3305: } ! 3306: if (p->features & AHC_QUEUE_REGS) ! 3307: aic_outb(p, p->qinfifonext, HNSCB_QOFF); ! 3308: else ! 3309: aic_outb(p, p->qinfifonext, KERNEL_QINPOS); ! 3310: ! 3311: return (found); ! 3312: } ! 3313: ! 3314: /*+F************************************************************************* ! 3315: * Function: ! 3316: * aic7xxx_scb_on_qoutfifo ! 3317: * ! 3318: * Description: ! 3319: * Is the scb that was passed to us currently on the qoutfifo? ! 3320: *-F*************************************************************************/ ! 3321: static int ! 3322: aic7xxx_scb_on_qoutfifo(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 3323: { ! 3324: int i=0; ! 3325: ! 3326: while(p->qoutfifo[(p->qoutfifonext + i) & 0xff ] != SCB_LIST_NULL) ! 3327: { ! 3328: if(p->qoutfifo[(p->qoutfifonext + i) & 0xff ] == scb->hscb->tag) ! 3329: return TRUE; ! 3330: else ! 3331: i++; ! 3332: } ! 3333: return FALSE; ! 3334: } ! 3335: ! 3336: ! 3337: /*+F************************************************************************* ! 3338: * Function: ! 3339: * aic7xxx_reset_device ! 3340: * ! 3341: * Description: ! 3342: * The device at the given target/channel has been reset. Abort ! 3343: * all active and queued scbs for that target/channel. This function ! 3344: * need not worry about linked next pointers because if was a MSG_ABORT_TAG ! 3345: * then we had a tagged command (no linked next), if it was MSG_ABORT or ! 3346: * MSG_BUS_DEV_RESET then the device won't know about any commands any more ! 3347: * and no busy commands will exist, and if it was a bus reset, then nothing ! 3348: * knows about any linked next commands any more. In all cases, we don't ! 3349: * need to worry about the linked next or busy scb, we just need to clear ! 3350: * them. ! 3351: *-F*************************************************************************/ ! 3352: static void ! 3353: aic7xxx_reset_device(struct aic7xxx_host *p, int target, int channel, ! 3354: int lun, unsigned char tag) ! 3355: { ! 3356: struct aic7xxx_scb *scbp; ! 3357: unsigned char active_scb, tcl; ! 3358: int i = 0, j, init_lists = FALSE; ! 3359: ! 3360: /* ! 3361: * Restore this when we're done ! 3362: */ ! 3363: active_scb = aic_inb(p, SCBPTR); ! 3364: ! 3365: if (aic7xxx_verbose & (VERBOSE_RESET_PROCESS | VERBOSE_ABORT_PROCESS)) ! 3366: printk(INFO_LEAD "Reset device, active_scb %d\n", ! 3367: p->host_no, channel, target, lun, active_scb); ! 3368: /* ! 3369: * Deal with the busy target and linked next issues. ! 3370: */ ! 3371: { ! 3372: int min_target, max_target; ! 3373: struct aic7xxx_scb *scbp, *prev_scbp; ! 3374: ! 3375: /* Make all targets 'relative' to bus A. */ ! 3376: if (target == ALL_TARGETS) ! 3377: { ! 3378: switch (channel) ! 3379: { ! 3380: case 0: ! 3381: min_target = 0; ! 3382: max_target = (p->features & AHC_WIDE) ? 15 : 7; ! 3383: break; ! 3384: case 1: ! 3385: min_target = 8; ! 3386: max_target = 15; ! 3387: break; ! 3388: case ALL_CHANNELS: ! 3389: default: ! 3390: min_target = 0; ! 3391: max_target = (p->features & (AHC_TWIN|AHC_WIDE)) ? 15 : 7; ! 3392: break; ! 3393: } ! 3394: } ! 3395: else ! 3396: { ! 3397: min_target = target | (channel << 3); ! 3398: max_target = min_target; ! 3399: } ! 3400: ! 3401: ! 3402: for (i = min_target; i <= max_target; i++) ! 3403: { ! 3404: if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS)) ! 3405: printk(INFO_LEAD "Cleaning up status information " ! 3406: "and delayed_scbs.\n", p->host_no, channel, i, lun); ! 3407: if ( !(p->dev_flags[i] & DEVICE_TAGGED_SUCCESS) && ! 3408: (p->dev_active_cmds[i]) && ! 3409: (p->tagenable & (0x01 << i)) ) ! 3410: { ! 3411: printk(INFO_LEAD "Device appears to be choking on tagged commands.\n", ! 3412: p->host_no, channel, i, lun); ! 3413: printk(INFO_LEAD "Will use untagged I/O instead.\n", p->host_no, ! 3414: channel, i, lun); ! 3415: p->dev_max_queue_depth[i] = 1; ! 3416: p->dev_temp_queue_depth[i] = 1; ! 3417: p->tagenable &= ~(0x01 << i); ! 3418: p->orderedtag &= ~(0x01 << i); ! 3419: } ! 3420: p->dev_flags[i] &= ~BUS_DEVICE_RESET_PENDING; ! 3421: if ( tag == SCB_LIST_NULL ) ! 3422: { ! 3423: p->dev_flags[i] |= DEVICE_PRINT_WDTR | DEVICE_PRINT_SDTR; ! 3424: p->dev_last_reset[i] = jiffies; ! 3425: p->dev_last_queue_full_count[i] = 0; ! 3426: p->dev_last_queue_full[i] = 0; ! 3427: p->dev_temp_queue_depth[i] = ! 3428: p->dev_max_queue_depth[i]; ! 3429: /* ! 3430: * In case this isn't a full bus reset, we want to add a 4 second timer in ! 3431: * here so that we can delay all re-sent commands for this device for the ! 3432: * 4 seconds and then have our timer routine pick them back up. ! 3433: */ ! 3434: if(p->dev_timer[i].expires) ! 3435: { ! 3436: del_timer(&p->dev_timer[i]); ! 3437: } ! 3438: p->dev_timer[i].expires = jiffies + (4 * HZ); ! 3439: add_timer(&p->dev_timer[i]); ! 3440: } ! 3441: for(j=0; j<MAX_LUNS; j++) ! 3442: { ! 3443: if (channel == 1) ! 3444: tcl = ((i << 4) & 0x70) | (channel << 3) | j; ! 3445: else ! 3446: tcl = (i << 4) | (channel << 3) | j; ! 3447: if ( (aic7xxx_index_busy_target(p, tcl, FALSE) == tag) || ! 3448: (tag == SCB_LIST_NULL) ) ! 3449: aic7xxx_index_busy_target(p, tcl, /* unbusy */ TRUE); ! 3450: } ! 3451: j = 0; ! 3452: prev_scbp = NULL; ! 3453: scbp = p->delayed_scbs[i].head; ! 3454: while ( (scbp != NULL) && (j++ <= (p->scb_data->numscbs + 1)) ) ! 3455: { ! 3456: prev_scbp = scbp; ! 3457: scbp = scbp->q_next; ! 3458: if ( prev_scbp == scbp ) ! 3459: { ! 3460: if (aic7xxx_verbose & (VERBOSE_ABORT | VERBOSE_RESET)) ! 3461: printk(WARN_LEAD "Yikes!! scb->q_next == scb " ! 3462: "in the delayed_scbs queue!\n", p->host_no, channel, i, lun); ! 3463: scbp = NULL; ! 3464: prev_scbp->q_next = NULL; ! 3465: p->delayed_scbs[i].tail = prev_scbp; ! 3466: } ! 3467: if (aic7xxx_match_scb(p, prev_scbp, target, channel, lun, tag)) ! 3468: { ! 3469: scbq_remove(&p->delayed_scbs[i], prev_scbp); ! 3470: if (prev_scbp->flags & SCB_WAITINGQ) ! 3471: { ! 3472: p->dev_active_cmds[i]++; ! 3473: p->activescbs++; ! 3474: } ! 3475: prev_scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ); ! 3476: prev_scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE; ! 3477: } ! 3478: } ! 3479: if ( j > (p->scb_data->maxscbs + 1) ) ! 3480: { ! 3481: if (aic7xxx_verbose & (VERBOSE_ABORT | VERBOSE_RESET)) ! 3482: printk(WARN_LEAD "Yikes!! There's a loop in the " ! 3483: "delayed_scbs queue!\n", p->host_no, channel, i, lun); ! 3484: scbq_init(&p->delayed_scbs[i]); ! 3485: } ! 3486: if ( (p->delayed_scbs[i].head == NULL) && ! 3487: (p->dev_timer[i].expires) ) ! 3488: { ! 3489: del_timer(&p->dev_timer[i]); ! 3490: p->dev_timer[i].expires = 0; ! 3491: } ! 3492: } ! 3493: } ! 3494: ! 3495: if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS)) ! 3496: printk(INFO_LEAD "Cleaning QINFIFO.\n", p->host_no, channel, target, lun ); ! 3497: aic7xxx_search_qinfifo(p, target, channel, lun, tag, ! 3498: SCB_RESET | SCB_QUEUED_FOR_DONE, /* requeue */ FALSE, NULL); ! 3499: ! 3500: /* ! 3501: * Search the waiting_scbs queue for matches, this catches any SCB_QUEUED ! 3502: * ABORT/RESET commands. ! 3503: */ ! 3504: if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS)) ! 3505: printk(INFO_LEAD "Cleaning waiting_scbs.\n", p->host_no, channel, ! 3506: target, lun ); ! 3507: { ! 3508: struct aic7xxx_scb *scbp, *prev_scbp; ! 3509: ! 3510: j = 0; ! 3511: prev_scbp = NULL; ! 3512: scbp = p->waiting_scbs.head; ! 3513: while ( (scbp != NULL) && (j++ <= (p->scb_data->numscbs + 1)) ) ! 3514: { ! 3515: prev_scbp = scbp; ! 3516: scbp = scbp->q_next; ! 3517: if ( prev_scbp == scbp ) ! 3518: { ! 3519: if (aic7xxx_verbose & (VERBOSE_ABORT | VERBOSE_RESET)) ! 3520: printk(WARN_LEAD "Yikes!! scb->q_next == scb " ! 3521: "in the waiting_scbs queue!\n", p->host_no, CTL_OF_SCB(scbp)); ! 3522: scbp = NULL; ! 3523: prev_scbp->q_next = NULL; ! 3524: p->waiting_scbs.tail = prev_scbp; ! 3525: } ! 3526: if (aic7xxx_match_scb(p, prev_scbp, target, channel, lun, tag)) ! 3527: { ! 3528: scbq_remove(&p->waiting_scbs, prev_scbp); ! 3529: if (prev_scbp->flags & SCB_WAITINGQ) ! 3530: { ! 3531: p->dev_active_cmds[TARGET_INDEX(prev_scbp->cmd)]++; ! 3532: p->activescbs++; ! 3533: } ! 3534: prev_scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ); ! 3535: prev_scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE; ! 3536: } ! 3537: } ! 3538: if ( j > (p->scb_data->maxscbs + 1) ) ! 3539: { ! 3540: if (aic7xxx_verbose & (VERBOSE_ABORT | VERBOSE_RESET)) ! 3541: printk(WARN_LEAD "Yikes!! There's a loop in the " ! 3542: "waiting_scbs queue!\n", p->host_no, channel, target, lun); ! 3543: scbq_init(&p->waiting_scbs); ! 3544: } ! 3545: } ! 3546: ! 3547: ! 3548: /* ! 3549: * Search waiting for selection list. ! 3550: */ ! 3551: if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS)) ! 3552: printk(INFO_LEAD "Cleaning waiting for selection " ! 3553: "list.\n", p->host_no, channel, target, lun); ! 3554: { ! 3555: unsigned char next, prev, scb_index; ! 3556: ! 3557: next = aic_inb(p, WAITING_SCBH); /* Start at head of list. */ ! 3558: prev = SCB_LIST_NULL; ! 3559: j = 0; ! 3560: while ( (next != SCB_LIST_NULL) && (j++ <= (p->scb_data->maxscbs + 1)) ) ! 3561: { ! 3562: aic_outb(p, next, SCBPTR); ! 3563: scb_index = aic_inb(p, SCB_TAG); ! 3564: if (scb_index >= p->scb_data->numscbs) ! 3565: { ! 3566: /* ! 3567: * No aic7xxx_verbose check here.....we want to see this since it ! 3568: * means either the kernel driver or the sequencer screwed things up ! 3569: */ ! 3570: printk(WARN_LEAD "Waiting List inconsistency; SCB index=%d, " ! 3571: "numscbs=%d\n", p->host_no, channel, target, lun, scb_index, ! 3572: p->scb_data->numscbs); ! 3573: next = aic_inb(p, SCB_NEXT); ! 3574: aic7xxx_add_curscb_to_free_list(p); ! 3575: } ! 3576: else ! 3577: { ! 3578: scbp = p->scb_data->scb_array[scb_index]; ! 3579: if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag)) ! 3580: { ! 3581: next = aic7xxx_abort_waiting_scb(p, scbp, next, prev); ! 3582: if (scbp->flags & SCB_WAITINGQ) ! 3583: { ! 3584: p->dev_active_cmds[TARGET_INDEX(scbp->cmd)]++; ! 3585: p->activescbs++; ! 3586: } ! 3587: scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ); ! 3588: scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE; ! 3589: if (prev == SCB_LIST_NULL) ! 3590: { ! 3591: /* ! 3592: * This is either the first scb on the waiting list, or we ! 3593: * have already yanked the first and haven't left any behind. ! 3594: * Either way, we need to turn off the selection hardware if ! 3595: * it isn't already off. ! 3596: */ ! 3597: aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ); ! 3598: aic_outb(p, CLRSELTIMEO, CLRSINT1); ! 3599: } ! 3600: } ! 3601: else ! 3602: { ! 3603: prev = next; ! 3604: next = aic_inb(p, SCB_NEXT); ! 3605: } ! 3606: } ! 3607: } ! 3608: if ( j > (p->scb_data->maxscbs + 1) ) ! 3609: { ! 3610: printk(WARN_LEAD "Yikes!! There is a loop in the waiting for " ! 3611: "selection list!\n", p->host_no, channel, target, lun); ! 3612: init_lists = TRUE; ! 3613: } ! 3614: } ! 3615: ! 3616: /* ! 3617: * Go through disconnected list and remove any entries we have queued ! 3618: * for completion, zeroing their control byte too. ! 3619: */ ! 3620: if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS)) ! 3621: printk(INFO_LEAD "Cleaning disconnected scbs " ! 3622: "list.\n", p->host_no, channel, target, lun); ! 3623: if (p->features & AHC_PAGESCBS) ! 3624: { ! 3625: unsigned char next, prev, scb_index; ! 3626: ! 3627: next = aic_inb(p, DISCONNECTED_SCBH); ! 3628: prev = SCB_LIST_NULL; ! 3629: j = 0; ! 3630: while ( (next != SCB_LIST_NULL) && (j++ <= (p->scb_data->maxscbs + 1)) ) ! 3631: { ! 3632: aic_outb(p, next, SCBPTR); ! 3633: scb_index = aic_inb(p, SCB_TAG); ! 3634: if (scb_index > p->scb_data->numscbs) ! 3635: { ! 3636: printk(WARN_LEAD "Disconnected List inconsistency; SCB index=%d, " ! 3637: "numscbs=%d\n", p->host_no, channel, target, lun, scb_index, ! 3638: p->scb_data->numscbs); ! 3639: next = aic7xxx_rem_scb_from_disc_list(p, next); ! 3640: } ! 3641: else ! 3642: { ! 3643: scbp = p->scb_data->scb_array[scb_index]; ! 3644: if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag)) ! 3645: { ! 3646: next = aic7xxx_rem_scb_from_disc_list(p, next); ! 3647: if (scbp->flags & SCB_WAITINGQ) ! 3648: { ! 3649: p->dev_active_cmds[TARGET_INDEX(scbp->cmd)]++; ! 3650: p->activescbs++; ! 3651: } ! 3652: scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ); ! 3653: scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE; ! 3654: scbp->hscb->control = 0; ! 3655: } ! 3656: else ! 3657: { ! 3658: prev = next; ! 3659: next = aic_inb(p, SCB_NEXT); ! 3660: } ! 3661: } ! 3662: } ! 3663: if ( j > (p->scb_data->maxscbs + 1) ) ! 3664: { ! 3665: printk(WARN_LEAD "Yikes!! There is a loop in the disconnected list!\n", ! 3666: p->host_no, channel, target, lun); ! 3667: init_lists = TRUE; ! 3668: } ! 3669: } ! 3670: ! 3671: /* ! 3672: * Walk the free list making sure no entries on the free list have ! 3673: * a valid SCB_TAG value or SCB_CONTROL byte. ! 3674: */ ! 3675: if (p->features & AHC_PAGESCBS) ! 3676: { ! 3677: unsigned char next; ! 3678: ! 3679: j = 0; ! 3680: next = aic_inb(p, FREE_SCBH); ! 3681: if ( (next >= p->scb_data->maxhscbs) && (next != SCB_LIST_NULL) ) ! 3682: { ! 3683: printk(WARN_LEAD "Bogus FREE_SCBH!.\n", p->host_no, channel, ! 3684: target, lun); ! 3685: init_lists = TRUE; ! 3686: next = SCB_LIST_NULL; ! 3687: } ! 3688: while ( (next != SCB_LIST_NULL) && (j++ <= (p->scb_data->maxscbs + 1)) ) ! 3689: { ! 3690: aic_outb(p, next, SCBPTR); ! 3691: if (aic_inb(p, SCB_TAG) < p->scb_data->numscbs) ! 3692: { ! 3693: printk(WARN_LEAD "Free list inconsistency!.\n", p->host_no, channel, ! 3694: target, lun); ! 3695: init_lists = TRUE; ! 3696: next = SCB_LIST_NULL; ! 3697: } ! 3698: else ! 3699: { ! 3700: aic_outb(p, SCB_LIST_NULL, SCB_TAG); ! 3701: aic_outb(p, 0, SCB_CONTROL); ! 3702: next = aic_inb(p, SCB_NEXT); ! 3703: } ! 3704: } ! 3705: if ( j > (p->scb_data->maxscbs + 1) ) ! 3706: { ! 3707: printk(WARN_LEAD "Yikes!! There is a loop in the free list!\n", ! 3708: p->host_no, channel, target, lun); ! 3709: init_lists = TRUE; ! 3710: } ! 3711: } ! 3712: ! 3713: /* ! 3714: * Go through the hardware SCB array looking for commands that ! 3715: * were active but not on any list. ! 3716: */ ! 3717: if (init_lists) ! 3718: { ! 3719: aic_outb(p, SCB_LIST_NULL, FREE_SCBH); ! 3720: aic_outb(p, SCB_LIST_NULL, WAITING_SCBH); ! 3721: aic_outb(p, SCB_LIST_NULL, DISCONNECTED_SCBH); ! 3722: } ! 3723: for (i = p->scb_data->maxhscbs - 1; i >= 0; i--) ! 3724: { ! 3725: unsigned char scbid; ! 3726: ! 3727: aic_outb(p, i, SCBPTR); ! 3728: if (init_lists) ! 3729: { ! 3730: aic_outb(p, SCB_LIST_NULL, SCB_TAG); ! 3731: aic_outb(p, SCB_LIST_NULL, SCB_NEXT); ! 3732: aic_outb(p, SCB_LIST_NULL, SCB_PREV); ! 3733: aic_outb(p, 0, SCB_CONTROL); ! 3734: aic7xxx_add_curscb_to_free_list(p); ! 3735: } ! 3736: else ! 3737: { ! 3738: scbid = aic_inb(p, SCB_TAG); ! 3739: if (scbid < p->scb_data->numscbs) ! 3740: { ! 3741: scbp = p->scb_data->scb_array[scbid]; ! 3742: if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag)) ! 3743: { ! 3744: aic_outb(p, 0, SCB_CONTROL); ! 3745: aic_outb(p, SCB_LIST_NULL, SCB_TAG); ! 3746: aic7xxx_add_curscb_to_free_list(p); ! 3747: } ! 3748: } ! 3749: } ! 3750: } ! 3751: ! 3752: /* ! 3753: * Go through the entire SCB array now and look for commands for ! 3754: * for this target that are stillactive. These are other (most likely ! 3755: * tagged) commands that were disconnected when the reset occurred. ! 3756: * Any commands we find here we know this about, it wasn't on any queue, ! 3757: * it wasn't in the qinfifo, it wasn't in the disconnected or waiting ! 3758: * lists, so it really must have been a paged out SCB. In that case, ! 3759: * we shouldn't need to bother with updating any counters, just mark ! 3760: * the correct flags and go on. ! 3761: */ ! 3762: for (i = 0; i < p->scb_data->numscbs; i++) ! 3763: { ! 3764: scbp = p->scb_data->scb_array[i]; ! 3765: if ((scbp->flags & SCB_ACTIVE) && ! 3766: aic7xxx_match_scb(p, scbp, target, channel, lun, tag) && ! 3767: !aic7xxx_scb_on_qoutfifo(p, scbp)) ! 3768: { ! 3769: if (scbp->flags & SCB_WAITINGQ) ! 3770: { ! 3771: scbq_remove(&p->waiting_scbs, scbp); ! 3772: scbq_remove(&p->delayed_scbs[TARGET_INDEX(scbp->cmd)], scbp); ! 3773: p->dev_active_cmds[TARGET_INDEX(scbp->cmd)]++; ! 3774: p->activescbs++; ! 3775: } ! 3776: scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE; ! 3777: scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ); ! 3778: } ! 3779: } ! 3780: ! 3781: aic_outb(p, active_scb, SCBPTR); ! 3782: } ! 3783: ! 3784: ! 3785: /*+F************************************************************************* ! 3786: * Function: ! 3787: * aic7xxx_clear_intstat ! 3788: * ! 3789: * Description: ! 3790: * Clears the interrupt status. ! 3791: *-F*************************************************************************/ ! 3792: static void ! 3793: aic7xxx_clear_intstat(struct aic7xxx_host *p) ! 3794: { ! 3795: /* Clear any interrupt conditions this may have caused. */ ! 3796: aic_outb(p, CLRSELDO | CLRSELDI | CLRSELINGO, CLRSINT0); ! 3797: aic_outb(p, CLRSELTIMEO | CLRATNO | CLRSCSIRSTI | CLRBUSFREE | CLRSCSIPERR | ! 3798: CLRPHASECHG | CLRREQINIT, CLRSINT1); ! 3799: aic_outb(p, CLRSCSIINT | CLRSEQINT | CLRBRKADRINT | CLRPARERR, CLRINT); ! 3800: } ! 3801: ! 3802: /*+F************************************************************************* ! 3803: * Function: ! 3804: * aic7xxx_reset_current_bus ! 3805: * ! 3806: * Description: ! 3807: * Reset the current SCSI bus. ! 3808: *-F*************************************************************************/ ! 3809: static void ! 3810: aic7xxx_reset_current_bus(struct aic7xxx_host *p) ! 3811: { ! 3812: ! 3813: /* Disable reset interrupts. */ ! 3814: aic_outb(p, aic_inb(p, SIMODE1) & ~ENSCSIRST, SIMODE1); ! 3815: ! 3816: /* Turn off the bus' current operations, after all, we shouldn't have any ! 3817: * valid commands left to cause a RSELI and SELO once we've tossed the ! 3818: * bus away with this reset, so we might as well shut down the sequencer ! 3819: * until the bus is restarted as oppossed to saving the current settings ! 3820: * and restoring them (which makes no sense to me). */ ! 3821: ! 3822: /* Turn on the bus reset. */ ! 3823: aic_outb(p, aic_inb(p, SCSISEQ) | SCSIRSTO, SCSISEQ); ! 3824: while ( (aic_inb(p, SCSISEQ) & SCSIRSTO) == 0) ! 3825: mdelay(5); ! 3826: ! 3827: mdelay(10); ! 3828: ! 3829: /* Turn off the bus reset. */ ! 3830: aic_outb(p, 0, SCSISEQ); ! 3831: mdelay(5); ! 3832: ! 3833: aic7xxx_clear_intstat(p); ! 3834: /* Re-enable reset interrupts. */ ! 3835: aic_outb(p, aic_inb(p, SIMODE1) | ENSCSIRST, SIMODE1); ! 3836: ! 3837: } ! 3838: ! 3839: /*+F************************************************************************* ! 3840: * Function: ! 3841: * aic7xxx_reset_channel ! 3842: * ! 3843: * Description: ! 3844: * Reset the channel. ! 3845: *-F*************************************************************************/ ! 3846: static void ! 3847: aic7xxx_reset_channel(struct aic7xxx_host *p, int channel, int initiate_reset) ! 3848: { ! 3849: unsigned long offset_min, offset_max; ! 3850: unsigned char sblkctl; ! 3851: int cur_channel; ! 3852: ! 3853: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 3854: printk(INFO_LEAD "Reset channel called, %s initiate reset.\n", ! 3855: p->host_no, channel, -1, -1, (initiate_reset==TRUE) ? "will" : "won't" ); ! 3856: ! 3857: ! 3858: if (channel == 1) ! 3859: { ! 3860: p->needsdtr |= (p->needsdtr_copy & 0xFF00); ! 3861: p->sdtr_pending &= 0x00FF; ! 3862: offset_min = 8; ! 3863: offset_max = 16; ! 3864: } ! 3865: else ! 3866: { ! 3867: if (p->features & AHC_WIDE) ! 3868: { ! 3869: p->needsdtr = p->needsdtr_copy; ! 3870: p->needwdtr = p->needwdtr_copy; ! 3871: p->sdtr_pending = 0x0; ! 3872: p->wdtr_pending = 0x0; ! 3873: offset_min = 0; ! 3874: offset_max = 16; ! 3875: } ! 3876: else ! 3877: { ! 3878: /* Channel A */ ! 3879: p->needsdtr |= (p->needsdtr_copy & 0x00FF); ! 3880: p->sdtr_pending &= 0xFF00; ! 3881: offset_min = 0; ! 3882: offset_max = 8; ! 3883: } ! 3884: } ! 3885: ! 3886: while (offset_min < offset_max) ! 3887: { ! 3888: /* ! 3889: * Revert to async/narrow transfers until we renegotiate. ! 3890: */ ! 3891: aic_outb(p, 0, TARG_SCSIRATE + offset_min); ! 3892: if (p->features & AHC_ULTRA2) ! 3893: { ! 3894: aic_outb(p, 0, TARG_OFFSET + offset_min); ! 3895: } ! 3896: offset_min++; ! 3897: } ! 3898: ! 3899: /* ! 3900: * Reset the bus and unpause/restart the controller ! 3901: */ ! 3902: sblkctl = aic_inb(p, SBLKCTL); ! 3903: if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 ) ! 3904: cur_channel = (sblkctl & SELBUSB) >> 3; ! 3905: else ! 3906: cur_channel = 0; ! 3907: if ( (cur_channel != channel) && (p->features & AHC_TWIN) ) ! 3908: { ! 3909: /* ! 3910: * Case 1: Command for another bus is active ! 3911: */ ! 3912: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 3913: printk(INFO_LEAD "Stealthily resetting idle channel.\n", p->host_no, ! 3914: channel, -1, -1); ! 3915: /* ! 3916: * Stealthily reset the other bus without upsetting the current bus. ! 3917: */ ! 3918: aic_outb(p, sblkctl ^ SELBUSB, SBLKCTL); ! 3919: aic_outb(p, aic_inb(p, SIMODE1) & ~ENBUSFREE, SIMODE1); ! 3920: if (initiate_reset) ! 3921: { ! 3922: aic7xxx_reset_current_bus(p); ! 3923: } ! 3924: aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), SCSISEQ); ! 3925: aic7xxx_clear_intstat(p); ! 3926: aic_outb(p, sblkctl, SBLKCTL); ! 3927: } ! 3928: else ! 3929: { ! 3930: /* ! 3931: * Case 2: A command from this bus is active or we're idle. ! 3932: */ ! 3933: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 3934: printk(INFO_LEAD "Resetting currently active channel.\n", p->host_no, ! 3935: channel, -1, -1); ! 3936: aic_outb(p, aic_inb(p, SIMODE1) & ~(ENBUSFREE|ENREQINIT), ! 3937: SIMODE1); ! 3938: p->flags &= ~AHC_HANDLING_REQINITS; ! 3939: p->msg_type = MSG_TYPE_NONE; ! 3940: p->msg_len = 0; ! 3941: if (initiate_reset) ! 3942: { ! 3943: aic7xxx_reset_current_bus(p); ! 3944: } ! 3945: aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), SCSISEQ); ! 3946: aic7xxx_clear_intstat(p); ! 3947: } ! 3948: if (aic7xxx_verbose & VERBOSE_RESET_RETURN) ! 3949: printk(INFO_LEAD "Channel reset\n", p->host_no, channel, -1, -1); ! 3950: /* ! 3951: * Clean up all the state information for the pending transactions ! 3952: * on this bus. ! 3953: */ ! 3954: aic7xxx_reset_device(p, ALL_TARGETS, channel, ALL_LUNS, SCB_LIST_NULL); ! 3955: ! 3956: /* ! 3957: * Convince Mid Level SCSI code to leave us be for a little bit... ! 3958: */ ! 3959: p->last_reset = jiffies; ! 3960: p->host->last_reset = (jiffies + (HZ * AIC7XXX_RESET_DELAY)); ! 3961: ! 3962: if ( !(p->features & AHC_TWIN) ) ! 3963: { ! 3964: restart_sequencer(p); ! 3965: } ! 3966: ! 3967: return; ! 3968: } ! 3969: ! 3970: /*+F************************************************************************* ! 3971: * Function: ! 3972: * aic7xxx_run_waiting_queues ! 3973: * ! 3974: * Description: ! 3975: * Scan the awaiting_scbs queue downloading and starting as many ! 3976: * scbs as we can. ! 3977: *-F*************************************************************************/ ! 3978: static void ! 3979: aic7xxx_run_waiting_queues(struct aic7xxx_host *p) ! 3980: { ! 3981: struct aic7xxx_scb *scb; ! 3982: int tindex; ! 3983: int sent; ! 3984: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 3985: unsigned long cpu_flags = 0; ! 3986: #endif ! 3987: ! 3988: ! 3989: if (p->waiting_scbs.head == NULL) ! 3990: return; ! 3991: ! 3992: sent = 0; ! 3993: ! 3994: /* ! 3995: * First handle SCBs that are waiting but have been assigned a slot. ! 3996: */ ! 3997: DRIVER_LOCK ! 3998: while ((scb = scbq_remove_head(&p->waiting_scbs)) != NULL) ! 3999: { ! 4000: tindex = TARGET_INDEX(scb->cmd); ! 4001: if ( !scb->tag_action && (p->tagenable & (1<<tindex)) ) ! 4002: { ! 4003: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 4004: if (aic7xxx_verbose > 0xffff) ! 4005: printk(INFO_LEAD "Reducing Queue depth for untagged command.\n", ! 4006: p->host_no, CTL_OF_SCB(scb)); ! 4007: #endif ! 4008: p->dev_temp_queue_depth[tindex] = 1; ! 4009: } ! 4010: if ( (p->dev_active_cmds[tindex] >= ! 4011: p->dev_temp_queue_depth[tindex]) || ! 4012: (p->dev_last_reset[tindex] >= (jiffies - (4 * HZ))) ) ! 4013: { ! 4014: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 4015: if (aic7xxx_verbose > 0xffff) ! 4016: printk(INFO_LEAD "Moving SCB to Delayed Queue.\n", ! 4017: p->host_no, CTL_OF_SCB(scb)); ! 4018: #endif ! 4019: scbq_insert_tail(&p->delayed_scbs[tindex], scb); ! 4020: if ( !(p->dev_timer[tindex].expires) && ! 4021: !(p->dev_active_cmds[tindex]) ) ! 4022: { ! 4023: p->dev_timer[tindex].expires = p->dev_last_reset[tindex] + (4 * HZ); ! 4024: add_timer(&p->dev_timer[tindex]); ! 4025: } ! 4026: } ! 4027: else ! 4028: { ! 4029: scb->flags &= ~SCB_WAITINGQ; ! 4030: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 4031: if (aic7xxx_verbose > 0xffff) ! 4032: printk(INFO_LEAD "Sending command %d/0x%x to QINFIFO\n", p->host_no, ! 4033: CTL_OF_SCB(scb), scb->hscb->tag, scb->flags); ! 4034: #endif ! 4035: p->dev_active_cmds[tindex]++; ! 4036: p->activescbs++; ! 4037: if ( !(scb->tag_action) ) ! 4038: { ! 4039: aic7xxx_busy_target(p, scb); ! 4040: } ! 4041: p->qinfifo[p->qinfifonext++] = scb->hscb->tag; ! 4042: sent++; ! 4043: } ! 4044: } ! 4045: if (sent) ! 4046: { ! 4047: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 4048: if (aic7xxx_verbose > 0xffff) ! 4049: { ! 4050: printk(INFO_LEAD "Sending commands to QINFIFO\n", p->host_no, ! 4051: -1, -1, -1); ! 4052: if ( (p->isr_count < 16) && (aic7xxx_panic_on_abort) && ! 4053: (p->flags & AHC_PAGESCBS) ) ! 4054: aic7xxx_check_scbs(p, "While sending commands to QINFIFO"); ! 4055: } ! 4056: #endif ! 4057: if (p->features & AHC_QUEUE_REGS) ! 4058: aic_outb(p, p->qinfifonext, HNSCB_QOFF); ! 4059: else ! 4060: { ! 4061: pause_sequencer(p); ! 4062: aic_outb(p, p->qinfifonext, KERNEL_QINPOS); ! 4063: unpause_sequencer(p, FALSE); ! 4064: } ! 4065: if (p->activescbs > p->max_activescbs) ! 4066: p->max_activescbs = p->activescbs; ! 4067: } ! 4068: DRIVER_UNLOCK ! 4069: } ! 4070: ! 4071: #ifdef CONFIG_PCI ! 4072: ! 4073: #define DPE 0x80 ! 4074: #define SSE 0x40 ! 4075: #define RMA 0x20 ! 4076: #define RTA 0x10 ! 4077: #define STA 0x08 ! 4078: #define DPR 0x01 ! 4079: ! 4080: /*+F************************************************************************* ! 4081: * Function: ! 4082: * aic7xxx_pci_intr ! 4083: * ! 4084: * Description: ! 4085: * Check the scsi card for PCI errors and clear the interrupt ! 4086: * ! 4087: * NOTE: If you don't have this function and a 2940 card encounters ! 4088: * a PCI error condition, the machine will end up locked as the ! 4089: * interrupt handler gets slammed with non-stop PCI error interrupts ! 4090: *-F*************************************************************************/ ! 4091: static void ! 4092: aic7xxx_pci_intr(struct aic7xxx_host *p) ! 4093: { ! 4094: unsigned char status1; ! 4095: ! 4096: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 4097: pci_read_config_byte(p->pdev, PCI_STATUS + 1, &status1); ! 4098: #else ! 4099: pcibios_read_config_byte(p->pci_bus, p->pci_device_fn, ! 4100: PCI_STATUS + 1, &status1); ! 4101: #endif ! 4102: ! 4103: if ( (status1 & DPE) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ) ! 4104: printk(WARN_LEAD "Data Parity Error during PCI address or PCI write" ! 4105: "phase.\n", p->host_no, -1, -1, -1); ! 4106: if ( (status1 & SSE) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ) ! 4107: printk(WARN_LEAD "Signal System Error Detected\n", p->host_no, ! 4108: -1, -1, -1); ! 4109: if ( (status1 & RMA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ) ! 4110: printk(WARN_LEAD "Received a PCI Master Abort\n", p->host_no, ! 4111: -1, -1, -1); ! 4112: if ( (status1 & RTA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ) ! 4113: printk(WARN_LEAD "Received a PCI Target Abort\n", p->host_no, ! 4114: -1, -1, -1); ! 4115: if ( (status1 & STA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ) ! 4116: printk(WARN_LEAD "Signaled a PCI Target Abort\n", p->host_no, ! 4117: -1, -1, -1); ! 4118: if ( (status1 & DPR) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ) ! 4119: printk(WARN_LEAD "Data Parity Error has been reported via PCI pin " ! 4120: "PERR#\n", p->host_no, -1, -1, -1); ! 4121: ! 4122: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 4123: pci_write_config_byte(p->pdev, PCI_STATUS + 1, status1); ! 4124: #else ! 4125: pcibios_write_config_byte(p->pci_bus, p->pci_device_fn, ! 4126: PCI_STATUS + 1, status1); ! 4127: #endif ! 4128: if (status1 & (DPR|RMA|RTA)) ! 4129: aic_outb(p, CLRPARERR, CLRINT); ! 4130: ! 4131: if ( (aic7xxx_panic_on_abort) && (p->spurious_int > 500) ) ! 4132: aic7xxx_panic_abort(p, NULL); ! 4133: ! 4134: } ! 4135: #endif /* CONFIG_PCI */ ! 4136: ! 4137: /*+F************************************************************************* ! 4138: * Function: ! 4139: * aic7xxx_timer ! 4140: * ! 4141: * Description: ! 4142: * Take expired extries off of delayed queues and place on waiting queue ! 4143: * then run waiting queue to start commands. ! 4144: ***************************************************************************/ ! 4145: static void ! 4146: aic7xxx_timer(struct aic7xxx_host *p) ! 4147: { ! 4148: int i, j; ! 4149: unsigned long cpu_flags = 0; ! 4150: struct aic7xxx_scb *scb; ! 4151: ! 4152: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 4153: DRIVER_LOCK ! 4154: #else ! 4155: spin_lock_irqsave(&io_request_lock, cpu_flags); ! 4156: #endif ! 4157: for(i=0; i<MAX_TARGETS; i++) ! 4158: { ! 4159: if ( (p->dev_timer[i].expires) && ! 4160: (p->dev_timer[i].expires <= jiffies) ) ! 4161: { ! 4162: p->dev_timer[i].expires = 0; ! 4163: if ( (p->dev_timer[i].prev != NULL) || ! 4164: (p->dev_timer[i].next != NULL) ) ! 4165: { ! 4166: del_timer(&p->dev_timer[i]); ! 4167: } ! 4168: p->dev_temp_queue_depth[i] = p->dev_max_queue_depth[i]; ! 4169: j = 0; ! 4170: while ( ((scb = scbq_remove_head(&p->delayed_scbs[i])) != NULL) && ! 4171: (j++ < p->scb_data->numscbs) ) ! 4172: { ! 4173: scbq_insert_tail(&p->waiting_scbs, scb); ! 4174: } ! 4175: if (j == p->scb_data->numscbs) ! 4176: { ! 4177: printk(INFO_LEAD "timer: Yikes, loop in delayed_scbs list.\n", ! 4178: p->host_no, 0, i, -1); ! 4179: scbq_init(&p->delayed_scbs[i]); ! 4180: scbq_init(&p->waiting_scbs); ! 4181: /* ! 4182: * Well, things are screwed now, wait for a reset to clean the junk ! 4183: * out. ! 4184: */ ! 4185: } ! 4186: } ! 4187: } ! 4188: aic7xxx_run_waiting_queues(p); ! 4189: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 4190: DRIVER_UNLOCK ! 4191: #else ! 4192: spin_unlock_irqrestore(&io_request_lock, cpu_flags); ! 4193: #endif ! 4194: } ! 4195: ! 4196: /*+F************************************************************************* ! 4197: * Function: ! 4198: * aic7xxx_construct_sdtr ! 4199: * ! 4200: * Description: ! 4201: * Constucts a synchronous data transfer message in the message ! 4202: * buffer on the sequencer. ! 4203: *-F*************************************************************************/ ! 4204: static void ! 4205: aic7xxx_construct_sdtr(struct aic7xxx_host *p, unsigned char period, ! 4206: unsigned char offset) ! 4207: { ! 4208: p->msg_buf[p->msg_index++] = MSG_EXTENDED; ! 4209: p->msg_buf[p->msg_index++] = MSG_EXT_SDTR_LEN; ! 4210: p->msg_buf[p->msg_index++] = MSG_EXT_SDTR; ! 4211: p->msg_buf[p->msg_index++] = period; ! 4212: p->msg_buf[p->msg_index++] = offset; ! 4213: p->msg_len += 5; ! 4214: } ! 4215: ! 4216: /*+F************************************************************************* ! 4217: * Function: ! 4218: * aic7xxx_construct_wdtr ! 4219: * ! 4220: * Description: ! 4221: * Constucts a wide data transfer message in the message buffer ! 4222: * on the sequencer. ! 4223: *-F*************************************************************************/ ! 4224: static void ! 4225: aic7xxx_construct_wdtr(struct aic7xxx_host *p, unsigned char bus_width) ! 4226: { ! 4227: p->msg_buf[p->msg_index++] = MSG_EXTENDED; ! 4228: p->msg_buf[p->msg_index++] = MSG_EXT_WDTR_LEN; ! 4229: p->msg_buf[p->msg_index++] = MSG_EXT_WDTR; ! 4230: p->msg_buf[p->msg_index++] = bus_width; ! 4231: p->msg_len += 4; ! 4232: } ! 4233: ! 4234: /*+F************************************************************************* ! 4235: * Function: ! 4236: * aic7xxx_calc_residual ! 4237: * ! 4238: * Description: ! 4239: * Calculate the residual data not yet transferred. ! 4240: *-F*************************************************************************/ ! 4241: static void ! 4242: aic7xxx_calculate_residual (struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 4243: { ! 4244: struct aic7xxx_hwscb *hscb; ! 4245: Scsi_Cmnd *cmd; ! 4246: int actual, i; ! 4247: ! 4248: cmd = scb->cmd; ! 4249: hscb = scb->hscb; ! 4250: ! 4251: /* ! 4252: * Don't destroy valid residual information with ! 4253: * residual coming from a check sense operation. ! 4254: */ ! 4255: if (((scb->hscb->control & DISCONNECTED) == 0) && ! 4256: (scb->flags & SCB_SENSE) == 0) ! 4257: { ! 4258: /* ! 4259: * We had an underflow. At this time, there's only ! 4260: * one other driver that bothers to check for this, ! 4261: * and cmd->underflow seems to be set rather half- ! 4262: * heartedly in the higher-level SCSI code. ! 4263: */ ! 4264: actual = scb->sg_length; ! 4265: for (i=1; i < hscb->residual_SG_segment_count; i++) ! 4266: { ! 4267: actual -= scb->sg_list[scb->sg_count - i].length; ! 4268: } ! 4269: actual -= (hscb->residual_data_count[2] << 16) | ! 4270: (hscb->residual_data_count[1] << 8) | ! 4271: hscb->residual_data_count[0]; ! 4272: ! 4273: if (actual < cmd->underflow) ! 4274: { ! 4275: if (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ! 4276: printk(INFO_LEAD "Underflow - Wanted %u, %s %u, residual SG " ! 4277: "count %d.\n", p->host_no, CTL_OF_SCB(scb), cmd->underflow, ! 4278: (cmd->request.cmd == WRITE) ? "wrote" : "read", actual, ! 4279: hscb->residual_SG_segment_count); ! 4280: aic7xxx_error(cmd) = DID_RETRY_COMMAND; ! 4281: aic7xxx_status(cmd) = hscb->target_status; ! 4282: } ! 4283: } ! 4284: ! 4285: /* ! 4286: * Clean out the residual information in the SCB for the ! 4287: * next consumer. ! 4288: */ ! 4289: hscb->residual_data_count[2] = 0; ! 4290: hscb->residual_data_count[1] = 0; ! 4291: hscb->residual_data_count[0] = 0; ! 4292: hscb->residual_SG_segment_count = 0; ! 4293: } ! 4294: ! 4295: /*+F************************************************************************* ! 4296: * Function: ! 4297: * aic7xxx_handle_device_reset ! 4298: * ! 4299: * Description: ! 4300: * Interrupt handler for sequencer interrupts (SEQINT). ! 4301: *-F*************************************************************************/ ! 4302: static void ! 4303: aic7xxx_handle_device_reset(struct aic7xxx_host *p, int target, int channel) ! 4304: { ! 4305: unsigned short targ_mask; ! 4306: unsigned char tindex = target; ! 4307: ! 4308: tindex |= ((channel & 0x01) << 3); ! 4309: ! 4310: targ_mask = (0x01 << tindex); ! 4311: /* ! 4312: * Go back to async/narrow transfers and renegotiate. ! 4313: */ ! 4314: p->needsdtr |= (p->needsdtr_copy & targ_mask); ! 4315: p->needwdtr |= (p->needwdtr_copy & targ_mask); ! 4316: p->sdtr_pending &= ~targ_mask; ! 4317: p->wdtr_pending &= ~targ_mask; ! 4318: aic_outb(p, 0, TARG_SCSIRATE + tindex); ! 4319: if (p->features & AHC_ULTRA2) ! 4320: aic_outb(p, 0, TARG_OFFSET + tindex); ! 4321: aic7xxx_reset_device(p, target, channel, ALL_LUNS, SCB_LIST_NULL); ! 4322: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 4323: printk(INFO_LEAD "Bus Device Reset delivered.\n", p->host_no, channel, ! 4324: target, -1); ! 4325: aic7xxx_run_done_queue(p, /*complete*/ FALSE); ! 4326: } ! 4327: ! 4328: /*+F************************************************************************* ! 4329: * Function: ! 4330: * aic7xxx_handle_seqint ! 4331: * ! 4332: * Description: ! 4333: * Interrupt handler for sequencer interrupts (SEQINT). ! 4334: *-F*************************************************************************/ ! 4335: static void ! 4336: aic7xxx_handle_seqint(struct aic7xxx_host *p, unsigned char intstat) ! 4337: { ! 4338: struct aic7xxx_scb *scb; ! 4339: unsigned short target_mask; ! 4340: unsigned char target, lun, tindex; ! 4341: unsigned char queue_flag = FALSE; ! 4342: char channel; ! 4343: ! 4344: target = ((aic_inb(p, SAVED_TCL) >> 4) & 0x0f); ! 4345: if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 ) ! 4346: channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3; ! 4347: else ! 4348: channel = 0; ! 4349: tindex = target + (channel << 3); ! 4350: lun = aic_inb(p, SAVED_TCL) & 0x07; ! 4351: target_mask = (0x01 << tindex); ! 4352: ! 4353: /* ! 4354: * Go ahead and clear the SEQINT now, that avoids any interrupt race ! 4355: * conditions later on in case we enable some other interrupt. ! 4356: */ ! 4357: aic_outb(p, CLRSEQINT, CLRINT); ! 4358: switch (intstat & SEQINT_MASK) ! 4359: { ! 4360: case NO_MATCH: ! 4361: { ! 4362: aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), ! 4363: SCSISEQ); ! 4364: printk(WARN_LEAD "No active SCB for reconnecting target - Issuing " ! 4365: "BUS DEVICE RESET.\n", p->host_no, channel, target, lun); ! 4366: printk(WARN_LEAD " SAVED_TCL=0x%x, ARG_1=0x%x, SEQADDR=0x%x\n", ! 4367: p->host_no, channel, target, lun, ! 4368: aic_inb(p, SAVED_TCL), aic_inb(p, ARG_1), ! 4369: (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0)); ! 4370: } ! 4371: break; ! 4372: ! 4373: case SEND_REJECT: ! 4374: { ! 4375: if (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ! 4376: printk(INFO_LEAD "Rejecting unknown message (0x%x) received from " ! 4377: "target, SEQ_FLAGS=0x%x\n", p->host_no, channel, target, lun, ! 4378: aic_inb(p, ACCUM), aic_inb(p, SEQ_FLAGS)); ! 4379: } ! 4380: break; ! 4381: ! 4382: case NO_IDENT: ! 4383: { ! 4384: /* ! 4385: * The reconnecting target either did not send an identify ! 4386: * message, or did, but we didn't find an SCB to match and ! 4387: * before it could respond to our ATN/abort, it hit a dataphase. ! 4388: * The only safe thing to do is to blow it away with a bus ! 4389: * reset. ! 4390: */ ! 4391: if (aic7xxx_verbose & (VERBOSE_SEQINT | VERBOSE_RESET_MID)) ! 4392: printk(INFO_LEAD "Target did not send an IDENTIFY message; " ! 4393: "LASTPHASE 0x%x, SAVED_TCL 0x%x\n", p->host_no, channel, target, ! 4394: lun, aic_inb(p, LASTPHASE), aic_inb(p, SAVED_TCL)); ! 4395: ! 4396: aic7xxx_reset_channel(p, channel, /*initiate reset*/ TRUE); ! 4397: aic7xxx_run_done_queue(p, FALSE); ! 4398: ! 4399: } ! 4400: break; ! 4401: ! 4402: case BAD_PHASE: ! 4403: if (aic_inb(p, LASTPHASE) == P_BUSFREE) ! 4404: { ! 4405: if (aic7xxx_verbose & VERBOSE_SEQINT) ! 4406: printk(INFO_LEAD "Missed busfree.\n", p->host_no, channel, ! 4407: target, lun); ! 4408: restart_sequencer(p); ! 4409: } ! 4410: else ! 4411: { ! 4412: if (aic7xxx_verbose & VERBOSE_SEQINT) ! 4413: printk(INFO_LEAD "Unknown scsi bus phase, continuing\n", p->host_no, ! 4414: channel, target, lun); ! 4415: } ! 4416: break; ! 4417: ! 4418: case EXTENDED_MSG: ! 4419: { ! 4420: p->msg_type = MSG_TYPE_INITIATOR_MSGIN; ! 4421: p->msg_len = 0; ! 4422: p->msg_index = 0; ! 4423: ! 4424: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 4425: if (aic7xxx_verbose > 0xffff) ! 4426: printk(INFO_LEAD "Enabling REQINITs for MSG_IN\n", p->host_no, ! 4427: channel, target, lun); ! 4428: #endif ! 4429: ! 4430: /* ! 4431: * To actually receive the message, simply turn on ! 4432: * REQINIT interrupts and let our interrupt handler ! 4433: * do the rest (REQINIT should already be true). ! 4434: */ ! 4435: p->flags |= AHC_HANDLING_REQINITS; ! 4436: aic_outb(p, aic_inb(p, SIMODE1) | ENREQINIT, SIMODE1); ! 4437: ! 4438: /* ! 4439: * We don't want the sequencer unpaused yet so we return early ! 4440: */ ! 4441: return; ! 4442: } ! 4443: ! 4444: case REJECT_MSG: ! 4445: { ! 4446: /* ! 4447: * What we care about here is if we had an outstanding SDTR ! 4448: * or WDTR message for this target. If we did, this is a ! 4449: * signal that the target is refusing negotiation. ! 4450: */ ! 4451: unsigned char scb_index; ! 4452: unsigned char last_msg; ! 4453: ! 4454: scb_index = aic_inb(p, SCB_TAG); ! 4455: scb = p->scb_data->scb_array[scb_index]; ! 4456: last_msg = aic_inb(p, LAST_MSG); ! 4457: ! 4458: if ( (last_msg == MSG_IDENTIFYFLAG) && ! 4459: (scb->tag_action) && ! 4460: !(scb->flags & SCB_MSGOUT_BITS) ) ! 4461: { ! 4462: if ((scb->tag_action == MSG_ORDERED_Q_TAG) && ! 4463: (p->dev_flags[tindex] & DEVICE_TAGGED_SUCCESS)) ! 4464: { ! 4465: /* ! 4466: * OK...the device seems able to accept tagged commands, but ! 4467: * not ordered tag commands, only simple tag commands. So, we ! 4468: * disable ordered tag commands and go on with life just like ! 4469: * normal. ! 4470: */ ! 4471: p->orderedtag &= ~target_mask; ! 4472: scb->tag_action = MSG_SIMPLE_Q_TAG; ! 4473: scb->hscb->control &= ~SCB_TAG_TYPE; ! 4474: scb->hscb->control |= MSG_SIMPLE_Q_TAG; ! 4475: aic_outb(p, scb->hscb->control, SCB_CONTROL); ! 4476: /* ! 4477: * OK..we set the tag type to simple tag command, now we re-assert ! 4478: * ATNO and hope this will take us into the identify phase again ! 4479: * so we can resend the tag type and info to the device. ! 4480: */ ! 4481: aic_outb(p, MSG_IDENTIFYFLAG, MSG_OUT); ! 4482: aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO); ! 4483: } ! 4484: else if ( (scb->tag_action == MSG_SIMPLE_Q_TAG) && ! 4485: !(p->dev_flags[tindex] & DEVICE_TAGGED_SUCCESS) ) ! 4486: { ! 4487: unsigned char i, reset = 0; ! 4488: struct aic7xxx_scb *scbp; ! 4489: int old_verbose; ! 4490: /* ! 4491: * Hmmmm....the device is flaking out on tagged commands. The ! 4492: * bad thing is that we already have tagged commands enabled in ! 4493: * the device struct in the mid level code. We also have a queue ! 4494: * set according to the tagged queue depth. Gonna have to live ! 4495: * with it by controlling our queue depth internally and making ! 4496: * sure we don't set the tagged command flag any more. ! 4497: */ ! 4498: p->tagenable &= ~target_mask; ! 4499: p->orderedtag &= ~target_mask; ! 4500: p->dev_max_queue_depth[tindex] = ! 4501: p->dev_temp_queue_depth[tindex] = 1; ! 4502: /* ! 4503: * We set this command up as a bus device reset. However, we have ! 4504: * to clear the tag type as it's causing us problems. We shouldnt ! 4505: * have to worry about any other commands being active, since if ! 4506: * the device is refusing tagged commands, this should be the ! 4507: * first tagged command sent to the device, however, we do have ! 4508: * to worry about any other tagged commands that may already be ! 4509: * in the qinfifo. The easiest way to do this, is to issue a BDR, ! 4510: * send all the commands back to the mid level code, then let them ! 4511: * come back and get rebuilt as untagged commands. ! 4512: */ ! 4513: scb->tag_action = 0; ! 4514: scb->hscb->control &= ~(TAG_ENB | SCB_TAG_TYPE); ! 4515: aic_outb(p, scb->hscb->control, SCB_CONTROL); ! 4516: ! 4517: old_verbose = aic7xxx_verbose; ! 4518: aic7xxx_verbose &= ~(VERBOSE_RESET|VERBOSE_ABORT); ! 4519: for (i=0; i!=p->scb_data->numscbs; i++) ! 4520: { ! 4521: scbp = p->scb_data->scb_array[i]; ! 4522: if ((scbp->flags & SCB_ACTIVE) && (scbp != scb)) ! 4523: { ! 4524: if (aic7xxx_match_scb(p, scbp, target, channel, lun, i)) ! 4525: { ! 4526: aic7xxx_reset_device(p, target, channel, lun, i); ! 4527: reset++; ! 4528: } ! 4529: aic7xxx_run_done_queue(p, FALSE); ! 4530: } ! 4531: } ! 4532: aic7xxx_verbose = old_verbose; ! 4533: /* ! 4534: * Wait until after the for loop to set the busy index since ! 4535: * aic7xxx_reset_device will clear the busy index during its ! 4536: * operation. ! 4537: */ ! 4538: aic7xxx_busy_target(p, scb); ! 4539: printk(INFO_LEAD "Device is refusing tagged commands, using " ! 4540: "untagged I/O.\n", p->host_no, channel, target, lun); ! 4541: aic_outb(p, MSG_IDENTIFYFLAG, MSG_OUT); ! 4542: aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO); ! 4543: } ! 4544: } ! 4545: else if (scb->flags & SCB_MSGOUT_WDTR) ! 4546: { ! 4547: /* ! 4548: * note 8bit xfers and clear flag ! 4549: */ ! 4550: p->needwdtr &= ~target_mask; ! 4551: p->needwdtr_copy &= ~target_mask; ! 4552: p->wdtr_pending &= ~target_mask; ! 4553: scb->flags &= ~SCB_MSGOUT_BITS; ! 4554: aic7xxx_set_width(p, target, channel, lun, MSG_EXT_WDTR_BUS_8_BIT, ! 4555: (AHC_TRANS_ACTIVE|AHC_TRANS_GOAL|AHC_TRANS_CUR)); ! 4556: aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, ! 4557: AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE); ! 4558: if ( (p->needsdtr_copy & target_mask) && ! 4559: !(p->sdtr_pending & target_mask) ) ! 4560: { ! 4561: p->sdtr_pending |= target_mask; ! 4562: scb->flags |= SCB_MSGOUT_SDTR; ! 4563: aic_outb(p, HOST_MSG, MSG_OUT); ! 4564: aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO); ! 4565: } ! 4566: } ! 4567: else if (scb->flags & SCB_MSGOUT_SDTR) ! 4568: { ! 4569: /* ! 4570: * note asynch xfers and clear flag ! 4571: */ ! 4572: p->needsdtr &= ~target_mask; ! 4573: p->needsdtr_copy &= ~target_mask; ! 4574: p->sdtr_pending &= ~target_mask; ! 4575: scb->flags &= ~SCB_MSGOUT_SDTR; ! 4576: aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, ! 4577: (AHC_TRANS_CUR|AHC_TRANS_ACTIVE|AHC_TRANS_GOAL)); ! 4578: } ! 4579: else if (aic7xxx_verbose & VERBOSE_SEQINT) ! 4580: { ! 4581: /* ! 4582: * Otherwise, we ignore it. ! 4583: */ ! 4584: printk(INFO_LEAD "Received MESSAGE_REJECT for unknown cause. " ! 4585: "Ignoring.\n", p->host_no, channel, target, lun); ! 4586: } ! 4587: } ! 4588: break; ! 4589: ! 4590: case BAD_STATUS: ! 4591: { ! 4592: unsigned char scb_index; ! 4593: struct aic7xxx_hwscb *hscb; ! 4594: Scsi_Cmnd *cmd; ! 4595: ! 4596: /* The sequencer will notify us when a command has an error that ! 4597: * would be of interest to the kernel. This allows us to leave ! 4598: * the sequencer running in the common case of command completes ! 4599: * without error. The sequencer will have DMA'd the SCB back ! 4600: * up to us, so we can reference the drivers SCB array. ! 4601: * ! 4602: * Set the default return value to 0 indicating not to send ! 4603: * sense. The sense code will change this if needed and this ! 4604: * reduces code duplication. ! 4605: */ ! 4606: aic_outb(p, 0, RETURN_1); ! 4607: scb_index = aic_inb(p, SCB_TAG); ! 4608: if (scb_index > p->scb_data->numscbs) ! 4609: { ! 4610: printk(WARN_LEAD "Invalid SCB during SEQINT 0x%02x, SCB_TAG %d.\n", ! 4611: p->host_no, channel, target, lun, intstat, scb_index); ! 4612: break; ! 4613: } ! 4614: scb = p->scb_data->scb_array[scb_index]; ! 4615: hscb = scb->hscb; ! 4616: ! 4617: if (!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL)) ! 4618: { ! 4619: printk(WARN_LEAD "Invalid SCB during SEQINT 0x%x, scb %d, flags 0x%x," ! 4620: " cmd 0x%lx.\n", p->host_no, channel, target, lun, intstat, ! 4621: scb_index, scb->flags, (unsigned long) scb->cmd); ! 4622: } ! 4623: else ! 4624: { ! 4625: cmd = scb->cmd; ! 4626: hscb->target_status = aic_inb(p, SCB_TARGET_STATUS); ! 4627: aic7xxx_status(cmd) = hscb->target_status; ! 4628: ! 4629: cmd->result = hscb->target_status; ! 4630: ! 4631: switch (status_byte(hscb->target_status)) ! 4632: { ! 4633: case GOOD: ! 4634: if (aic7xxx_verbose & VERBOSE_SEQINT) ! 4635: printk(INFO_LEAD "Interrupted for status of GOOD???\n", ! 4636: p->host_no, CTL_OF_SCB(scb)); ! 4637: break; ! 4638: ! 4639: case COMMAND_TERMINATED: ! 4640: case CHECK_CONDITION: ! 4641: if ( !(scb->flags & SCB_SENSE) ) ! 4642: { ! 4643: /* ! 4644: * XXX - How do we save the residual (if there is one). ! 4645: */ ! 4646: if ( hscb->residual_SG_segment_count != 0 ) ! 4647: aic7xxx_calculate_residual(p, scb); ! 4648: ! 4649: /* ! 4650: * Send a sense command to the requesting target. ! 4651: * XXX - revisit this and get rid of the memcopys. ! 4652: */ ! 4653: memcpy(&scb->sense_cmd[0], &generic_sense[0], ! 4654: sizeof(generic_sense)); ! 4655: ! 4656: scb->sense_cmd[1] = (cmd->lun << 5); ! 4657: scb->sense_cmd[4] = sizeof(cmd->sense_buffer); ! 4658: ! 4659: scb->sg_list[0].address = ! 4660: cpu_to_le32(VIRT_TO_BUS(&cmd->sense_buffer[0])); ! 4661: scb->sg_list[0].length = ! 4662: cpu_to_le32(sizeof(cmd->sense_buffer)); ! 4663: ! 4664: /* ! 4665: * XXX - We should allow disconnection, but can't as it ! 4666: * might allow overlapped tagged commands. ! 4667: */ ! 4668: /* hscb->control &= DISCENB; */ ! 4669: hscb->control = 0; ! 4670: hscb->target_status = 0; ! 4671: hscb->SG_list_pointer = ! 4672: cpu_to_le32(VIRT_TO_BUS(&scb->sg_list[0])); ! 4673: hscb->data_pointer = scb->sg_list[0].address; ! 4674: hscb->data_count = scb->sg_list[0].length; ! 4675: hscb->SCSI_cmd_pointer = ! 4676: cpu_to_le32(VIRT_TO_BUS(&scb->sense_cmd[0])); ! 4677: hscb->SCSI_cmd_length = COMMAND_SIZE(scb->sense_cmd[0]); ! 4678: hscb->residual_SG_segment_count = 0; ! 4679: hscb->residual_data_count[0] = 0; ! 4680: hscb->residual_data_count[1] = 0; ! 4681: hscb->residual_data_count[2] = 0; ! 4682: ! 4683: scb->sg_count = hscb->SG_segment_count = 1; ! 4684: scb->sg_length = sizeof(cmd->sense_buffer); ! 4685: scb->tag_action = 0; ! 4686: /* ! 4687: * This problem could be caused if the target has lost power ! 4688: * or found some other way to loose the negotiation settings, ! 4689: * so if needed, we'll re-negotiate while doing the sense cmd. ! 4690: * However, if this SCB already was attempting to negotiate, ! 4691: * then we assume this isn't the problem and skip this part. ! 4692: */ ! 4693: #ifdef AIC7XXX_FAKE_NEGOTIATION_CMDS ! 4694: if ( (scb->cmd->cmnd[0] != TEST_UNIT_READY) && ! 4695: (p->dev_flags[tindex] & DEVICE_SCANNED) && ! 4696: !(p->wdtr_pending & target_mask) && ! 4697: !(p->sdtr_pending & target_mask) ) ! 4698: { ! 4699: p->needwdtr |= (p->needwdtr_copy & target_mask); ! 4700: p->needsdtr |= (p->needsdtr_copy & target_mask); ! 4701: } ! 4702: else if ( (scb->cmd == p->dev_wdtr_cmnd[tindex]) || ! 4703: (scb->cmd == p->dev_sdtr_cmnd[tindex]) ) ! 4704: { ! 4705: /* ! 4706: * This is already a negotiation command, so we must have ! 4707: * already done either WDTR or SDTR (or maybe both). So ! 4708: * we simply check sdtr_pending and needsdtr to see if we ! 4709: * should throw out SDTR on this command. ! 4710: * ! 4711: * Note: Don't check the needsdtr_copy here, instead just ! 4712: * check to see if WDTR wiped out our SDTR and set needsdtr. ! 4713: * Even if WDTR did wipe out SDTR and set needsdtr, if ! 4714: * parse_msg() then turned around and started our SDTR ! 4715: * in back to back fasion, then conclusion of that should ! 4716: * have negated any needsdtr setting. That's why we only ! 4717: * check needsdtr and sdtr_pending. ! 4718: */ ! 4719: scb->flags &= ~SCB_MSGOUT_BITS; ! 4720: if ( (scb->cmd == p->dev_wdtr_cmnd[tindex]) && ! 4721: !(p->sdtr_pending & target_mask) && ! 4722: (p->needsdtr & target_mask) ) ! 4723: { ! 4724: p->sdtr_pending |= target_mask; ! 4725: hscb->control |= MK_MESSAGE; ! 4726: scb->flags |= SCB_MSGOUT_SDTR; ! 4727: } ! 4728: ! 4729: /* ! 4730: * This is the important part though. We are getting sense ! 4731: * info back from this device. It's going into a fake ! 4732: * command. We need to put that into the real command ! 4733: * instead so that the mid level SCSI code can act upon it. ! 4734: * So, when we set up these fake commands, the next pointer ! 4735: * is used to point to the real command. Use that to change ! 4736: * the address of our sense_buffer[] to the real command. ! 4737: * However, don't do this if the real command is also a ! 4738: * TEST_UNIT_READY as it will most likely pull down its own ! 4739: * SENSE information anyway. ! 4740: */ ! 4741: if (cmd->next->cmnd[0] != TEST_UNIT_READY) ! 4742: { ! 4743: scb->sg_list[0].address = ! 4744: cpu_to_le32(VIRT_TO_BUS(&cmd->next->sense_buffer[0])); ! 4745: hscb->data_pointer = scb->sg_list[0].address; ! 4746: } ! 4747: } ! 4748: #else ! 4749: if ( (scb->cmd->cmnd[0] != TEST_UNIT_READY) && ! 4750: !(scb->flags & SCB_MSGOUT_BITS) && ! 4751: (scb->cmd->lun == 0) && ! 4752: (p->dev_flags[TARGET_INDEX(scb->cmd)] & DEVICE_SCANNED) ) ! 4753: { ! 4754: if ( (p->needwdtr_copy & target_mask) && ! 4755: !(p->wdtr_pending & target_mask) && ! 4756: !(p->sdtr_pending & target_mask) ) ! 4757: { ! 4758: p->needwdtr |= target_mask; ! 4759: p->wdtr_pending |= target_mask; ! 4760: hscb->control |= MK_MESSAGE; ! 4761: scb->flags |= SCB_MSGOUT_WDTR; ! 4762: } ! 4763: if ( p->needsdtr_copy & target_mask ) ! 4764: { ! 4765: p->needsdtr |= target_mask; ! 4766: if ( !(p->wdtr_pending & target_mask) && ! 4767: !(p->sdtr_pending & target_mask) ) ! 4768: { ! 4769: p->sdtr_pending |= target_mask; ! 4770: hscb->control |= MK_MESSAGE; ! 4771: scb->flags |= SCB_MSGOUT_SDTR; ! 4772: } ! 4773: } ! 4774: } ! 4775: else ! 4776: scb->flags &= ~SCB_MSGOUT_BITS; ! 4777: #endif /* AIC7XXX_FAKE_NEGOTIATION_CMDS */ ! 4778: scb->flags |= SCB_SENSE; ! 4779: /* ! 4780: * Ensure the target is busy since this will be an ! 4781: * an untagged request. ! 4782: */ ! 4783: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 4784: if (aic7xxx_verbose > 0xffff) ! 4785: { ! 4786: if (scb->flags & SCB_MSGOUT_BITS) ! 4787: printk(INFO_LEAD "Requesting SENSE with %s\n", p->host_no, ! 4788: CTL_OF_SCB(scb), (scb->flags & SCB_MSGOUT_SDTR) ? ! 4789: "SDTR" : "WDTR"); ! 4790: else ! 4791: printk(INFO_LEAD "Requesting SENSE, no MSG\n", p->host_no, ! 4792: CTL_OF_SCB(scb)); ! 4793: } ! 4794: #endif ! 4795: aic7xxx_busy_target(p, scb); ! 4796: aic_outb(p, SEND_SENSE, RETURN_1); ! 4797: aic7xxx_error(cmd) = DID_OK; ! 4798: break; ! 4799: } /* first time sense, no errors */ ! 4800: aic7xxx_error(cmd) = DID_OK; ! 4801: scb->flags &= ~SCB_SENSE; ! 4802: break; ! 4803: ! 4804: case QUEUE_FULL: ! 4805: queue_flag = TRUE; /* Mark that this is a QUEUE_FULL and */ ! 4806: case BUSY: /* drop through to here */ ! 4807: { ! 4808: struct aic7xxx_scb *next_scbp, *prev_scbp; ! 4809: unsigned char active_hscb, next_hscb, prev_hscb, scb_index; ! 4810: /* ! 4811: * We have to look three places for queued commands: ! 4812: * 1: QINFIFO ! 4813: * 2: p->waiting_scbs queue ! 4814: * 3: WAITING_SCBS list on card (for commands that are started ! 4815: * but haven't yet made it to the device) ! 4816: */ ! 4817: aic7xxx_search_qinfifo(p, target, channel, lun, ! 4818: SCB_LIST_NULL, 0, TRUE, ! 4819: &p->delayed_scbs[tindex]); ! 4820: next_scbp = p->waiting_scbs.head; ! 4821: while ( next_scbp != NULL ) ! 4822: { ! 4823: prev_scbp = next_scbp; ! 4824: next_scbp = next_scbp->q_next; ! 4825: if ( aic7xxx_match_scb(p, prev_scbp, target, channel, lun, ! 4826: SCB_LIST_NULL) ) ! 4827: { ! 4828: scbq_remove(&p->waiting_scbs, prev_scbp); ! 4829: scbq_insert_tail(&p->delayed_scbs[tindex], ! 4830: prev_scbp); ! 4831: } ! 4832: } ! 4833: next_scbp = NULL; ! 4834: active_hscb = aic_inb(p, SCBPTR); ! 4835: prev_hscb = next_hscb = scb_index = SCB_LIST_NULL; ! 4836: next_hscb = aic_inb(p, WAITING_SCBH); ! 4837: while (next_hscb != SCB_LIST_NULL) ! 4838: { ! 4839: aic_outb(p, next_hscb, SCBPTR); ! 4840: scb_index = aic_inb(p, SCB_TAG); ! 4841: if (scb_index < p->scb_data->numscbs) ! 4842: { ! 4843: next_scbp = p->scb_data->scb_array[scb_index]; ! 4844: if (aic7xxx_match_scb(p, next_scbp, target, channel, lun, ! 4845: SCB_LIST_NULL) ) ! 4846: { ! 4847: if (next_scbp->flags & SCB_WAITINGQ) ! 4848: { ! 4849: p->dev_active_cmds[tindex]++; ! 4850: p->activescbs--; ! 4851: scbq_remove(&p->delayed_scbs[tindex], next_scbp); ! 4852: scbq_remove(&p->waiting_scbs, next_scbp); ! 4853: } ! 4854: scbq_insert_head(&p->delayed_scbs[tindex], ! 4855: next_scbp); ! 4856: next_scbp->flags |= SCB_WAITINGQ; ! 4857: p->dev_active_cmds[tindex]--; ! 4858: p->activescbs--; ! 4859: next_hscb = aic_inb(p, SCB_NEXT); ! 4860: aic_outb(p, 0, SCB_CONTROL); ! 4861: aic_outb(p, SCB_LIST_NULL, SCB_TAG); ! 4862: aic7xxx_add_curscb_to_free_list(p); ! 4863: if (prev_hscb == SCB_LIST_NULL) ! 4864: { ! 4865: /* We were first on the list, ! 4866: * so we kill the selection ! 4867: * hardware. Let the sequencer ! 4868: * re-init the hardware itself ! 4869: */ ! 4870: aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ); ! 4871: aic_outb(p, CLRSELTIMEO, CLRSINT1); ! 4872: aic_outb(p, next_hscb, WAITING_SCBH); ! 4873: } ! 4874: else ! 4875: { ! 4876: aic_outb(p, prev_hscb, SCBPTR); ! 4877: aic_outb(p, next_hscb, SCB_NEXT); ! 4878: } ! 4879: } ! 4880: else ! 4881: { ! 4882: prev_hscb = next_hscb; ! 4883: next_hscb = aic_inb(p, SCB_NEXT); ! 4884: } ! 4885: } /* scb_index >= p->scb_data->numscbs */ ! 4886: } ! 4887: aic_outb(p, active_hscb, SCBPTR); ! 4888: if (scb->flags & SCB_WAITINGQ) ! 4889: { ! 4890: scbq_remove(&p->delayed_scbs[tindex], scb); ! 4891: scbq_remove(&p->waiting_scbs, scb); ! 4892: p->dev_active_cmds[tindex]++; ! 4893: p->activescbs++; ! 4894: } ! 4895: scbq_insert_head(&p->delayed_scbs[tindex], scb); ! 4896: p->dev_active_cmds[tindex]--; ! 4897: p->activescbs--; ! 4898: scb->flags |= SCB_WAITINGQ | SCB_WAS_BUSY; ! 4899: ! 4900: if (p->dev_timer[tindex].expires == 0) ! 4901: { ! 4902: if ( p->dev_active_cmds[tindex] ) ! 4903: { ! 4904: p->dev_timer[tindex].expires = jiffies + (HZ * 2); ! 4905: add_timer(&p->dev_timer[tindex]); ! 4906: } ! 4907: else ! 4908: { ! 4909: p->dev_timer[tindex].expires = jiffies + (HZ / 2); ! 4910: add_timer(&p->dev_timer[tindex]); ! 4911: } ! 4912: } ! 4913: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 4914: if (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ! 4915: { ! 4916: if (queue_flag) ! 4917: printk(INFO_LEAD "Queue full received; queue depth %d, " ! 4918: "active %d\n", p->host_no, CTL_OF_SCB(scb), ! 4919: p->dev_max_queue_depth[tindex], ! 4920: p->dev_active_cmds[tindex]); ! 4921: else ! 4922: printk(INFO_LEAD "Target busy\n", p->host_no, CTL_OF_SCB(scb)); ! 4923: ! 4924: } ! 4925: #endif ! 4926: if (queue_flag) ! 4927: { ! 4928: p->dev_temp_queue_depth[tindex] = ! 4929: p->dev_active_cmds[tindex]; ! 4930: if ( p->dev_last_queue_full[tindex] != ! 4931: p->dev_active_cmds[tindex] ) ! 4932: { ! 4933: p->dev_last_queue_full[tindex] = ! 4934: p->dev_active_cmds[tindex]; ! 4935: p->dev_last_queue_full_count[tindex] = 0; ! 4936: } ! 4937: else ! 4938: { ! 4939: p->dev_last_queue_full_count[tindex]++; ! 4940: } ! 4941: if ( (p->dev_last_queue_full_count[tindex] > 14) && ! 4942: (p->dev_active_cmds[tindex] > 4) ) ! 4943: { ! 4944: if (aic7xxx_verbose & VERBOSE_NEGOTIATION2) ! 4945: printk(INFO_LEAD "Queue depth reduced to %d\n", p->host_no, ! 4946: CTL_OF_SCB(scb), p->dev_active_cmds[tindex]); ! 4947: p->dev_max_queue_depth[tindex] = ! 4948: p->dev_active_cmds[tindex]; ! 4949: p->dev_last_queue_full[tindex] = 0; ! 4950: p->dev_last_queue_full_count[tindex] = 0; ! 4951: } ! 4952: } ! 4953: break; ! 4954: } ! 4955: ! 4956: default: ! 4957: if (aic7xxx_verbose & VERBOSE_SEQINT) ! 4958: printk(INFO_LEAD "Unexpected target status 0x%x.\n", p->host_no, ! 4959: CTL_OF_SCB(scb), scb->hscb->target_status); ! 4960: if (!aic7xxx_error(cmd)) ! 4961: { ! 4962: aic7xxx_error(cmd) = DID_RETRY_COMMAND; ! 4963: } ! 4964: break; ! 4965: } /* end switch */ ! 4966: } /* end else of */ ! 4967: } ! 4968: break; ! 4969: ! 4970: case AWAITING_MSG: ! 4971: { ! 4972: unsigned char scb_index, msg_out; ! 4973: ! 4974: scb_index = aic_inb(p, SCB_TAG); ! 4975: msg_out = aic_inb(p, MSG_OUT); ! 4976: scb = p->scb_data->scb_array[scb_index]; ! 4977: p->msg_index = p->msg_len = 0; ! 4978: /* ! 4979: * This SCB had a MK_MESSAGE set in its control byte informing ! 4980: * the sequencer that we wanted to send a special message to ! 4981: * this target. ! 4982: */ ! 4983: ! 4984: if ( !(scb->flags & SCB_DEVICE_RESET) && ! 4985: (aic_inb(p, MSG_OUT) == MSG_IDENTIFYFLAG) && ! 4986: (scb->hscb->control & TAG_ENB) ) ! 4987: { ! 4988: p->msg_buf[p->msg_index++] = scb->tag_action; ! 4989: p->msg_buf[p->msg_index++] = scb->hscb->tag; ! 4990: p->msg_len += 2; ! 4991: } ! 4992: ! 4993: if (scb->flags & SCB_DEVICE_RESET) ! 4994: { ! 4995: p->msg_buf[p->msg_index++] = MSG_BUS_DEV_RESET; ! 4996: p->msg_len++; ! 4997: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 4998: printk(INFO_LEAD "Bus device reset mailed.\n", ! 4999: p->host_no, CTL_OF_SCB(scb)); ! 5000: } ! 5001: else if (scb->flags & SCB_ABORT) ! 5002: { ! 5003: if (scb->tag_action) ! 5004: { ! 5005: p->msg_buf[p->msg_index++] = MSG_ABORT_TAG; ! 5006: } ! 5007: else ! 5008: { ! 5009: p->msg_buf[p->msg_index++] = MSG_ABORT; ! 5010: } ! 5011: p->msg_len++; ! 5012: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 5013: printk(INFO_LEAD "Abort message mailed.\n", p->host_no, ! 5014: CTL_OF_SCB(scb)); ! 5015: } ! 5016: else if (scb->flags & SCB_MSGOUT_WDTR) ! 5017: { ! 5018: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5019: if (aic7xxx_verbose > 0xffff) ! 5020: printk(INFO_LEAD "Sending WDTR message.\n", p->host_no, ! 5021: CTL_OF_SCB(scb)); ! 5022: #endif ! 5023: aic7xxx_construct_wdtr(p, ! 5024: p->transinfo[TARGET_INDEX(scb->cmd)].goal_width); ! 5025: } ! 5026: else if (scb->flags & SCB_MSGOUT_SDTR) ! 5027: { ! 5028: unsigned int max_sync, period; ! 5029: /* ! 5030: * We need to set an accurate goal_offset instead of ! 5031: * the ridiculously high one we default to. We should ! 5032: * now know if we are wide. Plus, the WDTR code will ! 5033: * set our goal_offset for us as well. ! 5034: */ ! 5035: if (p->transinfo[tindex].goal_offset) ! 5036: { ! 5037: if (p->features & AHC_ULTRA2) ! 5038: p->transinfo[tindex].goal_offset = MAX_OFFSET_ULTRA2; ! 5039: else if (p->transinfo[tindex].cur_width == MSG_EXT_WDTR_BUS_16_BIT) ! 5040: p->transinfo[tindex].goal_offset = MAX_OFFSET_16BIT; ! 5041: else ! 5042: p->transinfo[tindex].goal_offset = MAX_OFFSET_8BIT; ! 5043: } ! 5044: /* ! 5045: * Now that the device is selected, use the bits in SBLKCTL and ! 5046: * SSTAT2 to determine the max sync rate for this device. ! 5047: */ ! 5048: if (p->features & AHC_ULTRA2) ! 5049: { ! 5050: if ( (aic_inb(p, SBLKCTL) & ENAB40) && ! 5051: !(aic_inb(p, SSTAT2) & EXP_ACTIVE) ) ! 5052: { ! 5053: max_sync = AHC_SYNCRATE_ULTRA2; ! 5054: } ! 5055: else ! 5056: { ! 5057: max_sync = AHC_SYNCRATE_ULTRA; ! 5058: } ! 5059: } ! 5060: else if (p->features & AHC_ULTRA) ! 5061: { ! 5062: max_sync = AHC_SYNCRATE_ULTRA; ! 5063: } ! 5064: else ! 5065: { ! 5066: max_sync = AHC_SYNCRATE_FAST; ! 5067: } ! 5068: period = p->transinfo[tindex].goal_period; ! 5069: aic7xxx_find_syncrate(p, &period, max_sync); ! 5070: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5071: if (aic7xxx_verbose > 0xffff) ! 5072: printk(INFO_LEAD "Sending SDTR %d/%d message.\n", p->host_no, ! 5073: CTL_OF_SCB(scb), ! 5074: p->transinfo[tindex].goal_period, ! 5075: p->transinfo[tindex].goal_offset); ! 5076: #endif ! 5077: aic7xxx_construct_sdtr(p, period, ! 5078: p->transinfo[tindex].goal_offset); ! 5079: } ! 5080: else ! 5081: { ! 5082: sti(); ! 5083: panic("aic7xxx: AWAITING_MSG for an SCB that does " ! 5084: "not have a waiting message.\n"); ! 5085: } ! 5086: /* ! 5087: * We've set everything up to send our message, now to actually do ! 5088: * so we need to enable reqinit interrupts and let the interrupt ! 5089: * handler do the rest. We don't want to unpause the sequencer yet ! 5090: * though so we'll return early. We also have to make sure that ! 5091: * we clear the SEQINT *BEFORE* we set the REQINIT handler active ! 5092: * or else it's possible on VLB cards to loose the first REQINIT ! 5093: * interrupt. Edge triggered EISA cards could also loose this ! 5094: * interrupt, although PCI and level triggered cards should not ! 5095: * have this problem since they continually interrupt the kernel ! 5096: * until we take care of the situation. ! 5097: */ ! 5098: scb->flags |= SCB_MSGOUT_SENT; ! 5099: p->msg_index = 0; ! 5100: p->msg_type = MSG_TYPE_INITIATOR_MSGOUT; ! 5101: p->flags |= AHC_HANDLING_REQINITS; ! 5102: aic_outb(p, aic_inb(p, SIMODE1) | ENREQINIT, SIMODE1); ! 5103: return; ! 5104: } ! 5105: break; ! 5106: ! 5107: case DATA_OVERRUN: ! 5108: { ! 5109: unsigned char scb_index = aic_inb(p, SCB_TAG); ! 5110: unsigned char lastphase = aic_inb(p, LASTPHASE); ! 5111: unsigned int i; ! 5112: ! 5113: scb = (p->scb_data->scb_array[scb_index]); ! 5114: /* ! 5115: * XXX - What do we really want to do on an overrun? The ! 5116: * mid-level SCSI code should handle this, but for now, ! 5117: * we'll just indicate that the command should retried. ! 5118: * If we retrieved sense info on this target, then the ! 5119: * base SENSE info should have been saved prior to the ! 5120: * overrun error. In that case, we return DID_OK and let ! 5121: * the mid level code pick up on the sense info. Otherwise ! 5122: * we return DID_ERROR so the command will get retried. ! 5123: */ ! 5124: if ( !(scb->flags & SCB_SENSE) ) ! 5125: { ! 5126: printk(WARN_LEAD "Data overrun detected in %s phase, tag %d;\n", ! 5127: p->host_no, CTL_OF_SCB(scb), ! 5128: (lastphase == P_DATAIN) ? "Data-In" : "Data-Out", scb->hscb->tag); ! 5129: printk(KERN_WARNING " %s seen Data Phase. Length=%d, NumSGs=%d.\n", ! 5130: (aic_inb(p, SEQ_FLAGS) & DPHASE) ? "Have" : "Haven't", ! 5131: scb->sg_length, scb->sg_count); ! 5132: for (i = 0; i < scb->sg_count; i++) ! 5133: { ! 5134: printk(KERN_WARNING " sg[%d] - Addr 0x%x : Length %d\n", ! 5135: i, ! 5136: le32_to_cpu(scb->sg_list[i].address), ! 5137: le32_to_cpu(scb->sg_list[i].length) ); ! 5138: } ! 5139: aic7xxx_error(scb->cmd) = DID_ERROR; ! 5140: } ! 5141: else ! 5142: printk(INFO_LEAD "Data Overrun during SEND_SENSE operation.\n", ! 5143: p->host_no, CTL_OF_SCB(scb)); ! 5144: } ! 5145: break; ! 5146: ! 5147: #if AIC7XXX_NOT_YET ! 5148: case TRACEPOINT: ! 5149: { ! 5150: printk(INFO_LEAD "Tracepoint #1 reached.\n", p->host_no, channel, ! 5151: target, lun); ! 5152: } ! 5153: break; ! 5154: ! 5155: case TRACEPOINT2: ! 5156: { ! 5157: printk(INFO_LEAD "Tracepoint #2 reached.\n", p->host_no, channel, ! 5158: target, lun); ! 5159: } ! 5160: break; ! 5161: ! 5162: /* XXX Fill these in later */ ! 5163: case MSG_BUFFER_BUSY: ! 5164: printk("aic7xxx: Message buffer busy.\n"); ! 5165: break; ! 5166: case MSGIN_PHASEMIS: ! 5167: printk("aic7xxx: Message-in phasemis.\n"); ! 5168: break; ! 5169: #endif ! 5170: ! 5171: default: /* unknown */ ! 5172: printk(WARN_LEAD "Unknown SEQINT, INTSTAT 0x%x, SCSISIGI 0x%x.\n", ! 5173: p->host_no, channel, target, lun, intstat, ! 5174: aic_inb(p, SCSISIGI)); ! 5175: break; ! 5176: } ! 5177: ! 5178: /* ! 5179: * Clear the sequencer interrupt and unpause the sequencer. ! 5180: */ ! 5181: unpause_sequencer(p, /* unpause always */ TRUE); ! 5182: } ! 5183: ! 5184: /*+F************************************************************************* ! 5185: * Function: ! 5186: * aic7xxx_parse_msg ! 5187: * ! 5188: * Description: ! 5189: * Parses incoming messages into actions on behalf of ! 5190: * aic7xxx_handle_reqinit ! 5191: *_F*************************************************************************/ ! 5192: static int ! 5193: aic7xxx_parse_msg(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 5194: { ! 5195: int reject, reply, done; ! 5196: unsigned char target_scsirate, tindex; ! 5197: unsigned short target_mask; ! 5198: unsigned char target, channel, lun; ! 5199: ! 5200: target = scb->cmd->target; ! 5201: channel = scb->cmd->channel; ! 5202: lun = scb->cmd->lun; ! 5203: reply = reject = done = FALSE; ! 5204: tindex = TARGET_INDEX(scb->cmd); ! 5205: target_scsirate = aic_inb(p, TARG_SCSIRATE + tindex); ! 5206: target_mask = (0x01 << tindex); ! 5207: ! 5208: /* ! 5209: * Parse as much of the message as is availible, ! 5210: * rejecting it if we don't support it. When ! 5211: * the entire message is availible and has been ! 5212: * handled, return TRUE indicating that we have ! 5213: * parsed an entire message. ! 5214: */ ! 5215: ! 5216: if (p->msg_buf[0] != MSG_EXTENDED) ! 5217: { ! 5218: reject = TRUE; ! 5219: } ! 5220: ! 5221: /* ! 5222: * Just accept the length byte outright and perform ! 5223: * more checking once we know the message type. ! 5224: */ ! 5225: ! 5226: if ( !reject && (p->msg_len > 2) ) ! 5227: { ! 5228: switch(p->msg_buf[2]) ! 5229: { ! 5230: case MSG_EXT_SDTR: ! 5231: { ! 5232: unsigned int period, offset; ! 5233: unsigned char maxsync, saved_offset; ! 5234: struct aic7xxx_syncrate *syncrate; ! 5235: ! 5236: if (p->msg_buf[1] != MSG_EXT_SDTR_LEN) ! 5237: { ! 5238: reject = TRUE; ! 5239: break; ! 5240: } ! 5241: ! 5242: if (p->msg_len < (MSG_EXT_SDTR_LEN + 2)) ! 5243: { ! 5244: break; ! 5245: } ! 5246: ! 5247: period = p->msg_buf[3]; ! 5248: saved_offset = offset = p->msg_buf[4]; ! 5249: ! 5250: if (p->features & AHC_ULTRA2) ! 5251: { ! 5252: if ( (aic_inb(p, SBLKCTL) & ENAB40) && ! 5253: !(aic_inb(p, SSTAT2) & EXP_ACTIVE) ) ! 5254: { ! 5255: maxsync = AHC_SYNCRATE_ULTRA2; ! 5256: } ! 5257: else ! 5258: { ! 5259: maxsync = AHC_SYNCRATE_ULTRA; ! 5260: } ! 5261: } ! 5262: else if (p->features & AHC_ULTRA) ! 5263: { ! 5264: maxsync = AHC_SYNCRATE_ULTRA; ! 5265: } ! 5266: else ! 5267: { ! 5268: maxsync = AHC_SYNCRATE_FAST; ! 5269: } ! 5270: ! 5271: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5272: if (aic7xxx_verbose > 0xffff) ! 5273: { ! 5274: printk(INFO_LEAD "Finished receipt of SDTR, parsing %d/%d\n", ! 5275: p->host_no, CTL_OF_SCB(scb), period, offset); ! 5276: syncrate = aic7xxx_find_syncrate(p, &period, maxsync); ! 5277: printk(INFO_LEAD "After find_syncrate() %d/%d\n", ! 5278: p->host_no, CTL_OF_SCB(scb), period, offset); ! 5279: aic7xxx_validate_offset(p, syncrate, &offset, ! 5280: target_scsirate & WIDEXFER); ! 5281: printk(INFO_LEAD "After validate_offset() %d/%d\n", ! 5282: p->host_no, CTL_OF_SCB(scb), period, offset); ! 5283: aic7xxx_set_syncrate(p, syncrate, target, channel, period, ! 5284: offset, AHC_TRANS_ACTIVE|AHC_TRANS_CUR); ! 5285: printk(INFO_LEAD "Final values of Period/Offset as set: %d/%d\n", ! 5286: p->host_no, CTL_OF_SCB(scb), period, offset); ! 5287: } ! 5288: else ! 5289: { ! 5290: syncrate = aic7xxx_find_syncrate(p, &period, maxsync); ! 5291: aic7xxx_validate_offset(p, syncrate, &offset, ! 5292: target_scsirate & WIDEXFER); ! 5293: aic7xxx_set_syncrate(p, syncrate, target, channel, period, ! 5294: offset, AHC_TRANS_ACTIVE|AHC_TRANS_CUR); ! 5295: } ! 5296: #else ! 5297: syncrate = aic7xxx_find_syncrate(p, &period, maxsync); ! 5298: aic7xxx_validate_offset(p, syncrate, &offset, ! 5299: target_scsirate & WIDEXFER); ! 5300: aic7xxx_set_syncrate(p, syncrate, target, channel, period, ! 5301: offset, AHC_TRANS_ACTIVE|AHC_TRANS_CUR); ! 5302: #endif ! 5303: ! 5304: if (offset == 0) ! 5305: { ! 5306: /* ! 5307: * Uhh ohh, things fell through to async....update the goal ! 5308: * items and the needsdtr_copy to reflect this... ! 5309: */ ! 5310: aic7xxx_set_syncrate(p, syncrate, target, channel, period, ! 5311: offset, AHC_TRANS_GOAL|AHC_TRANS_QUITE); ! 5312: p->needsdtr_copy &= ~target_mask; ! 5313: } ! 5314: /* ! 5315: * Did we start this, if not, or if we went to low and had to ! 5316: * go async, then send an SDTR back to the target ! 5317: */ ! 5318: p->needsdtr &= ~target_mask; ! 5319: p->sdtr_pending &= ~target_mask; ! 5320: if ( ((scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_SDTR)) == ! 5321: (SCB_MSGOUT_SENT|SCB_MSGOUT_SDTR)) && ! 5322: (offset == saved_offset) ) ! 5323: { ! 5324: scb->flags &= ~SCB_MSGOUT_BITS; ! 5325: } ! 5326: else ! 5327: { ! 5328: /* ! 5329: * Send a reply SDTR back. Even if we sent the first one, it ! 5330: * is valid to send another one out immediately to re-negotiate ! 5331: * things, and a few devices don't like getting rejects after ! 5332: * we already sent them one SDTR. Just send an SDTR for async ! 5333: * this time if need be (or for the correct params if we didn't ! 5334: * start all of this). If this is a Reject Reply type message, ! 5335: * then we've put the async settings into the goal area for ! 5336: * future reference (when we get the AWAITING_MSG interrupt). ! 5337: * If this is a case where we are responding to the target's ! 5338: * initiated SDTR, then leave our own goal and user values in ! 5339: * place (unless the device hasn't been scanned yet, in which ! 5340: * case, put the user values into the goal values so we don't ! 5341: * send out an Async message). ! 5342: */ ! 5343: if ( !(p->dev_flags[tindex] & DEVICE_SCANNED) ) ! 5344: { ! 5345: p->transinfo[tindex].goal_width = ! 5346: p->transinfo[tindex].user_width; ! 5347: p->transinfo[tindex].goal_period = ! 5348: p->transinfo[tindex].user_period; ! 5349: p->transinfo[tindex].goal_offset = ! 5350: p->transinfo[tindex].user_offset; ! 5351: p->needwdtr_copy |= target_mask; ! 5352: p->needsdtr_copy |= target_mask; ! 5353: } ! 5354: scb->flags &= ~SCB_MSGOUT_BITS; ! 5355: scb->flags |= SCB_MSGOUT_SDTR; ! 5356: aic_outb(p, HOST_MSG, MSG_OUT); ! 5357: aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO); ! 5358: } ! 5359: done = TRUE; ! 5360: break; ! 5361: } ! 5362: case MSG_EXT_WDTR: ! 5363: { ! 5364: unsigned char bus_width; ! 5365: ! 5366: if (p->msg_buf[1] != MSG_EXT_WDTR_LEN) ! 5367: { ! 5368: reject = TRUE; ! 5369: break; ! 5370: } ! 5371: ! 5372: if (p->msg_len < (MSG_EXT_WDTR_LEN + 2)) ! 5373: { ! 5374: break; ! 5375: } ! 5376: ! 5377: bus_width = p->msg_buf[3]; ! 5378: if ( (scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_WDTR)) == ! 5379: (SCB_MSGOUT_SENT|SCB_MSGOUT_WDTR) ) ! 5380: { ! 5381: switch(bus_width) ! 5382: { ! 5383: default: ! 5384: { ! 5385: reject = TRUE; ! 5386: if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) && ! 5387: ((p->dev_flags[tindex] & DEVICE_PRINT_WDTR) || ! 5388: (aic7xxx_verbose > 0xffff)) ) ! 5389: { ! 5390: printk(INFO_LEAD "Requesting %d bit transfers, rejecting.\n", ! 5391: p->host_no, CTL_OF_SCB(scb), 8 * (0x01 << bus_width)); ! 5392: p->dev_flags[tindex] &= ~DEVICE_PRINT_WDTR; ! 5393: } ! 5394: } /* We fall through on purpose */ ! 5395: case MSG_EXT_WDTR_BUS_8_BIT: ! 5396: { ! 5397: bus_width = MSG_EXT_WDTR_BUS_8_BIT; ! 5398: p->needwdtr_copy &= ~target_mask; ! 5399: break; ! 5400: } ! 5401: case MSG_EXT_WDTR_BUS_16_BIT: ! 5402: { ! 5403: break; ! 5404: } ! 5405: } ! 5406: scb->flags &= ~SCB_MSGOUT_BITS; ! 5407: p->wdtr_pending &= ~target_mask; ! 5408: p->needwdtr &= ~target_mask; ! 5409: } ! 5410: else ! 5411: { ! 5412: scb->flags &= ~SCB_MSGOUT_BITS; ! 5413: scb->flags |= SCB_MSGOUT_WDTR; ! 5414: reply = TRUE; ! 5415: if ( !(p->dev_flags[tindex] & DEVICE_SCANNED) ) ! 5416: { ! 5417: /* ! 5418: * Well, we now know the WDTR and SYNC caps of this device since ! 5419: * it contacted us first, mark it as such and copy the user stuff ! 5420: * over to the goal stuff. ! 5421: */ ! 5422: p->transinfo[tindex].goal_width = ! 5423: p->transinfo[tindex].user_width; ! 5424: p->transinfo[tindex].goal_period = ! 5425: p->transinfo[tindex].user_period; ! 5426: p->transinfo[tindex].goal_offset = ! 5427: p->transinfo[tindex].user_offset; ! 5428: p->needwdtr_copy |= target_mask; ! 5429: p->needsdtr_copy |= target_mask; ! 5430: } ! 5431: switch(bus_width) ! 5432: { ! 5433: default: ! 5434: { ! 5435: if ( (p->features & AHC_WIDE) && ! 5436: (p->transinfo[tindex].goal_width == ! 5437: MSG_EXT_WDTR_BUS_16_BIT) ) ! 5438: { ! 5439: bus_width = MSG_EXT_WDTR_BUS_16_BIT; ! 5440: break; ! 5441: } ! 5442: } /* Fall through if we aren't a wide card */ ! 5443: case MSG_EXT_WDTR_BUS_8_BIT: ! 5444: { ! 5445: p->needwdtr_copy &= ~target_mask; ! 5446: bus_width = MSG_EXT_WDTR_BUS_8_BIT; ! 5447: break; ! 5448: } ! 5449: } ! 5450: p->needwdtr &= ~target_mask; ! 5451: p->wdtr_pending &= ~target_mask; ! 5452: aic_outb(p, HOST_MSG, MSG_OUT); ! 5453: aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO); ! 5454: } ! 5455: aic7xxx_set_width(p, target, channel, lun, bus_width, ! 5456: AHC_TRANS_ACTIVE|AHC_TRANS_CUR); ! 5457: ! 5458: /* ! 5459: * By virtue of the SCSI spec, a WDTR message negates any existing ! 5460: * SDTR negotiations. So, even if needsdtr isn't marked for this ! 5461: * device, we still have to do a new SDTR message if the device ! 5462: * supports SDTR at all. Therefore, we check needsdtr_copy instead ! 5463: * of needstr. ! 5464: */ ! 5465: aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, ! 5466: AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE); ! 5467: if ( (p->needsdtr_copy & target_mask) && ! 5468: !(p->sdtr_pending & target_mask)) ! 5469: { ! 5470: p->needsdtr |= target_mask; ! 5471: if ( !reject && !reply ) ! 5472: { ! 5473: scb->flags &= ~SCB_MSGOUT_WDTR; ! 5474: if (p->transinfo[tindex].goal_period) ! 5475: { ! 5476: p->sdtr_pending |= target_mask; ! 5477: scb->flags |= SCB_MSGOUT_SDTR; ! 5478: aic_outb(p, HOST_MSG, MSG_OUT); ! 5479: aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO); ! 5480: } ! 5481: } ! 5482: } ! 5483: done = TRUE; ! 5484: break; ! 5485: } ! 5486: default: ! 5487: { ! 5488: reject = TRUE; ! 5489: break; ! 5490: } ! 5491: } /* end of switch(p->msg_type) */ ! 5492: } /* end of if (!reject && (p->msg_len > 2)) */ ! 5493: ! 5494: if (reject) ! 5495: { ! 5496: aic_outb(p, MSG_MESSAGE_REJECT, MSG_OUT); ! 5497: aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO); ! 5498: done = TRUE; ! 5499: } ! 5500: return(done); ! 5501: } ! 5502: ! 5503: ! 5504: /*+F************************************************************************* ! 5505: * Function: ! 5506: * aic7xxx_handle_reqinit ! 5507: * ! 5508: * Description: ! 5509: * Interrupt handler for REQINIT interrupts (used to transfer messages to ! 5510: * and from devices). ! 5511: *_F*************************************************************************/ ! 5512: static void ! 5513: aic7xxx_handle_reqinit(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 5514: { ! 5515: unsigned char lastbyte; ! 5516: unsigned char phasemis; ! 5517: int done = FALSE; ! 5518: ! 5519: switch(p->msg_type) ! 5520: { ! 5521: case MSG_TYPE_INITIATOR_MSGOUT: ! 5522: { ! 5523: if (p->msg_len == 0) ! 5524: panic("aic7xxx: REQINIT with no active message!\n"); ! 5525: ! 5526: lastbyte = (p->msg_index == (p->msg_len - 1)); ! 5527: phasemis = ( aic_inb(p, SCSISIGI) & PHASE_MASK) != P_MESGOUT; ! 5528: ! 5529: if (lastbyte || phasemis) ! 5530: { ! 5531: /* Time to end the message */ ! 5532: p->msg_len = 0; ! 5533: p->msg_type = MSG_TYPE_NONE; ! 5534: /* ! 5535: * NOTE-TO-MYSELF: If you clear the REQINIT after you ! 5536: * disable REQINITs, then cases of REJECT_MSG stop working ! 5537: * and hang the bus ! 5538: */ ! 5539: aic_outb(p, aic_inb(p, SIMODE1) & ~ENREQINIT, SIMODE1); ! 5540: aic_outb(p, CLRSCSIINT, CLRINT); ! 5541: p->flags &= ~AHC_HANDLING_REQINITS; ! 5542: ! 5543: if (phasemis == 0) ! 5544: { ! 5545: aic_outb(p, p->msg_buf[p->msg_index], SINDEX); ! 5546: aic_outb(p, 0, RETURN_1); ! 5547: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5548: if (aic7xxx_verbose > 0xffff) ! 5549: printk(INFO_LEAD "Completed sending of REQINIT message.\n", ! 5550: p->host_no, CTL_OF_SCB(scb)); ! 5551: #endif ! 5552: } ! 5553: else ! 5554: { ! 5555: aic_outb(p, MSGOUT_PHASEMIS, RETURN_1); ! 5556: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5557: if (aic7xxx_verbose > 0xffff) ! 5558: printk(INFO_LEAD "PHASEMIS while sending REQINIT message.\n", ! 5559: p->host_no, CTL_OF_SCB(scb)); ! 5560: #endif ! 5561: } ! 5562: unpause_sequencer(p, TRUE); ! 5563: } ! 5564: else ! 5565: { ! 5566: /* ! 5567: * Present the byte on the bus (clearing REQINIT) but don't ! 5568: * unpause the sequencer. ! 5569: */ ! 5570: aic_outb(p, CLRREQINIT, CLRSINT1); ! 5571: aic_outb(p, CLRSCSIINT, CLRINT); ! 5572: aic_outb(p, p->msg_buf[p->msg_index++], SCSIDATL); ! 5573: } ! 5574: break; ! 5575: } ! 5576: case MSG_TYPE_INITIATOR_MSGIN: ! 5577: { ! 5578: phasemis = ( aic_inb(p, SCSISIGI) & PHASE_MASK ) != P_MESGIN; ! 5579: ! 5580: if (phasemis == 0) ! 5581: { ! 5582: p->msg_len++; ! 5583: /* Pull the byte in without acking it */ ! 5584: p->msg_buf[p->msg_index] = aic_inb(p, SCSIBUSL); ! 5585: done = aic7xxx_parse_msg(p, scb); ! 5586: /* Ack the byte */ ! 5587: aic_outb(p, CLRREQINIT, CLRSINT1); ! 5588: aic_outb(p, CLRSCSIINT, CLRINT); ! 5589: aic_inb(p, SCSIDATL); ! 5590: p->msg_index++; ! 5591: } ! 5592: if (phasemis || done) ! 5593: { ! 5594: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5595: if (aic7xxx_verbose > 0xffff) ! 5596: { ! 5597: if (phasemis) ! 5598: printk(INFO_LEAD "PHASEMIS while receiving REQINIT message.\n", ! 5599: p->host_no, CTL_OF_SCB(scb)); ! 5600: else ! 5601: printk(INFO_LEAD "Completed receipt of REQINIT message.\n", ! 5602: p->host_no, CTL_OF_SCB(scb)); ! 5603: } ! 5604: #endif ! 5605: /* Time to end our message session */ ! 5606: p->msg_len = 0; ! 5607: p->msg_type = MSG_TYPE_NONE; ! 5608: aic_outb(p, aic_inb(p, SIMODE1) & ~ENREQINIT, SIMODE1); ! 5609: aic_outb(p, CLRSCSIINT, CLRINT); ! 5610: p->flags &= ~AHC_HANDLING_REQINITS; ! 5611: unpause_sequencer(p, TRUE); ! 5612: } ! 5613: break; ! 5614: } ! 5615: default: ! 5616: { ! 5617: panic("aic7xxx: Unknown REQINIT message type.\n"); ! 5618: break; ! 5619: } ! 5620: } /* End of switch(p->msg_type) */ ! 5621: } ! 5622: ! 5623: /*+F************************************************************************* ! 5624: * Function: ! 5625: * aic7xxx_handle_scsiint ! 5626: * ! 5627: * Description: ! 5628: * Interrupt handler for SCSI interrupts (SCSIINT). ! 5629: *-F*************************************************************************/ ! 5630: static void ! 5631: aic7xxx_handle_scsiint(struct aic7xxx_host *p, unsigned char intstat) ! 5632: { ! 5633: unsigned char scb_index; ! 5634: unsigned char status; ! 5635: struct aic7xxx_scb *scb; ! 5636: ! 5637: scb_index = aic_inb(p, SCB_TAG); ! 5638: status = aic_inb(p, SSTAT1); ! 5639: ! 5640: if (scb_index < p->scb_data->numscbs) ! 5641: { ! 5642: scb = p->scb_data->scb_array[scb_index]; ! 5643: if ((scb->flags & SCB_ACTIVE) == 0) ! 5644: { ! 5645: scb = NULL; ! 5646: } ! 5647: } ! 5648: else ! 5649: { ! 5650: scb = NULL; ! 5651: } ! 5652: ! 5653: ! 5654: if ((status & SCSIRSTI) != 0) ! 5655: { ! 5656: int channel; ! 5657: ! 5658: if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 ) ! 5659: channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3; ! 5660: else ! 5661: channel = 0; ! 5662: ! 5663: if (aic7xxx_verbose & VERBOSE_RESET) ! 5664: printk(WARN_LEAD "Someone else reset the channel!!\n", ! 5665: p->host_no, channel, -1, -1); ! 5666: /* ! 5667: * Go through and abort all commands for the channel, but do not ! 5668: * reset the channel again. ! 5669: */ ! 5670: aic7xxx_reset_channel(p, channel, /* Initiate Reset */ FALSE); ! 5671: aic7xxx_run_done_queue(p, FALSE); ! 5672: scb = NULL; ! 5673: } ! 5674: else if ( ((status & BUSFREE) != 0) && ((status & SELTO) == 0) ) ! 5675: { ! 5676: /* ! 5677: * First look at what phase we were last in. If it's message-out, ! 5678: * chances are pretty good that the bus free was in response to ! 5679: * one of our abort requests. ! 5680: */ ! 5681: unsigned char lastphase = aic_inb(p, LASTPHASE); ! 5682: unsigned char saved_tcl = aic_inb(p, SAVED_TCL); ! 5683: unsigned char target = (saved_tcl >> 4) & 0x0F; ! 5684: int channel; ! 5685: int printerror = TRUE; ! 5686: ! 5687: if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 ) ! 5688: channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3; ! 5689: else ! 5690: channel = 0; ! 5691: ! 5692: aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), ! 5693: SCSISEQ); ! 5694: if (lastphase == P_MESGOUT) ! 5695: { ! 5696: unsigned char message; ! 5697: ! 5698: message = aic_inb(p, SINDEX); ! 5699: ! 5700: if ((message == MSG_ABORT) || (message == MSG_ABORT_TAG)) ! 5701: { ! 5702: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 5703: printk(INFO_LEAD "SCB %d abort delivered.\n", p->host_no, ! 5704: CTL_OF_SCB(scb), scb->hscb->tag); ! 5705: aic7xxx_reset_device(p, target, channel, ALL_LUNS, ! 5706: (message == MSG_ABORT) ? SCB_LIST_NULL : scb->hscb->tag ); ! 5707: aic7xxx_run_done_queue(p, FALSE); ! 5708: scb = NULL; ! 5709: printerror = 0; ! 5710: } ! 5711: else if (message == MSG_BUS_DEV_RESET) ! 5712: { ! 5713: aic7xxx_handle_device_reset(p, target, channel); ! 5714: scb = NULL; ! 5715: printerror = 0; ! 5716: } ! 5717: } ! 5718: if (printerror != 0) ! 5719: { ! 5720: if (scb != NULL) ! 5721: { ! 5722: unsigned char tag; ! 5723: ! 5724: if ((scb->hscb->control & TAG_ENB) != 0) ! 5725: { ! 5726: tag = scb->hscb->tag; ! 5727: } ! 5728: else ! 5729: { ! 5730: tag = SCB_LIST_NULL; ! 5731: } ! 5732: aic7xxx_reset_device(p, target, channel, ALL_LUNS, tag); ! 5733: aic7xxx_run_done_queue(p, FALSE); ! 5734: } ! 5735: printk(INFO_LEAD "Unexpected busfree, LASTPHASE = 0x%x, " ! 5736: "SEQADDR = 0x%x\n", p->host_no, channel, target, -1, lastphase, ! 5737: (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0)); ! 5738: scb = NULL; ! 5739: } ! 5740: aic_outb(p, MSG_NOOP, MSG_OUT); ! 5741: aic_outb(p, aic_inb(p, SIMODE1) & ~(ENBUSFREE|ENREQINIT), ! 5742: SIMODE1); ! 5743: p->flags &= ~AHC_HANDLING_REQINITS; ! 5744: aic_outb(p, CLRBUSFREE, CLRSINT1); ! 5745: aic_outb(p, CLRSCSIINT, CLRINT); ! 5746: restart_sequencer(p); ! 5747: unpause_sequencer(p, TRUE); ! 5748: } ! 5749: else if ((status & SELTO) != 0) ! 5750: { ! 5751: unsigned char scbptr; ! 5752: unsigned char nextscb; ! 5753: Scsi_Cmnd *cmd; ! 5754: ! 5755: scbptr = aic_inb(p, WAITING_SCBH); ! 5756: if (scbptr > p->scb_data->maxhscbs) ! 5757: { ! 5758: /* ! 5759: * I'm still trying to track down exactly how this happens, but until ! 5760: * I find it, this code will make sure we aren't passing bogus values ! 5761: * into the SCBPTR register, even if that register will just wrap ! 5762: * things around, we still don't like having out of range variables. ! 5763: * ! 5764: * NOTE: Don't check the aic7xxx_verbose variable, I want this message ! 5765: * to always be displayed. ! 5766: */ ! 5767: printk(INFO_LEAD "Invalid WAITING_SCBH value %d, improvising.\n", ! 5768: p->host_no, -1, -1, -1, scbptr); ! 5769: if (p->scb_data->maxhscbs > 4) ! 5770: scbptr &= (p->scb_data->maxhscbs - 1); ! 5771: else ! 5772: scbptr &= 0x03; ! 5773: } ! 5774: aic_outb(p, scbptr, SCBPTR); ! 5775: scb_index = aic_inb(p, SCB_TAG); ! 5776: ! 5777: scb = NULL; ! 5778: if (scb_index < p->scb_data->numscbs) ! 5779: { ! 5780: scb = p->scb_data->scb_array[scb_index]; ! 5781: if ((scb->flags & SCB_ACTIVE) == 0) ! 5782: { ! 5783: scb = NULL; ! 5784: } ! 5785: } ! 5786: if (scb == NULL) ! 5787: { ! 5788: printk(WARN_LEAD "Referenced SCB %d not valid during SELTO.\n", ! 5789: p->host_no, -1, -1, -1, scb_index); ! 5790: printk(KERN_WARNING " SCSISEQ = 0x%x SEQADDR = 0x%x SSTAT0 = 0x%x " ! 5791: "SSTAT1 = 0x%x\n", aic_inb(p, SCSISEQ), ! 5792: aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8), ! 5793: aic_inb(p, SSTAT0), aic_inb(p, SSTAT1)); ! 5794: if (aic7xxx_panic_on_abort) ! 5795: aic7xxx_panic_abort(p, NULL); ! 5796: } ! 5797: else ! 5798: { ! 5799: cmd = scb->cmd; ! 5800: cmd->result = (DID_TIME_OUT << 16); ! 5801: ! 5802: /* ! 5803: * Clear out this hardware SCB ! 5804: */ ! 5805: aic_outb(p, 0, SCB_CONTROL); ! 5806: ! 5807: /* ! 5808: * Clear out a few values in the card that are in an undetermined ! 5809: * state. ! 5810: */ ! 5811: aic_outb(p, MSG_NOOP, MSG_OUT); ! 5812: ! 5813: /* ! 5814: * Shift the waiting for selection queue forward ! 5815: */ ! 5816: nextscb = aic_inb(p, SCB_NEXT); ! 5817: aic_outb(p, nextscb, WAITING_SCBH); ! 5818: ! 5819: /* ! 5820: * Put this SCB back on the free list. ! 5821: */ ! 5822: aic7xxx_add_curscb_to_free_list(p); ! 5823: /* ! 5824: * XXX - If we queued an abort tag, go clean up the disconnected list. ! 5825: * We know that this particular SCB had to be the queued abort since ! 5826: * the disconnected SCB would have gotten a reconnect instead. ! 5827: * However, if this is an abort command, then DID_TIMEOUT isn't ! 5828: * appropriate, neither is returning the command for that matter. ! 5829: * What we need to do then is to let the command timeout again so ! 5830: * we get a reset since this abort just failed. ! 5831: */ ! 5832: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5833: if (aic7xxx_verbose > 0xffff) ! 5834: printk(INFO_LEAD "Selection Timeout.\n", p->host_no, CTL_OF_SCB(scb)); ! 5835: #endif ! 5836: if (p->flags & SCB_QUEUED_ABORT) ! 5837: { ! 5838: cmd->result = 0; ! 5839: scb->flags &= ~SCB_QUEUED_ABORT; ! 5840: scb = NULL; ! 5841: } ! 5842: } ! 5843: /* ! 5844: * Restarting the sequencer will stop the selection and make sure devices ! 5845: * are allowed to reselect in. ! 5846: */ ! 5847: aic_outb(p, 0, SCSISEQ); ! 5848: aic_outb(p, aic_inb(p, SIMODE1) & ~(ENREQINIT|ENBUSFREE), SIMODE1); ! 5849: p->flags &= ~AHC_HANDLING_REQINITS; ! 5850: aic_outb(p, CLRSELTIMEO | CLRBUSFREE, CLRSINT1); ! 5851: aic_outb(p, CLRSCSIINT, CLRINT); ! 5852: restart_sequencer(p); ! 5853: unpause_sequencer(p, TRUE); ! 5854: } ! 5855: else if (scb == NULL) ! 5856: { ! 5857: printk(WARN_LEAD "aic7xxx_isr - referenced scb not valid " ! 5858: "during scsiint 0x%x scb(%d)\n" ! 5859: " SIMODE0 0x%x, SIMODE1 0x%x, SSTAT0 0x%x, SEQADDR 0x%x\n", ! 5860: p->host_no, -1, -1, -1, status, scb_index, aic_inb(p, SIMODE0), ! 5861: aic_inb(p, SIMODE1), aic_inb(p, SSTAT0), ! 5862: (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0)); ! 5863: /* ! 5864: * Turn off the interrupt and set status to zero, so that it ! 5865: * falls through the rest of the SCSIINT code. ! 5866: */ ! 5867: aic_outb(p, status, CLRSINT1); ! 5868: aic_outb(p, CLRSCSIINT, CLRINT); ! 5869: unpause_sequencer(p, /* unpause always */ TRUE); ! 5870: scb = NULL; ! 5871: } ! 5872: else if (status & SCSIPERR) ! 5873: { ! 5874: /* ! 5875: * Determine the bus phase and queue an appropriate message. ! 5876: */ ! 5877: char *phase; ! 5878: Scsi_Cmnd *cmd; ! 5879: unsigned char mesg_out = MSG_NOOP; ! 5880: unsigned char lastphase = aic_inb(p, LASTPHASE); ! 5881: ! 5882: cmd = scb->cmd; ! 5883: switch (lastphase) ! 5884: { ! 5885: case P_DATAOUT: ! 5886: phase = "Data-Out"; ! 5887: break; ! 5888: case P_DATAIN: ! 5889: phase = "Data-In"; ! 5890: mesg_out = MSG_INITIATOR_DET_ERR; ! 5891: break; ! 5892: case P_COMMAND: ! 5893: phase = "Command"; ! 5894: break; ! 5895: case P_MESGOUT: ! 5896: phase = "Message-Out"; ! 5897: break; ! 5898: case P_STATUS: ! 5899: phase = "Status"; ! 5900: mesg_out = MSG_INITIATOR_DET_ERR; ! 5901: break; ! 5902: case P_MESGIN: ! 5903: phase = "Message-In"; ! 5904: mesg_out = MSG_PARITY_ERROR; ! 5905: break; ! 5906: default: ! 5907: phase = "unknown"; ! 5908: break; ! 5909: } ! 5910: ! 5911: /* ! 5912: * A parity error has occurred during a data ! 5913: * transfer phase. Flag it and continue. ! 5914: */ ! 5915: printk(WARN_LEAD "Parity error during %s phase.\n", ! 5916: p->host_no, CTL_OF_SCB(scb), phase); ! 5917: ! 5918: /* ! 5919: * We've set the hardware to assert ATN if we get a parity ! 5920: * error on "in" phases, so all we need to do is stuff the ! 5921: * message buffer with the appropriate message. "In" phases ! 5922: * have set mesg_out to something other than MSG_NOP. ! 5923: */ ! 5924: if (mesg_out != MSG_NOOP) ! 5925: { ! 5926: aic_outb(p, mesg_out, MSG_OUT); ! 5927: scb = NULL; ! 5928: } ! 5929: aic_outb(p, CLRSCSIPERR, CLRSINT1); ! 5930: aic_outb(p, CLRSCSIINT, CLRINT); ! 5931: unpause_sequencer(p, /* unpause_always */ TRUE); ! 5932: } ! 5933: else if ( (status & REQINIT) && ! 5934: (p->flags & AHC_HANDLING_REQINITS) ) ! 5935: { ! 5936: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5937: if (aic7xxx_verbose > 0xffff) ! 5938: printk(INFO_LEAD "Handling REQINIT, SSTAT1=0x%x.\n", p->host_no, ! 5939: CTL_OF_SCB(scb), aic_inb(p, SSTAT1)); ! 5940: #endif ! 5941: aic7xxx_handle_reqinit(p, scb); ! 5942: return; ! 5943: } ! 5944: else ! 5945: { ! 5946: /* ! 5947: * We don't know what's going on. Turn off the ! 5948: * interrupt source and try to continue. ! 5949: */ ! 5950: if (aic7xxx_verbose & VERBOSE_SCSIINT) ! 5951: printk(INFO_LEAD "Unknown SCSIINT status, SSTAT1(0x%x).\n", ! 5952: p->host_no, -1, -1, -1, status); ! 5953: aic_outb(p, status, CLRSINT1); ! 5954: aic_outb(p, CLRSCSIINT, CLRINT); ! 5955: unpause_sequencer(p, /* unpause always */ TRUE); ! 5956: scb = NULL; ! 5957: } ! 5958: if (scb != NULL) ! 5959: { ! 5960: aic7xxx_done(p, scb); ! 5961: } ! 5962: } ! 5963: ! 5964: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 5965: static void ! 5966: aic7xxx_check_scbs(struct aic7xxx_host *p, char *buffer) ! 5967: { ! 5968: unsigned char saved_scbptr, free_scbh, dis_scbh, wait_scbh, temp; ! 5969: int i, bogus, lost; ! 5970: static unsigned char scb_status[AIC7XXX_MAXSCB]; ! 5971: ! 5972: #define SCB_NO_LIST 0 ! 5973: #define SCB_FREE_LIST 1 ! 5974: #define SCB_WAITING_LIST 2 ! 5975: #define SCB_DISCONNECTED_LIST 4 ! 5976: #define SCB_CURRENTLY_ACTIVE 8 ! 5977: ! 5978: /* ! 5979: * Note, these checks will fail on a regular basis once the machine moves ! 5980: * beyond the bus scan phase. The problem is race conditions concerning ! 5981: * the scbs and where they are linked in. When you have 30 or so commands ! 5982: * outstanding on the bus, and run this twice with every interrupt, the ! 5983: * chances get pretty good that you'll catch the sequencer with an SCB ! 5984: * only partially linked in. Therefore, once we pass the scan phase ! 5985: * of the bus, we really should disable this function. ! 5986: */ ! 5987: bogus = FALSE; ! 5988: memset(&scb_status[0], 0, sizeof(scb_status)); ! 5989: pause_sequencer(p); ! 5990: saved_scbptr = aic_inb(p, SCBPTR); ! 5991: if (saved_scbptr >= p->scb_data->maxhscbs) ! 5992: { ! 5993: printk("Bogus SCBPTR %d\n", saved_scbptr); ! 5994: bogus = TRUE; ! 5995: } ! 5996: scb_status[saved_scbptr] = SCB_CURRENTLY_ACTIVE; ! 5997: free_scbh = aic_inb(p, FREE_SCBH); ! 5998: if ( (free_scbh != SCB_LIST_NULL) && ! 5999: (free_scbh >= p->scb_data->maxhscbs) ) ! 6000: { ! 6001: printk("Bogus FREE_SCBH %d\n", free_scbh); ! 6002: bogus = TRUE; ! 6003: } ! 6004: else ! 6005: { ! 6006: temp = free_scbh; ! 6007: while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) ) ! 6008: { ! 6009: if(scb_status[temp] & 0x07) ! 6010: { ! 6011: printk("HSCB %d on multiple lists, status 0x%02x", temp, ! 6012: scb_status[temp] | SCB_FREE_LIST); ! 6013: bogus = TRUE; ! 6014: } ! 6015: scb_status[temp] |= SCB_FREE_LIST; ! 6016: aic_outb(p, temp, SCBPTR); ! 6017: temp = aic_inb(p, SCB_NEXT); ! 6018: } ! 6019: } ! 6020: ! 6021: dis_scbh = aic_inb(p, DISCONNECTED_SCBH); ! 6022: if ( (dis_scbh != SCB_LIST_NULL) && ! 6023: (dis_scbh >= p->scb_data->maxhscbs) ) ! 6024: { ! 6025: printk("Bogus DISCONNECTED_SCBH %d\n", dis_scbh); ! 6026: bogus = TRUE; ! 6027: } ! 6028: else ! 6029: { ! 6030: temp = dis_scbh; ! 6031: while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) ) ! 6032: { ! 6033: if(scb_status[temp] & 0x07) ! 6034: { ! 6035: printk("HSCB %d on multiple lists, status 0x%02x", temp, ! 6036: scb_status[temp] | SCB_DISCONNECTED_LIST); ! 6037: bogus = TRUE; ! 6038: } ! 6039: scb_status[temp] |= SCB_DISCONNECTED_LIST; ! 6040: aic_outb(p, temp, SCBPTR); ! 6041: temp = aic_inb(p, SCB_NEXT); ! 6042: } ! 6043: } ! 6044: ! 6045: wait_scbh = aic_inb(p, WAITING_SCBH); ! 6046: if ( (wait_scbh != SCB_LIST_NULL) && ! 6047: (wait_scbh >= p->scb_data->maxhscbs) ) ! 6048: { ! 6049: printk("Bogus WAITING_SCBH %d\n", wait_scbh); ! 6050: bogus = TRUE; ! 6051: } ! 6052: else ! 6053: { ! 6054: temp = wait_scbh; ! 6055: while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) ) ! 6056: { ! 6057: if(scb_status[temp] & 0x07) ! 6058: { ! 6059: printk("HSCB %d on multiple lists, status 0x%02x", temp, ! 6060: scb_status[temp] | SCB_WAITING_LIST); ! 6061: bogus = TRUE; ! 6062: } ! 6063: scb_status[temp] |= SCB_WAITING_LIST; ! 6064: aic_outb(p, temp, SCBPTR); ! 6065: temp = aic_inb(p, SCB_NEXT); ! 6066: } ! 6067: } ! 6068: ! 6069: lost=0; ! 6070: for(i=0; i < p->scb_data->maxhscbs; i++) ! 6071: { ! 6072: aic_outb(p, i, SCBPTR); ! 6073: temp = aic_inb(p, SCB_NEXT); ! 6074: if ( ((temp != SCB_LIST_NULL) && ! 6075: (temp >= p->scb_data->maxhscbs)) ) ! 6076: { ! 6077: printk("HSCB %d bad, SCB_NEXT invalid(%d).\n", i, temp); ! 6078: bogus = TRUE; ! 6079: } ! 6080: if ( temp == i ) ! 6081: { ! 6082: printk("HSCB %d bad, SCB_NEXT points to self.\n", i); ! 6083: bogus = TRUE; ! 6084: } ! 6085: temp = aic_inb(p, SCB_PREV); ! 6086: if ((temp != SCB_LIST_NULL) && ! 6087: (temp >= p->scb_data->maxhscbs)) ! 6088: { ! 6089: printk("HSCB %d bad, SCB_PREV invalid(%d).\n", i, temp); ! 6090: bogus = TRUE; ! 6091: } ! 6092: if (scb_status[i] == 0) ! 6093: lost++; ! 6094: if (lost > 1) ! 6095: { ! 6096: printk("Too many lost scbs.\n"); ! 6097: bogus=TRUE; ! 6098: } ! 6099: } ! 6100: aic_outb(p, saved_scbptr, SCBPTR); ! 6101: unpause_sequencer(p, FALSE); ! 6102: if (bogus) ! 6103: { ! 6104: printk("Bogus parameters found in card SCB array structures.\n"); ! 6105: printk("%s\n", buffer); ! 6106: aic7xxx_panic_abort(p, NULL); ! 6107: } ! 6108: return; ! 6109: } ! 6110: #endif ! 6111: ! 6112: /*+F************************************************************************* ! 6113: * Function: ! 6114: * aic7xxx_isr ! 6115: * ! 6116: * Description: ! 6117: * SCSI controller interrupt handler. ! 6118: *-F*************************************************************************/ ! 6119: static void ! 6120: aic7xxx_isr(int irq, void *dev_id, struct pt_regs *regs) ! 6121: { ! 6122: struct aic7xxx_host *p; ! 6123: unsigned char intstat; ! 6124: ! 6125: p = (struct aic7xxx_host *)dev_id; ! 6126: ! 6127: /* ! 6128: * Just a few sanity checks. Make sure that we have an int pending. ! 6129: * Also, if PCI, then we are going to check for a PCI bus error status ! 6130: * should we get too many spurious interrupts. ! 6131: */ ! 6132: if (!((intstat = aic_inb(p, INTSTAT)) & INT_PEND)) ! 6133: { ! 6134: #ifdef CONFIG_PCI ! 6135: if ( (p->chip & AHC_PCI) && (p->spurious_int > 500) && ! 6136: !(p->flags & AHC_HANDLING_REQINITS) ) ! 6137: { ! 6138: if ( aic_inb(p, ERROR) & PCIERRSTAT ) ! 6139: { ! 6140: aic7xxx_pci_intr(p); ! 6141: } ! 6142: p->spurious_int = 0; ! 6143: } ! 6144: else if ( !(p->flags & AHC_HANDLING_REQINITS) ) ! 6145: { ! 6146: p->spurious_int++; ! 6147: } ! 6148: #endif ! 6149: return; ! 6150: } ! 6151: ! 6152: p->spurious_int = 0; ! 6153: ! 6154: /* ! 6155: * Keep track of interrupts for /proc/scsi ! 6156: */ ! 6157: p->isr_count++; ! 6158: ! 6159: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 6160: if ( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) && ! 6161: (aic7xxx_panic_on_abort) && (p->flags & AHC_PAGESCBS) ) ! 6162: aic7xxx_check_scbs(p, "Bogus settings at start of interrupt."); ! 6163: #endif ! 6164: ! 6165: /* ! 6166: * Handle all the interrupt sources - especially for SCSI ! 6167: * interrupts, we won't get a second chance at them. ! 6168: */ ! 6169: if (intstat & CMDCMPLT) ! 6170: { ! 6171: struct aic7xxx_scb *scb = NULL; ! 6172: Scsi_Cmnd *cmd; ! 6173: unsigned char scb_index; ! 6174: ! 6175: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 6176: if(aic7xxx_verbose > 0xffff) ! 6177: printk(INFO_LEAD "Command Complete Int.\n", p->host_no, -1, -1, -1); ! 6178: #endif ! 6179: ! 6180: /* ! 6181: * Clear interrupt status before running the completion loop. ! 6182: * This eliminates a race condition whereby a command could ! 6183: * complete between the last check of qoutfifo and the ! 6184: * CLRCMDINT statement. This would result in us thinking the ! 6185: * qoutfifo was empty when it wasn't, and in actuality be a lost ! 6186: * completion interrupt. With multiple devices or tagged queueing ! 6187: * this could be very bad if we caught all but the last completion ! 6188: * and no more are imediately sent. ! 6189: */ ! 6190: aic_outb(p, CLRCMDINT, CLRINT); ! 6191: /* ! 6192: * The sequencer will continue running when it ! 6193: * issues this interrupt. There may be >1 commands ! 6194: * finished, so loop until we've processed them all. ! 6195: */ ! 6196: ! 6197: while (p->qoutfifo[p->qoutfifonext] != SCB_LIST_NULL) ! 6198: { ! 6199: scb_index = p->qoutfifo[p->qoutfifonext]; ! 6200: p->qoutfifo[p->qoutfifonext++] = SCB_LIST_NULL; ! 6201: if ( scb_index >= p->scb_data->numscbs ) ! 6202: scb = NULL; ! 6203: else ! 6204: scb = p->scb_data->scb_array[scb_index]; ! 6205: if (scb == NULL) ! 6206: { ! 6207: printk(WARN_LEAD "CMDCMPLT with invalid SCB index %d\n", p->host_no, ! 6208: -1, -1, -1, scb_index); ! 6209: continue; ! 6210: } ! 6211: else if (!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL)) ! 6212: { ! 6213: printk(WARN_LEAD "CMDCMPLT without command for SCB %d, SCB flags " ! 6214: "0x%x, cmd 0x%lx\n", p->host_no, -1, -1, -1, scb_index, scb->flags, ! 6215: (unsigned long) scb->cmd); ! 6216: continue; ! 6217: } ! 6218: else if (scb->flags & SCB_QUEUED_ABORT) ! 6219: { ! 6220: pause_sequencer(p); ! 6221: if ( ((aic_inb(p, LASTPHASE) & PHASE_MASK) != P_BUSFREE) && ! 6222: (aic_inb(p, SCB_TAG) == scb->hscb->tag) ) ! 6223: { ! 6224: unpause_sequencer(p, FALSE); ! 6225: continue; ! 6226: } ! 6227: aic7xxx_reset_device(p, scb->cmd->target, scb->cmd->channel, ! 6228: scb->cmd->lun, scb->hscb->tag); ! 6229: scb->flags &= ~(SCB_QUEUED_FOR_DONE | SCB_RESET | SCB_ABORT | ! 6230: SCB_QUEUED_ABORT); ! 6231: unpause_sequencer(p, FALSE); ! 6232: } ! 6233: else if (scb->flags & SCB_ABORT) ! 6234: { ! 6235: /* ! 6236: * We started to abort this, but it completed on us, let it ! 6237: * through as successful ! 6238: */ ! 6239: scb->flags &= ~(SCB_ABORT|SCB_RESET); ! 6240: } ! 6241: switch (status_byte(scb->hscb->target_status)) ! 6242: { ! 6243: case QUEUE_FULL: ! 6244: case BUSY: ! 6245: scb->hscb->target_status = 0; ! 6246: scb->cmd->result = 0; ! 6247: aic7xxx_error(scb->cmd) = DID_OK; ! 6248: break; ! 6249: default: ! 6250: cmd = scb->cmd; ! 6251: if (scb->hscb->residual_SG_segment_count != 0) ! 6252: { ! 6253: aic7xxx_calculate_residual(p, scb); ! 6254: } ! 6255: cmd->result |= (aic7xxx_error(cmd) << 16); ! 6256: if (scb->tag_action) ! 6257: p->dev_flags[TARGET_INDEX(cmd)] |= ! 6258: DEVICE_TAGGED_SUCCESS | DEVICE_SUCCESS | DEVICE_PRESENT; ! 6259: else ! 6260: p->dev_flags[TARGET_INDEX(cmd)] |= ! 6261: DEVICE_SUCCESS | DEVICE_PRESENT; ! 6262: aic7xxx_done(p, scb); ! 6263: break; ! 6264: } ! 6265: } ! 6266: } ! 6267: ! 6268: if (intstat & BRKADRINT) ! 6269: { ! 6270: int i; ! 6271: unsigned char errno = aic_inb(p, ERROR); ! 6272: ! 6273: printk(KERN_ERR "(scsi%d) BRKADRINT error(0x%x):\n", p->host_no, errno); ! 6274: for (i = 0; i < NUMBER(hard_error); i++) ! 6275: { ! 6276: if (errno & hard_error[i].errno) ! 6277: { ! 6278: printk(KERN_ERR " %s\n", hard_error[i].errmesg); ! 6279: } ! 6280: } ! 6281: printk(KERN_ERR "(scsi%d) SEQADDR=0x%x\n", p->host_no, ! 6282: (((aic_inb(p, SEQADDR1) << 8) & 0x100) | aic_inb(p, SEQADDR0))); ! 6283: if (aic7xxx_panic_on_abort) ! 6284: aic7xxx_panic_abort(p, NULL); ! 6285: #ifdef CONFIG_PCI ! 6286: if (errno & PCIERRSTAT) ! 6287: aic7xxx_pci_intr(p); ! 6288: #endif ! 6289: if (errno & (SQPARERR | ILLOPCODE | ILLSADDR)) ! 6290: { ! 6291: sti(); ! 6292: panic("aic7xxx: unrecoverable BRKADRINT.\n"); ! 6293: } ! 6294: if (errno & ILLHADDR) ! 6295: { ! 6296: printk(KERN_ERR "(scsi%d) BUG! Driver accessed chip without first " ! 6297: "pausing controller!\n", p->host_no); ! 6298: } ! 6299: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 6300: if (errno & DPARERR) ! 6301: { ! 6302: if (aic_inb(p, DMAPARAMS) & DIRECTION) ! 6303: printk("(scsi%d) while DMAing SCB from host to card.\n", p->host_no); ! 6304: else ! 6305: printk("(scsi%d) while DMAing SCB from card to host.\n", p->host_no); ! 6306: } ! 6307: #endif ! 6308: aic_outb(p, CLRPARERR | CLRBRKADRINT, CLRINT); ! 6309: unpause_sequencer(p, FALSE); ! 6310: } ! 6311: ! 6312: if (intstat & SEQINT) ! 6313: { ! 6314: aic7xxx_handle_seqint(p, intstat); ! 6315: } ! 6316: ! 6317: if (intstat & SCSIINT) ! 6318: { ! 6319: aic7xxx_handle_scsiint(p, intstat); ! 6320: } ! 6321: ! 6322: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 6323: if ( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) && ! 6324: (aic7xxx_panic_on_abort) && (p->flags & AHC_PAGESCBS) ) ! 6325: aic7xxx_check_scbs(p, "Bogus settings at end of interrupt."); ! 6326: #endif ! 6327: ! 6328: } ! 6329: ! 6330: /*+F************************************************************************* ! 6331: * Function: ! 6332: * do_aic7xxx_isr ! 6333: * ! 6334: * Description: ! 6335: * This is a gross hack to solve a problem in linux kernels 2.1.85 and ! 6336: * above. Please, children, do not try this at home, and if you ever see ! 6337: * anything like it, please inform the Gross Hack Police immediately ! 6338: *-F*************************************************************************/ ! 6339: static void ! 6340: do_aic7xxx_isr(int irq, void *dev_id, struct pt_regs *regs) ! 6341: { ! 6342: unsigned long cpu_flags; ! 6343: struct aic7xxx_host *p; ! 6344: ! 6345: p = (struct aic7xxx_host *)dev_id; ! 6346: if(!p) ! 6347: return; ! 6348: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,95) ! 6349: spin_lock_irqsave(&io_request_lock, cpu_flags); ! 6350: if(test_and_set_bit(AHC_IN_ISR_BIT, &p->flags)) ! 6351: { ! 6352: return; ! 6353: } ! 6354: do ! 6355: { ! 6356: aic7xxx_isr(irq, dev_id, regs); ! 6357: } while ( (aic_inb(p, INTSTAT) & INT_PEND) ); ! 6358: aic7xxx_done_cmds_complete(p); ! 6359: aic7xxx_run_waiting_queues(p); ! 6360: clear_bit(AHC_IN_ISR_BIT, &p->flags); ! 6361: spin_unlock_irqrestore(&io_request_lock, cpu_flags); ! 6362: #else ! 6363: if(set_bit(AHC_IN_ISR_BIT, (int *)&p->flags)) ! 6364: { ! 6365: return; ! 6366: } ! 6367: DRIVER_LOCK ! 6368: do ! 6369: { ! 6370: aic7xxx_isr(irq, dev_id, regs); ! 6371: } while ( (aic_inb(p, INTSTAT) & INT_PEND) ); ! 6372: DRIVER_UNLOCK ! 6373: aic7xxx_done_cmds_complete(p); ! 6374: aic7xxx_run_waiting_queues(p); ! 6375: clear_bit(AHC_IN_ISR_BIT, (int *)&p->flags); ! 6376: #endif ! 6377: } ! 6378: ! 6379: /*+F************************************************************************* ! 6380: * Function: ! 6381: * aic7xxx_device_queue_depth ! 6382: * ! 6383: * Description: ! 6384: * Determines the queue depth for a given device. There are two ways ! 6385: * a queue depth can be obtained for a tagged queueing device. One ! 6386: * way is the default queue depth which is determined by whether ! 6387: * AIC7XXX_CMDS_PER_LUN is defined. If it is defined, then it is used ! 6388: * as the default queue depth. Otherwise, we use either 4 or 8 as the ! 6389: * default queue depth (dependent on the number of hardware SCBs). ! 6390: * The other way we determine queue depth is through the use of the ! 6391: * aic7xxx_tag_info array which is enabled by defining ! 6392: * AIC7XXX_TAGGED_QUEUEING_BY_DEVICE. This array can be initialized ! 6393: * with queue depths for individual devices. It also allows tagged ! 6394: * queueing to be [en|dis]abled for a specific adapter. ! 6395: *-F*************************************************************************/ ! 6396: static void ! 6397: aic7xxx_device_queue_depth(struct aic7xxx_host *p, Scsi_Device *device) ! 6398: { ! 6399: int default_depth = 3; ! 6400: unsigned char tindex; ! 6401: unsigned short target_mask; ! 6402: ! 6403: tindex = device->id | (device->channel << 3); ! 6404: target_mask = (1 << tindex); ! 6405: ! 6406: device->queue_depth = default_depth; ! 6407: p->dev_mid_level_queue_depth[tindex] = 3; ! 6408: p->dev_temp_queue_depth[tindex] = 1; ! 6409: p->dev_max_queue_depth[tindex] = 1; ! 6410: p->tagenable &= ~target_mask; ! 6411: ! 6412: if (device->tagged_supported) ! 6413: { ! 6414: int tag_enabled = TRUE; ! 6415: ! 6416: #ifdef AIC7XXX_CMDS_PER_LUN ! 6417: default_depth = AIC7XXX_CMDS_PER_LUN; ! 6418: #else ! 6419: default_depth = 8; /* Not many SCBs to work with. */ ! 6420: #endif ! 6421: ! 6422: if (!(p->discenable & target_mask)) ! 6423: { ! 6424: if (aic7xxx_verbose & VERBOSE_NEGOTIATION2) ! 6425: printk(INFO_LEAD "Disconnection disabled, unable to " ! 6426: "enable tagged queueing.\n", ! 6427: p->host_no, device->channel, device->id, device->lun); ! 6428: } ! 6429: else ! 6430: { ! 6431: if (p->instance >= NUMBER(aic7xxx_tag_info)) ! 6432: { ! 6433: static int print_warning = TRUE; ! 6434: if(print_warning) ! 6435: { ! 6436: printk(KERN_INFO "aic7xxx: WARNING, insufficient tag_info instances for" ! 6437: " installed controllers.\n"); ! 6438: printk(KERN_INFO "aic7xxx: Please update the aic7xxx_tag_info array in" ! 6439: " the aic7xxx.c source file.\n"); ! 6440: print_warning = FALSE; ! 6441: } ! 6442: device->queue_depth = default_depth; ! 6443: } ! 6444: else ! 6445: { ! 6446: ! 6447: if (aic7xxx_tag_info[p->instance].tag_commands[tindex] == 255) ! 6448: { ! 6449: tag_enabled = FALSE; ! 6450: device->queue_depth = 3; /* Tagged queueing is disabled. */ ! 6451: } ! 6452: else if (aic7xxx_tag_info[p->instance].tag_commands[tindex] == 0) ! 6453: { ! 6454: device->queue_depth = default_depth; ! 6455: } ! 6456: else ! 6457: { ! 6458: device->queue_depth = ! 6459: aic7xxx_tag_info[p->instance].tag_commands[tindex]; ! 6460: } ! 6461: } ! 6462: if ((device->tagged_queue == 0) && tag_enabled) ! 6463: { ! 6464: if (aic7xxx_verbose & VERBOSE_NEGOTIATION2) ! 6465: { ! 6466: printk(INFO_LEAD "Enabled tagged queuing, queue depth %d.\n", ! 6467: p->host_no, device->channel, device->id, ! 6468: device->lun, device->queue_depth); ! 6469: } ! 6470: p->dev_max_queue_depth[tindex] = device->queue_depth; ! 6471: p->dev_temp_queue_depth[tindex] = device->queue_depth; ! 6472: p->dev_mid_level_queue_depth[tindex] = device->queue_depth; ! 6473: p->tagenable |= target_mask; ! 6474: p->orderedtag |= target_mask; ! 6475: device->tagged_queue = 1; ! 6476: device->current_tag = SCB_LIST_NULL; ! 6477: } ! 6478: } ! 6479: } ! 6480: } ! 6481: ! 6482: /*+F************************************************************************* ! 6483: * Function: ! 6484: * aic7xxx_select_queue_depth ! 6485: * ! 6486: * Description: ! 6487: * Sets the queue depth for each SCSI device hanging off the input ! 6488: * host adapter. We use a queue depth of 2 for devices that do not ! 6489: * support tagged queueing. If AIC7XXX_CMDS_PER_LUN is defined, we ! 6490: * use that for tagged queueing devices; otherwise we use our own ! 6491: * algorithm for determining the queue depth based on the maximum ! 6492: * SCBs for the controller. ! 6493: *-F*************************************************************************/ ! 6494: static void ! 6495: aic7xxx_select_queue_depth(struct Scsi_Host *host, ! 6496: Scsi_Device *scsi_devs) ! 6497: { ! 6498: Scsi_Device *device; ! 6499: struct aic7xxx_host *p = (struct aic7xxx_host *) host->hostdata; ! 6500: int scbnum; ! 6501: ! 6502: scbnum = 0; ! 6503: for (device = scsi_devs; device != NULL; device = device->next) ! 6504: { ! 6505: if (device->host == host) ! 6506: { ! 6507: aic7xxx_device_queue_depth(p, device); ! 6508: scbnum += device->queue_depth; ! 6509: } ! 6510: } ! 6511: while (scbnum > p->scb_data->numscbs) ! 6512: { ! 6513: /* ! 6514: * Pre-allocate the needed SCBs to get around the possibility of having ! 6515: * to allocate some when memory is more or less exhausted and we need ! 6516: * the SCB in order to perform a swap operation (possible deadlock) ! 6517: */ ! 6518: if ( aic7xxx_allocate_scb(p) == 0 ) ! 6519: return; ! 6520: } ! 6521: } ! 6522: ! 6523: /*+F************************************************************************* ! 6524: * Function: ! 6525: * aic7xxx_probe ! 6526: * ! 6527: * Description: ! 6528: * Probing for EISA boards: it looks like the first two bytes ! 6529: * are a manufacturer code - three characters, five bits each: ! 6530: * ! 6531: * BYTE 0 BYTE 1 BYTE 2 BYTE 3 ! 6532: * ?1111122 22233333 PPPPPPPP RRRRRRRR ! 6533: * ! 6534: * The characters are baselined off ASCII '@', so add that value ! 6535: * to each to get the real ASCII code for it. The next two bytes ! 6536: * appear to be a product and revision number, probably vendor- ! 6537: * specific. This is what is being searched for at each port, ! 6538: * and what should probably correspond to the ID= field in the ! 6539: * ECU's .cfg file for the card - if your card is not detected, ! 6540: * make sure your signature is listed in the array. ! 6541: * ! 6542: * The fourth byte's lowest bit seems to be an enabled/disabled ! 6543: * flag (rest of the bits are reserved?). ! 6544: * ! 6545: * NOTE: This function is only needed on Intel and Alpha platforms, ! 6546: * the other platforms we support don't have EISA/VLB busses. So, ! 6547: * we #ifdef this entire function to avoid compiler warnings about ! 6548: * an unused function. ! 6549: *-F*************************************************************************/ ! 6550: #if defined(__i386__) || defined(__alpha__) ! 6551: static int ! 6552: aic7xxx_probe(int slot, int base, ahc_flag_type *flags) ! 6553: { ! 6554: int i; ! 6555: unsigned char buf[4]; ! 6556: ! 6557: static struct { ! 6558: int n; ! 6559: unsigned char signature[sizeof(buf)]; ! 6560: ahc_chip type; ! 6561: int bios_disabled; ! 6562: } AIC7xxx[] = { ! 6563: { 4, { 0x04, 0x90, 0x77, 0x70 }, ! 6564: AHC_AIC7770|AHC_EISA, FALSE }, /* mb 7770 */ ! 6565: { 4, { 0x04, 0x90, 0x77, 0x71 }, ! 6566: AHC_AIC7770|AHC_EISA, FALSE }, /* host adapter 274x */ ! 6567: { 4, { 0x04, 0x90, 0x77, 0x56 }, ! 6568: AHC_AIC7770|AHC_VL, FALSE }, /* 284x BIOS enabled */ ! 6569: { 4, { 0x04, 0x90, 0x77, 0x57 }, ! 6570: AHC_AIC7770|AHC_VL, TRUE } /* 284x BIOS disabled */ ! 6571: }; ! 6572: ! 6573: /* ! 6574: * The VL-bus cards need to be primed by ! 6575: * writing before a signature check. ! 6576: */ ! 6577: for (i = 0; i < sizeof(buf); i++) ! 6578: { ! 6579: outb(0x80 + i, base); ! 6580: buf[i] = inb(base + i); ! 6581: } ! 6582: ! 6583: for (i = 0; i < NUMBER(AIC7xxx); i++) ! 6584: { ! 6585: /* ! 6586: * Signature match on enabled card? ! 6587: */ ! 6588: if (!memcmp(buf, AIC7xxx[i].signature, AIC7xxx[i].n)) ! 6589: { ! 6590: if (inb(base + 4) & 1) ! 6591: { ! 6592: if (AIC7xxx[i].bios_disabled) ! 6593: { ! 6594: *flags |= AHC_USEDEFAULTS; ! 6595: } ! 6596: else ! 6597: { ! 6598: *flags |= AHC_BIOS_ENABLED; ! 6599: } ! 6600: return (i); ! 6601: } ! 6602: ! 6603: printk("aic7xxx: <Adaptec 7770 SCSI Host Adapter> " ! 6604: "disabled at slot %d, ignored.\n", slot); ! 6605: } ! 6606: } ! 6607: ! 6608: return (-1); ! 6609: } ! 6610: #endif /* (__i386__) || (__alpha__) */ ! 6611: ! 6612: ! 6613: /*+F************************************************************************* ! 6614: * Function: ! 6615: * read_2840_seeprom ! 6616: * ! 6617: * Description: ! 6618: * Reads the 2840 serial EEPROM and returns 1 if successful and 0 if ! 6619: * not successful. ! 6620: * ! 6621: * See read_seeprom (for the 2940) for the instruction set of the 93C46 ! 6622: * chip. ! 6623: * ! 6624: * The 2840 interface to the 93C46 serial EEPROM is through the ! 6625: * STATUS_2840 and SEECTL_2840 registers. The CS_2840, CK_2840, and ! 6626: * DO_2840 bits of the SEECTL_2840 register are connected to the chip ! 6627: * select, clock, and data out lines respectively of the serial EEPROM. ! 6628: * The DI_2840 bit of the STATUS_2840 is connected to the data in line ! 6629: * of the serial EEPROM. The EEPROM_TF bit of STATUS_2840 register is ! 6630: * useful in that it gives us an 800 nsec timer. After a read from the ! 6631: * SEECTL_2840 register the timing flag is cleared and goes high 800 nsec ! 6632: * later. ! 6633: *-F*************************************************************************/ ! 6634: static int ! 6635: read_284x_seeprom(struct aic7xxx_host *p, struct seeprom_config *sc) ! 6636: { ! 6637: int i = 0, k = 0; ! 6638: unsigned char temp; ! 6639: unsigned short checksum = 0; ! 6640: unsigned short *seeprom = (unsigned short *) sc; ! 6641: struct seeprom_cmd { ! 6642: unsigned char len; ! 6643: unsigned char bits[3]; ! 6644: }; ! 6645: struct seeprom_cmd seeprom_read = {3, {1, 1, 0}}; ! 6646: ! 6647: #define CLOCK_PULSE(p) \ ! 6648: while ((aic_inb(p, STATUS_2840) & EEPROM_TF) == 0) \ ! 6649: { \ ! 6650: ; /* Do nothing */ \ ! 6651: } \ ! 6652: (void) aic_inb(p, SEECTL_2840); ! 6653: ! 6654: /* ! 6655: * Read the first 32 registers of the seeprom. For the 2840, ! 6656: * the 93C46 SEEPROM is a 1024-bit device with 64 16-bit registers ! 6657: * but only the first 32 are used by Adaptec BIOS. The loop ! 6658: * will range from 0 to 31. ! 6659: */ ! 6660: for (k = 0; k < (sizeof(*sc) / 2); k++) ! 6661: { ! 6662: /* ! 6663: * Send chip select for one clock cycle. ! 6664: */ ! 6665: aic_outb(p, CK_2840 | CS_2840, SEECTL_2840); ! 6666: CLOCK_PULSE(p); ! 6667: ! 6668: /* ! 6669: * Now we're ready to send the read command followed by the ! 6670: * address of the 16-bit register we want to read. ! 6671: */ ! 6672: for (i = 0; i < seeprom_read.len; i++) ! 6673: { ! 6674: temp = CS_2840 | seeprom_read.bits[i]; ! 6675: aic_outb(p, temp, SEECTL_2840); ! 6676: CLOCK_PULSE(p); ! 6677: temp = temp ^ CK_2840; ! 6678: aic_outb(p, temp, SEECTL_2840); ! 6679: CLOCK_PULSE(p); ! 6680: } ! 6681: /* ! 6682: * Send the 6 bit address (MSB first, LSB last). ! 6683: */ ! 6684: for (i = 5; i >= 0; i--) ! 6685: { ! 6686: temp = k; ! 6687: temp = (temp >> i) & 1; /* Mask out all but lower bit. */ ! 6688: temp = CS_2840 | temp; ! 6689: aic_outb(p, temp, SEECTL_2840); ! 6690: CLOCK_PULSE(p); ! 6691: temp = temp ^ CK_2840; ! 6692: aic_outb(p, temp, SEECTL_2840); ! 6693: CLOCK_PULSE(p); ! 6694: } ! 6695: ! 6696: /* ! 6697: * Now read the 16 bit register. An initial 0 precedes the ! 6698: * register contents which begins with bit 15 (MSB) and ends ! 6699: * with bit 0 (LSB). The initial 0 will be shifted off the ! 6700: * top of our word as we let the loop run from 0 to 16. ! 6701: */ ! 6702: for (i = 0; i <= 16; i++) ! 6703: { ! 6704: temp = CS_2840; ! 6705: aic_outb(p, temp, SEECTL_2840); ! 6706: CLOCK_PULSE(p); ! 6707: temp = temp ^ CK_2840; ! 6708: seeprom[k] = (seeprom[k] << 1) | (aic_inb(p, STATUS_2840) & DI_2840); ! 6709: aic_outb(p, temp, SEECTL_2840); ! 6710: CLOCK_PULSE(p); ! 6711: } ! 6712: /* ! 6713: * The serial EEPROM has a checksum in the last word. Keep a ! 6714: * running checksum for all words read except for the last ! 6715: * word. We'll verify the checksum after all words have been ! 6716: * read. ! 6717: */ ! 6718: if (k < (sizeof(*sc) / 2) - 1) ! 6719: { ! 6720: checksum = checksum + seeprom[k]; ! 6721: } ! 6722: ! 6723: /* ! 6724: * Reset the chip select for the next command cycle. ! 6725: */ ! 6726: aic_outb(p, 0, SEECTL_2840); ! 6727: CLOCK_PULSE(p); ! 6728: aic_outb(p, CK_2840, SEECTL_2840); ! 6729: CLOCK_PULSE(p); ! 6730: aic_outb(p, 0, SEECTL_2840); ! 6731: CLOCK_PULSE(p); ! 6732: } ! 6733: ! 6734: #if 0 ! 6735: printk("Computed checksum 0x%x, checksum read 0x%x\n", checksum, sc->checksum); ! 6736: printk("Serial EEPROM:"); ! 6737: for (k = 0; k < (sizeof(*sc) / 2); k++) ! 6738: { ! 6739: if (((k % 8) == 0) && (k != 0)) ! 6740: { ! 6741: printk("\n "); ! 6742: } ! 6743: printk(" 0x%x", seeprom[k]); ! 6744: } ! 6745: printk("\n"); ! 6746: #endif ! 6747: ! 6748: if (checksum != sc->checksum) ! 6749: { ! 6750: printk("aic7xxx: SEEPROM checksum error, ignoring SEEPROM settings.\n"); ! 6751: return (0); ! 6752: } ! 6753: ! 6754: return (1); ! 6755: #undef CLOCK_PULSE ! 6756: } ! 6757: ! 6758: /*+F************************************************************************* ! 6759: * Function: ! 6760: * acquire_seeprom ! 6761: * ! 6762: * Description: ! 6763: * Acquires access to the memory port on PCI controllers. ! 6764: *-F*************************************************************************/ ! 6765: static int ! 6766: acquire_seeprom(struct aic7xxx_host *p) ! 6767: { ! 6768: int wait; ! 6769: ! 6770: /* ! 6771: * Request access of the memory port. When access is ! 6772: * granted, SEERDY will go high. We use a 1 second ! 6773: * timeout which should be near 1 second more than ! 6774: * is needed. Reason: after the 7870 chip reset, there ! 6775: * should be no contention. ! 6776: */ ! 6777: aic_outb(p, SEEMS, SEECTL); ! 6778: wait = 1000; /* 1000 msec = 1 second */ ! 6779: while ((wait > 0) && ((aic_inb(p, SEECTL) & SEERDY) == 0)) ! 6780: { ! 6781: wait--; ! 6782: mdelay(1); /* 1 msec */ ! 6783: } ! 6784: if ((aic_inb(p, SEECTL) & SEERDY) == 0) ! 6785: { ! 6786: aic_outb(p, 0, SEECTL); ! 6787: return (0); ! 6788: } ! 6789: return (1); ! 6790: } ! 6791: ! 6792: /*+F************************************************************************* ! 6793: * Function: ! 6794: * release_seeprom ! 6795: * ! 6796: * Description: ! 6797: * Releases access to the memory port on PCI controllers. ! 6798: *-F*************************************************************************/ ! 6799: static void ! 6800: release_seeprom(struct aic7xxx_host *p) ! 6801: { ! 6802: aic_outb(p, 0, SEECTL); ! 6803: } ! 6804: ! 6805: /*+F************************************************************************* ! 6806: * Function: ! 6807: * read_seeprom ! 6808: * ! 6809: * Description: ! 6810: * Reads the serial EEPROM and returns 1 if successful and 0 if ! 6811: * not successful. ! 6812: * ! 6813: * The instruction set of the 93C46/56/66 chips is as follows: ! 6814: * ! 6815: * Start OP ! 6816: * Function Bit Code Address Data Description ! 6817: * ------------------------------------------------------------------- ! 6818: * READ 1 10 A5 - A0 Reads data stored in memory, ! 6819: * starting at specified address ! 6820: * EWEN 1 00 11XXXX Write enable must precede ! 6821: * all programming modes ! 6822: * ERASE 1 11 A5 - A0 Erase register A5A4A3A2A1A0 ! 6823: * WRITE 1 01 A5 - A0 D15 - D0 Writes register ! 6824: * ERAL 1 00 10XXXX Erase all registers ! 6825: * WRAL 1 00 01XXXX D15 - D0 Writes to all registers ! 6826: * EWDS 1 00 00XXXX Disables all programming ! 6827: * instructions ! 6828: * *Note: A value of X for address is a don't care condition. ! 6829: * *Note: The 93C56 and 93C66 have 8 address bits. ! 6830: * ! 6831: * ! 6832: * The 93C46 has a four wire interface: clock, chip select, data in, and ! 6833: * data out. In order to perform one of the above functions, you need ! 6834: * to enable the chip select for a clock period (typically a minimum of ! 6835: * 1 usec, with the clock high and low a minimum of 750 and 250 nsec ! 6836: * respectively. While the chip select remains high, you can clock in ! 6837: * the instructions (above) starting with the start bit, followed by the ! 6838: * OP code, Address, and Data (if needed). For the READ instruction, the ! 6839: * requested 16-bit register contents is read from the data out line but ! 6840: * is preceded by an initial zero (leading 0, followed by 16-bits, MSB ! 6841: * first). The clock cycling from low to high initiates the next data ! 6842: * bit to be sent from the chip. ! 6843: * ! 6844: * The 78xx interface to the 93C46 serial EEPROM is through the SEECTL ! 6845: * register. After successful arbitration for the memory port, the ! 6846: * SEECS bit of the SEECTL register is connected to the chip select. ! 6847: * The SEECK, SEEDO, and SEEDI are connected to the clock, data out, ! 6848: * and data in lines respectively. The SEERDY bit of SEECTL is useful ! 6849: * in that it gives us an 800 nsec timer. After a write to the SEECTL ! 6850: * register, the SEERDY goes high 800 nsec later. The one exception ! 6851: * to this is when we first request access to the memory port. The ! 6852: * SEERDY goes high to signify that access has been granted and, for ! 6853: * this case, has no implied timing. ! 6854: *-F*************************************************************************/ ! 6855: static int ! 6856: read_seeprom(struct aic7xxx_host *p, int offset, ! 6857: unsigned short *scarray, unsigned int len, seeprom_chip_type chip) ! 6858: { ! 6859: int i = 0, k; ! 6860: unsigned char temp; ! 6861: unsigned short checksum = 0; ! 6862: struct seeprom_cmd { ! 6863: unsigned char len; ! 6864: unsigned char bits[3]; ! 6865: }; ! 6866: struct seeprom_cmd seeprom_read = {3, {1, 1, 0}}; ! 6867: ! 6868: #define CLOCK_PULSE(p) \ ! 6869: while ((aic_inb(p, SEECTL) & SEERDY) == 0) \ ! 6870: { \ ! 6871: ; /* Do nothing */ \ ! 6872: } ! 6873: ! 6874: /* ! 6875: * Request access of the memory port. ! 6876: */ ! 6877: if (acquire_seeprom(p) == 0) ! 6878: { ! 6879: return (0); ! 6880: } ! 6881: ! 6882: /* ! 6883: * Read 'len' registers of the seeprom. For the 7870, the 93C46 ! 6884: * SEEPROM is a 1024-bit device with 64 16-bit registers but only ! 6885: * the first 32 are used by Adaptec BIOS. Some adapters use the ! 6886: * 93C56 SEEPROM which is a 2048-bit device. The loop will range ! 6887: * from 0 to 'len' - 1. ! 6888: */ ! 6889: for (k = 0; k < len; k++) ! 6890: { ! 6891: /* ! 6892: * Send chip select for one clock cycle. ! 6893: */ ! 6894: aic_outb(p, SEEMS | SEECK | SEECS, SEECTL); ! 6895: CLOCK_PULSE(p); ! 6896: ! 6897: /* ! 6898: * Now we're ready to send the read command followed by the ! 6899: * address of the 16-bit register we want to read. ! 6900: */ ! 6901: for (i = 0; i < seeprom_read.len; i++) ! 6902: { ! 6903: temp = SEEMS | SEECS | (seeprom_read.bits[i] << 1); ! 6904: aic_outb(p, temp, SEECTL); ! 6905: CLOCK_PULSE(p); ! 6906: temp = temp ^ SEECK; ! 6907: aic_outb(p, temp, SEECTL); ! 6908: CLOCK_PULSE(p); ! 6909: } ! 6910: /* ! 6911: * Send the 6 or 8 bit address (MSB first, LSB last). ! 6912: */ ! 6913: for (i = ((int) chip - 1); i >= 0; i--) ! 6914: { ! 6915: temp = k + offset; ! 6916: temp = (temp >> i) & 1; /* Mask out all but lower bit. */ ! 6917: temp = SEEMS | SEECS | (temp << 1); ! 6918: aic_outb(p, temp, SEECTL); ! 6919: CLOCK_PULSE(p); ! 6920: temp = temp ^ SEECK; ! 6921: aic_outb(p, temp, SEECTL); ! 6922: CLOCK_PULSE(p); ! 6923: } ! 6924: ! 6925: /* ! 6926: * Now read the 16 bit register. An initial 0 precedes the ! 6927: * register contents which begins with bit 15 (MSB) and ends ! 6928: * with bit 0 (LSB). The initial 0 will be shifted off the ! 6929: * top of our word as we let the loop run from 0 to 16. ! 6930: */ ! 6931: for (i = 0; i <= 16; i++) ! 6932: { ! 6933: temp = SEEMS | SEECS; ! 6934: aic_outb(p, temp, SEECTL); ! 6935: CLOCK_PULSE(p); ! 6936: temp = temp ^ SEECK; ! 6937: scarray[k] = (scarray[k] << 1) | (aic_inb(p, SEECTL) & SEEDI); ! 6938: aic_outb(p, temp, SEECTL); ! 6939: CLOCK_PULSE(p); ! 6940: } ! 6941: ! 6942: /* ! 6943: * The serial EEPROM should have a checksum in the last word. ! 6944: * Keep a running checksum for all words read except for the ! 6945: * last word. We'll verify the checksum after all words have ! 6946: * been read. ! 6947: */ ! 6948: if (k < (len - 1)) ! 6949: { ! 6950: checksum = checksum + scarray[k]; ! 6951: } ! 6952: ! 6953: /* ! 6954: * Reset the chip select for the next command cycle. ! 6955: */ ! 6956: aic_outb(p, SEEMS, SEECTL); ! 6957: CLOCK_PULSE(p); ! 6958: aic_outb(p, SEEMS | SEECK, SEECTL); ! 6959: CLOCK_PULSE(p); ! 6960: aic_outb(p, SEEMS, SEECTL); ! 6961: CLOCK_PULSE(p); ! 6962: } ! 6963: ! 6964: /* ! 6965: * Release access to the memory port and the serial EEPROM. ! 6966: */ ! 6967: release_seeprom(p); ! 6968: ! 6969: #if 0 ! 6970: printk("Computed checksum 0x%x, checksum read 0x%x\n", ! 6971: checksum, scarray[len - 1]); ! 6972: printk("Serial EEPROM:"); ! 6973: for (k = 0; k < len; k++) ! 6974: { ! 6975: if (((k % 8) == 0) && (k != 0)) ! 6976: { ! 6977: printk("\n "); ! 6978: } ! 6979: printk(" 0x%x", scarray[k]); ! 6980: } ! 6981: printk("\n"); ! 6982: #endif ! 6983: if (checksum != scarray[len - 1]) ! 6984: { ! 6985: return (0); ! 6986: } ! 6987: ! 6988: return (1); ! 6989: #undef CLOCK_PULSE ! 6990: } ! 6991: ! 6992: /*+F************************************************************************* ! 6993: * Function: ! 6994: * write_brdctl ! 6995: * ! 6996: * Description: ! 6997: * Writes a value to the BRDCTL register. ! 6998: *-F*************************************************************************/ ! 6999: static void ! 7000: write_brdctl(struct aic7xxx_host *p, unsigned char value) ! 7001: { ! 7002: unsigned char brdctl; ! 7003: ! 7004: if ((p->chip & AHC_CHIPID_MASK) == AHC_AIC7895) ! 7005: { ! 7006: brdctl = BRDSTB; ! 7007: if (p->flags & AHC_CHNLB) ! 7008: brdctl |= BRDCS; ! 7009: } ! 7010: else if (p->features & AHC_ULTRA2) ! 7011: brdctl = 0; ! 7012: else ! 7013: brdctl = BRDSTB | BRDCS; ! 7014: aic_outb(p, brdctl, BRDCTL); ! 7015: udelay(1); ! 7016: brdctl |= value; ! 7017: aic_outb(p, brdctl, BRDCTL); ! 7018: udelay(1); ! 7019: if (p->features & AHC_ULTRA2) ! 7020: brdctl |= BRDSTB_ULTRA2; ! 7021: else ! 7022: brdctl &= ~BRDSTB; ! 7023: aic_outb(p, brdctl, BRDCTL); ! 7024: udelay(1); ! 7025: if (p->features & AHC_ULTRA2) ! 7026: brdctl = 0; ! 7027: else ! 7028: brdctl &= ~BRDCS; ! 7029: aic_outb(p, brdctl, BRDCTL); ! 7030: udelay(1); ! 7031: } ! 7032: ! 7033: /*+F************************************************************************* ! 7034: * Function: ! 7035: * read_brdctl ! 7036: * ! 7037: * Description: ! 7038: * Reads the BRDCTL register. ! 7039: *-F*************************************************************************/ ! 7040: static unsigned char ! 7041: read_brdctl(struct aic7xxx_host *p) ! 7042: { ! 7043: unsigned char brdctl, value; ! 7044: ! 7045: if ((p->chip & AHC_CHIPID_MASK) == AHC_AIC7895) ! 7046: { ! 7047: brdctl = BRDRW; ! 7048: if (p->flags & AHC_CHNLB) ! 7049: brdctl |= BRDCS; ! 7050: } ! 7051: else if (p->features & AHC_ULTRA2) ! 7052: brdctl = BRDRW_ULTRA2; ! 7053: else ! 7054: brdctl = BRDRW | BRDCS; ! 7055: aic_outb(p, brdctl, BRDCTL); ! 7056: udelay(1); ! 7057: value = aic_inb(p, BRDCTL); ! 7058: aic_outb(p, 0, BRDCTL); ! 7059: udelay(1); ! 7060: return (value); ! 7061: } ! 7062: ! 7063: /*+F************************************************************************* ! 7064: * Function: ! 7065: * aic785x_cable_detect ! 7066: * ! 7067: * Description: ! 7068: * Detect the cables that are present on aic785x class controller chips ! 7069: *-F*************************************************************************/ ! 7070: static void ! 7071: aic785x_cable_detect(struct aic7xxx_host *p, int *int_50, ! 7072: int *ext_present, int *eeprom) ! 7073: { ! 7074: unsigned char brdctl; ! 7075: ! 7076: aic_outb(p, BRDRW | BRDCS, BRDCTL); ! 7077: udelay(1); ! 7078: aic_outb(p, 0, BRDCTL); ! 7079: udelay(1); ! 7080: brdctl = aic_inb(p, BRDCTL); ! 7081: udelay(1); ! 7082: *int_50 = !(brdctl & BRDDAT5); ! 7083: *ext_present = !(brdctl & BRDDAT6); ! 7084: *eeprom = (aic_inb(p, SPIOCAP) & EEPROM); ! 7085: } ! 7086: ! 7087: /*+F************************************************************************* ! 7088: * Function: ! 7089: * aic787x_cable_detect ! 7090: * ! 7091: * Description: ! 7092: * Detect the cables that are present on aic787x class controller chips ! 7093: * ! 7094: * NOTE: This functions assumes the SEEPROM will have already been aquired ! 7095: * prior to invocation of this function. ! 7096: *-F*************************************************************************/ ! 7097: static void ! 7098: aic787x_cable_detect(struct aic7xxx_host *p, int *int_50, int *int_68, ! 7099: int *ext_present, int *eeprom) ! 7100: { ! 7101: unsigned char brdctl; ! 7102: ! 7103: /* ! 7104: * First read the status of our cables. Set the rom bank to ! 7105: * 0 since the bank setting serves as a multiplexor for the ! 7106: * cable detection logic. BRDDAT5 controls the bank switch. ! 7107: */ ! 7108: write_brdctl(p, 0); ! 7109: ! 7110: /* ! 7111: * Now we read the state of the two internal connectors. BRDDAT6 ! 7112: * is internal 50, BRDDAT7 is internal 68. For each, the cable is ! 7113: * present if the bit is 0 ! 7114: */ ! 7115: brdctl = read_brdctl(p); ! 7116: *int_50 = !(brdctl & BRDDAT6); ! 7117: *int_68 = !(brdctl & BRDDAT7); ! 7118: ! 7119: /* ! 7120: * Set the bank bit in brdctl and then read the external cable state ! 7121: * and the EEPROM status ! 7122: */ ! 7123: write_brdctl(p, BRDDAT5); ! 7124: brdctl = read_brdctl(p); ! 7125: ! 7126: *ext_present = !(brdctl & BRDDAT6); ! 7127: *eeprom = !(brdctl & BRDDAT7); ! 7128: ! 7129: /* ! 7130: * We're done, the calling function will release the SEEPROM for us ! 7131: */ ! 7132: } ! 7133: ! 7134: /*+F************************************************************************* ! 7135: * Function: ! 7136: * aic787x_ultra2_term_detect ! 7137: * ! 7138: * Description: ! 7139: * Detect the termination settings present on ultra2 class controllers ! 7140: * ! 7141: * NOTE: This functions assumes the SEEPROM will have already been aquired ! 7142: * prior to invocation of this function. ! 7143: *-F*************************************************************************/ ! 7144: static void ! 7145: aic7xxx_ultra2_term_detect(struct aic7xxx_host *p, int *enableSE_low, ! 7146: int *enableSE_high, int *enableLVD_low, ! 7147: int *enableLVD_high, int *eprom_present) ! 7148: { ! 7149: unsigned char brdctl; ! 7150: ! 7151: brdctl = read_brdctl(p); ! 7152: ! 7153: *eprom_present = (brdctl & BRDDAT7); ! 7154: *enableSE_high = (brdctl & BRDDAT6); ! 7155: *enableSE_low = (brdctl & BRDDAT5); ! 7156: *enableLVD_high = (brdctl & BRDDAT4); ! 7157: *enableLVD_low = (brdctl & BRDDAT3); ! 7158: } ! 7159: ! 7160: /*+F************************************************************************* ! 7161: * Function: ! 7162: * configure_termination ! 7163: * ! 7164: * Description: ! 7165: * Configures the termination settings on PCI adapters that have ! 7166: * SEEPROMs available. ! 7167: *-F*************************************************************************/ ! 7168: static void ! 7169: configure_termination(struct aic7xxx_host *p) ! 7170: { ! 7171: int internal50_present = 0; ! 7172: int internal68_present = 0; ! 7173: int external_present = 0; ! 7174: int eprom_present = 0; ! 7175: int enableSE_low = 0; ! 7176: int enableSE_high = 0; ! 7177: int enableLVD_low = 0; ! 7178: int enableLVD_high = 0; ! 7179: unsigned char brddat = 0; ! 7180: unsigned char max_target = 0; ! 7181: unsigned char sxfrctl1 = aic_inb(p, SXFRCTL1); ! 7182: ! 7183: if (acquire_seeprom(p)) ! 7184: { ! 7185: if (p->features & (AHC_WIDE|AHC_TWIN)) ! 7186: max_target = 16; ! 7187: else ! 7188: max_target = 8; ! 7189: aic_outb(p, SEEMS | SEECS, SEECTL); ! 7190: sxfrctl1 &= ~STPWEN; ! 7191: if ( (p->adapter_control & CFAUTOTERM) || ! 7192: (p->features & AHC_ULTRA2) ) ! 7193: { ! 7194: if ( (p->adapter_control & CFAUTOTERM) && !(p->features & AHC_ULTRA2) ) ! 7195: { ! 7196: printk(KERN_INFO "(scsi%d) Warning - detected auto-termination\n", ! 7197: p->host_no); ! 7198: printk(KERN_INFO "(scsi%d) Please verify driver detected settings are " ! 7199: "correct.\n", p->host_no); ! 7200: printk(KERN_INFO "(scsi%d) If not, then please properly set the device " ! 7201: "termination\n", p->host_no); ! 7202: printk(KERN_INFO "(scsi%d) in the Adaptec SCSI BIOS by hitting CTRL-A " ! 7203: "when prompted\n", p->host_no); ! 7204: printk(KERN_INFO "(scsi%d) during machine bootup.\n", p->host_no); ! 7205: } ! 7206: /* Configure auto termination. */ ! 7207: ! 7208: if (p->features & AHC_ULTRA2) ! 7209: { ! 7210: if (aic7xxx_override_term == -1) ! 7211: aic7xxx_ultra2_term_detect(p, &enableSE_low, &enableSE_high, ! 7212: &enableLVD_low, &enableLVD_high, ! 7213: &eprom_present); ! 7214: if (!(p->adapter_control & CFSEAUTOTERM)) ! 7215: { ! 7216: enableSE_low = (p->adapter_control & CFSTERM); ! 7217: enableSE_high = (p->adapter_control & CFWSTERM); ! 7218: } ! 7219: if (!(p->adapter_control & CFAUTOTERM)) ! 7220: { ! 7221: enableLVD_low = enableLVD_high = (p->adapter_control & CFLVDSTERM); ! 7222: } ! 7223: internal50_present = 0; ! 7224: internal68_present = 1; ! 7225: external_present = 1; ! 7226: } ! 7227: else if ( (p->chip & AHC_CHIPID_MASK) >= AHC_AIC7870 ) ! 7228: { ! 7229: aic787x_cable_detect(p, &internal50_present, &internal68_present, ! 7230: &external_present, &eprom_present); ! 7231: } ! 7232: else ! 7233: { ! 7234: aic785x_cable_detect(p, &internal50_present, &external_present, ! 7235: &eprom_present); ! 7236: } ! 7237: ! 7238: if (max_target <= 8) ! 7239: internal68_present = 0; ! 7240: ! 7241: if ( !(p->features & AHC_ULTRA2) ) ! 7242: { ! 7243: if (max_target > 8) ! 7244: { ! 7245: printk(KERN_INFO "(scsi%d) Cables present (Int-50 %s, Int-68 %s, " ! 7246: "Ext-68 %s)\n", p->host_no, ! 7247: internal50_present ? "YES" : "NO", ! 7248: internal68_present ? "YES" : "NO", ! 7249: external_present ? "YES" : "NO"); ! 7250: } ! 7251: else ! 7252: { ! 7253: printk(KERN_INFO "(scsi%d) Cables present (Int-50 %s, Ext-50 %s)\n", ! 7254: p->host_no, ! 7255: internal50_present ? "YES" : "NO", ! 7256: external_present ? "YES" : "NO"); ! 7257: } ! 7258: } ! 7259: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7260: printk(KERN_INFO "(scsi%d) EEPROM %s present.\n", p->host_no, ! 7261: eprom_present ? "is" : "is not"); ! 7262: ! 7263: /* ! 7264: * Now set the termination based on what we found. BRDDAT6 ! 7265: * controls wide termination enable. ! 7266: * Flash Enable = BRDDAT7 ! 7267: * SE High Term Enable = BRDDAT6 ! 7268: * SE Low Term Enable = BRDDAT5 (7890) ! 7269: * LVD High Term Enable = BRDDAT4 (7890) ! 7270: */ ! 7271: if ( !(p->features & AHC_ULTRA2) && ! 7272: (internal50_present && internal68_present && external_present) ) ! 7273: { ! 7274: printk(KERN_INFO "(scsi%d) Illegal cable configuration!! Only two\n", ! 7275: p->host_no); ! 7276: printk(KERN_INFO "(scsi%d) connectors on the SCSI controller may be " ! 7277: "in use at a time!\n", p->host_no); ! 7278: /* ! 7279: * Force termination (low and high byte) on. This is safer than ! 7280: * leaving it completely off, especially since this message comes ! 7281: * most often from motherboard controllers that don't even have 3 ! 7282: * connectors, but instead are failing the cable detection. ! 7283: */ ! 7284: internal50_present = external_present = 0; ! 7285: enableSE_high = enableSE_low = 1; ! 7286: } ! 7287: ! 7288: if ((max_target > 8) && ! 7289: ((external_present == 0) || (internal68_present == 0) || ! 7290: (enableSE_high != 0))) ! 7291: { ! 7292: brddat |= BRDDAT6; ! 7293: p->flags |= AHC_TERM_ENB_SE_HIGH; ! 7294: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7295: printk(KERN_INFO "(scsi%d) SE High byte termination Enabled\n", ! 7296: p->host_no); ! 7297: } ! 7298: ! 7299: if ( (((internal50_present ? 1 : 0) + ! 7300: (internal68_present ? 1 : 0) + ! 7301: (external_present ? 1 : 0)) <= 1) || ! 7302: (enableSE_low != 0) ) ! 7303: { ! 7304: if (p->features & AHC_ULTRA2) ! 7305: brddat |= BRDDAT5; ! 7306: else ! 7307: sxfrctl1 |= STPWEN; ! 7308: p->flags |= AHC_TERM_ENB_SE_LOW; ! 7309: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7310: printk(KERN_INFO "(scsi%d) SE Low byte termination Enabled\n", ! 7311: p->host_no); ! 7312: } ! 7313: ! 7314: if (enableLVD_low != 0) ! 7315: { ! 7316: sxfrctl1 |= STPWEN; ! 7317: p->flags |= AHC_TERM_ENB_LVD; ! 7318: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7319: printk(KERN_INFO "(scsi%d) LVD Low byte termination Enabled\n", ! 7320: p->host_no); ! 7321: } ! 7322: ! 7323: if (enableLVD_high != 0) ! 7324: { ! 7325: brddat |= BRDDAT4; ! 7326: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7327: printk(KERN_INFO "(scsi%d) LVD High byte termination Enabled\n", ! 7328: p->host_no); ! 7329: } ! 7330: } ! 7331: else ! 7332: { ! 7333: if (p->adapter_control & CFSTERM) ! 7334: { ! 7335: if (p->features & AHC_ULTRA2) ! 7336: brddat |= BRDDAT5; ! 7337: else ! 7338: sxfrctl1 |= STPWEN; ! 7339: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7340: printk(KERN_INFO "(scsi%d) SE Low byte termination Enabled\n", ! 7341: p->host_no); ! 7342: } ! 7343: ! 7344: if (p->adapter_control & CFWSTERM) ! 7345: { ! 7346: brddat |= BRDDAT6; ! 7347: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7348: printk(KERN_INFO "(scsi%d) SE High byte termination Enabled\n", ! 7349: p->host_no); ! 7350: } ! 7351: } ! 7352: write_brdctl(p, brddat); ! 7353: release_seeprom(p); ! 7354: aic_outb(p, sxfrctl1, SXFRCTL1); ! 7355: } ! 7356: } ! 7357: ! 7358: /*+F************************************************************************* ! 7359: * Function: ! 7360: * detect_maxscb ! 7361: * ! 7362: * Description: ! 7363: * Detects the maximum number of SCBs for the controller and returns ! 7364: * the count and a mask in p (p->maxscbs, p->qcntmask). ! 7365: *-F*************************************************************************/ ! 7366: static void ! 7367: detect_maxscb(struct aic7xxx_host *p) ! 7368: { ! 7369: int i; ! 7370: ! 7371: /* ! 7372: * It's possible that we've already done this for multichannel ! 7373: * adapters. ! 7374: */ ! 7375: if (p->scb_data->maxhscbs == 0) ! 7376: { ! 7377: /* ! 7378: * We haven't initialized the SCB settings yet. Walk the SCBs to ! 7379: * determince how many there are. ! 7380: */ ! 7381: aic_outb(p, 0, FREE_SCBH); ! 7382: ! 7383: for (i = 0; i < AIC7XXX_MAXSCB; i++) ! 7384: { ! 7385: aic_outb(p, i, SCBPTR); ! 7386: aic_outb(p, i, SCB_CONTROL); ! 7387: if (aic_inb(p, SCB_CONTROL) != i) ! 7388: break; ! 7389: aic_outb(p, 0, SCBPTR); ! 7390: if (aic_inb(p, SCB_CONTROL) != 0) ! 7391: break; ! 7392: ! 7393: aic_outb(p, i, SCBPTR); ! 7394: aic_outb(p, 0, SCB_CONTROL); /* Clear the control byte. */ ! 7395: aic_outb(p, i + 1, SCB_NEXT); /* Set the next pointer. */ ! 7396: aic_outb(p, i - 1, SCB_PREV); /* Set the prev pointer. */ ! 7397: aic_outb(p, SCB_LIST_NULL, SCB_TAG); /* Make the tag invalid. */ ! 7398: aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS); /* no busy untagged */ ! 7399: aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS+1);/* targets active yet */ ! 7400: aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS+2); ! 7401: aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS+3); ! 7402: } ! 7403: ! 7404: /* Make sure the last SCB terminates the free list. */ ! 7405: aic_outb(p, i - 1, SCBPTR); ! 7406: aic_outb(p, SCB_LIST_NULL, SCB_NEXT); ! 7407: ! 7408: /* Ensure we clear the first (0) SCBs control byte. */ ! 7409: aic_outb(p, 0, SCBPTR); ! 7410: aic_outb(p, 0, SCB_CONTROL); ! 7411: ! 7412: p->scb_data->maxhscbs = i; ! 7413: /* ! 7414: * Use direct indexing instead for speed ! 7415: */ ! 7416: if ( i == AIC7XXX_MAXSCB ) ! 7417: p->flags &= ~AHC_PAGESCBS; ! 7418: } ! 7419: ! 7420: } ! 7421: ! 7422: /*+F************************************************************************* ! 7423: * Function: ! 7424: * aic7xxx_register ! 7425: * ! 7426: * Description: ! 7427: * Register a Adaptec aic7xxx chip SCSI controller with the kernel. ! 7428: *-F*************************************************************************/ ! 7429: static int ! 7430: aic7xxx_register(Scsi_Host_Template *template, struct aic7xxx_host *p, ! 7431: int reset_delay) ! 7432: { ! 7433: int i, result; ! 7434: int max_targets; ! 7435: int found = 1; ! 7436: unsigned char term, scsi_conf; ! 7437: struct Scsi_Host *host; ! 7438: ! 7439: /* ! 7440: * Lock out other contenders for our i/o space. ! 7441: */ ! 7442: request_region(p->base, MAXREG - MINREG, "aic7xxx"); ! 7443: ! 7444: ! 7445: host = p->host; ! 7446: ! 7447: p->scb_data->maxscbs = AIC7XXX_MAXSCB; ! 7448: host->can_queue = AIC7XXX_MAXSCB; ! 7449: host->cmd_per_lun = 3; ! 7450: host->sg_tablesize = AIC7XXX_MAX_SG; ! 7451: host->select_queue_depths = aic7xxx_select_queue_depth; ! 7452: host->this_id = p->scsi_id; ! 7453: host->io_port = p->base; ! 7454: host->n_io_port = 0xFF; ! 7455: host->base = (unsigned char *) p->mbase; ! 7456: host->irq = p->irq; ! 7457: if (p->features & AHC_WIDE) ! 7458: { ! 7459: host->max_id = 16; ! 7460: } ! 7461: if (p->features & AHC_TWIN) ! 7462: { ! 7463: host->max_channel = 1; ! 7464: } ! 7465: ! 7466: p->host = host; ! 7467: p->last_reset = 0; ! 7468: p->host_no = host->host_no; ! 7469: host->unique_id = p->instance; ! 7470: p->isr_count = 0; ! 7471: p->next = NULL; ! 7472: p->completeq.head = NULL; ! 7473: p->completeq.tail = NULL; ! 7474: scbq_init(&p->scb_data->free_scbs); ! 7475: scbq_init(&p->waiting_scbs); ! 7476: ! 7477: for (i = 0; i < NUMBER(p->untagged_scbs); i++) ! 7478: { ! 7479: p->untagged_scbs[i] = SCB_LIST_NULL; ! 7480: p->qinfifo[i] = SCB_LIST_NULL; ! 7481: p->qoutfifo[i] = SCB_LIST_NULL; ! 7482: } ! 7483: /* ! 7484: * We currently have no commands of any type ! 7485: */ ! 7486: p->qinfifonext = 0; ! 7487: p->qoutfifonext = 0; ! 7488: ! 7489: for (i = 0; i < MAX_TARGETS; i++) ! 7490: { ! 7491: p->dev_commands_sent[i] = 0; ! 7492: p->dev_flags[i] = 0; ! 7493: p->dev_active_cmds[i] = 0; ! 7494: p->dev_last_reset[i] = 0; ! 7495: p->dev_last_queue_full[i] = 0; ! 7496: p->dev_last_queue_full_count[i] = 0; ! 7497: p->dev_max_queue_depth[i] = 1; ! 7498: p->dev_temp_queue_depth[i] = 1; ! 7499: p->dev_mid_level_queue_depth[i] = 3; ! 7500: scbq_init(&p->delayed_scbs[i]); ! 7501: init_timer(&p->dev_timer[i]); ! 7502: p->dev_timer[i].expires = 0; ! 7503: p->dev_timer[i].data = (unsigned long)p; ! 7504: p->dev_timer[i].function = (void *)aic7xxx_timer; ! 7505: } ! 7506: ! 7507: printk(KERN_INFO "(scsi%d) <%s> found at ", p->host_no, ! 7508: board_names[p->board_name_index]); ! 7509: switch(p->chip) ! 7510: { ! 7511: case (AHC_AIC7770|AHC_EISA): ! 7512: printk("EISA slot %d\n", p->pci_device_fn); ! 7513: break; ! 7514: case (AHC_AIC7770|AHC_VL): ! 7515: printk("VLB slot %d\n", p->pci_device_fn); ! 7516: break; ! 7517: default: ! 7518: printk("PCI %d/%d\n", PCI_SLOT(p->pci_device_fn), ! 7519: PCI_FUNC(p->pci_device_fn)); ! 7520: break; ! 7521: } ! 7522: if (p->features & AHC_TWIN) ! 7523: { ! 7524: printk(KERN_INFO "(scsi%d) Twin Channel, A SCSI ID %d, B SCSI ID %d, ", ! 7525: p->host_no, p->scsi_id, p->scsi_id_b); ! 7526: } ! 7527: else ! 7528: { ! 7529: char *channel; ! 7530: ! 7531: channel = ""; ! 7532: ! 7533: if ((p->flags & AHC_MULTI_CHANNEL) != 0) ! 7534: { ! 7535: channel = " A"; ! 7536: ! 7537: if ( (p->flags & (AHC_CHNLB|AHC_CHNLC)) != 0 ) ! 7538: { ! 7539: channel = (p->flags & AHC_CHNLB) ? " B" : " C"; ! 7540: } ! 7541: } ! 7542: if (p->features & AHC_WIDE) ! 7543: { ! 7544: printk(KERN_INFO "(scsi%d) Wide ", p->host_no); ! 7545: } ! 7546: else ! 7547: { ! 7548: printk(KERN_INFO "(scsi%d) Narrow ", p->host_no); ! 7549: } ! 7550: printk("Channel%s, SCSI ID=%d, ", channel, p->scsi_id); ! 7551: } ! 7552: aic_outb(p, 0, SEQ_FLAGS); ! 7553: ! 7554: /* ! 7555: * Detect SCB parameters and initialize the SCB array. ! 7556: */ ! 7557: detect_maxscb(p); ! 7558: printk("%d/%d SCBs\n", p->scb_data->maxhscbs, p->scb_data->maxscbs); ! 7559: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7560: { ! 7561: printk(KERN_INFO "(scsi%d) BIOS %sabled, IO Port 0x%lx, IRQ %d\n", ! 7562: p->host_no, (p->flags & AHC_BIOS_ENABLED) ? "en" : "dis", ! 7563: p->base, p->irq); ! 7564: printk(KERN_INFO "(scsi%d) IO Memory at 0x%lx, MMAP Memory at 0x%lx\n", ! 7565: p->host_no, p->mbase, (unsigned long)p->maddr); ! 7566: } ! 7567: ! 7568: #ifdef CONFIG_PCI ! 7569: /* ! 7570: * Now that we know our instance number, we can set the flags we need to ! 7571: * force termination if need be. ! 7572: */ ! 7573: if (aic7xxx_stpwlev != -1) ! 7574: { ! 7575: /* ! 7576: * This option only applies to PCI controllers. ! 7577: */ ! 7578: if ( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI) ! 7579: { ! 7580: unsigned char devconfig; ! 7581: ! 7582: #if LINUX_KERNEL_VERSION > KERNEL_VERSION(2,1,92) ! 7583: pci_read_config_byte(p->pdev, DEVCONFIG, &devconfig); ! 7584: #else ! 7585: pcibios_read_config_byte(p->pci_bus, p->pci_device_fn, ! 7586: DEVCONFIG, &devconfig); ! 7587: #endif ! 7588: if ( (aic7xxx_stpwlev >> p->instance) & 0x01 ) ! 7589: { ! 7590: devconfig |= 0x02; ! 7591: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7592: printk("(scsi%d) Force setting STPWLEV bit\n", p->host_no); ! 7593: } ! 7594: else ! 7595: { ! 7596: devconfig &= ~0x02; ! 7597: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7598: printk("(scsi%d) Force clearing STPWLEV bit\n", p->host_no); ! 7599: } ! 7600: #if LINUX_KERNEL_VERSION > KERNEL_VERSION(2,1,92) ! 7601: pci_write_config_byte(p->pdev, DEVCONFIG, devconfig); ! 7602: #else ! 7603: pcibios_write_config_byte(p->pci_bus, p->pci_device_fn, ! 7604: DEVCONFIG, devconfig); ! 7605: #endif ! 7606: } ! 7607: } ! 7608: #endif ! 7609: ! 7610: /* ! 7611: * That took care of devconfig and stpwlev, now for the actual termination ! 7612: * settings. ! 7613: */ ! 7614: if (aic7xxx_override_term != -1) ! 7615: { ! 7616: /* ! 7617: * Again, this only applies to PCI controllers. We don't have problems ! 7618: * with the termination on 274x controllers to the best of my knowledge. ! 7619: */ ! 7620: if ( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI) ! 7621: { ! 7622: unsigned char term_override; ! 7623: ! 7624: term_override = ( (aic7xxx_override_term >> (p->instance * 4)) & 0x0f); ! 7625: p->adapter_control &= ! 7626: ~(CFSTERM|CFWSTERM|CFLVDSTERM|CFAUTOTERM|CFSEAUTOTERM); ! 7627: if ( (p->features & AHC_ULTRA2) && (term_override & 0x0c) ) ! 7628: { ! 7629: p->adapter_control |= CFLVDSTERM; ! 7630: } ! 7631: if (term_override & 0x02) ! 7632: { ! 7633: p->adapter_control |= CFWSTERM; ! 7634: } ! 7635: if (term_override & 0x01) ! 7636: { ! 7637: p->adapter_control |= CFSTERM; ! 7638: } ! 7639: } ! 7640: } ! 7641: ! 7642: if ( (p->flags & AHC_SEEPROM_FOUND) || (aic7xxx_override_term != -1) ) ! 7643: { ! 7644: if (p->features & AHC_SPIOCAP) ! 7645: { ! 7646: if ( aic_inb(p, SPIOCAP) & SSPIOCPS ) ! 7647: /* ! 7648: * Update the settings in sxfrctl1 to match the termination ! 7649: * settings. ! 7650: */ ! 7651: configure_termination(p); ! 7652: } ! 7653: else if ((p->chip & AHC_CHIPID_MASK) >= AHC_AIC7870) ! 7654: { ! 7655: configure_termination(p); ! 7656: } ! 7657: } ! 7658: ! 7659: /* ! 7660: * Clear out any possible pending interrupts. ! 7661: */ ! 7662: aic7xxx_clear_intstat(p); ! 7663: ! 7664: /* ! 7665: * Set the SCSI Id, SXFRCTL0, SXFRCTL1, and SIMODE1, for both channels ! 7666: */ ! 7667: if (p->features & AHC_TWIN) ! 7668: { ! 7669: /* Select channel B */ ! 7670: aic_outb(p, aic_inb(p, SBLKCTL) | SELBUSB, SBLKCTL); ! 7671: ! 7672: term = ((p->flags & AHC_TERM_ENB_B) != 0) ? STPWEN : 0; ! 7673: aic_outb(p, p->scsi_id_b, SCSIID); ! 7674: scsi_conf = aic_inb(p, SCSICONF + 1); ! 7675: aic_outb(p, DFON | SPIOEN, SXFRCTL0); ! 7676: aic_outb(p, (scsi_conf & ENSPCHK) | term | ! 7677: ENSTIMER | ACTNEGEN, SXFRCTL1); ! 7678: aic_outb(p, 0, SIMODE0); ! 7679: aic_outb(p, ENSELTIMO | ENSCSIRST | ENSCSIPERR, SIMODE1); ! 7680: aic_outb(p, 0, SCSIRATE); ! 7681: ! 7682: /* Select channel A */ ! 7683: aic_outb(p, aic_inb(p, SBLKCTL) & ~SELBUSB, SBLKCTL); ! 7684: } ! 7685: ! 7686: term = ((p->flags & AHC_TERM_ENB_SE_LOW) != 0) ? STPWEN : 0; ! 7687: if (p->features & AHC_ULTRA2) ! 7688: aic_outb(p, p->scsi_id, SCSIID_ULTRA2); ! 7689: else ! 7690: aic_outb(p, p->scsi_id, SCSIID); ! 7691: scsi_conf = aic_inb(p, SCSICONF); ! 7692: aic_outb(p, DFON | SPIOEN, SXFRCTL0); ! 7693: aic_outb(p, (scsi_conf & ENSPCHK) | term | ! 7694: ENSTIMER | ACTNEGEN, SXFRCTL1); ! 7695: aic_outb(p, 0, SIMODE0); ! 7696: aic_outb(p, ENSELTIMO | ENSCSIRST | ENSCSIPERR, SIMODE1); ! 7697: aic_outb(p, 0, SCSIRATE); ! 7698: if ( p->features & AHC_ULTRA2) ! 7699: aic_outb(p, 0, SCSIOFFSET); ! 7700: ! 7701: /* ! 7702: * Look at the information that board initialization or the board ! 7703: * BIOS has left us. In the lower four bits of each target's ! 7704: * scratch space any value other than 0 indicates that we should ! 7705: * initiate synchronous transfers. If it's zero, the user or the ! 7706: * BIOS has decided to disable synchronous negotiation to that ! 7707: * target so we don't activate the needsdtr flag. ! 7708: */ ! 7709: if ((p->features & (AHC_TWIN|AHC_WIDE)) == 0) ! 7710: { ! 7711: max_targets = 8; ! 7712: } ! 7713: else ! 7714: { ! 7715: max_targets = 16; ! 7716: } ! 7717: ! 7718: if (!(aic7xxx_no_reset)) ! 7719: { ! 7720: /* ! 7721: * If we reset the bus, then clear the transfer settings, else leave ! 7722: * them be ! 7723: */ ! 7724: for (i = 0; i < max_targets; i++) ! 7725: { ! 7726: aic_outb(p, 0, TARG_SCSIRATE + i); ! 7727: if (p->features & AHC_ULTRA2) ! 7728: { ! 7729: aic_outb(p, 0, TARG_OFFSET + i); ! 7730: } ! 7731: p->transinfo[i].cur_offset = 0; ! 7732: p->transinfo[i].cur_period = 0; ! 7733: p->transinfo[i].cur_width = MSG_EXT_WDTR_BUS_8_BIT; ! 7734: } ! 7735: ! 7736: /* ! 7737: * If we reset the bus, then clear the transfer settings, else leave ! 7738: * them be. ! 7739: */ ! 7740: aic_outb(p, 0, ULTRA_ENB); ! 7741: aic_outb(p, 0, ULTRA_ENB + 1); ! 7742: p->ultraenb = 0; ! 7743: } ! 7744: ! 7745: /* ! 7746: * Allocate enough hardware scbs to handle the maximum number of ! 7747: * concurrent transactions we can have. We have to make sure that ! 7748: * the allocated memory is contiguous memory. The Linux kmalloc ! 7749: * routine should only allocate contiguous memory, but note that ! 7750: * this could be a problem if kmalloc() is changed. ! 7751: */ ! 7752: { ! 7753: size_t array_size; ! 7754: unsigned int hscb_physaddr; ! 7755: unsigned long temp; ! 7756: ! 7757: array_size = p->scb_data->maxscbs * sizeof(struct aic7xxx_hwscb); ! 7758: if (p->scb_data->hscbs == NULL) ! 7759: { ! 7760: /* ! 7761: * A little padding so we can align thing the way we want ! 7762: */ ! 7763: p->scb_data->hscbs = kmalloc(array_size + 0x1f, GFP_ATOMIC); ! 7764: } ! 7765: if (p->scb_data->hscbs == NULL) ! 7766: { ! 7767: printk("(scsi%d) Unable to allocate hardware SCB array; " ! 7768: "failing detection.\n", p->host_no); ! 7769: p->irq = 0; ! 7770: return(0); ! 7771: } ! 7772: /* ! 7773: * Save the actual kmalloc buffer pointer off, then align our ! 7774: * buffer to a 32 byte boundary ! 7775: */ ! 7776: p->scb_data->hscb_kmalloc_ptr = p->scb_data->hscbs; ! 7777: temp = (unsigned long)p->scb_data->hscbs; ! 7778: temp += 0x1f; ! 7779: temp &= ~0x1f; ! 7780: p->scb_data->hscbs = (struct aic7xxx_hwscb *)temp; ! 7781: /* At least the control byte of each SCB needs to be 0. */ ! 7782: memset(p->scb_data->hscbs, 0, array_size); ! 7783: ! 7784: /* Tell the sequencer where it can find the hardware SCB array. */ ! 7785: hscb_physaddr = VIRT_TO_BUS(p->scb_data->hscbs); ! 7786: aic_outb(p, hscb_physaddr & 0xFF, HSCB_ADDR); ! 7787: aic_outb(p, (hscb_physaddr >> 8) & 0xFF, HSCB_ADDR + 1); ! 7788: aic_outb(p, (hscb_physaddr >> 16) & 0xFF, HSCB_ADDR + 2); ! 7789: aic_outb(p, (hscb_physaddr >> 24) & 0xFF, HSCB_ADDR + 3); ! 7790: ! 7791: /* Set up the fifo areas at the same time */ ! 7792: hscb_physaddr = VIRT_TO_BUS(&p->untagged_scbs[0]); ! 7793: aic_outb(p, hscb_physaddr & 0xFF, SCBID_ADDR); ! 7794: aic_outb(p, (hscb_physaddr >> 8) & 0xFF, SCBID_ADDR + 1); ! 7795: aic_outb(p, (hscb_physaddr >> 16) & 0xFF, SCBID_ADDR + 2); ! 7796: aic_outb(p, (hscb_physaddr >> 24) & 0xFF, SCBID_ADDR + 3); ! 7797: } ! 7798: ! 7799: /* The Q-FIFOs we just set up are all empty */ ! 7800: aic_outb(p, 0, QINPOS); ! 7801: aic_outb(p, 0, KERNEL_QINPOS); ! 7802: aic_outb(p, 0, QOUTPOS); ! 7803: ! 7804: if(p->features & AHC_QUEUE_REGS) ! 7805: { ! 7806: aic_outb(p, SCB_QSIZE_256, QOFF_CTLSTA); ! 7807: aic_outb(p, 0, SDSCB_QOFF); ! 7808: aic_outb(p, 0, SNSCB_QOFF); ! 7809: aic_outb(p, 0, HNSCB_QOFF); ! 7810: } ! 7811: ! 7812: /* ! 7813: * We don't have any waiting selections or disconnected SCBs. ! 7814: */ ! 7815: aic_outb(p, SCB_LIST_NULL, WAITING_SCBH); ! 7816: aic_outb(p, SCB_LIST_NULL, DISCONNECTED_SCBH); ! 7817: ! 7818: /* ! 7819: * Message out buffer starts empty ! 7820: */ ! 7821: aic_outb(p, MSG_NOOP, MSG_OUT); ! 7822: aic_outb(p, MSG_NOOP, LAST_MSG); ! 7823: ! 7824: /* ! 7825: * Set all the other asundry items that haven't been set yet. ! 7826: * This includes just dumping init values to a lot of registers simply ! 7827: * to make sure they've been touched and are ready for use parity wise ! 7828: * speaking. ! 7829: */ ! 7830: aic_outb(p, 0, TMODE_CMDADDR); ! 7831: aic_outb(p, 0, TMODE_CMDADDR + 1); ! 7832: aic_outb(p, 0, TMODE_CMDADDR + 2); ! 7833: aic_outb(p, 0, TMODE_CMDADDR + 3); ! 7834: aic_outb(p, 0, TMODE_CMDADDR_NEXT); ! 7835: ! 7836: /* ! 7837: * Link us into the list of valid hosts ! 7838: */ ! 7839: p->next = first_aic7xxx; ! 7840: first_aic7xxx = p; ! 7841: ! 7842: /* ! 7843: * Clear out any possible pending interrupts, again. ! 7844: */ ! 7845: aic7xxx_clear_intstat(p); ! 7846: ! 7847: /* ! 7848: * Allocate the first set of scbs for this controller. This is to stream- ! 7849: * line code elsewhere in the driver. If we have to check for the existence ! 7850: * of scbs in certain code sections, it slows things down. However, as ! 7851: * soon as we register the IRQ for this card, we could get an interrupt that ! 7852: * includes possibly the SCSI_RSTI interrupt. If we catch that interrupt ! 7853: * then we are likely to segfault if we don't have at least one chunk of ! 7854: * SCBs allocated or add checks all through the reset code to make sure ! 7855: * that the SCBs have been allocated which is an invalid running condition ! 7856: * and therefore I think it's preferable to simply pre-allocate the first ! 7857: * chunk of SCBs. ! 7858: */ ! 7859: aic7xxx_allocate_scb(p); ! 7860: ! 7861: /* ! 7862: * Load the sequencer program, then re-enable the board - ! 7863: * resetting the AIC-7770 disables it, leaving the lights ! 7864: * on with nobody home. ! 7865: */ ! 7866: aic7xxx_loadseq(p); ! 7867: ! 7868: if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 ) ! 7869: { ! 7870: aic_outb(p, ENABLE, BCTL); /* Enable the boards BUS drivers. */ ! 7871: } ! 7872: ! 7873: if ( !(aic7xxx_no_reset) ) ! 7874: { ! 7875: if (p->features & AHC_TWIN) ! 7876: { ! 7877: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7878: printk(KERN_INFO "(scsi%d) Resetting channel B\n", p->host_no); ! 7879: aic_outb(p, aic_inb(p, SBLKCTL) | SELBUSB, SBLKCTL); ! 7880: aic7xxx_reset_current_bus(p); ! 7881: aic_outb(p, aic_inb(p, SBLKCTL) & ~SELBUSB, SBLKCTL); ! 7882: } ! 7883: /* Reset SCSI bus A. */ ! 7884: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 7885: { /* In case we are a 3940, 3985, or 7895, print the right channel */ ! 7886: char *channel = ""; ! 7887: if (p->flags & AHC_MULTI_CHANNEL) ! 7888: { ! 7889: channel = " A"; ! 7890: if (p->flags & (AHC_CHNLB|AHC_CHNLC)) ! 7891: channel = (p->flags & AHC_CHNLB) ? " B" : " C"; ! 7892: } ! 7893: printk(KERN_INFO "(scsi%d) Resetting channel%s\n", p->host_no, channel); ! 7894: } ! 7895: ! 7896: /* ! 7897: * Some of the new Ultra2 chipsets need a longer delay after a chip ! 7898: * reset than just the init setup creates, so we have to delay here ! 7899: * before we go into a reset in order to make the chips happy. ! 7900: */ ! 7901: if (p->features & AHC_ULTRA2) ! 7902: mdelay(250); ! 7903: aic7xxx_reset_current_bus(p); ! 7904: ! 7905: /* ! 7906: * Delay for the reset delay. ! 7907: */ ! 7908: if (!reset_delay) ! 7909: aic7xxx_delay(AIC7XXX_RESET_DELAY); ! 7910: } ! 7911: else ! 7912: { ! 7913: if (!reset_delay) ! 7914: { ! 7915: printk(KERN_INFO "(scsi%d) Not resetting SCSI bus. Note: Don't use " ! 7916: "the no_reset\n", p->host_no); ! 7917: printk(KERN_INFO "(scsi%d) option unless you have a verifiable need " ! 7918: "for it.\n", p->host_no); ! 7919: printk(KERN_INFO "(scsi%d) The no_reset option is known to break some " ! 7920: "systems,\n", p->host_no); ! 7921: printk(KERN_INFO "(scsi%d) and is not supported by the driver author\n", ! 7922: p->host_no); ! 7923: aic7xxx_delay(AIC7XXX_RESET_DELAY); ! 7924: } ! 7925: } ! 7926: ! 7927: /* ! 7928: * Register IRQ with the kernel. Only allow sharing IRQs with ! 7929: * PCI devices. ! 7930: */ ! 7931: if (!(p->chip & AHC_PCI)) ! 7932: { ! 7933: result = (request_irq(p->irq, do_aic7xxx_isr, 0, "aic7xxx", p)); ! 7934: } ! 7935: else ! 7936: { ! 7937: result = (request_irq(p->irq, do_aic7xxx_isr, SA_SHIRQ, ! 7938: "aic7xxx", p)); ! 7939: if (result < 0) ! 7940: { ! 7941: result = (request_irq(p->irq, do_aic7xxx_isr, SA_INTERRUPT | SA_SHIRQ, ! 7942: "aic7xxx", p)); ! 7943: } ! 7944: } ! 7945: if (result < 0) ! 7946: { ! 7947: printk(KERN_WARNING "(scsi%d) Couldn't register IRQ %d, ignoring " ! 7948: "controller.\n", p->host_no, p->irq); ! 7949: p->irq = 0; ! 7950: return (0); ! 7951: } ! 7952: ! 7953: unpause_sequencer(p, /* unpause_always */ TRUE); ! 7954: ! 7955: return (found); ! 7956: } ! 7957: ! 7958: /*+F************************************************************************* ! 7959: * Function: ! 7960: * aic7xxx_chip_reset ! 7961: * ! 7962: * Description: ! 7963: * Perform a chip reset on the aic7xxx SCSI controller. The controller ! 7964: * is paused upon return. ! 7965: *-F*************************************************************************/ ! 7966: int ! 7967: aic7xxx_chip_reset(struct aic7xxx_host *p) ! 7968: { ! 7969: unsigned char sblkctl; ! 7970: int wait; ! 7971: ! 7972: /* ! 7973: * For some 274x boards, we must clear the CHIPRST bit and pause ! 7974: * the sequencer. For some reason, this makes the driver work. ! 7975: */ ! 7976: aic_outb(p, PAUSE | CHIPRST, HCNTRL); ! 7977: ! 7978: /* ! 7979: * In the future, we may call this function as a last resort for ! 7980: * error handling. Let's be nice and not do any unecessary delays. ! 7981: */ ! 7982: wait = 1000; /* 1 second (1000 * 1 msec) */ ! 7983: while (--wait && !(aic_inb(p, HCNTRL) & CHIPRSTACK)) ! 7984: { ! 7985: mdelay(1); /* 1 msec */ ! 7986: } ! 7987: ! 7988: pause_sequencer(p); ! 7989: ! 7990: sblkctl = aic_inb(p, SBLKCTL) & (SELBUSB|SELWIDE); ! 7991: if (p->chip & AHC_PCI) ! 7992: sblkctl &= ~SELBUSB; ! 7993: switch( sblkctl ) ! 7994: { ! 7995: case 0: /* normal narrow card */ ! 7996: break; ! 7997: case 2: /* Wide card */ ! 7998: p->features |= AHC_WIDE; ! 7999: break; ! 8000: case 8: /* Twin card */ ! 8001: p->features |= AHC_TWIN; ! 8002: p->flags |= AHC_MULTI_CHANNEL; ! 8003: break; ! 8004: default: /* hmmm...we don't know what this is */ ! 8005: printk(KERN_WARNING "aic7xxx: Unsupported adapter type %d, ignoring.\n", ! 8006: aic_inb(p, SBLKCTL) & 0x0a); ! 8007: return(-1); ! 8008: } ! 8009: return(0); ! 8010: } ! 8011: ! 8012: /*+F************************************************************************* ! 8013: * Function: ! 8014: * aic7xxx_alloc ! 8015: * ! 8016: * Description: ! 8017: * Allocate and initialize a host structure. Returns NULL upon error ! 8018: * and a pointer to a aic7xxx_host struct upon success. ! 8019: *-F*************************************************************************/ ! 8020: static struct aic7xxx_host * ! 8021: aic7xxx_alloc(Scsi_Host_Template *sht, struct aic7xxx_host *temp) ! 8022: { ! 8023: struct aic7xxx_host *p = NULL; ! 8024: struct Scsi_Host *host; ! 8025: int i; ! 8026: ! 8027: /* ! 8028: * Allocate a storage area by registering us with the mid-level ! 8029: * SCSI layer. ! 8030: */ ! 8031: host = scsi_register(sht, sizeof(struct aic7xxx_host)); ! 8032: ! 8033: if (host != NULL) ! 8034: { ! 8035: p = (struct aic7xxx_host *) host->hostdata; ! 8036: memset(p, 0, sizeof(struct aic7xxx_host)); ! 8037: *p = *temp; ! 8038: p->host = host; ! 8039: ! 8040: p->scb_data = kmalloc(sizeof(scb_data_type), GFP_ATOMIC); ! 8041: if (p->scb_data != NULL) ! 8042: { ! 8043: memset(p->scb_data, 0, sizeof(scb_data_type)); ! 8044: scbq_init (&p->scb_data->free_scbs); ! 8045: } ! 8046: else ! 8047: { ! 8048: /* ! 8049: * For some reason we don't have enough memory. Free the ! 8050: * allocated memory for the aic7xxx_host struct, and return NULL. ! 8051: */ ! 8052: release_region(p->base, MAXREG - MINREG); ! 8053: scsi_unregister(host); ! 8054: return(NULL); ! 8055: } ! 8056: p->host_no = host->host_no; ! 8057: p->tagenable = 0; ! 8058: p->orderedtag = 0; ! 8059: for (i=0; i<MAX_TARGETS; i++) ! 8060: { ! 8061: p->transinfo[i].goal_period = 0; ! 8062: p->transinfo[i].goal_offset = 0; ! 8063: p->transinfo[i].goal_width = MSG_EXT_WDTR_BUS_8_BIT; ! 8064: } ! 8065: DRIVER_LOCK_INIT ! 8066: } ! 8067: return (p); ! 8068: } ! 8069: ! 8070: /*+F************************************************************************* ! 8071: * Function: ! 8072: * aic7xxx_free ! 8073: * ! 8074: * Description: ! 8075: * Frees and releases all resources associated with an instance of ! 8076: * the driver (struct aic7xxx_host *). ! 8077: *-F*************************************************************************/ ! 8078: static void ! 8079: aic7xxx_free(struct aic7xxx_host *p) ! 8080: { ! 8081: int i; ! 8082: ! 8083: /* ! 8084: * Free the allocated hardware SCB space. ! 8085: */ ! 8086: if (p->scb_data != NULL) ! 8087: { ! 8088: if (p->scb_data->hscbs != NULL) ! 8089: { ! 8090: kfree(p->scb_data->hscb_kmalloc_ptr); ! 8091: p->scb_data->hscbs = p->scb_data->hscb_kmalloc_ptr = NULL; ! 8092: } ! 8093: /* ! 8094: * Free the driver SCBs. These were allocated on an as-need ! 8095: * basis. We allocated these in groups depending on how many ! 8096: * we could fit into a given amount of RAM. The tail SCB for ! 8097: * these allocations has a pointer to the alloced area. ! 8098: */ ! 8099: for (i = 0; i < p->scb_data->numscbs; i++) ! 8100: { ! 8101: if (p->scb_data->scb_array[i]->kmalloc_ptr != NULL) ! 8102: kfree(p->scb_data->scb_array[i]->kmalloc_ptr); ! 8103: p->scb_data->scb_array[i] = NULL; ! 8104: } ! 8105: ! 8106: /* ! 8107: * Free the SCB data area. ! 8108: */ ! 8109: kfree(p->scb_data); ! 8110: } ! 8111: ! 8112: /* ! 8113: * Free any alloced Scsi_Cmnd structures that might be around for ! 8114: * negotiation purposes.... ! 8115: */ ! 8116: for (i = 0; i < MAX_TARGETS; i++) ! 8117: { ! 8118: if(p->dev_wdtr_cmnd[i]) ! 8119: kfree(p->dev_wdtr_cmnd[i]); ! 8120: if(p->dev_sdtr_cmnd[i]) ! 8121: kfree(p->dev_sdtr_cmnd[i]); ! 8122: } ! 8123: ! 8124: } ! 8125: ! 8126: /*+F************************************************************************* ! 8127: * Function: ! 8128: * aic7xxx_load_seeprom ! 8129: * ! 8130: * Description: ! 8131: * Load the seeprom and configure adapter and target settings. ! 8132: * Returns 1 if the load was successful and 0 otherwise. ! 8133: *-F*************************************************************************/ ! 8134: static void ! 8135: aic7xxx_load_seeprom(struct aic7xxx_host *p, unsigned char *sxfrctl1) ! 8136: { ! 8137: int have_seeprom = 0; ! 8138: int i, max_targets, mask; ! 8139: unsigned char scsirate, scsi_conf; ! 8140: unsigned short scarray[128]; ! 8141: struct seeprom_config *sc = (struct seeprom_config *) scarray; ! 8142: ! 8143: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8144: { ! 8145: printk(KERN_INFO "aic7xxx: Loading serial EEPROM..."); ! 8146: } ! 8147: switch (p->chip) ! 8148: { ! 8149: case (AHC_AIC7770|AHC_EISA): /* None of these adapters have seeproms. */ ! 8150: if (aic_inb(p, SCSICONF) & TERM_ENB) ! 8151: p->flags |= AHC_TERM_ENB_A; ! 8152: if ( (p->features & AHC_TWIN) && (aic_inb(p, SCSICONF + 1) & TERM_ENB) ) ! 8153: p->flags |= AHC_TERM_ENB_B; ! 8154: break; ! 8155: ! 8156: case (AHC_AIC7770|AHC_VL): ! 8157: have_seeprom = read_284x_seeprom(p, (struct seeprom_config *) scarray); ! 8158: break; ! 8159: ! 8160: default: ! 8161: have_seeprom = read_seeprom(p, (p->flags & (AHC_CHNLB|AHC_CHNLC)), ! 8162: scarray, p->sc_size, p->sc_type); ! 8163: if (!have_seeprom) ! 8164: { ! 8165: if(p->sc_type == C46) ! 8166: have_seeprom = read_seeprom(p, (p->flags & (AHC_CHNLB|AHC_CHNLC)), ! 8167: scarray, p->sc_size, C56_66); ! 8168: else ! 8169: have_seeprom = read_seeprom(p, (p->flags & (AHC_CHNLB|AHC_CHNLC)), ! 8170: scarray, p->sc_size, C46); ! 8171: } ! 8172: break; ! 8173: } ! 8174: ! 8175: if (!have_seeprom) ! 8176: { ! 8177: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8178: { ! 8179: printk("\naic7xxx: No SEEPROM available.\n"); ! 8180: } ! 8181: p->flags |= AHC_NEWEEPROM_FMT; ! 8182: if (aic_inb(p, SCSISEQ) == 0) ! 8183: { ! 8184: p->flags |= AHC_USEDEFAULTS; ! 8185: p->flags &= ~AHC_BIOS_ENABLED; ! 8186: p->scsi_id = p->scsi_id_b = 7; ! 8187: *sxfrctl1 |= STPWEN; ! 8188: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8189: { ! 8190: printk("aic7xxx: Using default values.\n"); ! 8191: } ! 8192: } ! 8193: else if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8194: { ! 8195: printk("aic7xxx: Using leftover BIOS values.\n"); ! 8196: } ! 8197: if ( *sxfrctl1 & STPWEN ) ! 8198: { ! 8199: p->flags |= AHC_TERM_ENB_SE_LOW | AHC_TERM_ENB_SE_HIGH; ! 8200: sc->adapter_control &= ~CFAUTOTERM; ! 8201: sc->adapter_control |= CFSTERM | CFWSTERM | CFLVDSTERM; ! 8202: } ! 8203: p->flags |= AHC_EXTEND_TRANS_A | AHC_EXTEND_TRANS_B; ! 8204: } ! 8205: else ! 8206: { ! 8207: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8208: { ! 8209: printk("done\n"); ! 8210: } ! 8211: ! 8212: /* ! 8213: * Note things in our flags ! 8214: */ ! 8215: p->flags |= AHC_SEEPROM_FOUND; ! 8216: ! 8217: /* ! 8218: * Update the settings in sxfrctl1 to match the termination settings. ! 8219: */ ! 8220: *sxfrctl1 = 0; ! 8221: ! 8222: /* ! 8223: * Get our SCSI ID from the SEEPROM setting... ! 8224: */ ! 8225: p->scsi_id = (sc->brtime_id & CFSCSIID); ! 8226: ! 8227: /* ! 8228: * First process the settings that are different between the VLB ! 8229: * and PCI adapter seeproms. ! 8230: */ ! 8231: if ((p->chip & AHC_CHIPID_MASK) == AHC_AIC7770) ! 8232: { ! 8233: /* VLB adapter seeproms */ ! 8234: if (sc->bios_control & CF284XEXTEND) ! 8235: p->flags |= AHC_EXTEND_TRANS_A; ! 8236: ! 8237: if (sc->adapter_control & CF284XSTERM) ! 8238: { ! 8239: *sxfrctl1 |= STPWEN; ! 8240: p->flags |= AHC_TERM_ENB_SE_LOW | AHC_TERM_ENB_SE_HIGH; ! 8241: } ! 8242: } ! 8243: else ! 8244: { ! 8245: /* PCI adapter seeproms */ ! 8246: if (sc->bios_control & CFEXTEND) ! 8247: p->flags |= AHC_EXTEND_TRANS_A; ! 8248: if (sc->bios_control & CFBIOSEN) ! 8249: p->flags |= AHC_BIOS_ENABLED; ! 8250: else ! 8251: p->flags &= ~AHC_BIOS_ENABLED; ! 8252: ! 8253: if (sc->adapter_control & CFSTERM) ! 8254: { ! 8255: *sxfrctl1 |= STPWEN; ! 8256: p->flags |= AHC_TERM_ENB_SE_LOW | AHC_TERM_ENB_SE_HIGH; ! 8257: } ! 8258: } ! 8259: p->sc = *sc; ! 8260: } ! 8261: ! 8262: p->discenable = 0; ! 8263: ! 8264: /* ! 8265: * Limit to 16 targets just in case. The 2842 for one is known to ! 8266: * blow the max_targets setting, future cards might also. ! 8267: */ ! 8268: max_targets = MIN(sc->max_targets & CFMAXTARG, ! 8269: ((p->features & (AHC_TWIN | AHC_WIDE)) ? 16 : 8)); ! 8270: ! 8271: if (have_seeprom) ! 8272: { ! 8273: for (i = 0; i < max_targets; i++) ! 8274: { ! 8275: if( ((p->features & AHC_ULTRA) && ! 8276: !(sc->adapter_control & CFULTRAEN) && ! 8277: (sc->device_flags[i] & CFSYNCHISULTRA)) || ! 8278: (sc->device_flags[i] & CFNEWULTRAFORMAT) ) ! 8279: { ! 8280: p->flags |= AHC_NEWEEPROM_FMT; ! 8281: break; ! 8282: } ! 8283: } ! 8284: } ! 8285: ! 8286: for (i = 0; i < max_targets; i++) ! 8287: { ! 8288: mask = (0x01 << i); ! 8289: if (!have_seeprom) ! 8290: { ! 8291: if(aic_inb(p, SCSISEQ) != 0) ! 8292: { ! 8293: /* ! 8294: * OK...the BIOS set things up and left behind the settings we need. ! 8295: * Just make our sc->device_flags[i] entry match what the card has ! 8296: * set for this device. ! 8297: */ ! 8298: p->discenable = ! 8299: ~(aic_inb(p, DISC_DSB) | (aic_inb(p, DISC_DSB + 1) << 8) ); ! 8300: p->ultraenb = ! 8301: (aic_inb(p, ULTRA_ENB) | (aic_inb(p, ULTRA_ENB + 1) << 8) ); ! 8302: sc->device_flags[i] = (p->discenable & mask) ? CFDISC : 0; ! 8303: if (aic_inb(p, TARG_SCSIRATE + i) & WIDEXFER) ! 8304: sc->device_flags[i] |= CFWIDEB; ! 8305: if (p->features & AHC_ULTRA2) ! 8306: { ! 8307: if (aic_inb(p, TARG_OFFSET + i)) ! 8308: { ! 8309: sc->device_flags[i] |= CFSYNCH; ! 8310: sc->device_flags[i] |= (aic_inb(p, TARG_SCSIRATE + i) & 0x07); ! 8311: if ( (aic_inb(p, TARG_SCSIRATE + i) & 0x18) == 0x18 ) ! 8312: sc->device_flags[i] |= CFSYNCHISULTRA; ! 8313: } ! 8314: } ! 8315: else ! 8316: { ! 8317: if (aic_inb(p, TARG_SCSIRATE + i) & ~WIDEXFER) ! 8318: { ! 8319: sc->device_flags[i] |= CFSYNCH; ! 8320: if (p->features & AHC_ULTRA) ! 8321: sc->device_flags[i] |= ((p->ultraenb & mask) ? ! 8322: CFSYNCHISULTRA : 0); ! 8323: } ! 8324: } ! 8325: } ! 8326: else ! 8327: { ! 8328: /* ! 8329: * Assume the BIOS has NOT been run on this card and nothing between ! 8330: * the card and the devices is configured yet. ! 8331: */ ! 8332: sc->device_flags[i] = CFDISC; ! 8333: if (p->features & AHC_WIDE) ! 8334: sc->device_flags[i] |= CFWIDEB; ! 8335: if (p->features & AHC_ULTRA2) ! 8336: sc->device_flags[i] |= 3; ! 8337: else if (p->features & AHC_ULTRA) ! 8338: sc->device_flags[i] |= CFSYNCHISULTRA; ! 8339: sc->device_flags[i] |= CFSYNCH; ! 8340: aic_outb(p, 0, TARG_SCSIRATE + i); ! 8341: if (p->features & AHC_ULTRA2) ! 8342: aic_outb(p, 0, TARG_OFFSET + i); ! 8343: } ! 8344: } ! 8345: if (sc->device_flags[i] & CFDISC) ! 8346: { ! 8347: p->discenable |= mask; ! 8348: } ! 8349: if (p->flags & AHC_NEWEEPROM_FMT) ! 8350: { ! 8351: if (sc->device_flags[i] & CFSYNCHISULTRA) ! 8352: { ! 8353: p->ultraenb |= mask; ! 8354: } ! 8355: else if (sc->device_flags[i] & CFNEWULTRAFORMAT) ! 8356: { ! 8357: if ( (sc->device_flags[i] & (CFSYNCHISULTRA | CFXFER)) == 0x03 ) ! 8358: { ! 8359: sc->device_flags[i] &= ~CFXFER; ! 8360: sc->device_flags[i] |= CFSYNCHISULTRA; ! 8361: p->ultraenb |= mask; ! 8362: } ! 8363: } ! 8364: } ! 8365: else if (sc->adapter_control & CFULTRAEN) ! 8366: { ! 8367: p->ultraenb |= mask; ! 8368: } ! 8369: if ( (sc->device_flags[i] & CFSYNCH) == 0) ! 8370: { ! 8371: sc->device_flags[i] &= ~CFXFER; ! 8372: p->ultraenb &= ~mask; ! 8373: p->transinfo[i].user_offset = 0; ! 8374: p->transinfo[i].user_period = 0; ! 8375: p->transinfo[i].cur_offset = 0; ! 8376: p->transinfo[i].cur_period = 0; ! 8377: p->needsdtr_copy &= ~mask; ! 8378: } ! 8379: else ! 8380: { ! 8381: if (p->features & AHC_ULTRA2) ! 8382: { ! 8383: p->transinfo[i].user_offset = MAX_OFFSET_ULTRA2; ! 8384: p->transinfo[i].cur_offset = aic_inb(p, TARG_OFFSET + i); ! 8385: scsirate = (sc->device_flags[i] & CFXFER) | ! 8386: ((p->ultraenb & mask) ? 0x18 : 0x10); ! 8387: p->transinfo[i].user_period = aic7xxx_find_period(p, scsirate, ! 8388: AHC_SYNCRATE_ULTRA2); ! 8389: p->transinfo[i].cur_period = aic7xxx_find_period(p, ! 8390: aic_inb(p, TARG_SCSIRATE + i), ! 8391: AHC_SYNCRATE_ULTRA2); ! 8392: } ! 8393: else ! 8394: { ! 8395: scsirate = (sc->device_flags[i] & CFXFER) << 4; ! 8396: if (sc->device_flags[i] & CFWIDEB) ! 8397: p->transinfo[i].user_offset = MAX_OFFSET_16BIT; ! 8398: else ! 8399: p->transinfo[i].user_offset = MAX_OFFSET_8BIT; ! 8400: if (p->features & AHC_ULTRA) ! 8401: { ! 8402: short ultraenb; ! 8403: ultraenb = aic_inb(p, ULTRA_ENB) | ! 8404: (aic_inb(p, ULTRA_ENB + 1) << 8); ! 8405: p->transinfo[i].user_period = aic7xxx_find_period(p, ! 8406: scsirate, ! 8407: (p->ultraenb & mask) ? ! 8408: AHC_SYNCRATE_ULTRA : ! 8409: AHC_SYNCRATE_FAST); ! 8410: p->transinfo[i].cur_period = aic7xxx_find_period(p, ! 8411: aic_inb(p, TARG_SCSIRATE + i), ! 8412: (ultraenb & mask) ? ! 8413: AHC_SYNCRATE_ULTRA : ! 8414: AHC_SYNCRATE_FAST); ! 8415: } ! 8416: else ! 8417: p->transinfo[i].user_period = aic7xxx_find_period(p, ! 8418: scsirate, AHC_SYNCRATE_FAST); ! 8419: } ! 8420: p->needsdtr_copy |= mask; ! 8421: } ! 8422: if ( (sc->device_flags[i] & CFWIDEB) && (p->features & AHC_WIDE) ) ! 8423: { ! 8424: p->transinfo[i].user_width = MSG_EXT_WDTR_BUS_16_BIT; ! 8425: p->needwdtr_copy |= mask; ! 8426: } ! 8427: else ! 8428: { ! 8429: p->transinfo[i].user_width = MSG_EXT_WDTR_BUS_8_BIT; ! 8430: p->needwdtr_copy &= ~mask; ! 8431: } ! 8432: p->transinfo[i].cur_width = ! 8433: (aic_inb(p, TARG_SCSIRATE + i) & WIDEXFER) ? ! 8434: MSG_EXT_WDTR_BUS_16_BIT : MSG_EXT_WDTR_BUS_8_BIT; ! 8435: } ! 8436: aic_outb(p, ~(p->discenable & 0xFF), DISC_DSB); ! 8437: aic_outb(p, ~((p->discenable >> 8) & 0xFF), DISC_DSB + 1); ! 8438: p->needwdtr = p->needwdtr_copy; ! 8439: p->needsdtr = p->needsdtr_copy; ! 8440: p->wdtr_pending = p->sdtr_pending = 0; ! 8441: ! 8442: /* ! 8443: * We set the p->ultraenb from the SEEPROM to begin with, but now we make ! 8444: * it match what is already down in the card. If we are doing a reset ! 8445: * on the card then this will get put back to a default state anyway. ! 8446: * This allows us to not have to pre-emptively negotiate when using the ! 8447: * no_reset option. ! 8448: */ ! 8449: if (p->features & AHC_ULTRA) ! 8450: p->ultraenb = aic_inb(p, ULTRA_ENB) | (aic_inb(p, ULTRA_ENB + 1) << 8); ! 8451: ! 8452: ! 8453: scsi_conf = (p->scsi_id & HSCSIID); ! 8454: ! 8455: if(have_seeprom) ! 8456: { ! 8457: p->adapter_control = sc->adapter_control; ! 8458: p->bios_control = sc->bios_control; ! 8459: ! 8460: switch (p->chip & AHC_CHIPID_MASK) ! 8461: { ! 8462: case AHC_AIC7895: ! 8463: case AHC_AIC7896: ! 8464: if (p->adapter_control & CFBPRIMARY) ! 8465: p->flags |= AHC_CHANNEL_B_PRIMARY; ! 8466: default: ! 8467: break; ! 8468: } ! 8469: ! 8470: if (sc->adapter_control & CFSPARITY) ! 8471: scsi_conf |= ENSPCHK; ! 8472: } ! 8473: else ! 8474: { ! 8475: scsi_conf |= ENSPCHK | RESET_SCSI; ! 8476: } ! 8477: ! 8478: /* ! 8479: * Only set the SCSICONF and SCSICONF + 1 registers if we are a PCI card. ! 8480: * The 2842 and 2742 cards already have these registers set and we don't ! 8481: * want to muck with them since we don't set all the bits they do. ! 8482: */ ! 8483: if ( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI ) ! 8484: { ! 8485: /* Set the host ID */ ! 8486: aic_outb(p, scsi_conf, SCSICONF); ! 8487: /* In case we are a wide card */ ! 8488: aic_outb(p, p->scsi_id, SCSICONF + 1); ! 8489: } ! 8490: } ! 8491: ! 8492: /*+F************************************************************************* ! 8493: * Function: ! 8494: * aic7xxx_detect ! 8495: * ! 8496: * Description: ! 8497: * Try to detect and register an Adaptec 7770 or 7870 SCSI controller. ! 8498: * ! 8499: * XXX - This should really be called aic7xxx_probe(). A sequence of ! 8500: * probe(), attach()/detach(), and init() makes more sense than ! 8501: * one do-it-all function. This may be useful when (and if) the ! 8502: * mid-level SCSI code is overhauled. ! 8503: *-F*************************************************************************/ ! 8504: int ! 8505: aic7xxx_detect(Scsi_Host_Template *template) ! 8506: { ! 8507: struct aic7xxx_host *temp_p = NULL; ! 8508: struct aic7xxx_host *current_p = NULL; ! 8509: struct aic7xxx_host *list_p = NULL; ! 8510: int found = 0; ! 8511: #if defined(__i386__) || defined(__alpha__) ! 8512: ahc_flag_type flags = 0; ! 8513: int type; ! 8514: #endif ! 8515: unsigned char sxfrctl1; ! 8516: #if defined(__i386__) || defined(__alpha__) ! 8517: unsigned char hcntrl, hostconf; ! 8518: unsigned int slot, base; ! 8519: #endif ! 8520: ! 8521: #ifdef MODULE ! 8522: /* ! 8523: * If we are called as a module, the aic7xxx pointer may not be null ! 8524: * and it would point to our bootup string, just like on the lilo ! 8525: * command line. IF not NULL, then process this config string with ! 8526: * aic7xxx_setup ! 8527: */ ! 8528: if(aic7xxx) ! 8529: aic7xxx_setup(aic7xxx, NULL); ! 8530: if(dummy_buffer[0] != 'P') ! 8531: printk(KERN_WARNING "aic7xxx: Please read the file /usr/src/linux/drivers" ! 8532: "/scsi/README.aic7xxx\n" ! 8533: "aic7xxx: to see the proper way to specify options to the aic7xxx " ! 8534: "module\n" ! 8535: "aic7xxx: Specifically, don't use any commas when passing arguments to\n" ! 8536: "aic7xxx: insmod or else it might trash certain memory areas.\n"); ! 8537: #endif ! 8538: ! 8539: template->proc_dir = &proc_scsi_aic7xxx; ! 8540: template->sg_tablesize = AIC7XXX_MAX_SG; ! 8541: ! 8542: ! 8543: #if defined(__i386__) || defined(__alpha__) ! 8544: /* ! 8545: * EISA/VL-bus card signature probe. ! 8546: */ ! 8547: slot = MINSLOT; ! 8548: while ( (slot <= MAXSLOT) && !(aic7xxx_no_probe) ) ! 8549: { ! 8550: base = SLOTBASE(slot) + MINREG; ! 8551: ! 8552: if (check_region(base, MAXREG - MINREG)) ! 8553: { ! 8554: /* ! 8555: * Some other driver has staked a ! 8556: * claim to this i/o region already. ! 8557: */ ! 8558: slot++; ! 8559: continue; /* back to the beginning of the for loop */ ! 8560: } ! 8561: flags = 0; ! 8562: type = aic7xxx_probe(slot, base + AHC_HID0, &flags); ! 8563: if (type == -1) ! 8564: { ! 8565: slot++; ! 8566: continue; ! 8567: } ! 8568: temp_p = kmalloc(sizeof(struct aic7xxx_host), GFP_ATOMIC); ! 8569: if (temp_p == NULL) ! 8570: { ! 8571: printk(KERN_WARNING "aic7xxx: Unable to allocate device space.\n"); ! 8572: slot++; ! 8573: continue; /* back to the beginning of the while loop */ ! 8574: } ! 8575: /* ! 8576: * Pause the card preserving the IRQ type. Allow the operator ! 8577: * to override the IRQ trigger. ! 8578: */ ! 8579: if (aic7xxx_irq_trigger == 1) ! 8580: hcntrl = IRQMS; /* Level */ ! 8581: else if (aic7xxx_irq_trigger == 0) ! 8582: hcntrl = 0; /* Edge */ ! 8583: else ! 8584: hcntrl = inb(base + HCNTRL) & IRQMS; /* Default */ ! 8585: memset(temp_p, 0, sizeof(struct aic7xxx_host)); ! 8586: temp_p->unpause = hcntrl | INTEN; ! 8587: temp_p->pause = hcntrl | PAUSE | INTEN; ! 8588: temp_p->base = base; ! 8589: temp_p->mbase = 0; ! 8590: temp_p->maddr = 0; ! 8591: temp_p->pci_bus = 0; ! 8592: temp_p->pci_device_fn = slot; ! 8593: aic_outb(temp_p, hcntrl | PAUSE, HCNTRL); ! 8594: while( (aic_inb(temp_p, HCNTRL) & PAUSE) == 0 ) ; ! 8595: if (aic7xxx_chip_reset(temp_p) == -1) ! 8596: temp_p->irq = 0; ! 8597: else ! 8598: temp_p->irq = aic_inb(temp_p, INTDEF) & 0x0F; ! 8599: temp_p->flags |= AHC_PAGESCBS; ! 8600: ! 8601: switch (temp_p->irq) ! 8602: { ! 8603: case 9: ! 8604: case 10: ! 8605: case 11: ! 8606: case 12: ! 8607: case 14: ! 8608: case 15: ! 8609: break; ! 8610: ! 8611: default: ! 8612: printk(KERN_WARNING "aic7xxx: Host adapter uses unsupported IRQ " ! 8613: "level %d, ignoring.\n", temp_p->irq); ! 8614: kfree(temp_p); ! 8615: slot++; ! 8616: continue; /* back to the beginning of the while loop */ ! 8617: } ! 8618: ! 8619: /* ! 8620: * We are commited now, everything has been checked and this card ! 8621: * has been found, now we just set it up ! 8622: */ ! 8623: ! 8624: /* ! 8625: * Insert our new struct into the list at the end ! 8626: */ ! 8627: if (list_p == NULL) ! 8628: { ! 8629: list_p = current_p = temp_p; ! 8630: } ! 8631: else ! 8632: { ! 8633: current_p = list_p; ! 8634: while (current_p->next != NULL) ! 8635: current_p = current_p->next; ! 8636: current_p->next = temp_p; ! 8637: } ! 8638: if (aic7xxx_extended) ! 8639: { ! 8640: temp_p->flags |= AHC_EXTEND_TRANS_A; ! 8641: if (temp_p->flags & AHC_MULTI_CHANNEL) ! 8642: temp_p->flags |= AHC_EXTEND_TRANS_B; ! 8643: } ! 8644: ! 8645: switch (type) ! 8646: { ! 8647: case 0: ! 8648: temp_p->board_name_index = 2; ! 8649: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8650: printk("aic7xxx: <%s> at EISA %d\n", ! 8651: board_names[2], slot); ! 8652: /* FALLTHROUGH */ ! 8653: case 1: ! 8654: { ! 8655: temp_p->chip = AHC_AIC7770 | AHC_EISA; ! 8656: temp_p->features |= AHC_AIC7770_FE; ! 8657: temp_p->bios_control = aic_inb(temp_p, HA_274_BIOSCTRL); ! 8658: ! 8659: /* ! 8660: * Get the primary channel information. Right now we don't ! 8661: * do anything with this, but someday we will be able to inform ! 8662: * the mid-level SCSI code which channel is primary. ! 8663: */ ! 8664: if (temp_p->board_name_index == 0) ! 8665: { ! 8666: temp_p->board_name_index = 3; ! 8667: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8668: printk("aic7xxx: <%s> at EISA %d\n", ! 8669: board_names[3], slot); ! 8670: } ! 8671: if (temp_p->bios_control & CHANNEL_B_PRIMARY) ! 8672: { ! 8673: temp_p->flags |= AHC_CHANNEL_B_PRIMARY; ! 8674: } ! 8675: ! 8676: if ((temp_p->bios_control & BIOSMODE) == BIOSDISABLED) ! 8677: { ! 8678: temp_p->flags &= ~AHC_BIOS_ENABLED; ! 8679: } ! 8680: else ! 8681: { ! 8682: temp_p->flags &= ~AHC_USEDEFAULTS; ! 8683: temp_p->flags |= AHC_BIOS_ENABLED; ! 8684: if ( (temp_p->bios_control & 0x20) == 0 ) ! 8685: { ! 8686: temp_p->bios_address = 0xcc000; ! 8687: temp_p->bios_address += (0x4000 * (temp_p->bios_control & 0x07)); ! 8688: } ! 8689: else ! 8690: { ! 8691: temp_p->bios_address = 0xd0000; ! 8692: temp_p->bios_address += (0x8000 * (temp_p->bios_control & 0x06)); ! 8693: } ! 8694: } ! 8695: temp_p->adapter_control = aic_inb(temp_p, SCSICONF) << 8; ! 8696: temp_p->adapter_control |= aic_inb(temp_p, SCSICONF + 1); ! 8697: if (temp_p->features & AHC_WIDE) ! 8698: { ! 8699: temp_p->scsi_id = temp_p->adapter_control & HWSCSIID; ! 8700: temp_p->scsi_id_b = temp_p->scsi_id; ! 8701: } ! 8702: else ! 8703: { ! 8704: temp_p->scsi_id = (temp_p->adapter_control >> 8) & HSCSIID; ! 8705: temp_p->scsi_id_b = temp_p->adapter_control & HSCSIID; ! 8706: } ! 8707: aic7xxx_load_seeprom(temp_p, &sxfrctl1); ! 8708: break; ! 8709: } ! 8710: ! 8711: case 2: ! 8712: case 3: ! 8713: temp_p->chip = AHC_AIC7770 | AHC_VL; ! 8714: temp_p->features |= AHC_AIC7770_FE; ! 8715: if (type == 2) ! 8716: temp_p->flags |= AHC_BIOS_ENABLED; ! 8717: else ! 8718: temp_p->flags &= ~AHC_BIOS_ENABLED; ! 8719: if (aic_inb(temp_p, SCSICONF) & TERM_ENB) ! 8720: sxfrctl1 = STPWEN; ! 8721: aic7xxx_load_seeprom(temp_p, &sxfrctl1); ! 8722: temp_p->board_name_index = 4; ! 8723: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8724: printk("aic7xxx: <%s> at VLB %d\n", ! 8725: board_names[2], slot); ! 8726: switch( aic_inb(temp_p, STATUS_2840) & BIOS_SEL ) ! 8727: { ! 8728: case 0x00: ! 8729: temp_p->bios_address = 0xe0000; ! 8730: break; ! 8731: case 0x20: ! 8732: temp_p->bios_address = 0xc8000; ! 8733: break; ! 8734: case 0x40: ! 8735: temp_p->bios_address = 0xd0000; ! 8736: break; ! 8737: case 0x60: ! 8738: temp_p->bios_address = 0xd8000; ! 8739: break; ! 8740: default: ! 8741: break; /* can't get here */ ! 8742: } ! 8743: break; ! 8744: ! 8745: default: /* Won't get here. */ ! 8746: break; ! 8747: } ! 8748: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8749: { ! 8750: printk(KERN_INFO "aic7xxx: BIOS %sabled, IO Port 0x%lx, IRQ %d (%s)\n", ! 8751: (temp_p->flags & AHC_USEDEFAULTS) ? "dis" : "en", temp_p->base, ! 8752: temp_p->irq, ! 8753: (temp_p->pause & IRQMS) ? "level sensitive" : "edge triggered"); ! 8754: printk(KERN_INFO "aic7xxx: Extended translation %sabled.\n", ! 8755: (temp_p->flags & AHC_EXTEND_TRANS_A) ? "en" : "dis"); ! 8756: } ! 8757: ! 8758: /* ! 8759: * Set the FIFO threshold and the bus off time. ! 8760: */ ! 8761: hostconf = aic_inb(temp_p, HOSTCONF); ! 8762: aic_outb(temp_p, hostconf & DFTHRSH, BUSSPD); ! 8763: aic_outb(temp_p, (hostconf << 2) & BOFF, BUSTIME); ! 8764: slot++; ! 8765: found++; ! 8766: } ! 8767: ! 8768: #endif /* defined(__i386__) || defined(__alpha__) */ ! 8769: ! 8770: #ifdef CONFIG_PCI ! 8771: /* ! 8772: * PCI-bus probe. ! 8773: */ ! 8774: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 8775: if (pci_present()) ! 8776: #else ! 8777: if (pcibios_present()) ! 8778: #endif ! 8779: { ! 8780: struct ! 8781: { ! 8782: unsigned short vendor_id; ! 8783: unsigned short device_id; ! 8784: ahc_chip chip; ! 8785: ahc_flag_type flags; ! 8786: ahc_feature features; ! 8787: int board_name_index; ! 8788: unsigned short seeprom_size; ! 8789: unsigned short seeprom_type; ! 8790: } const aic_pdevs[] = { ! 8791: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7810, AHC_NONE, ! 8792: AHC_FNONE, AHC_FENONE, 1, ! 8793: 32, C46 }, ! 8794: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7850, AHC_AIC7850, ! 8795: AHC_PAGESCBS, AHC_AIC7850_FE, 5, ! 8796: 32, C46 }, ! 8797: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7855, AHC_AIC7850, ! 8798: AHC_PAGESCBS, AHC_AIC7850_FE, 6, ! 8799: 32, C46 }, ! 8800: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7860, AHC_AIC7860, ! 8801: AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED, ! 8802: AHC_AIC7860_FE, 7, ! 8803: 32, C46 }, ! 8804: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7861, AHC_AIC7860, ! 8805: AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED, ! 8806: AHC_AIC7860_FE, 8, ! 8807: 32, C46 }, ! 8808: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7870, AHC_AIC7870, ! 8809: AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7870_FE, 9, ! 8810: 32, C46 }, ! 8811: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7871, AHC_AIC7870, ! 8812: AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7870_FE, 10, ! 8813: 32, C46 }, ! 8814: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7872, AHC_AIC7870, ! 8815: AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL, ! 8816: AHC_AIC7870_FE, 11, ! 8817: 32, C56_66 }, ! 8818: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7873, AHC_AIC7870, ! 8819: AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL, ! 8820: AHC_AIC7870_FE, 12, ! 8821: 32, C56_66 }, ! 8822: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7874, AHC_AIC7870, ! 8823: AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7870_FE, 13, ! 8824: 32, C46 }, ! 8825: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7880, AHC_AIC7880, ! 8826: AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE, 14, ! 8827: 32, C46 }, ! 8828: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7881, AHC_AIC7880, ! 8829: AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE, 15, ! 8830: 32, C46 }, ! 8831: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7882, AHC_AIC7880, ! 8832: AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL, ! 8833: AHC_AIC7880_FE, 16, ! 8834: 32, C56_66 }, ! 8835: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7883, AHC_AIC7880, ! 8836: AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL, ! 8837: AHC_AIC7880_FE, 17, ! 8838: 32, C56_66 }, ! 8839: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7884, AHC_AIC7880, ! 8840: AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE, 18, ! 8841: 32, C46 }, ! 8842: {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7895, AHC_AIC7895, ! 8843: AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL, ! 8844: AHC_AIC7895_FE, 19, ! 8845: 32, C56_66 }, ! 8846: {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7890, AHC_AIC7890, ! 8847: AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED, ! 8848: AHC_AIC7890_FE, 20, ! 8849: 32, C46 }, ! 8850: {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_2940U2, AHC_AIC7890, ! 8851: AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED, ! 8852: AHC_AIC7890_FE, 21, ! 8853: 32, C46 }, ! 8854: {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7896, AHC_AIC7896, ! 8855: AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL, ! 8856: AHC_AIC7896_FE, 22, ! 8857: 32, C56_66 }, ! 8858: {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_3940U2, AHC_AIC7896, ! 8859: AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL, ! 8860: AHC_AIC7896_FE, 23, ! 8861: 32, C56_66 }, ! 8862: }; ! 8863: ! 8864: unsigned short command; ! 8865: unsigned int devconfig, i, oldverbose; ! 8866: #ifdef MMAPIO ! 8867: unsigned long page_offset, base; ! 8868: #endif ! 8869: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 8870: struct pci_dev *pdev = NULL; ! 8871: #else ! 8872: int index; ! 8873: unsigned int piobase, mmapbase; ! 8874: unsigned char pci_bus, pci_devfn, pci_irq; ! 8875: #endif ! 8876: ! 8877: for (i = 0; i < NUMBER(aic_pdevs); i++) ! 8878: { ! 8879: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 8880: pdev = NULL; ! 8881: while ((pdev = pci_find_device(aic_pdevs[i].vendor_id, ! 8882: aic_pdevs[i].device_id, ! 8883: pdev))) ! 8884: #else ! 8885: index = 0; ! 8886: while (!(pcibios_find_device(aic_pdevs[i].vendor_id, ! 8887: aic_pdevs[i].device_id, ! 8888: index++, &pci_bus, &pci_devfn)) ) ! 8889: #endif ! 8890: { ! 8891: if ( i == 0 ) /* We found one, but it's the 7810 RAID cont. */ ! 8892: { ! 8893: if (aic7xxx_verbose & (VERBOSE_PROBE|VERBOSE_PROBE2)) ! 8894: { ! 8895: printk(KERN_INFO "aic7xxx: The 7810 RAID controller is not " ! 8896: "supported by\n"); ! 8897: printk(KERN_INFO " this driver, we are ignoring it.\n"); ! 8898: } ! 8899: } ! 8900: else if ( (temp_p = kmalloc(sizeof(struct aic7xxx_host), ! 8901: GFP_ATOMIC)) != NULL ) ! 8902: { ! 8903: memset(temp_p, 0, sizeof(struct aic7xxx_host)); ! 8904: temp_p->chip = aic_pdevs[i].chip | AHC_PCI; ! 8905: temp_p->flags = aic_pdevs[i].flags; ! 8906: temp_p->features = aic_pdevs[i].features; ! 8907: temp_p->board_name_index = aic_pdevs[i].board_name_index; ! 8908: temp_p->sc_size = aic_pdevs[i].seeprom_size; ! 8909: temp_p->sc_type = aic_pdevs[i].seeprom_type; ! 8910: ! 8911: /* ! 8912: * Read sundry information from PCI BIOS. ! 8913: */ ! 8914: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 8915: temp_p->irq = pdev->irq; ! 8916: temp_p->pdev = pdev; ! 8917: temp_p->pci_bus = pdev->bus->number; ! 8918: temp_p->pci_device_fn = pdev->devfn; ! 8919: temp_p->base = pdev->base_address[0]; ! 8920: temp_p->mbase = pdev->base_address[1]; ! 8921: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8922: printk("aic7xxx: <%s> at PCI %d/%d\n", ! 8923: board_names[aic_pdevs[i].board_name_index], ! 8924: PCI_SLOT(temp_p->pdev->devfn), ! 8925: PCI_FUNC(temp_p->pdev->devfn)); ! 8926: pci_read_config_word(pdev, PCI_COMMAND, &command); ! 8927: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8928: { ! 8929: printk("aic7xxx: Initial PCI_COMMAND value was 0x%x\n", ! 8930: (int)command); ! 8931: } ! 8932: #ifdef AIC7XXX_STRICT_PCI_SETUP ! 8933: command |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY | ! 8934: PCI_COMMAND_INVALIDATE | PCI_COMMAND_MASTER | ! 8935: PCI_COMMAND_MEMORY | PCI_COMMAND_IO; ! 8936: #else ! 8937: command |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY | PCI_COMMAND_IO; ! 8938: #endif ! 8939: if (aic7xxx_pci_parity == 0) ! 8940: command &= ~(PCI_COMMAND_SERR | PCI_COMMAND_PARITY); ! 8941: pci_write_config_word(pdev, PCI_COMMAND, command); ! 8942: #ifdef AIC7XXX_STRICT_PCI_SETUP ! 8943: pci_read_config_dword(pdev, DEVCONFIG, &devconfig); ! 8944: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8945: { ! 8946: printk("aic7xxx: Initial DEVCONFIG value was 0x%x\n", devconfig); ! 8947: } ! 8948: devconfig |= 0x80000000; ! 8949: if ((aic7xxx_pci_parity == 0) || (aic7xxx_pci_parity == -1)) ! 8950: { ! 8951: devconfig &= ~(0x00000008); ! 8952: } ! 8953: else ! 8954: { ! 8955: devconfig |= 0x00000008; ! 8956: } ! 8957: pci_write_config_dword(pdev, DEVCONFIG, devconfig); ! 8958: #endif /* AIC7XXX_STRICT_PCI_SETUP */ ! 8959: #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) */ ! 8960: temp_p->pci_bus = pci_bus; ! 8961: temp_p->pci_device_fn = pci_devfn; ! 8962: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8963: printk("aic7xxx: <%s> at PCI %d/%d\n", ! 8964: board_names[aic_pdevs[i].board_name_index], ! 8965: PCI_SLOT(temp_p->pci_device_fn), ! 8966: PCI_FUNC(temp_p->pci_device_fn)); ! 8967: pcibios_read_config_byte(pci_bus, pci_devfn, PCI_INTERRUPT_LINE, ! 8968: &pci_irq); ! 8969: temp_p->irq = pci_irq; ! 8970: pcibios_read_config_dword(pci_bus, pci_devfn, PCI_BASE_ADDRESS_0, ! 8971: &piobase); ! 8972: temp_p->base = piobase; ! 8973: pcibios_read_config_dword(pci_bus, pci_devfn, PCI_BASE_ADDRESS_1, ! 8974: &mmapbase); ! 8975: temp_p->mbase = mmapbase; ! 8976: pcibios_read_config_word(pci_bus, pci_devfn, PCI_COMMAND, &command); ! 8977: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8978: { ! 8979: printk("aic7xxx: Initial PCI_COMMAND value was 0x%x\n", ! 8980: (int)command); ! 8981: } ! 8982: #ifdef AIC7XXX_STRICT_PCI_SETUP ! 8983: command |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY | ! 8984: PCI_COMMAND_INVALIDATE | PCI_COMMAND_MASTER | ! 8985: PCI_COMMAND_MEMORY | PCI_COMMAND_IO; ! 8986: #else ! 8987: command |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY | PCI_COMMAND_IO; ! 8988: #endif ! 8989: if (aic7xxx_pci_parity == 0) ! 8990: command &= ~(PCI_COMMAND_SERR | PCI_COMMAND_PARITY); ! 8991: pcibios_write_config_word(pci_bus, pci_devfn, PCI_COMMAND, command); ! 8992: #ifdef AIC7XXX_STRICT_PCI_SETUP ! 8993: pcibios_read_config_dword(pci_bus, pci_devfn, DEVCONFIG, &devconfig); ! 8994: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 8995: { ! 8996: printk("aic7xxx: Initial DEVCONFIG value was 0x%x\n", devconfig); ! 8997: } ! 8998: devconfig |= 0x80000000; ! 8999: if ((aic7xxx_pci_parity == 0) || (aic7xxx_pci_parity == -1)) ! 9000: { ! 9001: devconfig &= ~(0x00000008); ! 9002: } ! 9003: else ! 9004: { ! 9005: devconfig |= 0x00000008; ! 9006: } ! 9007: pcibios_write_config_dword(pci_bus, pci_devfn, DEVCONFIG, devconfig); ! 9008: #endif /* AIC7XXX_STRICT_PCI_SETUP */ ! 9009: #endif /* LINUIX_VERSION_CODE > KERNEL_VERSION(2,1,92) */ ! 9010: ! 9011: /* ! 9012: * The first bit (LSB) of PCI_BASE_ADDRESS_0 is always set, so ! 9013: * we mask it off. ! 9014: */ ! 9015: temp_p->base &= PCI_BASE_ADDRESS_IO_MASK; ! 9016: temp_p->mbase &= PCI_BASE_ADDRESS_MEM_MASK; ! 9017: temp_p->unpause = INTEN; ! 9018: temp_p->pause = temp_p->unpause | PAUSE; ! 9019: ! 9020: #ifdef MMAPIO ! 9021: base = temp_p->mbase & PAGE_MASK; ! 9022: page_offset = temp_p->mbase - base; ! 9023: #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0) ! 9024: temp_p->maddr = ioremap_nocache(base, page_offset + 256); ! 9025: #else ! 9026: temp_p->maddr = vremap(base, page_offset + 256); ! 9027: #endif ! 9028: if(temp_p->maddr) ! 9029: { ! 9030: temp_p->maddr += page_offset; ! 9031: } ! 9032: #endif ! 9033: ! 9034: pause_sequencer(temp_p); ! 9035: ! 9036: /* ! 9037: * Clear out any pending PCI error status messages. Also set ! 9038: * verbose to 0 so that we don't emit strange PCI error messages ! 9039: * while cleaning out the current status bits. ! 9040: */ ! 9041: oldverbose = aic7xxx_verbose; ! 9042: aic7xxx_verbose = 0; ! 9043: aic7xxx_pci_intr(temp_p); ! 9044: aic7xxx_verbose = oldverbose; ! 9045: ! 9046: temp_p->bios_address = 0; ! 9047: ! 9048: /* ! 9049: * Remember how the card was setup in case there is no seeprom. ! 9050: */ ! 9051: if (temp_p->features & AHC_ULTRA2) ! 9052: temp_p->scsi_id = aic_inb(temp_p, SCSIID_ULTRA2) & OID; ! 9053: else ! 9054: temp_p->scsi_id = aic_inb(temp_p, SCSIID) & OID; ! 9055: /* ! 9056: * Get current termination setting ! 9057: */ ! 9058: sxfrctl1 = aic_inb(temp_p, SXFRCTL1) & STPWEN; ! 9059: ! 9060: if (aic7xxx_chip_reset(temp_p) == -1) ! 9061: { ! 9062: kfree(temp_p); ! 9063: temp_p = NULL; ! 9064: continue; ! 9065: } ! 9066: ! 9067: /* ! 9068: * Doing a switch based upon i is really gross, but since Justin ! 9069: * changed around the chip ID stuff, we can't use that any more. ! 9070: * Since we don't scan the devices the same way as FreeBSD, we end ! 9071: * up doing this gross hack in order to avoid totally splitting ! 9072: * away from Justin's init code in ahc_pci.c ! 9073: */ ! 9074: switch (i) ! 9075: { ! 9076: case 7: /* 3940 */ ! 9077: case 12: /* 3940-Ultra */ ! 9078: switch(PCI_SLOT(temp_p->pci_device_fn)) ! 9079: { ! 9080: case 5: ! 9081: temp_p->flags |= AHC_CHNLB; ! 9082: break; ! 9083: default: ! 9084: break; ! 9085: } ! 9086: break; ! 9087: ! 9088: case 8: /* 3985 */ ! 9089: case 13: /* 3985-Ultra */ ! 9090: switch(PCI_SLOT(temp_p->pci_device_fn)) ! 9091: { ! 9092: case 8: ! 9093: temp_p->flags |= AHC_CHNLB; ! 9094: break; ! 9095: case 12: ! 9096: temp_p->flags |= AHC_CHNLC; ! 9097: break; ! 9098: default: ! 9099: break; ! 9100: } ! 9101: break; ! 9102: ! 9103: case 15: ! 9104: case 18: ! 9105: case 19: ! 9106: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 9107: if (PCI_FUNC(temp_p->pdev->devfn) != 0) ! 9108: { ! 9109: temp_p->flags |= AHC_CHNLB; ! 9110: } ! 9111: /* ! 9112: * The 7895 is the only chipset that sets the SCBSIZE32 param ! 9113: * in the DEVCONFIG register. The Ultra2 chipsets use ! 9114: * the DSCOMMAND0 register instead. ! 9115: */ ! 9116: if ((temp_p->chip & AHC_CHIPID_MASK) == AHC_AIC7895) ! 9117: { ! 9118: pci_read_config_dword(pdev, DEVCONFIG, &devconfig); ! 9119: devconfig |= SCBSIZE32; ! 9120: pci_write_config_dword(pdev, DEVCONFIG, devconfig); ! 9121: } ! 9122: #else ! 9123: if (PCI_FUNC(temp_p->pci_device_fn) != 0) ! 9124: { ! 9125: temp_p->flags |= AHC_CHNLB; ! 9126: } ! 9127: /* ! 9128: * The 7895 is the only chipset that sets the SCBSIZE32 param ! 9129: * in the DEVCONFIG register. The Ultra2 chipsets use ! 9130: * the DSCOMMAND0 register instead. ! 9131: */ ! 9132: if ((temp_p->chip & AHC_CHIPID_MASK) == AHC_AIC7895) ! 9133: { ! 9134: pcibios_read_config_dword(pci_bus, pci_devfn, DEVCONFIG, ! 9135: &devconfig); ! 9136: devconfig |= SCBSIZE32; ! 9137: pcibios_write_config_dword(pci_bus, pci_devfn, DEVCONFIG, ! 9138: devconfig); ! 9139: } ! 9140: #endif ! 9141: break; ! 9142: default: ! 9143: break; ! 9144: } ! 9145: ! 9146: /* ! 9147: * Loading of the SEEPROM needs to come after we've set the flags ! 9148: * to indicate possible CHNLB and CHNLC assigments. Otherwise, ! 9149: * on 394x and 398x cards we'll end up reading the wrong settings ! 9150: * for channels B and C ! 9151: */ ! 9152: switch (temp_p->chip & AHC_CHIPID_MASK) ! 9153: { ! 9154: case AHC_AIC7890: ! 9155: case AHC_AIC7896: ! 9156: aic_outb(temp_p, 0, SCAMCTL); ! 9157: /* ! 9158: * We used to set DPARCKEN in this register, but after talking ! 9159: * to a tech from Adaptec, I found out they don't use that ! 9160: * particular bit in their own register settings, and when you ! 9161: * combine that with the fact that I determined that we were ! 9162: * seeing Data-Path Parity Errors on things we shouldn't see ! 9163: * them on, I think there is a bug in the silicon and the way ! 9164: * to work around it is to disable this particular check. Also ! 9165: * This bug only showed up on certain commands, so it seems to ! 9166: * be pattern related or some such. The commands we would ! 9167: * typically send as a linux TEST_UNIT_READY or INQUIRY command ! 9168: * could cause it to be triggered, while regular commands that ! 9169: * actually made reasonable use of the SG array capabilities ! 9170: * seemed not to cause the problem. ! 9171: */ ! 9172: /* ! 9173: aic_outb(temp_p, aic_inb(temp_p, DSCOMMAND0) | ! 9174: CACHETHEN | DPARCKEN | MPARCKEN | ! 9175: USCBSIZE32 | CIOPARCKEN, ! 9176: DSCOMMAND0); ! 9177: */ ! 9178: aic_outb(temp_p, (aic_inb(temp_p, DSCOMMAND0) | ! 9179: CACHETHEN | MPARCKEN | USCBSIZE32 | ! 9180: CIOPARCKEN) & ~DPARCKEN, DSCOMMAND0); ! 9181: /* FALLTHROUGH */ ! 9182: default: ! 9183: /* ! 9184: * We attempt to read a SEEPROM on *everything*. If we fail, ! 9185: * then we fail, but this covers things like 2910c cards that ! 9186: * now have SEEPROMs with their 7856 chipset that we would ! 9187: * otherwise ignore. They still don't have a BIOS, but they ! 9188: * have a SEEPROM that the SCSISelect utility on the Adaptec ! 9189: * diskettes can configure. ! 9190: */ ! 9191: aic7xxx_load_seeprom(temp_p, &sxfrctl1); ! 9192: break; ! 9193: case AHC_AIC7850: ! 9194: case AHC_AIC7860: ! 9195: /* ! 9196: * Set the DSCOMMAND0 register on these cards different from ! 9197: * on the 789x cards. Also, read the SEEPROM as well. ! 9198: */ ! 9199: aic_outb(temp_p, (aic_inb(temp_p, DSCOMMAND0) | ! 9200: CACHETHEN | MPARCKEN) & ~DPARCKEN, ! 9201: DSCOMMAND0); ! 9202: aic7xxx_load_seeprom(temp_p, &sxfrctl1); ! 9203: break; ! 9204: case AHC_AIC7880: ! 9205: /* ! 9206: * Only set the DSCOMMAND0 register if this is a Rev B. ! 9207: * chipset. For those, we also enable Ultra mode by ! 9208: * force due to brain-damage on the part of some BIOSes ! 9209: * We overload the devconfig variable here since we can. ! 9210: */ ! 9211: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 9212: pci_read_config_dword(pdev, DEVCONFIG, &devconfig); ! 9213: #else ! 9214: pcibios_read_config_dword(pci_bus, pci_devfn, DEVCONFIG, ! 9215: &devconfig); ! 9216: #endif ! 9217: if ((devconfig & 0xff) >= 1) ! 9218: { ! 9219: aic_outb(temp_p, (aic_inb(temp_p, DSCOMMAND0) | ! 9220: CACHETHEN | MPARCKEN) & ~DPARCKEN, ! 9221: DSCOMMAND0); ! 9222: } ! 9223: aic7xxx_load_seeprom(temp_p, &sxfrctl1); ! 9224: break; ! 9225: } ! 9226: ! 9227: ! 9228: /* ! 9229: * and then we need another switch based on the type in order to ! 9230: * make sure the channel B primary flag is set properly on 7895 ! 9231: * controllers....Arrrgggghhh!!! We also have to catch the fact ! 9232: * that when you disable the BIOS on the 7895 on the Intel DK440LX ! 9233: * motherboard, and possibly others, it only sets the BIOS disabled ! 9234: * bit on the A channel...I think I'm starting to lean towards ! 9235: * going postal.... ! 9236: */ ! 9237: switch(temp_p->chip & AHC_CHIPID_MASK) ! 9238: { ! 9239: case AHC_AIC7895: ! 9240: case AHC_AIC7896: ! 9241: current_p = list_p; ! 9242: while(current_p != NULL) ! 9243: { ! 9244: if ( (current_p->pci_bus == temp_p->pci_bus) && ! 9245: (PCI_SLOT(current_p->pci_device_fn) == ! 9246: PCI_SLOT(temp_p->pci_device_fn)) ) ! 9247: { ! 9248: if ( PCI_FUNC(current_p->pci_device_fn) == 0 ) ! 9249: { ! 9250: temp_p->flags |= ! 9251: (current_p->flags & AHC_CHANNEL_B_PRIMARY); ! 9252: temp_p->flags &= ~(AHC_BIOS_ENABLED|AHC_USEDEFAULTS); ! 9253: temp_p->flags |= ! 9254: (current_p->flags & (AHC_BIOS_ENABLED|AHC_USEDEFAULTS)); ! 9255: } ! 9256: else ! 9257: { ! 9258: current_p->flags |= ! 9259: (temp_p->flags & AHC_CHANNEL_B_PRIMARY); ! 9260: current_p->flags &= ~(AHC_BIOS_ENABLED|AHC_USEDEFAULTS); ! 9261: current_p->flags |= ! 9262: (temp_p->flags & (AHC_BIOS_ENABLED|AHC_USEDEFAULTS)); ! 9263: } ! 9264: } ! 9265: current_p = current_p->next; ! 9266: } ! 9267: break; ! 9268: default: ! 9269: break; ! 9270: } ! 9271: ! 9272: /* ! 9273: * We do another switch based on i so that we can exclude all ! 9274: * 3895 devices from the next option since the 3895 cards use ! 9275: * shared external SCB RAM while all other cards have dedicated ! 9276: * external SCB RAM per channel. Also exclude the 7850 and ! 9277: * 7860 based stuff since they can have garbage in the bit ! 9278: * that indicates external RAM and get some of this stuff ! 9279: * wrong as a result. ! 9280: */ ! 9281: switch(temp_p->chip & AHC_CHIPID_MASK) ! 9282: { ! 9283: default: ! 9284: break; ! 9285: case AHC_AIC7895: ! 9286: case AHC_AIC7896: ! 9287: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 9288: pci_read_config_dword(pdev, DEVCONFIG, &devconfig); ! 9289: #else ! 9290: pcibios_read_config_dword(pci_bus, pci_devfn, DEVCONFIG, ! 9291: &devconfig); ! 9292: #endif ! 9293: if (temp_p->features & AHC_ULTRA2) ! 9294: { ! 9295: if (aic_inb(temp_p, DSCOMMAND0) & RAMPSM_ULTRA2) ! 9296: { ! 9297: aic_outb(temp_p, ! 9298: aic_inb(temp_p, DSCOMMAND0) & ~SCBRAMSEL_ULTRA2, ! 9299: DSCOMMAND0); ! 9300: temp_p->flags |= AHC_EXTERNAL_SRAM; ! 9301: devconfig |= EXTSCBPEN; ! 9302: } ! 9303: } ! 9304: else if (devconfig & RAMPSM) ! 9305: { ! 9306: devconfig &= ~SCBRAMSEL; ! 9307: devconfig |= EXTSCBPEN; ! 9308: temp_p->flags |= AHC_EXTERNAL_SRAM; ! 9309: } ! 9310: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 9311: pci_write_config_dword(pdev, DEVCONFIG, devconfig); ! 9312: #else ! 9313: pcibios_write_config_dword(pci_bus, pci_devfn, DEVCONFIG, ! 9314: devconfig); ! 9315: #endif ! 9316: if ( (temp_p->flags & AHC_EXTERNAL_SRAM) && ! 9317: (temp_p->flags & AHC_CHNLB) ) ! 9318: aic_outb(temp_p, 1, CCSCBBADDR); ! 9319: break; ! 9320: } ! 9321: ! 9322: /* ! 9323: * Take the LED out of diagnostic mode ! 9324: */ ! 9325: aic_outb(temp_p, ! 9326: (aic_inb(temp_p, SBLKCTL) & ~(DIAGLEDEN | DIAGLEDON)), ! 9327: SBLKCTL); ! 9328: ! 9329: /* ! 9330: * We don't know where this is set in the SEEPROM or by the ! 9331: * BIOS, so we default to 100%. On Ultra2 controllers, use 75% ! 9332: * instead. ! 9333: */ ! 9334: if (temp_p->features & AHC_ULTRA2) ! 9335: { ! 9336: aic_outb(temp_p, RD_DFTHRSH_75 | WR_DFTHRSH_75, DFF_THRSH); ! 9337: } ! 9338: else ! 9339: { ! 9340: aic_outb(temp_p, DFTHRSH_100, DSPCISTATUS); ! 9341: } ! 9342: ! 9343: if (aic7xxx_extended) ! 9344: temp_p->flags |= AHC_EXTEND_TRANS_A; ! 9345: ! 9346: if ( list_p == NULL ) ! 9347: { ! 9348: list_p = current_p = temp_p; ! 9349: } ! 9350: else ! 9351: { ! 9352: current_p = list_p; ! 9353: while(current_p->next != NULL) ! 9354: current_p = current_p->next; ! 9355: current_p->next = temp_p; ! 9356: } ! 9357: temp_p->next = NULL; ! 9358: found++; ! 9359: } /* Found an Adaptec PCI device. */ ! 9360: else /* Well, we found one, but we couldn't get any memory */ ! 9361: { ! 9362: printk("aic7xxx: Found <%s>\n", ! 9363: board_names[aic_pdevs[i].board_name_index]); ! 9364: printk(KERN_INFO "aic7xxx: Unable to allocate device memory, " ! 9365: "skipping.\n"); ! 9366: } ! 9367: } /* while(pdev=....) */ ! 9368: } /* for PCI_DEVICES */ ! 9369: } /* PCI BIOS present */ ! 9370: #endif CONFIG_PCI ! 9371: /* ! 9372: * Now, we re-order the probed devices by BIOS address and BUS class. ! 9373: * In general, we follow this algorithm to make the adapters show up ! 9374: * in the same order under linux that the computer finds them. ! 9375: * 1: All VLB/EISA cards with BIOS_ENABLED first, according to BIOS ! 9376: * address, going from lowest to highest. ! 9377: * 2: All PCI controllers with BIOS_ENABLED next, according to BIOS ! 9378: * address, going from lowest to highest. ! 9379: * 3: Remaining VLB/EISA controllers going in slot order. ! 9380: * 4: Remaining PCI controllers, going in PCI device order (reversable) ! 9381: */ ! 9382: ! 9383: { ! 9384: struct aic7xxx_host *sort_list[4] = { NULL, NULL, NULL, NULL }; ! 9385: struct aic7xxx_host *vlb, *pci; ! 9386: struct aic7xxx_host *prev_p; ! 9387: struct aic7xxx_host *p; ! 9388: unsigned char left; ! 9389: ! 9390: prev_p = vlb = pci = NULL; ! 9391: ! 9392: temp_p = list_p; ! 9393: while (temp_p != NULL) ! 9394: { ! 9395: switch(temp_p->chip & ~AHC_CHIPID_MASK) ! 9396: { ! 9397: case AHC_EISA: ! 9398: case AHC_VL: ! 9399: { ! 9400: p = temp_p; ! 9401: if (p->flags & AHC_BIOS_ENABLED) ! 9402: vlb = sort_list[0]; ! 9403: else ! 9404: vlb = sort_list[2]; ! 9405: ! 9406: if (vlb == NULL) ! 9407: { ! 9408: vlb = temp_p; ! 9409: temp_p = temp_p->next; ! 9410: vlb->next = NULL; ! 9411: } ! 9412: else ! 9413: { ! 9414: current_p = vlb; ! 9415: prev_p = NULL; ! 9416: while ( (current_p != NULL) && ! 9417: (current_p->bios_address < temp_p->bios_address)) ! 9418: { ! 9419: prev_p = current_p; ! 9420: current_p = current_p->next; ! 9421: } ! 9422: if (prev_p != NULL) ! 9423: { ! 9424: prev_p->next = temp_p; ! 9425: temp_p = temp_p->next; ! 9426: prev_p->next->next = current_p; ! 9427: } ! 9428: else ! 9429: { ! 9430: vlb = temp_p; ! 9431: temp_p = temp_p->next; ! 9432: vlb->next = current_p; ! 9433: } ! 9434: } ! 9435: ! 9436: if (p->flags & AHC_BIOS_ENABLED) ! 9437: sort_list[0] = vlb; ! 9438: else ! 9439: sort_list[2] = vlb; ! 9440: ! 9441: break; ! 9442: } ! 9443: default: /* All PCI controllers fall through to default */ ! 9444: { ! 9445: ! 9446: p = temp_p; ! 9447: if (p->flags & AHC_BIOS_ENABLED) ! 9448: pci = sort_list[1]; ! 9449: else ! 9450: pci = sort_list[3]; ! 9451: ! 9452: if (pci == NULL) ! 9453: { ! 9454: pci = temp_p; ! 9455: temp_p = temp_p->next; ! 9456: pci->next = NULL; ! 9457: } ! 9458: else ! 9459: { ! 9460: current_p = pci; ! 9461: prev_p = NULL; ! 9462: if (!aic7xxx_reverse_scan) ! 9463: { ! 9464: while ( (current_p != NULL) && ! 9465: ( (PCI_SLOT(current_p->pci_device_fn) | ! 9466: (current_p->pci_bus << 8)) < ! 9467: (PCI_SLOT(temp_p->pci_device_fn) | ! 9468: (temp_p->pci_bus << 8)) ) ) ! 9469: { ! 9470: prev_p = current_p; ! 9471: current_p = current_p->next; ! 9472: } ! 9473: } ! 9474: else ! 9475: { ! 9476: while ( (current_p != NULL) && ! 9477: ( (PCI_SLOT(current_p->pci_device_fn) | ! 9478: (current_p->pci_bus << 8)) > ! 9479: (PCI_SLOT(temp_p->pci_device_fn) | ! 9480: (temp_p->pci_bus << 8)) ) ) ! 9481: { ! 9482: prev_p = current_p; ! 9483: current_p = current_p->next; ! 9484: } ! 9485: } ! 9486: /* ! 9487: * Are we dealing with a 7985 where we need to sort the ! 9488: * channels as well, if so, the bios_address values should ! 9489: * be the same ! 9490: */ ! 9491: if ( (current_p) && (temp_p->flags & AHC_MULTI_CHANNEL) && ! 9492: (temp_p->pci_bus == current_p->pci_bus) && ! 9493: (PCI_SLOT(temp_p->pci_device_fn) == ! 9494: PCI_SLOT(current_p->pci_device_fn)) ) ! 9495: { ! 9496: if (temp_p->flags & AHC_CHNLB) ! 9497: { ! 9498: if ( !(temp_p->flags & AHC_CHANNEL_B_PRIMARY) ) ! 9499: { ! 9500: prev_p = current_p; ! 9501: current_p = current_p->next; ! 9502: } ! 9503: } ! 9504: else ! 9505: { ! 9506: if (temp_p->flags & AHC_CHANNEL_B_PRIMARY) ! 9507: { ! 9508: prev_p = current_p; ! 9509: current_p = current_p->next; ! 9510: } ! 9511: } ! 9512: } ! 9513: if (prev_p != NULL) ! 9514: { ! 9515: prev_p->next = temp_p; ! 9516: temp_p = temp_p->next; ! 9517: prev_p->next->next = current_p; ! 9518: } ! 9519: else ! 9520: { ! 9521: pci = temp_p; ! 9522: temp_p = temp_p->next; ! 9523: pci->next = current_p; ! 9524: } ! 9525: } ! 9526: ! 9527: if (p->flags & AHC_BIOS_ENABLED) ! 9528: sort_list[1] = pci; ! 9529: else ! 9530: sort_list[3] = pci; ! 9531: ! 9532: break; ! 9533: } ! 9534: } /* End of switch(temp_p->type) */ ! 9535: } /* End of while (temp_p != NULL) */ ! 9536: /* ! 9537: * At this point, the cards have been broken into 4 sorted lists, now ! 9538: * we run through the lists in order and register each controller ! 9539: */ ! 9540: { ! 9541: int i; ! 9542: ! 9543: left = found; ! 9544: for (i=0; i<NUMBER(sort_list); i++) ! 9545: { ! 9546: temp_p = sort_list[i]; ! 9547: while(temp_p != NULL) ! 9548: { ! 9549: template->name = board_names[temp_p->board_name_index]; ! 9550: p = aic7xxx_alloc(template, temp_p); ! 9551: if (p != NULL) ! 9552: { ! 9553: p->instance = found - left; ! 9554: if (aic7xxx_register(template, p, (--left)) == 0) ! 9555: { ! 9556: found--; ! 9557: aic7xxx_release(p->host); ! 9558: scsi_unregister(p->host); ! 9559: } ! 9560: else if (aic7xxx_dump_card) ! 9561: { ! 9562: pause_sequencer(p); ! 9563: aic7xxx_print_card(p); ! 9564: aic7xxx_print_scratch_ram(p); ! 9565: unpause_sequencer(p, TRUE); ! 9566: } ! 9567: } ! 9568: current_p = temp_p; ! 9569: temp_p = (struct aic7xxx_host *)temp_p->next; ! 9570: kfree(current_p); ! 9571: } ! 9572: } ! 9573: } ! 9574: } ! 9575: return (found); ! 9576: } ! 9577: ! 9578: #ifdef AIC7XXX_FAKE_NEGOTIATION_CMDS ! 9579: ! 9580: /*+F************************************************************************* ! 9581: * Function: ! 9582: * aic7xxx_negotiation_complete ! 9583: * ! 9584: * Description: ! 9585: * Handle completion events for our Negotiation commands. Clear out the ! 9586: * struct and get it ready for its next use. ! 9587: *-F*************************************************************************/ ! 9588: static void ! 9589: aic7xxx_negotiation_complete(Scsi_Cmnd *cmd) ! 9590: { ! 9591: return; ! 9592: } ! 9593: ! 9594: /*+F************************************************************************* ! 9595: * Function: ! 9596: * aic7xxx_build_negotiation_command ! 9597: * ! 9598: * Description: ! 9599: * Build a Scsi_Cmnd structure to perform negotiation with or else send ! 9600: * a pre-built command specifically for this purpose. ! 9601: *-F*************************************************************************/ ! 9602: static void ! 9603: aic7xxx_build_negotiation_cmnd(struct aic7xxx_host *p, Scsi_Cmnd *old_cmd, ! 9604: int tindex) ! 9605: { ! 9606: ! 9607: if ( (p->needwdtr & (1<<tindex)) && !(p->wdtr_pending & (1<<tindex)) ) ! 9608: { ! 9609: if(p->dev_wdtr_cmnd[tindex] == NULL) ! 9610: { ! 9611: Scsi_Cmnd *cmd; ! 9612: ! 9613: if (!(p->dev_wdtr_cmnd[tindex] = kmalloc(sizeof(Scsi_Cmnd), GFP_ATOMIC)) ) ! 9614: { ! 9615: return; ! 9616: } ! 9617: cmd = p->dev_wdtr_cmnd[tindex]; ! 9618: memset(cmd, 0, sizeof(Scsi_Cmnd)); ! 9619: memcpy(cmd, old_cmd, sizeof(Scsi_Cmnd)); ! 9620: memset(&cmd->cmnd[0], 0, sizeof(cmd->cmnd)); ! 9621: memset(&cmd->data_cmnd[0], 0, sizeof(cmd->data_cmnd)); ! 9622: cmd->lun = 0; ! 9623: cmd->request_bufflen = 0; ! 9624: cmd->request_buffer = NULL; ! 9625: cmd->use_sg = cmd->old_use_sg = cmd->sglist_len = 0; ! 9626: cmd->bufflen = 0; ! 9627: cmd->buffer = NULL; ! 9628: cmd->underflow = 0; ! 9629: cmd->cmd_len = 6; ! 9630: } ! 9631: /* ! 9632: * Before sending this thing out, we also amke the cmd->next pointer ! 9633: * point to the real command so we can stuff any possible SENSE data ! 9634: * intp the real command instead of this fake command. This has to be ! 9635: * done each time the command is built, not just the first time, hence ! 9636: * it's outside of the above if()... ! 9637: */ ! 9638: p->dev_wdtr_cmnd[tindex]->next = old_cmd; ! 9639: aic7xxx_queue(p->dev_wdtr_cmnd[tindex], ! 9640: aic7xxx_negotiation_complete); ! 9641: } ! 9642: else if ( (p->needsdtr & (1<<tindex)) && !(p->sdtr_pending & (1<<tindex)) && ! 9643: !(p->wdtr_pending & (1<<tindex)) ) ! 9644: { ! 9645: if(p->dev_sdtr_cmnd[tindex] == NULL) ! 9646: { ! 9647: Scsi_Cmnd *cmd; ! 9648: ! 9649: if (!(p->dev_sdtr_cmnd[tindex] = kmalloc(sizeof(Scsi_Cmnd), GFP_ATOMIC)) ) ! 9650: { ! 9651: return; ! 9652: } ! 9653: cmd = p->dev_sdtr_cmnd[tindex]; ! 9654: memset(cmd, 0, sizeof(Scsi_Cmnd)); ! 9655: memcpy(cmd, old_cmd, sizeof(Scsi_Cmnd)); ! 9656: memset(&cmd->cmnd[0], 0, sizeof(cmd->cmnd)); ! 9657: memset(&cmd->data_cmnd[0], 0, sizeof(cmd->data_cmnd)); ! 9658: cmd->lun = 0; ! 9659: cmd->request_bufflen = 0; ! 9660: cmd->request_buffer = NULL; ! 9661: cmd->use_sg = cmd->old_use_sg = cmd->sglist_len = 0; ! 9662: cmd->bufflen = 0; ! 9663: cmd->buffer = NULL; ! 9664: cmd->underflow = 0; ! 9665: cmd->cmd_len = 6; ! 9666: } ! 9667: /* ! 9668: * Before sending this thing out, we also amke the cmd->next pointer ! 9669: * point to the real command so we can stuff any possible SENSE data ! 9670: * intp the real command instead of this fake command. This has to be ! 9671: * done each time the command is built, not just the first time, hence ! 9672: * it's outside of the above if()... ! 9673: */ ! 9674: p->dev_sdtr_cmnd[tindex]->next = old_cmd; ! 9675: aic7xxx_queue(p->dev_sdtr_cmnd[tindex], ! 9676: aic7xxx_negotiation_complete); ! 9677: } ! 9678: } ! 9679: ! 9680: #endif ! 9681: ! 9682: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 9683: /*+F************************************************************************* ! 9684: * Function: ! 9685: * aic7xxx_print_scb ! 9686: * ! 9687: * Description: ! 9688: * Dump the byte codes for an about to be sent SCB. ! 9689: *-F*************************************************************************/ ! 9690: static void ! 9691: aic7xxx_print_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb) ! 9692: { ! 9693: int i; ! 9694: unsigned char *x; ! 9695: ! 9696: x = (unsigned char *)&scb->hscb->control; ! 9697: ! 9698: for(i=0; i<32; i++) ! 9699: { ! 9700: printk("%02x ", x[i]); ! 9701: } ! 9702: printk("\n"); ! 9703: } ! 9704: #endif ! 9705: ! 9706: /*+F************************************************************************* ! 9707: * Function: ! 9708: * aic7xxx_buildscb ! 9709: * ! 9710: * Description: ! 9711: * Build a SCB. ! 9712: *-F*************************************************************************/ ! 9713: static void ! 9714: aic7xxx_buildscb(struct aic7xxx_host *p, Scsi_Cmnd *cmd, ! 9715: struct aic7xxx_scb *scb) ! 9716: { ! 9717: unsigned short mask; ! 9718: struct aic7xxx_hwscb *hscb; ! 9719: ! 9720: mask = (0x01 << TARGET_INDEX(cmd)); ! 9721: hscb = scb->hscb; ! 9722: ! 9723: /* ! 9724: * Setup the control byte if we need negotiation and have not ! 9725: * already requested it. ! 9726: */ ! 9727: hscb->control = 0; ! 9728: scb->tag_action = 0; ! 9729: if (p->discenable & mask) ! 9730: { ! 9731: hscb->control |= DISCENB; ! 9732: if (p->tagenable & mask) ! 9733: { ! 9734: cmd->tag = hscb->tag; ! 9735: p->dev_commands_sent[TARGET_INDEX(cmd)]++; ! 9736: if (p->dev_commands_sent[TARGET_INDEX(cmd)] < 200) ! 9737: { ! 9738: hscb->control |= MSG_SIMPLE_Q_TAG; ! 9739: scb->tag_action = MSG_SIMPLE_Q_TAG; ! 9740: } ! 9741: else ! 9742: { ! 9743: if (p->orderedtag & mask) ! 9744: { ! 9745: hscb->control |= MSG_ORDERED_Q_TAG; ! 9746: scb->tag_action = MSG_ORDERED_Q_TAG; ! 9747: } ! 9748: else ! 9749: { ! 9750: hscb->control |= MSG_SIMPLE_Q_TAG; ! 9751: scb->tag_action = MSG_SIMPLE_Q_TAG; ! 9752: } ! 9753: p->dev_commands_sent[TARGET_INDEX(cmd)] = 0; ! 9754: } ! 9755: } ! 9756: } ! 9757: if (p->dev_flags[TARGET_INDEX(cmd)] & DEVICE_SCANNED) ! 9758: { ! 9759: #ifdef AIC7XXX_FAKE_NEGOTIATION_CMDS ! 9760: if ( (p->needwdtr & mask) && !(p->wdtr_pending & mask) ) ! 9761: { ! 9762: if (cmd == p->dev_wdtr_cmnd[TARGET_INDEX(cmd)]) ! 9763: { ! 9764: p->wdtr_pending |= mask; ! 9765: scb->flags |= SCB_MSGOUT_WDTR; ! 9766: hscb->control &= DISCENB; ! 9767: hscb->control |= MK_MESSAGE; ! 9768: scb->tag_action = 0; ! 9769: } ! 9770: else ! 9771: { ! 9772: aic7xxx_build_negotiation_cmnd(p, cmd, TARGET_INDEX(cmd)); ! 9773: } ! 9774: } ! 9775: else if ( (p->needsdtr & mask) && !(p->sdtr_pending & mask) && ! 9776: !(p->wdtr_pending & mask) ) ! 9777: { ! 9778: if (cmd == p->dev_sdtr_cmnd[TARGET_INDEX(cmd)]) ! 9779: { ! 9780: p->sdtr_pending |= mask; ! 9781: scb->flags |= SCB_MSGOUT_SDTR; ! 9782: hscb->control &= DISCENB; ! 9783: hscb->control |= MK_MESSAGE; ! 9784: scb->tag_action = 0; ! 9785: } ! 9786: else if (cmd != p->dev_wdtr_cmnd[TARGET_INDEX(cmd)]) ! 9787: { ! 9788: aic7xxx_build_negotiation_cmnd(p, cmd, TARGET_INDEX(cmd)); ! 9789: } ! 9790: } ! 9791: #else ! 9792: if ( (p->needwdtr & mask) && !(p->wdtr_pending & mask) && ! 9793: !(p->sdtr_pending & mask) && (cmd->lun == 0) ) ! 9794: { ! 9795: p->wdtr_pending |= mask; ! 9796: scb->flags |= SCB_MSGOUT_WDTR; ! 9797: hscb->control &= DISCENB; ! 9798: hscb->control |= MK_MESSAGE; ! 9799: scb->tag_action = 0; ! 9800: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 9801: if (aic7xxx_verbose > 0xffff) ! 9802: printk(INFO_LEAD "Building WDTR command.\n", p->host_no, ! 9803: CTL_OF_CMD(cmd)); ! 9804: #endif ! 9805: } ! 9806: else if ( (p->needsdtr & mask) && !(p->wdtr_pending & mask) && ! 9807: !(p->sdtr_pending & mask) && (cmd->lun == 0) ) ! 9808: { ! 9809: p->sdtr_pending |= mask; ! 9810: scb->flags |= SCB_MSGOUT_SDTR; ! 9811: hscb->control &= DISCENB; ! 9812: hscb->control |= MK_MESSAGE; ! 9813: scb->tag_action = 0; ! 9814: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 9815: if (aic7xxx_verbose > 0xffff) ! 9816: printk(INFO_LEAD "Building SDTR command.\n", p->host_no, ! 9817: CTL_OF_CMD(cmd)); ! 9818: #endif ! 9819: } ! 9820: #endif ! 9821: } ! 9822: hscb->target_channel_lun = ((cmd->target << 4) & 0xF0) | ! 9823: ((cmd->channel & 0x01) << 3) | (cmd->lun & 0x07); ! 9824: ! 9825: /* ! 9826: * The interpretation of request_buffer and request_bufflen ! 9827: * changes depending on whether or not use_sg is zero; a ! 9828: * non-zero use_sg indicates the number of elements in the ! 9829: * scatter-gather array. ! 9830: */ ! 9831: ! 9832: /* ! 9833: * XXX - this relies on the host data being stored in a ! 9834: * little-endian format. ! 9835: */ ! 9836: hscb->SCSI_cmd_length = cmd->cmd_len; ! 9837: hscb->SCSI_cmd_pointer = cpu_to_le32(VIRT_TO_BUS(cmd->cmnd)); ! 9838: ! 9839: if (cmd->use_sg) ! 9840: { ! 9841: struct scatterlist *sg; /* Must be mid-level SCSI code scatterlist */ ! 9842: ! 9843: /* ! 9844: * We must build an SG list in adapter format, as the kernel's SG list ! 9845: * cannot be used directly because of data field size (__alpha__) ! 9846: * differences and the kernel SG list uses virtual addresses where ! 9847: * we need physical addresses. ! 9848: */ ! 9849: int i; ! 9850: ! 9851: sg = (struct scatterlist *)cmd->request_buffer; ! 9852: scb->sg_length = 0; ! 9853: /* ! 9854: * Copy the segments into the SG array. NOTE!!! - We used to ! 9855: * have the first entry both in the data_pointer area and the first ! 9856: * SG element. That has changed somewhat. We still have the first ! 9857: * entry in both places, but now we download the address of ! 9858: * scb->sg_list[1] instead of 0 to the sg pointer in the hscb. ! 9859: */ ! 9860: for (i = 0; i < cmd->use_sg; i++) ! 9861: { ! 9862: scb->sg_list[i].address = cpu_to_le32(VIRT_TO_BUS(sg[i].address)); ! 9863: scb->sg_list[i].length = cpu_to_le32(sg[i].length); ! 9864: scb->sg_length += sg[i].length; ! 9865: } ! 9866: /* Copy the first SG into the data pointer area. */ ! 9867: hscb->data_pointer = scb->sg_list[0].address; ! 9868: hscb->data_count = scb->sg_list[0].length; ! 9869: scb->sg_count = cmd->use_sg; ! 9870: hscb->SG_segment_count = cmd->use_sg; ! 9871: hscb->SG_list_pointer = cpu_to_le32(VIRT_TO_BUS(&scb->sg_list[1])); ! 9872: ! 9873: } ! 9874: else ! 9875: { ! 9876: if (cmd->request_bufflen) ! 9877: { ! 9878: scb->sg_count = 1; ! 9879: scb->sg_list[0].address = cpu_to_le32(VIRT_TO_BUS(cmd->request_buffer)); ! 9880: scb->sg_list[0].length = cpu_to_le32(cmd->request_bufflen); ! 9881: scb->sg_length = cmd->request_bufflen; ! 9882: hscb->SG_segment_count = 1; ! 9883: hscb->SG_list_pointer = cpu_to_le32(VIRT_TO_BUS(&scb->sg_list[0])); ! 9884: hscb->data_count = scb->sg_list[0].length; ! 9885: hscb->data_pointer = scb->sg_list[0].address; ! 9886: } ! 9887: else ! 9888: { ! 9889: scb->sg_count = 0; ! 9890: scb->sg_length = 0; ! 9891: hscb->SG_segment_count = 0; ! 9892: hscb->SG_list_pointer = 0; ! 9893: hscb->data_count = 0; ! 9894: hscb->data_pointer = 0; ! 9895: } ! 9896: } ! 9897: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 9898: if((cmd->cmnd[0] == TEST_UNIT_READY) && (aic7xxx_verbose & VERBOSE_PROBE2)) ! 9899: { ! 9900: aic7xxx_print_scb(p, scb); ! 9901: } ! 9902: #endif ! 9903: } ! 9904: ! 9905: /*+F************************************************************************* ! 9906: * Function: ! 9907: * aic7xxx_queue ! 9908: * ! 9909: * Description: ! 9910: * Queue a SCB to the controller. ! 9911: *-F*************************************************************************/ ! 9912: int ! 9913: aic7xxx_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *)) ! 9914: { ! 9915: struct aic7xxx_host *p; ! 9916: struct aic7xxx_scb *scb; ! 9917: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 9918: int tindex = TARGET_INDEX(cmd); ! 9919: #endif ! 9920: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 9921: unsigned long cpu_flags = 0; ! 9922: #endif ! 9923: ! 9924: p = (struct aic7xxx_host *) cmd->host->hostdata; ! 9925: /* ! 9926: * Check to see if channel was scanned. ! 9927: */ ! 9928: ! 9929: #ifdef AIC7XXX_VERBOSE_DEBUGGING ! 9930: if (!(p->flags & AHC_A_SCANNED) && (cmd->channel == 0)) ! 9931: { ! 9932: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 9933: printk(INFO_LEAD "Scanning channel for devices.\n", ! 9934: p->host_no, 0, -1, -1); ! 9935: p->flags |= AHC_A_SCANNED; ! 9936: } ! 9937: else ! 9938: { ! 9939: if (!(p->flags & AHC_B_SCANNED) && (cmd->channel == 1)) ! 9940: { ! 9941: if (aic7xxx_verbose & VERBOSE_PROBE2) ! 9942: printk(INFO_LEAD "Scanning channel for devices.\n", ! 9943: p->host_no, 1, -1, -1); ! 9944: p->flags |= AHC_B_SCANNED; ! 9945: } ! 9946: } ! 9947: ! 9948: if (p->dev_active_cmds[tindex] > (cmd->device->queue_depth + 1)) ! 9949: { ! 9950: printk(WARN_LEAD "Commands queued exceeds queue " ! 9951: "depth, active=%d\n", ! 9952: p->host_no, CTL_OF_CMD(cmd), ! 9953: p->dev_active_cmds[tindex]); ! 9954: if ( p->dev_active_cmds[tindex] > 220 ) ! 9955: p->dev_active_cmds[tindex] = 0; ! 9956: } ! 9957: #endif ! 9958: ! 9959: scb = scbq_remove_head(&p->scb_data->free_scbs); ! 9960: if (scb == NULL) ! 9961: { ! 9962: DRIVER_LOCK ! 9963: aic7xxx_allocate_scb(p); ! 9964: DRIVER_UNLOCK ! 9965: scb = scbq_remove_head(&p->scb_data->free_scbs); ! 9966: } ! 9967: if (scb == NULL) ! 9968: { ! 9969: printk(WARN_LEAD "Couldn't get a free SCB.\n", p->host_no, ! 9970: CTL_OF_CMD(cmd)); ! 9971: cmd->result = (DID_BUS_BUSY << 16); ! 9972: DRIVER_LOCK ! 9973: aic7xxx_queue_cmd_complete(p, cmd); ! 9974: DRIVER_UNLOCK ! 9975: return 0; ! 9976: } ! 9977: else ! 9978: { ! 9979: scb->cmd = cmd; ! 9980: aic7xxx_position(cmd) = scb->hscb->tag; ! 9981: ! 9982: /* ! 9983: * Construct the SCB beforehand, so the sequencer is ! 9984: * paused a minimal amount of time. ! 9985: */ ! 9986: aic7xxx_buildscb(p, cmd, scb); ! 9987: ! 9988: /* ! 9989: * Make sure the Scsi_Cmnd pointer is saved, the struct it points to ! 9990: * is set up properly, and the parity error flag is reset, then send ! 9991: * the SCB to the sequencer and watch the fun begin. ! 9992: */ ! 9993: cmd->scsi_done = fn; ! 9994: cmd->result = DID_OK; ! 9995: memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer)); ! 9996: aic7xxx_error(cmd) = DID_OK; ! 9997: aic7xxx_status(cmd) = 0; ! 9998: cmd->host_scribble = NULL; ! 9999: ! 10000: scb->flags |= SCB_ACTIVE | SCB_WAITINGQ; ! 10001: ! 10002: DRIVER_LOCK ! 10003: scbq_insert_tail(&p->waiting_scbs, scb); ! 10004: if ( (p->flags & (AHC_IN_ISR | AHC_IN_ABORT | AHC_IN_RESET)) == 0) ! 10005: { ! 10006: aic7xxx_run_waiting_queues(p); ! 10007: } ! 10008: DRIVER_UNLOCK ! 10009: } ! 10010: return (0); ! 10011: } ! 10012: ! 10013: /*+F************************************************************************* ! 10014: * Function: ! 10015: * aic7xxx_bus_device_reset ! 10016: * ! 10017: * Description: ! 10018: * Abort or reset the current SCSI command(s). If the scb has not ! 10019: * previously been aborted, then we attempt to send a BUS_DEVICE_RESET ! 10020: * message to the target. If the scb has previously been unsuccessfully ! 10021: * aborted, then we will reset the channel and have all devices renegotiate. ! 10022: * Returns an enumerated type that indicates the status of the operation. ! 10023: *-F*************************************************************************/ ! 10024: static int ! 10025: aic7xxx_bus_device_reset(struct aic7xxx_host *p, Scsi_Cmnd *cmd) ! 10026: { ! 10027: struct aic7xxx_scb *scb; ! 10028: struct aic7xxx_hwscb *hscb; ! 10029: int result = -1; ! 10030: int channel; ! 10031: unsigned char saved_scbptr, lastphase; ! 10032: unsigned char hscb_index; ! 10033: int disconnected; ! 10034: ! 10035: scb = (p->scb_data->scb_array[aic7xxx_position(cmd)]); ! 10036: hscb = scb->hscb; ! 10037: ! 10038: lastphase = aic_inb(p, LASTPHASE); ! 10039: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10040: { ! 10041: printk(INFO_LEAD "Bus Device reset, scb flags 0x%x, ", ! 10042: p->host_no, CTL_OF_SCB(scb), scb->flags); ! 10043: switch (lastphase) ! 10044: { ! 10045: case P_DATAOUT: ! 10046: printk("Data-Out phase\n"); ! 10047: break; ! 10048: case P_DATAIN: ! 10049: printk("Data-In phase\n"); ! 10050: break; ! 10051: case P_COMMAND: ! 10052: printk("Command phase\n"); ! 10053: break; ! 10054: case P_MESGOUT: ! 10055: printk("Message-Out phase\n"); ! 10056: break; ! 10057: case P_STATUS: ! 10058: printk("Status phase\n"); ! 10059: break; ! 10060: case P_MESGIN: ! 10061: printk("Message-In phase\n"); ! 10062: break; ! 10063: default: ! 10064: /* ! 10065: * We're not in a valid phase, so assume we're idle. ! 10066: */ ! 10067: printk("while idle, LASTPHASE = 0x%x\n", lastphase); ! 10068: break; ! 10069: } ! 10070: printk(INFO_LEAD "SCSISIGI 0x%x, SEQADDR 0x%x, SSTAT0 0x%x, SSTAT1 " ! 10071: "0x%x\n", p->host_no, CTL_OF_SCB(scb), ! 10072: aic_inb(p, SCSISIGI), ! 10073: aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8), ! 10074: aic_inb(p, SSTAT0), aic_inb(p, SSTAT1)); ! 10075: } ! 10076: ! 10077: channel = cmd->channel; ! 10078: ! 10079: /* ! 10080: * Send a Device Reset Message: ! 10081: * The target that is holding up the bus may not be the same as ! 10082: * the one that triggered this timeout (different commands have ! 10083: * different timeout lengths). Our strategy here is to queue an ! 10084: * abort message to the timed out target if it is disconnected. ! 10085: * Otherwise, if we have an active target we stuff the message buffer ! 10086: * with an abort message and assert ATN in the hopes that the target ! 10087: * will let go of the bus and go to the mesgout phase. If this ! 10088: * fails, we'll get another timeout a few seconds later which will ! 10089: * attempt a bus reset. ! 10090: */ ! 10091: saved_scbptr = aic_inb(p, SCBPTR); ! 10092: disconnected = FALSE; ! 10093: ! 10094: if (lastphase != P_BUSFREE) ! 10095: { ! 10096: if (aic_inb(p, SCB_TAG) >= p->scb_data->numscbs) ! 10097: { ! 10098: printk(WARN_LEAD "Invalid SCB ID %d is active, " ! 10099: "SCB flags = 0x%x.\n", p->host_no, ! 10100: CTL_OF_CMD(cmd), scb->hscb->tag, scb->flags); ! 10101: return(SCSI_RESET_ERROR); ! 10102: } ! 10103: if (scb->hscb->tag == aic_inb(p, SCB_TAG)) ! 10104: { ! 10105: if ( (lastphase != P_MESGOUT) && (lastphase != P_MESGIN) ) ! 10106: { ! 10107: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10108: printk(INFO_LEAD "Device reset message in " ! 10109: "message buffer\n", p->host_no, CTL_OF_SCB(scb)); ! 10110: scb->flags |= SCB_RESET | SCB_DEVICE_RESET; ! 10111: aic7xxx_error(scb->cmd) = DID_RESET; ! 10112: p->dev_flags[TARGET_INDEX(scb->cmd)] &= ! 10113: ~DEVICE_SUCCESS; ! 10114: p->dev_flags[TARGET_INDEX(scb->cmd)] |= ! 10115: BUS_DEVICE_RESET_PENDING; ! 10116: /* Send the abort message to the active SCB. */ ! 10117: aic_outb(p, HOST_MSG, MSG_OUT); ! 10118: aic_outb(p, lastphase | ATNO, SCSISIGO); ! 10119: return(SCSI_RESET_PENDING); ! 10120: } ! 10121: else ! 10122: { ! 10123: /* We want to send out the message, but it could screw an already */ ! 10124: /* in place and being used message. Instead, we return an error */ ! 10125: /* to try and start the bus reset phase since this command is */ ! 10126: /* probably hung (aborts failed, and now reset is failing). We */ ! 10127: /* also make sure to set BUS_DEVICE_RESET_PENDING so we won't try */ ! 10128: /* any more on this device, but instead will escalate to a bus or */ ! 10129: /* host reset (additionally, we won't try to abort any more). */ ! 10130: printk(WARN_LEAD "Device reset, Message buffer " ! 10131: "in use\n", p->host_no, CTL_OF_SCB(scb)); ! 10132: scb->flags |= SCB_RESET | SCB_DEVICE_RESET; ! 10133: aic7xxx_error(scb->cmd) = DID_RESET; ! 10134: p->dev_flags[TARGET_INDEX(scb->cmd)] &= ! 10135: ~DEVICE_SUCCESS; ! 10136: p->dev_flags[TARGET_INDEX(scb->cmd)] |= ! 10137: BUS_DEVICE_RESET_PENDING; ! 10138: return(SCSI_RESET_ERROR); ! 10139: } ! 10140: } ! 10141: } /* if (last_phase != P_BUSFREE).....indicates we are idle and can work */ ! 10142: hscb_index = aic7xxx_find_scb(p, scb); ! 10143: if (hscb_index == SCB_LIST_NULL) ! 10144: { ! 10145: disconnected = (aic7xxx_scb_on_qoutfifo(p, scb)) ? FALSE : TRUE; ! 10146: } ! 10147: else ! 10148: { ! 10149: aic_outb(p, hscb_index, SCBPTR); ! 10150: if (aic_inb(p, SCB_CONTROL) & DISCONNECTED) ! 10151: { ! 10152: disconnected = TRUE; ! 10153: } ! 10154: } ! 10155: if (disconnected) ! 10156: { ! 10157: /* ! 10158: * Simply set the MK_MESSAGE flag and the SEQINT handler will do ! 10159: * the rest on a reconnect. ! 10160: */ ! 10161: scb->hscb->control |= MK_MESSAGE; ! 10162: scb->flags |= SCB_RESET | SCB_DEVICE_RESET; ! 10163: p->dev_flags[TARGET_INDEX(scb->cmd)] &= ~DEVICE_SUCCESS; ! 10164: p->dev_flags[TARGET_INDEX(scb->cmd)] |= ! 10165: BUS_DEVICE_RESET_PENDING; ! 10166: if (hscb_index != SCB_LIST_NULL) ! 10167: { ! 10168: unsigned char scb_control; ! 10169: ! 10170: aic_outb(p, hscb_index, SCBPTR); ! 10171: scb_control = aic_inb(p, SCB_CONTROL); ! 10172: aic_outb(p, scb_control | MK_MESSAGE, SCB_CONTROL); ! 10173: } ! 10174: /* ! 10175: * Actually requeue this SCB in case we can select the ! 10176: * device before it reconnects. If the transaction we ! 10177: * want to abort is not tagged, then this will be the only ! 10178: * outstanding command and we can simply shove it on the ! 10179: * qoutfifo and be done. If it is tagged, then it goes right ! 10180: * in with all the others, no problem :) We need to add it ! 10181: * to the qinfifo and let the sequencer know it is there. ! 10182: * Now, the only problem left to deal with is, *IF* this ! 10183: * command completes, in spite of the MK_MESSAGE bit in the ! 10184: * control byte, then we need to pick that up in the interrupt ! 10185: * routine and clean things up. This *shouldn't* ever happen. ! 10186: */ ! 10187: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10188: printk(INFO_LEAD "Queueing device reset " ! 10189: "command.\n", p->host_no, CTL_OF_SCB(scb)); ! 10190: p->qinfifo[p->qinfifonext++] = scb->hscb->tag; ! 10191: if (p->features & AHC_QUEUE_REGS) ! 10192: aic_outb(p, p->qinfifonext, HNSCB_QOFF); ! 10193: else ! 10194: aic_outb(p, p->qinfifonext, KERNEL_QINPOS); ! 10195: scb->flags |= SCB_QUEUED_ABORT; ! 10196: result = SCSI_RESET_PENDING; ! 10197: } ! 10198: else if (result == -1) ! 10199: { ! 10200: result = SCSI_RESET_ERROR; ! 10201: } ! 10202: aic_outb(p, saved_scbptr, SCBPTR); ! 10203: return (result); ! 10204: } ! 10205: ! 10206: ! 10207: /*+F************************************************************************* ! 10208: * Function: ! 10209: * aic7xxx_panic_abort ! 10210: * ! 10211: * Description: ! 10212: * Abort the current SCSI command(s). ! 10213: *-F*************************************************************************/ ! 10214: void ! 10215: aic7xxx_panic_abort(struct aic7xxx_host *p, Scsi_Cmnd *cmd) ! 10216: { ! 10217: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) ! 10218: int i, mask, found, need_tag; ! 10219: struct aic7xxx_scb *scb; ! 10220: unsigned char qinpos, hscbp; ! 10221: ! 10222: found = FALSE; ! 10223: #endif ! 10224: ! 10225: printk("aic7xxx driver version %s/%s\n", AIC7XXX_C_VERSION, ! 10226: UTS_RELEASE); ! 10227: printk("Controller type:\n %s\n", board_names[p->board_name_index]); ! 10228: printk("p->flags=0x%x, p->chip=0x%x, p->features=0x%x, " ! 10229: "sequencer %s paused\n", ! 10230: p->flags, p->chip, p->features, ! 10231: (aic_inb(p, HCNTRL) & PAUSE) ? "is" : "isn't" ); ! 10232: pause_sequencer(p); ! 10233: disable_irq(p->irq); ! 10234: aic7xxx_print_card(p); ! 10235: aic7xxx_print_scratch_ram(p); ! 10236: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) ! 10237: for(i=0; i<MAX_TARGETS; i++) ! 10238: { ! 10239: if(p->dev_flags[i] & DEVICE_PRESENT) ! 10240: { ! 10241: mask = (0x01 << i); ! 10242: printk(INFO_LEAD "dev_flags=0x%x, WDTR:%c/%c/%c, SDTR:%c/%c/%c," ! 10243: " q_depth=%d:%d:%d\n", ! 10244: p->host_no, 0, i, 0, p->dev_flags[i], ! 10245: (p->wdtr_pending & mask) ? 'Y' : 'N', ! 10246: (p->needwdtr & mask) ? 'Y' : 'N', ! 10247: (p->needwdtr_copy & mask) ? 'Y' : 'N', ! 10248: (p->sdtr_pending & mask) ? 'Y' : 'N', ! 10249: (p->needsdtr & mask) ? 'Y' : 'N', ! 10250: (p->needsdtr_copy & mask) ? 'Y' : 'N', ! 10251: p->dev_active_cmds[i], ! 10252: p->dev_max_queue_depth[i], p->dev_mid_level_queue_depth[i]); ! 10253: printk(INFO_LEAD "targ_scsirate=0x%x", p->host_no, 0, i, 0, ! 10254: aic_inb(p, TARG_SCSIRATE + i)); ! 10255: if (p->features & AHC_ULTRA2) ! 10256: printk(", targ_offset=%d", aic_inb(p, TARG_OFFSET + i)); ! 10257: printk("\n"); ! 10258: } ! 10259: } ! 10260: /* ! 10261: * Search for this command and see if we can't track it down, it's the ! 10262: * one causing the timeout. Print out this command first, then all other ! 10263: * active commands afterwords. ! 10264: */ ! 10265: need_tag = -1; ! 10266: if ( cmd ) ! 10267: { ! 10268: scb = p->scb_data->scb_array[aic7xxx_position(cmd)]; ! 10269: if ( (scb->flags & SCB_ACTIVE) && (scb->cmd == cmd) ) ! 10270: { ! 10271: printk("Timed out command is scb #%d:\n", scb->hscb->tag); ! 10272: printk("Tag%d: flags=0x%x, control=0x%x, TCL=0x%x, %s\n", scb->hscb->tag, ! 10273: scb->flags, scb->hscb->control, scb->hscb->target_channel_lun, ! 10274: (scb->flags & SCB_WAITINGQ) ? "WAITINGQ" : "Sent" ); ! 10275: need_tag = scb->hscb->tag; ! 10276: if (scb->flags & SCB_WAITINGQ) found=TRUE; ! 10277: } ! 10278: } ! 10279: printk("QINFIFO: (TAG) "); ! 10280: qinpos = aic_inb(p, QINPOS); ! 10281: while ( qinpos != p->qinfifonext ) ! 10282: { ! 10283: if (p->qinfifo[qinpos] == need_tag) ! 10284: found=TRUE; ! 10285: printk("%d ", p->qinfifo[qinpos++]); ! 10286: } ! 10287: printk("\n"); ! 10288: printk("Current SCB: (SCBPTR/TAG/CONTROL) %d/%d/0x%x\n", aic_inb(p, SCBPTR), ! 10289: aic_inb(p, SCB_TAG), aic_inb(p, SCB_CONTROL) ); ! 10290: if (aic_inb(p, SCB_TAG) == need_tag) found=TRUE; ! 10291: printk("WAITING_SCBS: (SCBPTR/TAG/CONTROL) %d->", ! 10292: hscbp = aic_inb(p, WAITING_SCBH)); ! 10293: while (hscbp != SCB_LIST_NULL) ! 10294: { ! 10295: aic_outb(p, hscbp, SCBPTR); ! 10296: printk("%d/%d/0x%x ", hscbp, aic_inb(p, SCB_TAG), aic_inb(p, SCB_CONTROL)); ! 10297: hscbp = aic_inb(p, SCB_NEXT); ! 10298: if (aic_inb(p, SCB_TAG) == need_tag) found=TRUE; ! 10299: } ! 10300: printk("\n"); ! 10301: printk("DISCONNECTED_SCBS: (SCBPTR/TAG/CONTROL) %d->", ! 10302: hscbp = aic_inb(p, DISCONNECTED_SCBH)); ! 10303: while (hscbp != SCB_LIST_NULL) ! 10304: { ! 10305: aic_outb(p, hscbp, SCBPTR); ! 10306: printk("%d/%d/0x%x ", hscbp, aic_inb(p, SCB_TAG), aic_inb(p, SCB_CONTROL)); ! 10307: hscbp = aic_inb(p, SCB_NEXT); ! 10308: if (aic_inb(p, SCB_TAG) == need_tag) found=TRUE; ! 10309: } ! 10310: printk("\n"); ! 10311: printk("FREE_SCBS: (SCBPTR/TAG/CONTROL) %d->", ! 10312: hscbp = aic_inb(p, FREE_SCBH)); ! 10313: while (hscbp != SCB_LIST_NULL) ! 10314: { ! 10315: aic_outb(p, hscbp, SCBPTR); ! 10316: printk("%d/%d/0x%x ", hscbp, aic_inb(p, SCB_TAG), aic_inb(p, SCB_CONTROL)); ! 10317: hscbp = aic_inb(p, SCB_NEXT); ! 10318: } ! 10319: printk("\n"); ! 10320: ! 10321: if (found == FALSE) ! 10322: { ! 10323: /* ! 10324: * We haven't found the offending SCB yet, and it should be around ! 10325: * somewhere, so go look for it in the cards SCBs. ! 10326: */ ! 10327: printk("SCBPTR CONTROL TAG PREV NEXT\n"); ! 10328: for(i=0; i<p->scb_data->maxhscbs; i++) ! 10329: { ! 10330: aic_outb(p, i, SCBPTR); ! 10331: printk(" %3d %02x %02x %02x %02x\n", i, ! 10332: aic_inb(p, SCB_CONTROL), aic_inb(p, SCB_TAG), ! 10333: aic_inb(p, SCB_PREV), aic_inb(p, SCB_NEXT)); ! 10334: } ! 10335: } ! 10336: ! 10337: ! 10338: for (i=0; i < p->scb_data->numscbs; i++) ! 10339: { ! 10340: scb = p->scb_data->scb_array[i]; ! 10341: if ( (scb->flags & SCB_ACTIVE) && (scb->cmd != cmd) ) ! 10342: { ! 10343: printk("Tag%d: flags=0x%x, control=0x%x, TCL=0x%x, %s\n", scb->hscb->tag, ! 10344: scb->flags, scb->hscb->control, scb->hscb->target_channel_lun, ! 10345: (scb->flags & SCB_WAITINGQ) ? "WAITINGQ" : "Sent" ); ! 10346: } ! 10347: } ! 10348: #endif ! 10349: sti(); ! 10350: for(;;) barrier(); ! 10351: } ! 10352: ! 10353: /*+F************************************************************************* ! 10354: * Function: ! 10355: * aic7xxx_abort ! 10356: * ! 10357: * Description: ! 10358: * Abort the current SCSI command(s). ! 10359: *-F*************************************************************************/ ! 10360: int ! 10361: aic7xxx_abort(Scsi_Cmnd *cmd) ! 10362: { ! 10363: struct aic7xxx_scb *scb = NULL; ! 10364: struct aic7xxx_host *p; ! 10365: int result, found=0; ! 10366: unsigned char tmp_char, saved_hscbptr, next_hscbptr, prev_hscbptr; ! 10367: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 10368: unsigned long cpu_flags = 0; ! 10369: #endif ! 10370: Scsi_Cmnd *cmd_next, *cmd_prev; ! 10371: ! 10372: p = (struct aic7xxx_host *) cmd->host->hostdata; ! 10373: scb = (p->scb_data->scb_array[aic7xxx_position(cmd)]); ! 10374: ! 10375: /* ! 10376: * I added a new config option to the driver: "panic_on_abort" that will ! 10377: * cause the driver to panic and the machine to stop on the first abort ! 10378: * or reset call into the driver. At that point, it prints out a lot of ! 10379: * usefull information for me which I can then use to try and debug the ! 10380: * problem. Simply enable the boot time prompt in order to activate this ! 10381: * code. ! 10382: */ ! 10383: if (aic7xxx_panic_on_abort) ! 10384: aic7xxx_panic_abort(p, cmd); ! 10385: ! 10386: DRIVER_LOCK ! 10387: ! 10388: /* ! 10389: * Run the isr to grab any command in the QOUTFIFO and any other misc. ! 10390: * assundry tasks. This should also set up the bh handler if there is ! 10391: * anything to be done, but it won't run until we are done here since ! 10392: * we are following a straight code path without entering the scheduler ! 10393: * code. ! 10394: */ ! 10395: ! 10396: pause_sequencer(p); ! 10397: while ( (aic_inb(p, INTSTAT) & INT_PEND) && !(p->flags & AHC_IN_ISR)) ! 10398: { ! 10399: aic7xxx_isr(p->irq, p, (void *)NULL); ! 10400: pause_sequencer(p); ! 10401: aic7xxx_done_cmds_complete(p); ! 10402: } ! 10403: ! 10404: if ((scb == NULL) || (cmd->serial_number != cmd->serial_number_at_timeout)) ! 10405: /* Totally bogus cmd since it points beyond our */ ! 10406: { /* valid SCB range or doesn't even match it's own*/ ! 10407: /* timeout serial number. */ ! 10408: if (aic7xxx_verbose & VERBOSE_ABORT_MID) ! 10409: printk(INFO_LEAD "Abort called with bogus Scsi_Cmnd " ! 10410: "pointer.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10411: unpause_sequencer(p, FALSE); ! 10412: DRIVER_UNLOCK ! 10413: return(SCSI_ABORT_NOT_RUNNING); ! 10414: } ! 10415: if (scb->cmd != cmd) /* Hmmm...either this SCB is currently free with a */ ! 10416: { /* NULL cmd pointer (NULLed out when freed) or it */ ! 10417: /* has already been recycled for another command */ ! 10418: /* Either way, this SCB has nothing to do with this*/ ! 10419: /* command and we need to deal with cmd without */ ! 10420: /* touching the SCB. */ ! 10421: /* The theory here is to return a value that will */ ! 10422: /* make the queued for complete command actually */ ! 10423: /* finish successfully, or to indicate that we */ ! 10424: /* don't have this cmd any more and the mid level */ ! 10425: /* code needs to find it. */ ! 10426: cmd_next = p->completeq.head; ! 10427: cmd_prev = NULL; ! 10428: while (cmd_next != NULL) ! 10429: { ! 10430: if (cmd_next == cmd) ! 10431: { ! 10432: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 10433: printk(INFO_LEAD "Abort called for command " ! 10434: "on completeq, completing.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10435: if ( cmd_prev == NULL ) ! 10436: p->completeq.head = (Scsi_Cmnd *)cmd_next->host_scribble; ! 10437: else ! 10438: cmd_prev->host_scribble = cmd_next->host_scribble; ! 10439: cmd_next->scsi_done(cmd_next); ! 10440: unpause_sequencer(p, FALSE); ! 10441: DRIVER_UNLOCK ! 10442: return(SCSI_ABORT_NOT_RUNNING); /* It's already back as a successful ! 10443: * completion */ ! 10444: } ! 10445: cmd_prev = cmd_next; ! 10446: cmd_next = (Scsi_Cmnd *)cmd_next->host_scribble; ! 10447: } ! 10448: if (aic7xxx_verbose & VERBOSE_ABORT_MID) ! 10449: printk(INFO_LEAD "Abort called for already completed" ! 10450: " command.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10451: unpause_sequencer(p, FALSE); ! 10452: DRIVER_UNLOCK ! 10453: return(SCSI_ABORT_NOT_RUNNING); ! 10454: } ! 10455: ! 10456: /* At this point we know the following: ! 10457: * the SCB pointer is valid ! 10458: * the command pointer passed in to us and the scb->cmd pointer match ! 10459: * this then means that the command we need to abort is the same as the ! 10460: * command held by the scb pointer and is a valid abort request. ! 10461: * Now, we just have to figure out what to do from here. Current plan is: ! 10462: * if we have already been here on this command, escalate to a reset ! 10463: * if scb is on waiting list or QINFIFO, send it back as aborted, but ! 10464: * we also need to be aware of the possibility that we could be using ! 10465: * a faked negotiation command that is holding this command up, if ! 10466: * so we need to take care of that command instead, which means we ! 10467: * would then treat this one like it was sitting around disconnected ! 10468: * instead. ! 10469: * if scb is on WAITING_SCB list in sequencer, free scb and send back ! 10470: * if scb is disconnected and not completed, abort with abort message ! 10471: * if scb is currently running, then it may be causing the bus to hang ! 10472: * so we want a return value that indicates a reset would be appropriate ! 10473: * if the command does not finish shortly ! 10474: * if scb is already complete but not on completeq, we're screwed because ! 10475: * this can't happen (except if the command is in the QOUTFIFO, in which ! 10476: * case we would like it to complete successfully instead of having to ! 10477: * to be re-done) ! 10478: * All other scenarios already dealt with by previous code. ! 10479: */ ! 10480: ! 10481: if ( scb->flags & (SCB_ABORT | SCB_RESET | SCB_QUEUED_ABORT) ) ! 10482: { ! 10483: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 10484: printk(INFO_LEAD "SCB aborted once already, " ! 10485: "escalating.\n", p->host_no, CTL_OF_SCB(scb)); ! 10486: unpause_sequencer(p, FALSE); ! 10487: DRIVER_UNLOCK ! 10488: return(SCSI_ABORT_SNOOZE); ! 10489: } ! 10490: if ( (p->flags & (AHC_RESET_PENDING | AHC_ABORT_PENDING)) || ! 10491: (p->dev_flags[TARGET_INDEX(scb->cmd)] & ! 10492: BUS_DEVICE_RESET_PENDING) ) ! 10493: { ! 10494: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 10495: printk(INFO_LEAD "Reset/Abort pending for this " ! 10496: "device, not wasting our time.\n", p->host_no, CTL_OF_SCB(scb)); ! 10497: unpause_sequencer(p, FALSE); ! 10498: DRIVER_UNLOCK ! 10499: return(SCSI_ABORT_PENDING); ! 10500: } ! 10501: ! 10502: found = 0; ! 10503: p->flags |= AHC_IN_ABORT; ! 10504: if (aic7xxx_verbose & VERBOSE_ABORT) ! 10505: printk(INFO_LEAD "Aborting scb %d, flags 0x%x\n", ! 10506: p->host_no, CTL_OF_SCB(scb), scb->hscb->tag, scb->flags); ! 10507: ! 10508: /* ! 10509: * First, let's check to see if the currently running command is our target ! 10510: * since if it is, the return is fairly easy and quick since we don't want ! 10511: * to touch the command in case it might complete, but we do want a timeout ! 10512: * in case it's actually hung, so we really do nothing, but tell the mid ! 10513: * level code to reset the timeout. ! 10514: */ ! 10515: ! 10516: if ( scb->hscb->tag == aic_inb(p, SCB_TAG) ) ! 10517: { ! 10518: /* ! 10519: * Check to see if the sequencer is just sitting on this command, or ! 10520: * if it's actively being run. ! 10521: */ ! 10522: result = aic_inb(p, LASTPHASE); ! 10523: switch (result) ! 10524: { ! 10525: case P_DATAOUT: /* For any of these cases, we can assume we are */ ! 10526: case P_DATAIN: /* an active command and act according. For */ ! 10527: case P_COMMAND: /* anything else we are going to fall on through*/ ! 10528: case P_STATUS: /* The SCSI_ABORT_SNOOZE will give us two abort */ ! 10529: case P_MESGOUT: /* chances to finish and then escalate to a */ ! 10530: case P_MESGIN: /* reset call */ ! 10531: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 10532: printk(INFO_LEAD "SCB is currently active. " ! 10533: "Waiting on completion.\n", p->host_no, CTL_OF_SCB(scb)); ! 10534: unpause_sequencer(p, FALSE); ! 10535: p->flags &= ~AHC_IN_ABORT; ! 10536: scb->flags |= SCB_RECOVERY_SCB; /* Note the fact that we've been */ ! 10537: p->flags |= AHC_ABORT_PENDING; /* here so we will know not to */ ! 10538: DRIVER_UNLOCK /* muck with other SCBs if this */ ! 10539: return(SCSI_ABORT_PENDING); /* one doesn't complete and clear */ ! 10540: break; /* out. */ ! 10541: default: ! 10542: break; ! 10543: } ! 10544: } ! 10545: ! 10546: if ((found == 0) && (scb->flags & SCB_WAITINGQ)) ! 10547: { ! 10548: int tindex = TARGET_INDEX(cmd); ! 10549: #ifdef AIC7XXX_FAKE_NEGOTIATION_CMDS ! 10550: unsigned short mask; ! 10551: ! 10552: mask = (1 << tindex); ! 10553: ! 10554: if (p->wdtr_pending & mask) ! 10555: { ! 10556: if (p->dev_wdtr_cmnd[tindex]->next != cmd) ! 10557: found = 1; ! 10558: else ! 10559: found = 0; ! 10560: } ! 10561: else if (p->sdtr_pending & mask) ! 10562: { ! 10563: if (p->dev_sdtr_cmnd[tindex]->next != cmd) ! 10564: found = 1; ! 10565: else ! 10566: found = 0; ! 10567: } ! 10568: else ! 10569: { ! 10570: found = 1; ! 10571: } ! 10572: if (found == 0) ! 10573: { ! 10574: /* ! 10575: * OK..this means the command we are currently getting an abort ! 10576: * for has an outstanding negotiation command in front of it. ! 10577: * We don't really have a way to tie back into the negotiation ! 10578: * commands, so we just send this back as pending, then it ! 10579: * will get reset in 2 seconds. ! 10580: */ ! 10581: unpause_sequencer(p, TRUE); ! 10582: scb->flags |= SCB_ABORT; ! 10583: DRIVER_UNLOCK ! 10584: return(SCSI_ABORT_PENDING); ! 10585: } ! 10586: #endif ! 10587: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 10588: printk(INFO_LEAD "SCB found on waiting list and " ! 10589: "aborted.\n", p->host_no, CTL_OF_SCB(scb)); ! 10590: scbq_remove(&p->waiting_scbs, scb); ! 10591: scbq_remove(&p->delayed_scbs[tindex], scb); ! 10592: p->dev_active_cmds[tindex]++; ! 10593: p->activescbs++; ! 10594: scb->flags &= ~(SCB_WAITINGQ | SCB_ACTIVE); ! 10595: scb->flags |= SCB_ABORT | SCB_QUEUED_FOR_DONE; ! 10596: found = 1; ! 10597: } ! 10598: ! 10599: /* ! 10600: * We just checked the waiting_q, now for the QINFIFO ! 10601: */ ! 10602: if ( found == 0 ) ! 10603: { ! 10604: if ( ((found = aic7xxx_search_qinfifo(p, cmd->target, ! 10605: cmd->channel, ! 10606: cmd->lun, scb->hscb->tag, SCB_ABORT | SCB_QUEUED_FOR_DONE, ! 10607: FALSE, NULL)) != 0) && ! 10608: (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)) ! 10609: printk(INFO_LEAD "SCB found in QINFIFO and " ! 10610: "aborted.\n", p->host_no, CTL_OF_SCB(scb)); ! 10611: } ! 10612: ! 10613: /* ! 10614: * QINFIFO, waitingq, completeq done. Next, check WAITING_SCB list in card ! 10615: */ ! 10616: ! 10617: if ( found == 0 ) ! 10618: { ! 10619: unsigned char scb_next_ptr; ! 10620: prev_hscbptr = SCB_LIST_NULL; ! 10621: saved_hscbptr = aic_inb(p, SCBPTR); ! 10622: next_hscbptr = aic_inb(p, WAITING_SCBH); ! 10623: while ( next_hscbptr != SCB_LIST_NULL ) ! 10624: { ! 10625: aic_outb(p, next_hscbptr, SCBPTR ); ! 10626: if ( scb->hscb->tag == aic_inb(p, SCB_TAG) ) ! 10627: { ! 10628: found = 1; ! 10629: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 10630: printk(INFO_LEAD "SCB found on hardware waiting" ! 10631: " list and aborted.\n", p->host_no, CTL_OF_SCB(scb)); ! 10632: if ( prev_hscbptr == SCB_LIST_NULL ) ! 10633: { ! 10634: aic_outb(p, aic_inb(p, SCB_NEXT), WAITING_SCBH); ! 10635: /* stop the selection since we just ! 10636: * grabbed the scb out from under the ! 10637: * card ! 10638: */ ! 10639: aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ); ! 10640: aic_outb(p, CLRSELTIMEO, CLRSINT1); ! 10641: } ! 10642: else ! 10643: { ! 10644: scb_next_ptr = aic_inb(p, SCB_NEXT); ! 10645: aic_outb(p, prev_hscbptr, SCBPTR); ! 10646: aic_outb(p, scb_next_ptr, SCB_NEXT); ! 10647: aic_outb(p, next_hscbptr, SCBPTR); ! 10648: } ! 10649: aic_outb(p, SCB_LIST_NULL, SCB_TAG); ! 10650: aic_outb(p, 0, SCB_CONTROL); ! 10651: aic7xxx_add_curscb_to_free_list(p); ! 10652: scb->flags = SCB_ABORT | SCB_QUEUED_FOR_DONE; ! 10653: break; ! 10654: } ! 10655: prev_hscbptr = next_hscbptr; ! 10656: next_hscbptr = aic_inb(p, SCB_NEXT); ! 10657: } ! 10658: aic_outb(p, saved_hscbptr, SCBPTR ); ! 10659: } ! 10660: ! 10661: /* ! 10662: * Hmmm...completeq, QOUTFIFO, QINFIFO, WAITING_SCBH, waitingq all checked. ! 10663: * OK...the sequencer's paused, interrupts are off, and we haven't found the ! 10664: * command anyplace where it could be easily aborted. Time for the hard ! 10665: * work. We also know the command is valid. This essentially means the ! 10666: * command is disconnected, or connected but not into any phases yet, which ! 10667: * we know due to the tests we ran earlier on the current active scb phase. ! 10668: * At this point we can queue the abort tag and go on with life. ! 10669: */ ! 10670: ! 10671: if ( found == 0 ) ! 10672: { ! 10673: p->flags |= AHC_ABORT_PENDING; ! 10674: scb->flags |= SCB_QUEUED_ABORT | SCB_ABORT | SCB_RECOVERY_SCB; ! 10675: scb->hscb->control |= MK_MESSAGE; ! 10676: result=aic7xxx_find_scb(p, scb); ! 10677: if ( result != SCB_LIST_NULL ) ! 10678: { ! 10679: saved_hscbptr = aic_inb(p, SCBPTR); ! 10680: aic_outb(p, result, SCBPTR); ! 10681: tmp_char = aic_inb(p, SCB_CONTROL); ! 10682: aic_outb(p, tmp_char | MK_MESSAGE, SCB_CONTROL); ! 10683: aic_outb(p, saved_hscbptr, SCBPTR); ! 10684: } ! 10685: if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS) ! 10686: printk(INFO_LEAD "SCB disconnected. Queueing Abort" ! 10687: " SCB.\n", p->host_no, CTL_OF_SCB(scb)); ! 10688: p->qinfifo[p->qinfifonext++] = scb->hscb->tag; ! 10689: if (p->features & AHC_QUEUE_REGS) ! 10690: aic_outb(p, p->qinfifonext, HNSCB_QOFF); ! 10691: else ! 10692: aic_outb(p, p->qinfifonext, KERNEL_QINPOS); ! 10693: } ! 10694: if (found) ! 10695: { ! 10696: aic7xxx_run_done_queue(p, TRUE); ! 10697: aic7xxx_run_waiting_queues(p); ! 10698: } ! 10699: p->flags &= ~AHC_IN_ABORT; ! 10700: unpause_sequencer(p, FALSE); ! 10701: DRIVER_UNLOCK ! 10702: ! 10703: /* ! 10704: * On the return value. If we found the command and aborted it, then we know ! 10705: * it's already sent back and there is no reason for a further timeout, so ! 10706: * we use SCSI_ABORT_SUCCESS. On the queued abort side, we aren't so certain ! 10707: * there hasn't been a bus hang or something that might keep the abort from ! 10708: * from completing. Therefore, we use SCSI_ABORT_PENDING. The first time this ! 10709: * is passed back, the timeout on the command gets extended, the second time ! 10710: * we pass this back, the mid level SCSI code calls our reset function, which ! 10711: * would shake loose a hung bus. ! 10712: */ ! 10713: if ( found != 0 ) ! 10714: return(SCSI_ABORT_SUCCESS); ! 10715: else ! 10716: return(SCSI_ABORT_PENDING); ! 10717: } ! 10718: ! 10719: ! 10720: /*+F************************************************************************* ! 10721: * Function: ! 10722: * aic7xxx_reset ! 10723: * ! 10724: * Description: ! 10725: * Resetting the bus always succeeds - is has to, otherwise the ! 10726: * kernel will panic! Try a surgical technique - sending a BUS ! 10727: * DEVICE RESET message - on the offending target before pulling ! 10728: * the SCSI bus reset line. ! 10729: *-F*************************************************************************/ ! 10730: int ! 10731: aic7xxx_reset(Scsi_Cmnd *cmd, unsigned int flags) ! 10732: { ! 10733: struct aic7xxx_scb *scb = NULL; ! 10734: struct aic7xxx_host *p; ! 10735: int tindex; ! 10736: int result = -1; ! 10737: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) ! 10738: unsigned long cpu_flags = 0; ! 10739: #endif ! 10740: #define DEVICE_RESET 0x01 ! 10741: #define BUS_RESET 0x02 ! 10742: #define HOST_RESET 0x04 ! 10743: #define FAIL 0x08 ! 10744: #define RESET_DELAY 0x10 ! 10745: int action; ! 10746: Scsi_Cmnd *cmd_prev, *cmd_next; ! 10747: ! 10748: ! 10749: if ( cmd == NULL ) ! 10750: { ! 10751: printk(KERN_WARNING "(scsi?:?:?:?) Reset called with NULL Scsi_Cmnd " ! 10752: "pointer, failing.\n"); ! 10753: return(SCSI_RESET_SNOOZE); ! 10754: } ! 10755: ! 10756: p = (struct aic7xxx_host *) cmd->host->hostdata; ! 10757: scb = (p->scb_data->scb_array[aic7xxx_position(cmd)]); ! 10758: tindex = TARGET_INDEX(cmd); ! 10759: ! 10760: /* ! 10761: * I added a new config option to the driver: "panic_on_abort" that will ! 10762: * cause the driver to panic and the machine to stop on the first abort ! 10763: * or reset call into the driver. At that point, it prints out a lot of ! 10764: * usefull information for me which I can then use to try and debug the ! 10765: * problem. Simply enable the boot time prompt in order to activate this ! 10766: * code. ! 10767: */ ! 10768: if (aic7xxx_panic_on_abort) ! 10769: aic7xxx_panic_abort(p, cmd); ! 10770: ! 10771: DRIVER_LOCK ! 10772: ! 10773: pause_sequencer(p); ! 10774: while ( (aic_inb(p, INTSTAT) & INT_PEND) && !(p->flags & AHC_IN_ISR)) ! 10775: { ! 10776: aic7xxx_isr(p->irq, p, (void *)NULL ); ! 10777: pause_sequencer(p); ! 10778: aic7xxx_done_cmds_complete(p); ! 10779: } ! 10780: ! 10781: if (scb == NULL) ! 10782: { ! 10783: if (aic7xxx_verbose & VERBOSE_RESET_MID) ! 10784: printk(INFO_LEAD "Reset called with bogus Scsi_Cmnd" ! 10785: "->SCB mapping, improvising.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10786: if ( flags & SCSI_RESET_SUGGEST_HOST_RESET ) ! 10787: { ! 10788: action = HOST_RESET; ! 10789: } ! 10790: else ! 10791: { ! 10792: action = BUS_RESET; ! 10793: } ! 10794: } ! 10795: else if (scb->cmd != cmd) ! 10796: { ! 10797: if (aic7xxx_verbose & VERBOSE_RESET_MID) ! 10798: printk(INFO_LEAD "Reset called with recycled SCB " ! 10799: "for cmd.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10800: cmd_prev = NULL; ! 10801: cmd_next = p->completeq.head; ! 10802: while ( cmd_next != NULL ) ! 10803: { ! 10804: if (cmd_next == cmd) ! 10805: { ! 10806: if (aic7xxx_verbose & VERBOSE_RESET_RETURN) ! 10807: printk(INFO_LEAD "Reset, found cmd on completeq" ! 10808: ", completing.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10809: unpause_sequencer(p, FALSE); ! 10810: DRIVER_UNLOCK ! 10811: return(SCSI_RESET_NOT_RUNNING); ! 10812: } ! 10813: cmd_prev = cmd_next; ! 10814: cmd_next = (Scsi_Cmnd *)cmd_next->host_scribble; ! 10815: } ! 10816: if ( !(flags & SCSI_RESET_SYNCHRONOUS) ) ! 10817: { ! 10818: if (aic7xxx_verbose & VERBOSE_RESET_RETURN) ! 10819: printk(INFO_LEAD "Reset, cmd not found," ! 10820: " failing.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10821: unpause_sequencer(p, FALSE); ! 10822: DRIVER_UNLOCK ! 10823: return(SCSI_RESET_NOT_RUNNING); ! 10824: } ! 10825: else ! 10826: { ! 10827: if (aic7xxx_verbose & VERBOSE_RESET_MID) ! 10828: printk(INFO_LEAD "Reset called, no scb, " ! 10829: "flags 0x%x\n", p->host_no, CTL_OF_CMD(cmd), flags); ! 10830: scb = NULL; ! 10831: action = HOST_RESET; ! 10832: } ! 10833: } ! 10834: else ! 10835: { ! 10836: if (aic7xxx_verbose & VERBOSE_RESET_MID) ! 10837: printk(INFO_LEAD "Reset called, scb %d, flags " ! 10838: "0x%x\n", p->host_no, CTL_OF_SCB(scb), scb->hscb->tag, scb->flags); ! 10839: if ( aic7xxx_scb_on_qoutfifo(p, scb) ) ! 10840: { ! 10841: if(aic7xxx_verbose & VERBOSE_RESET_RETURN) ! 10842: printk(INFO_LEAD "SCB on qoutfifo, returning.\n", p->host_no, ! 10843: CTL_OF_SCB(scb)); ! 10844: unpause_sequencer(p, FALSE); ! 10845: DRIVER_UNLOCK ! 10846: return(SCSI_RESET_NOT_RUNNING); ! 10847: } ! 10848: if ( flags & SCSI_RESET_SUGGEST_HOST_RESET ) ! 10849: { ! 10850: action = HOST_RESET; ! 10851: } ! 10852: else if ( flags & SCSI_RESET_SUGGEST_BUS_RESET ) ! 10853: { ! 10854: action = BUS_RESET; ! 10855: } ! 10856: else ! 10857: { ! 10858: action = DEVICE_RESET; ! 10859: } ! 10860: } ! 10861: if ( (action & DEVICE_RESET) && ! 10862: (p->dev_flags[tindex] & BUS_DEVICE_RESET_PENDING) ) ! 10863: { ! 10864: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10865: printk(INFO_LEAD "Bus device reset already sent to " ! 10866: "device, escalating.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10867: action = BUS_RESET; ! 10868: } ! 10869: if ( (action & DEVICE_RESET) && ! 10870: (scb->flags & SCB_QUEUED_ABORT) ) ! 10871: { ! 10872: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10873: { ! 10874: printk(INFO_LEAD "Have already attempted to reach " ! 10875: "device with queued\n", p->host_no, CTL_OF_CMD(cmd)); ! 10876: printk(INFO_LEAD "message, will escalate to bus " ! 10877: "reset.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10878: } ! 10879: action = BUS_RESET; ! 10880: } ! 10881: if ( (action & DEVICE_RESET) && ! 10882: (p->flags & (AHC_RESET_PENDING | AHC_ABORT_PENDING)) ) ! 10883: { ! 10884: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10885: printk(INFO_LEAD "Bus device reset stupid when " ! 10886: "other action has failed.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10887: action = BUS_RESET; ! 10888: } ! 10889: if ( (action & BUS_RESET) && !(p->features & AHC_TWIN) ) ! 10890: { ! 10891: action = HOST_RESET; ! 10892: } ! 10893: if ( ((jiffies - p->dev_last_reset[tindex]) < (HZ * 3)) && ! 10894: !(action & (HOST_RESET | BUS_RESET))) ! 10895: { ! 10896: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10897: { ! 10898: printk(INFO_LEAD "Reset called too soon after last " ! 10899: "reset without requesting\n", p->host_no, CTL_OF_CMD(cmd)); ! 10900: printk(INFO_LEAD "bus or host reset, escalating.\n", p->host_no, ! 10901: CTL_OF_CMD(cmd)); ! 10902: } ! 10903: action = BUS_RESET; ! 10904: } ! 10905: if ( ((jiffies - p->last_reset) < (HZ * 3)) && ! 10906: (action & (HOST_RESET | BUS_RESET)) ) ! 10907: { ! 10908: if (aic7xxx_verbose & VERBOSE_RESET_PROCESS) ! 10909: printk(INFO_LEAD "Reset called too soon after " ! 10910: "last bus reset, delaying.\n", p->host_no, CTL_OF_CMD(cmd)); ! 10911: action = RESET_DELAY; ! 10912: } ! 10913: if ( (action & (BUS_RESET | HOST_RESET)) && (p->flags & AHC_IN_RESET) ! 10914: && ((jiffies - p->reset_start) > (2 * HZ * 3)) ) ! 10915: { ! 10916: printk(KERN_ERR "(scsi%d:%d:%d:%d) Yikes!! Card must have left to go " ! 10917: "back to Adaptec!!\n", p->host_no, CTL_OF_CMD(cmd)); ! 10918: unpause_sequencer(p, FALSE); ! 10919: DRIVER_UNLOCK ! 10920: return(SCSI_RESET_SNOOZE); ! 10921: } ! 10922: /* ! 10923: * By this point, we want to already know what we are going to do and ! 10924: * only have the following code implement our course of action. ! 10925: */ ! 10926: switch (action) ! 10927: { ! 10928: case RESET_DELAY: ! 10929: unpause_sequencer(p, FALSE); ! 10930: DRIVER_UNLOCK ! 10931: return(SCSI_RESET_PENDING); ! 10932: break; ! 10933: case FAIL: ! 10934: unpause_sequencer(p, FALSE); ! 10935: DRIVER_UNLOCK ! 10936: return(SCSI_RESET_ERROR); ! 10937: break; ! 10938: case DEVICE_RESET: ! 10939: p->flags |= AHC_IN_RESET; ! 10940: result = aic7xxx_bus_device_reset(p, cmd); ! 10941: aic7xxx_run_done_queue(p, TRUE); ! 10942: /* We can't rely on run_waiting_queues to unpause the sequencer for ! 10943: * PCI based controllers since we use AAP */ ! 10944: aic7xxx_run_waiting_queues(p); ! 10945: unpause_sequencer(p, FALSE); ! 10946: p->flags &= ~AHC_IN_RESET; ! 10947: DRIVER_UNLOCK ! 10948: return(result); ! 10949: break; ! 10950: case BUS_RESET: ! 10951: case HOST_RESET: ! 10952: default: ! 10953: p->reset_start = jiffies; ! 10954: p->flags |= AHC_IN_RESET; ! 10955: aic7xxx_reset_channel(p, cmd->channel, TRUE); ! 10956: if ( (p->features & AHC_TWIN) && (action & HOST_RESET) ) ! 10957: { ! 10958: aic7xxx_reset_channel(p, cmd->channel ^ 0x01, TRUE); ! 10959: restart_sequencer(p); ! 10960: } ! 10961: p->last_reset = jiffies; ! 10962: if (action != HOST_RESET) ! 10963: result = SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET; ! 10964: else ! 10965: { ! 10966: result = SCSI_RESET_SUCCESS | SCSI_RESET_HOST_RESET; ! 10967: aic_outb(p, aic_inb(p, SIMODE1) & ~(ENREQINIT|ENBUSFREE), ! 10968: SIMODE1); ! 10969: aic7xxx_clear_intstat(p); ! 10970: p->flags &= ~AHC_HANDLING_REQINITS; ! 10971: p->msg_type = MSG_TYPE_NONE; ! 10972: p->msg_index = 0; ! 10973: p->msg_len = 0; ! 10974: } ! 10975: aic7xxx_run_done_queue(p, TRUE); ! 10976: p->flags &= ~AHC_IN_RESET; ! 10977: /* We can't rely on run_waiting_queues to unpause the sequencer for ! 10978: * PCI based controllers since we use AAP */ ! 10979: aic7xxx_run_waiting_queues(p); ! 10980: unpause_sequencer(p, FALSE); ! 10981: DRIVER_UNLOCK ! 10982: return(result); ! 10983: break; ! 10984: } ! 10985: } ! 10986: ! 10987: /*+F************************************************************************* ! 10988: * Function: ! 10989: * aic7xxx_biosparam ! 10990: * ! 10991: * Description: ! 10992: * Return the disk geometry for the given SCSI device. ! 10993: *-F*************************************************************************/ ! 10994: int ! 10995: aic7xxx_biosparam(Disk *disk, kdev_t dev, int geom[]) ! 10996: { ! 10997: int heads, sectors, cylinders; ! 10998: struct aic7xxx_host *p; ! 10999: ! 11000: p = (struct aic7xxx_host *) disk->device->host->hostdata; ! 11001: ! 11002: /* ! 11003: * XXX - if I could portably find the card's configuration ! 11004: * information, then this could be autodetected instead ! 11005: * of left to a boot-time switch. ! 11006: */ ! 11007: heads = 64; ! 11008: sectors = 32; ! 11009: cylinders = disk->capacity / (heads * sectors); ! 11010: ! 11011: if ((p->flags & AHC_EXTEND_TRANS_A) && (cylinders > 1024)) ! 11012: { ! 11013: heads = 255; ! 11014: sectors = 63; ! 11015: cylinders = disk->capacity / (heads * sectors); ! 11016: } ! 11017: ! 11018: geom[0] = heads; ! 11019: geom[1] = sectors; ! 11020: geom[2] = cylinders; ! 11021: ! 11022: return (0); ! 11023: } ! 11024: ! 11025: /*+F************************************************************************* ! 11026: * Function: ! 11027: * aic7xxx_release ! 11028: * ! 11029: * Description: ! 11030: * Free the passed in Scsi_Host memory structures prior to unloading the ! 11031: * module. ! 11032: *-F*************************************************************************/ ! 11033: int ! 11034: aic7xxx_release(struct Scsi_Host *host) ! 11035: { ! 11036: struct aic7xxx_host *p = (struct aic7xxx_host *) host->hostdata; ! 11037: struct aic7xxx_host *next, *prev; ! 11038: ! 11039: if(p->irq) ! 11040: free_irq(p->irq, p); ! 11041: release_region(p->base, MAXREG - MINREG); ! 11042: #ifdef MMAPIO ! 11043: if(p->maddr) ! 11044: { ! 11045: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0) ! 11046: vfree((void *) (((unsigned long) p->maddr) & PAGE_MASK)); ! 11047: #else ! 11048: iounmap((void *) (((unsigned long) p->maddr) & PAGE_MASK)); ! 11049: #endif ! 11050: } ! 11051: #endif /* MMAPIO */ ! 11052: prev = NULL; ! 11053: next = first_aic7xxx; ! 11054: while(next != NULL) ! 11055: { ! 11056: if(next == p) ! 11057: { ! 11058: if(prev == NULL) ! 11059: first_aic7xxx = next->next; ! 11060: else ! 11061: prev->next = next->next; ! 11062: } ! 11063: else ! 11064: { ! 11065: prev = next; ! 11066: } ! 11067: next = next->next; ! 11068: } ! 11069: aic7xxx_free(p); ! 11070: return(0); ! 11071: } ! 11072: ! 11073: /*+F************************************************************************* ! 11074: * Function: ! 11075: * aic7xxx_print_card ! 11076: * ! 11077: * Description: ! 11078: * Print out all of the control registers on the card ! 11079: * ! 11080: * NOTE: This function is not yet safe for use on the VLB and EISA ! 11081: * controllers, so it isn't used on those controllers at all. ! 11082: *-F*************************************************************************/ ! 11083: static void ! 11084: aic7xxx_print_card(struct aic7xxx_host *p) ! 11085: { ! 11086: int i, j, k, chip; ! 11087: static struct register_ranges { ! 11088: int num_ranges; ! 11089: int range_val[32]; ! 11090: } cards_ds[] = { ! 11091: { 0, {0,} }, /* none */ ! 11092: {10, {0x00, 0x05, 0x08, 0x11, 0x18, 0x19, 0x1f, 0x1f, 0x60, 0x60, /*7771*/ ! 11093: 0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9b, 0x9f} }, ! 11094: { 9, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7850*/ ! 11095: 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} }, ! 11096: { 9, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7860*/ ! 11097: 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} }, ! 11098: {10, {0x00, 0x05, 0x08, 0x11, 0x18, 0x19, 0x1c, 0x1f, 0x60, 0x60, /*7870*/ ! 11099: 0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} }, ! 11100: {10, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1a, 0x1c, 0x1f, 0x60, 0x60, /*7880*/ ! 11101: 0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} }, ! 11102: {16, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7890*/ ! 11103: 0x84, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a, 0x9f, 0x9f, ! 11104: 0xe0, 0xf1, 0xf4, 0xf4, 0xf6, 0xf6, 0xf8, 0xf8, 0xfa, 0xfc, ! 11105: 0xfe, 0xff} }, ! 11106: {12, {0x00, 0x05, 0x08, 0x11, 0x18, 0x19, 0x1b, 0x1f, 0x60, 0x60, /*7895*/ ! 11107: 0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a, ! 11108: 0x9f, 0x9f, 0xe0, 0xf1} }, ! 11109: {16, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7896*/ ! 11110: 0x84, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a, 0x9f, 0x9f, ! 11111: 0xe0, 0xf1, 0xf4, 0xf4, 0xf6, 0xf6, 0xf8, 0xf8, 0xfa, 0xfc, ! 11112: 0xfe, 0xff} }, ! 11113: }; ! 11114: #ifdef CONFIG_PCI ! 11115: static struct register_ranges cards_ns[] = { ! 11116: { 0, {0,} }, /* none */ ! 11117: { 0, {0,} }, /* 7771 */ ! 11118: { 7, {0x04, 0x08, 0x0c, 0x0e, 0x10, 0x17, 0x28, 0x2b, 0x30, 0x33, ! 11119: 0x3c, 0x41, 0x43, 0x47} }, ! 11120: { 7, {0x04, 0x08, 0x0c, 0x0e, 0x10, 0x17, 0x28, 0x2b, 0x30, 0x33, ! 11121: 0x3c, 0x41, 0x43, 0x47} }, ! 11122: { 5, {0x04, 0x08, 0x0c, 0x0e, 0x10, 0x17, 0x30, 0x33, 0x3c, 0x41} }, ! 11123: { 5, {0x04, 0x08, 0x0c, 0x0e, 0x10, 0x17, 0x30, 0x34, 0x3c, 0x47} }, ! 11124: { 5, {0x04, 0x08, 0x0c, 0x1b, 0x30, 0x34, 0x3c, 0x43, 0xdc, 0xe3} }, ! 11125: { 6, {0x04, 0x08, 0x0c, 0x0e, 0x10, 0x17, 0x30, 0x34, 0x3c, 0x47, ! 11126: 0xdc, 0xe3} }, ! 11127: { 6, {0x04, 0x08, 0x0c, 0x1b, 0x30, 0x34, 0x3c, 0x43, 0xdc, 0xe3, ! 11128: 0xff, 0xff} } ! 11129: }; ! 11130: #endif ! 11131: chip = p->chip & AHC_CHIPID_MASK; ! 11132: /* ! 11133: * Let's run through the PCI space first.... ! 11134: */ ! 11135: printk("%s at ", ! 11136: board_names[p->board_name_index]); ! 11137: switch(p->chip & ~AHC_CHIPID_MASK) ! 11138: { ! 11139: case AHC_VL: ! 11140: printk("VLB Slot %d.\n", p->pci_device_fn); ! 11141: break; ! 11142: case AHC_EISA: ! 11143: printk("EISA Slot %d.\n", p->pci_device_fn); ! 11144: break; ! 11145: case AHC_PCI: ! 11146: default: ! 11147: printk("PCI %d/%d.\n", PCI_SLOT(p->pci_device_fn), ! 11148: PCI_FUNC(p->pci_device_fn)); ! 11149: break; ! 11150: } ! 11151: ! 11152: #ifdef CONFIG_PCI ! 11153: { ! 11154: unsigned char temp; ! 11155: ! 11156: printk("PCI Dump:\n"); ! 11157: k=0; ! 11158: for(i=0; i<cards_ns[chip].num_ranges; i++) ! 11159: { ! 11160: for(j = cards_ns[chip].range_val[ i * 2 ]; ! 11161: j <= cards_ns[chip].range_val[ i * 2 + 1 ] ; ! 11162: j++) ! 11163: { ! 11164: #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92) ! 11165: pci_read_config_byte(p->pdev, j, &temp); ! 11166: #else ! 11167: pcibios_read_config_byte(p->pci_bus, p->pci_device_fn, j, &temp); ! 11168: #endif ! 11169: printk("%02x:%02x ", j, temp); ! 11170: if(++k == 13) ! 11171: { ! 11172: printk("\n"); ! 11173: k = 0; ! 11174: } ! 11175: } ! 11176: } ! 11177: } ! 11178: if(k != 0) ! 11179: printk("\n"); ! 11180: #endif /* CONFIG_PCI */ ! 11181: ! 11182: /* ! 11183: * Now the registers on the card.... ! 11184: */ ! 11185: printk("Card Dump:\n"); ! 11186: k = 0; ! 11187: for(i=0; i<cards_ds[chip].num_ranges; i++) ! 11188: { ! 11189: for(j = cards_ds[chip].range_val[ i * 2 ]; ! 11190: j <= cards_ds[chip].range_val[ i * 2 + 1 ] ; ! 11191: j++) ! 11192: { ! 11193: printk("%02x:%02x ", j, aic_inb(p, j)); ! 11194: if(++k == 13) ! 11195: { ! 11196: printk("\n"); ! 11197: k=0; ! 11198: } ! 11199: } ! 11200: } ! 11201: if(k != 0) ! 11202: printk("\n"); ! 11203: if (p->flags & AHC_SEEPROM_FOUND) ! 11204: { ! 11205: unsigned short *sc1; ! 11206: sc1 = (unsigned short *)&p->sc; ! 11207: ! 11208: printk("SEEPROM dump.\n"); ! 11209: for(i=1; i<=32; i++) ! 11210: { ! 11211: printk("0x%04x", sc1[i-1]); ! 11212: if ( (i % 8) == 0 ) ! 11213: printk("\n"); ! 11214: else ! 11215: printk(" "); ! 11216: } ! 11217: } ! 11218: ! 11219: /* ! 11220: * If this was an Ultra2 controller, then we just hosed the card in terms ! 11221: * of the QUEUE REGS. This function is only called at init time or by ! 11222: * the panic_abort function, so it's safe to assume a generic init time ! 11223: * setting here ! 11224: */ ! 11225: ! 11226: if(p->features & AHC_QUEUE_REGS) ! 11227: { ! 11228: aic_outb(p, 0, SDSCB_QOFF); ! 11229: aic_outb(p, 0, SNSCB_QOFF); ! 11230: aic_outb(p, 0, HNSCB_QOFF); ! 11231: } ! 11232: ! 11233: } ! 11234: ! 11235: /*+F************************************************************************* ! 11236: * Function: ! 11237: * aic7xxx_print_scratch_ram ! 11238: * ! 11239: * Description: ! 11240: * Print out the scratch RAM values on the card. ! 11241: *-F*************************************************************************/ ! 11242: static void ! 11243: aic7xxx_print_scratch_ram(struct aic7xxx_host *p) ! 11244: { ! 11245: int i, k; ! 11246: ! 11247: k = 0; ! 11248: printk("Scratch RAM:\n"); ! 11249: for(i = SRAM_BASE; i < SEQCTL; i++) ! 11250: { ! 11251: printk("%02x:%02x ", i, aic_inb(p, i)); ! 11252: if(++k == 13) ! 11253: { ! 11254: printk("\n"); ! 11255: k=0; ! 11256: } ! 11257: } ! 11258: if (p->features & AHC_MORE_SRAM) ! 11259: { ! 11260: for(i = TARG_OFFSET; i < 0x80; i++) ! 11261: { ! 11262: printk("%02x:%02x ", i, aic_inb(p, i)); ! 11263: if(++k == 13) ! 11264: { ! 11265: printk("\n"); ! 11266: k=0; ! 11267: } ! 11268: } ! 11269: } ! 11270: printk("\n"); ! 11271: } ! 11272: ! 11273: ! 11274: #include "aic7xxx_proc.c" ! 11275: ! 11276: #ifdef MODULE ! 11277: /* Eventually this will go into an include file, but this will be later */ ! 11278: Scsi_Host_Template driver_template = AIC7XXX; ! 11279: ! 11280: #include "scsi_module.c" ! 11281: #endif ! 11282: ! 11283: /* ! 11284: * Overrides for Emacs so that we almost follow Linus's tabbing style. ! 11285: * Emacs will notice this stuff at the end of the file and automatically ! 11286: * adjust the settings for this buffer only. This must remain at the end ! 11287: * of the file. ! 11288: * --------------------------------------------------------------------------- ! 11289: * Local variables: ! 11290: * c-indent-level: 2 ! 11291: * c-brace-imaginary-offset: 0 ! 11292: * c-brace-offset: -2 ! 11293: * c-argdecl-indent: 2 ! 11294: * c-label-offset: -2 ! 11295: * c-continued-statement-offset: 2 ! 11296: * c-continued-brace-offset: 0 ! 11297: * indent-tabs-mode: nil ! 11298: * tab-width: 8 ! 11299: * End: ! 11300: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.