| blob | 812870cda72bf1185fbaf3e6da73efa304861fb3 |
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 (deischen@iworks.InterWorks.org):
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.119 1997/06/27 19:39:18 gibbs 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, deischen@iworks.InterWorks.org, 1/23/97
95 *
96 * $Id: aic7xxx.c,v 4.1 1997/06/12 08:23:42 deang Exp $
97 *-M*************************************************************************/
99 /*+M**************************************************************************
100 *
101 * Further driver modifications made by Doug Ledford <dledford@redhat.com>
102 *
103 * Copyright (c) 1997-1999 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*************************************************************************/
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 */
173 /*
174 * AIC7XXX_STRICT_PCI_SETUP
175 * Should we assume the PCI config options on our controllers are set with
176 * sane and proper values, or should we be anal about our PCI config
177 * registers and force them to what we want? The main advantage to
178 * defining this option is on non-Intel hardware where the BIOS may not
179 * have been run to set things up, or if you have one of the BIOSless
180 * Adaptec controllers, such as a 2910, that don't get set up by the
181 * BIOS. However, keep in mind that we really do set the most important
182 * items in the driver regardless of this setting, this only controls some
183 * of the more esoteric PCI options on these cards. In that sense, I
184 * would default to leaving this off. However, if people wish to try
185 * things both ways, that would also help me to know if there are some
186 * machines where it works one way but not another.
187 *
188 * -- July 7, 17:09
189 * OK...I need this on my machine for testing, so the default is to
190 * leave it defined.
191 *
192 * -- July 7, 18:49
193 * I needed it for testing, but it didn't make any difference, so back
194 * off she goes.
195 *
196 * -- July 16, 23:04
197 * I turned it back on to try and compensate for the 2.1.x PCI code
198 * which no longer relies solely on the BIOS and now tries to set
199 * things itself.
200 */
202 #define AIC7XXX_STRICT_PCI_SETUP
204 /*
205 * AIC7XXX_VERBOSE_DEBUGGING
206 * This option enables a lot of extra printk();s in the code, surrounded
207 * by if (aic7xxx_verbose ...) statements. Executing all of those if
208 * statements and the extra checks can get to where it actually does have
209 * an impact on CPU usage and such, as well as code size. Disabling this
210 * define will keep some of those from becoming part of the code.
211 *
212 * NOTE: Currently, this option has no real effect, I will be adding the
213 * various #ifdef's in the code later when I've decided a section is
214 * complete and no longer needs debugging. OK...a lot of things are now
215 * surrounded by this define, so turning this off does have an impact.
216 */
218 /*
219 * #define AIC7XXX_VERBOSE_DEBUGGING
220 */
222 #if defined(MODULE) || defined(PCMCIA)
223 #include <linux/module.h>
224 #endif
226 #if defined(PCMCIA)
227 # undef MODULE
228 #endif
230 #include <stdarg.h>
231 #include <asm/io.h>
232 #include <asm/irq.h>
233 #include <asm/byteorder.h>
234 #include <linux/version.h>
235 #include <linux/string.h>
236 #include <linux/errno.h>
237 #include <linux/kernel.h>
238 #include <linux/ioport.h>
239 #include <linux/delay.h>
240 #include <linux/sched.h>
241 #include <linux/pci.h>
242 #include <linux/proc_fs.h>
243 #include <linux/blk.h>
244 #include <linux/tqueue.h>
253 #include <scsi/scsicam.h>
255 #include <linux/stat.h>
260 /*
261 * To generate the correct addresses for the controller to issue
262 * on the bus. Originally added for DEC Alpha support.
263 */
264 #define VIRT_TO_BUS(a) (unsigned int)virt_to_bus((void *)(a))
270 };
274 #define NUMBER(arr) (sizeof(arr) / sizeof(arr[0]))
275 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
276 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
277 #define ALL_TARGETS -1
278 #define ALL_CHANNELS -1
279 #define ALL_LUNS -1
280 #define MAX_TARGETS 16
281 #define MAX_LUNS 8
282 #ifndef TRUE
283 # define TRUE 1
284 #endif
285 #ifndef FALSE
286 # define FALSE 0
287 #endif
289 #ifndef KERNEL_VERSION
290 # define KERNEL_VERSION(x,y,z) (((x)<<16)+((y)<<8)+(z))
291 #endif
293 /*
294 * We need the bios32.h file if we are kernel version 2.1.92 or less. The
295 * full set of pci_* changes wasn't in place until 2.1.93
296 */
298 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,1,92)
299 # if defined(__sparc_v9__) || defined(__powerpc__)
301 # endif
302 # include <linux/bios32.h>
303 #endif
305 #if defined(__powerpc__)
306 # define MMAPIO
307 # ifdef mb
308 # undef mb
309 # endif
310 # define mb() \
312 #elif defined(__i386__)
313 # define MMAPIO
314 # ifdef mb
315 # undef mb
316 # endif
317 # define mb() \
319 #elif defined(__alpha__)
320 # ifdef mb
321 # undef mb
322 # endif
323 # define mb() \
325 #endif
327 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,0)
328 # include <linux/spinlock.h>
329 # include <linux/smp.h>
330 # define cpuid smp_processor_id()
331 # if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
332 # define DRIVER_LOCK_INIT \
333 spin_lock_init(&p->spin_lock);
334 # define DRIVER_LOCK \
335 if(!p->cpu_lock_count[cpuid]) { \
336 spin_lock_irqsave(&p->spin_lock, cpu_flags); \
337 p->cpu_lock_count[cpuid]++; \
338 } else { \
339 p->cpu_lock_count[cpuid]++; \
340 }
341 # define DRIVER_UNLOCK \
342 if(--p->cpu_lock_count[cpuid] == 0) \
343 spin_unlock_irqrestore(&p->spin_lock, cpu_flags);
344 # else
345 # define DRIVER_LOCK_INIT
346 # define DRIVER_LOCK
347 # define DRIVER_UNLOCK
348 # endif
349 #else
350 # define cpuid 0
351 # define DRIVER_LOCK_INIT
352 # define DRIVER_LOCK \
353 save_flags(cpu_flags); \
354 cli();
355 # define DRIVER_UNLOCK \
356 restore_flags(cpu_flags);
357 # define le32_to_cpu(x) (x)
358 # define cpu_to_le32(x) (x)
359 #endif
361 /*
362 * You can try raising me if tagged queueing is enabled, or lowering
363 * me if you only have 4 SCBs.
364 */
365 #ifdef CONFIG_AIC7XXX_CMDS_PER_DEVICE
366 #define AIC7XXX_CMDS_PER_DEVICE CONFIG_AIC7XXX_CMDS_PER_DEVICE
367 #else
368 #define AIC7XXX_CMDS_PER_DEVICE 8
369 #endif
371 /* Set this to the delay in seconds after SCSI bus reset. */
372 #ifdef CONFIG_AIC7XXX_RESET_DELAY
373 #define AIC7XXX_RESET_DELAY CONFIG_AIC7XXX_RESET_DELAY
374 #else
375 #define AIC7XXX_RESET_DELAY 5
376 #endif
378 /*
379 * Control collection of SCSI transfer statistics for the /proc filesystem.
380 *
381 * NOTE: Do NOT enable this when running on kernels version 1.2.x and below.
382 * NOTE: This does affect performance since it has to maintain statistics.
383 */
384 #ifdef CONFIG_AIC7XXX_PROC_STATS
385 #define AIC7XXX_PROC_STATS
386 #endif
388 /*
389 * NOTE: Uncommenting the define below no longer has any effect, the
390 * tagged queue value array is always active now. I've added
391 * a setup option to set this particular array and I'm hoping
392 * insmod will be smart enough to set it properly as well. It's
393 * by use of this array that a person can enable tagged queueing.
394 * The DEFAULT_TAG_COMMANDS define has been changed to disable
395 * tagged queueing by default, so if your devices can handle tagged
396 * queueing you will need to add a line to their lilo.conf file like:
397 * append="aic7xxx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}"
398 * which will result in the first four devices on the first two
399 * controllers being set to a tagged queue depth of 32.
400 *
401 * Set this for defining the number of tagged commands on a device
402 * by device, and controller by controller basis. The first set
403 * of tagged commands will be used for the first detected aic7xxx
404 * controller, the second set will be used for the second detected
405 * aic7xxx controller, and so on. These values will *only* be used
406 * for targets that are tagged queueing capable; these values will
407 * be ignored in all other cases. The tag_commands is an array of
408 * 16 to allow for wide and twin adapters. Twin adapters will use
409 * indexes 0-7 for channel 0, and indexes 8-15 for channel 1.
410 *
411 * *** Determining commands per LUN ***
412 *
413 * When AIC7XXX_CMDS_PER_DEVICE is not defined, the driver will use its
414 * own algorithm to determine the commands/LUN. If SCB paging is
415 * enabled, which is always now, the default is 8 commands per lun
416 * that indicates it supports tagged queueing. All non-tagged devices
417 * use an internal queue depth of 3, with no more than one of those
418 * three commands active at one time.
419 */
420 /* #define AIC7XXX_TAGGED_QUEUEING_BY_DEVICE */
423 {
427 /*
428 * Make a define that will tell the driver not to use tagged queueing
429 * by default.
430 */
431 #ifdef CONFIG_AIC7XXX_TCQ_ON_BY_DEFAULT
432 #define DEFAULT_TAG_COMMANDS {0, 0, 0, 0, 0, 0, 0, 0,\
433 0, 0, 0, 0, 0, 0, 0, 0}
434 #else
435 #define DEFAULT_TAG_COMMANDS {255, 255, 255, 255, 255, 255, 255, 255,\
436 255, 255, 255, 255, 255, 255, 255, 255}
437 #endif
439 /*
440 * Modify this as you see fit for your system. By setting tag_commands
441 * to 0, the driver will use it's own algorithm for determining the
442 * number of commands to use (see above). When 255, the driver will
443 * not enable tagged queueing for that particular device. When positive
444 * (> 0) and (< 255) the values in the array are used for the queue_depth.
445 * Note that the maximum value for an entry is 254, but you're insane if
446 * you try to use that many commands on one device.
447 *
448 * In this example, the first line will disable tagged queueing for all
449 * the devices on the first probed aic7xxx adapter.
450 *
451 * The second line enables tagged queueing with 4 commands/LUN for IDs
452 * (1, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
453 * driver to use its own algorithm for ID 1.
454 *
455 * The third line is the same as the first line.
456 *
457 * The fourth line disables tagged queueing for devices 0 and 3. It
458 * enables tagged queueing for the other IDs, with 16 commands/LUN
459 * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
460 * IDs 2, 5-7, and 9-15.
461 */
463 /*
464 * NOTE: The below structure is for reference only, the actual structure
465 * to modify in order to change things is located around line
466 * number 1305
467 adapter_tag_info_t aic7xxx_tag_info[] =
468 {
469 {DEFAULT_TAG_COMMANDS},
470 {{4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 255, 4, 4, 4}},
471 {DEFAULT_TAG_COMMANDS},
472 {{255, 16, 4, 255, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
473 };
474 */
477 {
494 };
497 /*
498 * Define an array of board names that can be indexed by aha_type.
499 * Don't forget to change this when changing the types!
500 */
531 };
533 /*
534 * There should be a specific return value for this in scsi.h, but
535 * it seems that most drivers ignore it.
536 */
537 #define DID_UNDERFLOW DID_ERROR
539 /*
540 * What we want to do is have the higher level scsi driver requeue
541 * the command to us. There is no specific driver status for this
542 * condition, but the higher level scsi driver will requeue the
543 * command on a DID_BUS_BUSY error.
544 *
545 * Upon further inspection and testing, it seems that DID_BUS_BUSY
546 * will *always* retry the command. We can get into an infinite loop
547 * if this happens when we really want some sort of counter that
548 * will automatically abort/reset the command after so many retries.
549 * Using DID_ERROR will do just that. (Made by a suggestion by
550 * Doug Ledford 8/1/96)
551 */
552 #define DID_RETRY_COMMAND DID_ERROR
554 #define HSCSIID 0x07
555 #define SCSI_RESET 0x040
557 /*
558 * EISA/VL-bus stuff
559 */
560 #define MINSLOT 1
561 #define MAXSLOT 15
562 #define SLOTBASE(x) ((x) << 12)
563 #define BASE_TO_SLOT(x) ((x) >> 12)
565 /*
566 * Standard EISA Host ID regs (Offset from slot base)
567 */
573 /*
574 * AIC-7770 I/O range to reserve for a card
575 */
576 #define MINREG 0xC00
577 #define MAXREG 0xCBF
581 /*
582 * AIC-78X0 PCI registers
583 */
584 #define CLASS_PROGIF_REVID 0x08
585 #define DEVREVID 0x000000FFul
586 #define PROGINFC 0x0000FF00ul
587 #define SUBCLASS 0x00FF0000ul
588 #define BASECLASS 0xFF000000ul
590 #define CSIZE_LATTIME 0x0C
592 #define LATTIME 0x0000FF00ul
594 #define DEVCONFIG 0x40
598 #define RAMPSM_ULTRA2 0x00000004
599 #define VOLSENSE 0x00000100ul
600 #define SCBRAMSEL 0x00000080ul
601 #define SCBRAMSEL_ULTRA2 0x00000008
602 #define MRDCEN 0x00000040ul
605 #define BERREN 0x00000008ul
606 #define DACEN 0x00000004ul
607 #define STPWLEVEL 0x00000002ul
613 /*
614 * Define the different types of SEEPROMs on aic7xxx adapters
615 * and make it also represent the address size used in accessing
616 * its registers. The 93C46 chips have 1024 bits organized into
617 * 64 16-bit words, while the 93C56 chips have 2048 bits organized
618 * into 128 16-bit words. The C46 chips use 6 bits to address
619 * each word, while the C56 and C66 (4096 bits) use 8 bits to
620 * address each word.
621 */
624 /*
625 *
626 * Define the format of the SEEPROM registers (16 bits).
627 *
628 */
631 /*
632 * SCSI ID Configuration Flags
633 */
646 /* UNUSED 0x3000 */
649 /*
650 * BIOS Control Bits
651 */
655 /* UNUSED 0x0008 */
658 /* UNUSED 0x0040 */
660 /* UNUSED 0xFF00 */
663 /*
664 * Host Adapter Control Bits
665 */
678 /* UNUSED 0xF280 */
681 /*
682 * Bus Release, Host Adapter ID
683 */
685 /* UNUSED 0x00F0 */
689 /*
690 * Maximum targets
691 */
693 /* UNUSED 0xFF00 */
698 };
700 #define SELBUS_MASK 0x0a
701 #define SELNARROW 0x00
702 #define SELBUSB 0x08
703 #define SINGLE_BUS 0x00
705 #define SCB_TARGET(scb) \
706 (((scb)->hscb->target_channel_lun & TID) >> 4)
707 #define SCB_LUN(scb) \
708 ((scb)->hscb->target_channel_lun & LID)
709 #define SCB_IS_SCSIBUS_B(scb) \
710 (((scb)->hscb->target_channel_lun & SELBUSB) != 0)
712 /*
713 * If an error occurs during a data transfer phase, run the command
714 * to completion - it's easier that way - making a note of the error
715 * condition in this location. This then will modify a DID_OK status
716 * into an appropriate error for the higher-level SCSI code.
717 */
718 #define aic7xxx_error(cmd) ((cmd)->SCp.Status)
720 /*
721 * Keep track of the targets returned status.
722 */
723 #define aic7xxx_status(cmd) ((cmd)->SCp.sent_command)
725 /*
726 * The position of the SCSI commands scb within the scb array.
727 */
728 #define aic7xxx_position(cmd) ((cmd)->SCp.have_data_in)
730 /*
731 * So we can keep track of our host structs
732 */
735 /*
736 * As of Linux 2.1, the mid-level SCSI code uses virtual addresses
737 * in the scatter-gather lists. We need to convert the virtual
738 * addresses to physical addresses.
739 */
743 };
745 /*
746 * Maximum number of SG segments these cards can support.
747 */
748 #define AIC7XXX_MAX_SG 128
750 /*
751 * The maximum number of SCBs we could have for ANY type
752 * of card. DON'T FORGET TO CHANGE THE SCB MASK IN THE
753 * SEQUENCER CODE IF THIS IS MODIFIED!
754 */
755 #define AIC7XXX_MAXSCB 255
759 /* ------------ Begin hardware supported fields ---------------- */
772 * Also used as the tag for tagged I/O
773 */
775 * via PIO to initialize a transaction.
776 */
778 * or disconnected down in the sequencer.
779 */
782 * Unused by the kernel, but we require
783 * the padding so that the array of
784 * hardware SCBs is alligned on 32 byte
785 * boundaries so the sequencer can index
786 */
787 };
803 SCB_MSGOUT_SENT |
804 SCB_MSGOUT_SDTR |
805 SCB_MSGOUT_WDTR,
828 /*
829 * Here ends the FreeBSD defined flags and here begins the linux defined
830 * flags. NOTE: I did not preserve the old flag name during this change
831 * specifically to force me to evaluate what flags were being used properly
832 * and what flags weren't. This way, I could clean up the flag usage on
833 * a use by use basis. Doug Ledford
834 */
844 #define AHC_IN_ISR_BIT 28
903 * Allocate 6 characters for
904 * sense command.
905 */
907 * don't have to calculate anything
908 * during underflow/overflow/stat code
909 */
911 };
913 /*
914 * Define a linked list of SCBs.
915 */
933 };
935 static unsigned char
940 * SCBs assigned to free slot on
941 * card (no paging required)
942 */
954 };
956 #define AHC_TRANS_CUR 0x0001
957 #define AHC_TRANS_ACTIVE 0x0002
958 #define AHC_TRANS_GOAL 0x0004
959 #define AHC_TRANS_USER 0x0008
960 #define AHC_TRANS_QUITE 0x0010
976 /*
977 * Define a structure used for each host adapter. Note, in order to avoid
978 * problems with architectures I can't test on (because I don't have one,
979 * such as the Alpha based systems) which happen to give faults for
980 * non-aligned memory accesses, care was taken to align this structure
981 * in a way that gauranteed all accesses larger than 8 bits were aligned
982 * on the appropriate boundary. It's also organized to try and be more
983 * cache line efficient. Be careful when changing this lest you might hurt
984 * overall performance and bring down the wrath of the masses.
985 */
987 /*
988 * This is the first 64 bytes in the host struct
989 */
991 /*
992 * We are grouping things here....first, items that get either read or
993 * written with nearly every interrupt
994 */
1012 /*
1013 * Things read/written on nearly every entry into aic7xxx_queue()
1014 */
1026 #define DEVICE_PRESENT 0x01
1027 #define BUS_DEVICE_RESET_PENDING 0x02
1028 #define DEVICE_RESET_DELAY 0x04
1029 #define DEVICE_PRINT_DTR 0x08
1030 #define DEVICE_PARITY_ERROR 0x10
1031 #define DEVICE_WAS_BUSY 0x20
1032 #define DEVICE_SCSI_3 0x40
1033 #define DEVICE_SCANNED 0x80
1043 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,0)
1044 spinlock_t spin_lock;
1046 #endif
1062 #define MSG_TYPE_NONE 0x00
1063 #define MSG_TYPE_INITIATOR_MSGOUT 0x01
1064 #define MSG_TYPE_INITIATOR_MSGIN 0x02
1070 /*
1071 * We put the less frequently used host structure items after the more
1072 * frequently used items to try and ease the burden on the cache subsystem.
1073 * These entries are not *commonly* accessed, whereas the preceding entries
1074 * are accessed very often. The only exceptions are the qinfifo, qoutfifo,
1075 * and untagged_scbs array. But, they are often accessed only once and each
1076 * access into these arrays is likely to blow a cache line, so they are put
1077 * down here so we can minimize the number of cache lines required to hold
1078 * the preceeding entries.
1079 */
1096 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
1098 #endif
1110 /*
1111 * Statistics Kept:
1112 *
1113 * Total Xfers (count for each command that has a data xfer),
1114 * broken down further by reads && writes.
1115 *
1116 * Binned sizes, writes && reads:
1117 * < 512, 512, 1-2K, 2-4K, 4-8K, 8-16K, 16-32K, 32-64K, 64K-128K, > 128K
1118 *
1119 * Total amounts read/written above 512 bytes (amts under ignored)
1120 *
1121 * NOTE: Enabling this feature is likely to cause a noticeable performance
1122 * decrease as the accesses into the stats structures blows apart multiple
1123 * cache lines and is CPU time consuming.
1124 *
1125 * NOTE: Since it doesn't really buy us much, but consumes *tons* of RAM
1126 * and blows apart all sorts of cache lines, I modified this so that we
1127 * no longer look at the LUN. All LUNs now go into the same bin on each
1128 * device for stats purposes.
1129 */
1133 #ifdef AIC7XXX_PROC_STATS
1139 #if 0
1142 #endif
1144 };
1146 /*
1147 * Valid SCSIRATE values. (p. 3-17)
1148 * Provides a mapping of transfer periods in ns/4 to the proper value to
1149 * stick in the SCSIRATE reg to use that transfer rate.
1150 */
1151 #define AHC_SYNCRATE_ULTRA3 0
1152 #define AHC_SYNCRATE_ULTRA2 1
1153 #define AHC_SYNCRATE_ULTRA 3
1154 #define AHC_SYNCRATE_FAST 6
1155 #define AHC_SYNCRATE_CRC 0x40
1156 #define AHC_SYNCRATE_SE 0x10
1158 /* Rates in Ultra mode have bit 8 of sxfr set */
1159 #define ULTRA_SXFR 0x100
1180 };
1182 #define CTL_OF_SCB(scb) (((scb->hscb)->target_channel_lun >> 3) & 0x1), \
1183 (((scb->hscb)->target_channel_lun >> 4) & 0xf), \
1184 ((scb->hscb)->target_channel_lun & 0x07)
1186 #define CTL_OF_CMD(cmd) ((cmd->channel) & 0x01), \
1187 ((cmd->target) & 0x0f), \
1188 ((cmd->lun) & 0x07)
1190 #define TARGET_INDEX(cmd) ((cmd)->target | ((cmd)->channel << 3))
1192 /*
1193 * A nice little define to make doing our printks a little easier
1194 */
1199 /*
1200 * XXX - these options apply unilaterally to _all_ 274x/284x/294x
1201 * cards in the system. This should be fixed. Exceptions to this
1202 * rule are noted in the comments.
1203 */
1206 /*
1207 * Skip the scsi bus reset. Non 0 make us skip the reset at startup. This
1208 * has no effect on any later resets that might occur due to things like
1209 * SCSI bus timeouts.
1210 */
1212 /*
1213 * Certain PCI motherboards will scan PCI devices from highest to lowest,
1214 * others scan from lowest to highest, and they tend to do all kinds of
1215 * strange things when they come into contact with PCI bridge chips. The
1216 * net result of all this is that the PCI card that is actually used to boot
1217 * the machine is very hard to detect. Most motherboards go from lowest
1218 * PCI slot number to highest, and the first SCSI controller found is the
1219 * one you boot from. The only exceptions to this are when a controller
1220 * has its BIOS disabled. So, we by default sort all of our SCSI controllers
1221 * from lowest PCI slot number to highest PCI slot number. We also force
1222 * all controllers with their BIOS disabled to the end of the list. This
1223 * works on *almost* all computers. Where it doesn't work, we have this
1224 * option. Setting this option to non-0 will reverse the order of the sort
1225 * to highest first, then lowest, but will still leave cards with their BIOS
1226 * disabled at the very end. That should fix everyone up unless there are
1227 * really strange cirumstances.
1228 */
1230 /*
1231 * Should we force EXTENDED translation on a controller.
1232 * 0 == Use whatever is in the SEEPROM or default to off
1233 * 1 == Use whatever is in the SEEPROM or default to on
1234 */
1236 /*
1237 * The IRQ trigger method used on EISA controllers. Does not effect PCI cards.
1238 * -1 = Use detected settings.
1239 * 0 = Force Edge triggered mode.
1240 * 1 = Force Level triggered mode.
1241 */
1243 /*
1244 * This variable is used to override the termination settings on a controller.
1245 * This should not be used under normal conditions. However, in the case
1246 * that a controller does not have a readable SEEPROM (so that we can't
1247 * read the SEEPROM settings directly) and that a controller has a buggered
1248 * version of the cable detection logic, this can be used to force the
1249 * correct termination. It is preferable to use the manual termination
1250 * settings in the BIOS if possible, but some motherboard controllers store
1251 * those settings in a format we can't read. In other cases, auto term
1252 * should also work, but the chipset was put together with no auto term
1253 * logic (common on motherboard controllers). In those cases, we have
1254 * 32 bits here to work with. That's good for 8 controllers/channels. The
1255 * bits are organized as 4 bits per channel, with scsi0 getting the lowest
1256 * 4 bits in the int. A 1 in a bit position indicates the termination setting
1257 * that corresponds to that bit should be enabled, a 0 is disabled.
1258 * It looks something like this:
1259 *
1260 * 0x0f = 1111-Single Ended Low Byte Termination on/off
1261 * ||\-Single Ended High Byte Termination on/off
1262 * |\-LVD Low Byte Termination on/off
1263 * \-LVD High Byte Termination on/off
1264 *
1265 * For non-Ultra2 controllers, the upper 2 bits are not important. So, to
1266 * enable both high byte and low byte termination on scsi0, I would need to
1267 * make sure that the override_term variable was set to 0x03 (bits 0011).
1268 * To make sure that all termination is enabled on an Ultra2 controller at
1269 * scsi2 and only high byte termination on scsi1 and high and low byte
1270 * termination on scsi0, I would set override_term=0xf23 (bits 1111 0010 0011)
1271 *
1272 * For the most part, users should never have to use this, that's why I
1273 * left it fairly cryptic instead of easy to understand. If you need it,
1274 * most likely someone will be telling you what your's needs to be set to.
1275 */
1277 /*
1278 * Certain motherboard chipset controllers tend to screw
1279 * up the polarity of the term enable output pin. Use this variable
1280 * to force the correct polarity for your system. This is a bitfield variable
1281 * similar to the previous one, but this one has one bit per channel instead
1282 * of four.
1283 * 0 = Force the setting to active low.
1284 * 1 = Force setting to active high.
1285 * Most Adaptec cards are active high, several motherboards are active low.
1286 * To force a 2940 card at SCSI 0 to active high and a motherboard 7895
1287 * controller at scsi1 and scsi2 to active low, and a 2910 card at scsi3
1288 * to active high, you would need to set stpwlev=0x9 (bits 1001).
1289 *
1290 * People shouldn't need to use this, but if you are experiencing lots of
1291 * SCSI timeout problems, this may help. There is one sure way to test what
1292 * this option needs to be. Using a boot floppy to boot the system, configure
1293 * your system to enable all SCSI termination (in the Adaptec SCSI BIOS) and
1294 * if needed then also pass a value to override_term to make sure that the
1295 * driver is enabling SCSI termination, then set this variable to either 0
1296 * or 1. When the driver boots, make sure there are *NO* SCSI cables
1297 * connected to your controller. If it finds and inits the controller
1298 * without problem, then the setting you passed to stpwlev was correct. If
1299 * the driver goes into a reset loop and hangs the system, then you need the
1300 * other setting for this variable. If neither setting lets the machine
1301 * boot then you have definite termination problems that may not be fixable.
1302 */
1304 /*
1305 * Set this to non-0 in order to force the driver to panic the kernel
1306 * and print out debugging info on a SCSI abort or reset cycle.
1307 */
1309 /*
1310 * PCI bus parity checking of the Adaptec controllers. This is somewhat
1311 * dubious at best. To my knowledge, this option has never actually
1312 * solved a PCI parity problem, but on certain machines with broken PCI
1313 * chipset configurations, it can generate tons of false error messages.
1314 * It's included in the driver for completeness.
1315 * 0 = Shut off PCI parity check
1316 * -1 = Normal polarity pci parity checking
1317 * 1 = reverse polarity pci parity checking
1318 *
1319 * NOTE: you can't actually pass -1 on the lilo prompt. So, to set this
1320 * variable to -1 you would actually want to simply pass the variable
1321 * name without a number. That will invert the 0 which will result in
1322 * -1.
1323 */
1325 /*
1326 * Set this to any non-0 value to cause us to dump the contents of all
1327 * the card's registers in a hex dump format tailored to each model of
1328 * controller.
1329 *
1330 * NOTE: THE CONTROLLER IS LEFT IN AN UNUSEABLE STATE BY THIS OPTION.
1331 * YOU CANNOT BOOT UP WITH THIS OPTION, IT IS FOR DEBUGGING PURPOSES
1332 * ONLY
1333 */
1335 /*
1336 * Set this to a non-0 value to make us dump out the 32 bit instruction
1337 * registers on the card after completing the sequencer download. This
1338 * allows the actual sequencer download to be verified. It is possible
1339 * to use this option and still boot up and run your system. This is
1340 * only intended for debugging purposes.
1341 */
1343 /*
1344 * Certain newer motherboards have put new PCI based devices into the
1345 * IO spaces that used to typically be occupied by VLB or EISA cards.
1346 * This overlap can cause these newer motherboards to lock up when scanned
1347 * for older EISA and VLB devices. Setting this option to non-0 will
1348 * cause the driver to skip scanning for any VLB or EISA controllers and
1349 * only support the PCI controllers. NOTE: this means that if the kernel
1350 * os compiled with PCI support disabled, then setting this to non-0
1351 * would result in never finding any devices :)
1352 */
1355 /*
1356 * So that insmod can find the variable and make it point to something
1357 */
1358 #ifdef MODULE
1360 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,18)
1362 #endif
1364 /*
1365 * Just in case someone uses commas to separate items on the insmod
1366 * command line, we define a dummy buffer here to avoid having insmod
1367 * write wild stuff into our code segment
1368 */
1371 #endif
1373 #define VERBOSE_NORMAL 0x0000
1374 #define VERBOSE_NEGOTIATION 0x0001
1375 #define VERBOSE_SEQINT 0x0002
1376 #define VERBOSE_SCSIINT 0x0004
1377 #define VERBOSE_PROBE 0x0008
1378 #define VERBOSE_PROBE2 0x0010
1379 #define VERBOSE_NEGOTIATION2 0x0020
1380 #define VERBOSE_MINOR_ERROR 0x0040
1381 #define VERBOSE_TRACING 0x0080
1382 #define VERBOSE_ABORT 0x0f00
1383 #define VERBOSE_ABORT_MID 0x0100
1384 #define VERBOSE_ABORT_FIND 0x0200
1385 #define VERBOSE_ABORT_PROCESS 0x0400
1386 #define VERBOSE_ABORT_RETURN 0x0800
1387 #define VERBOSE_RESET 0xf000
1388 #define VERBOSE_RESET_MID 0x1000
1389 #define VERBOSE_RESET_FIND 0x2000
1390 #define VERBOSE_RESET_PROCESS 0x4000
1391 #define VERBOSE_RESET_RETURN 0x8000
1396 /****************************************************************************
1397 *
1398 * We're going to start putting in function declarations so that order of
1399 * functions is no longer important. As needed, they are added here.
1400 *
1401 ***************************************************************************/
1407 #ifdef AIC7XXX_VERBOSE_DEBUGGING
1409 #endif
1411 /****************************************************************************
1412 *
1413 * These functions are now used. They happen to be wrapped in useless
1414 * inb/outb port read/writes around the real reads and writes because it
1415 * seems that certain very fast CPUs have a problem dealing with us when
1416 * going at full speed.
1417 *
1418 ***************************************************************************/
1420 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
1423 {
1428 }
1432 {
1434 }
1438 {
1440 }
1442 #define PCI_DEVICE_ID_ADAPTEC_1480A 0x6075
1444 #endif
1448 {
1449 #ifdef MMAPIO
1452 {
1454 }
1455 else
1456 {
1458 }
1461 #else
1463 #endif
1464 }
1468 {
1469 #ifdef MMAPIO
1471 {
1473 }
1474 else
1475 {
1477 }
1479 #else
1481 #endif
1482 }
1484 /*+F*************************************************************************
1485 * Function:
1486 * aic7xxx_setup
1487 *
1488 * Description:
1489 * Handle Linux boot parameters. This routine allows for assigning a value
1490 * to a parameter with a ':' between the parameter and the value.
1491 * ie. aic7xxx=unpause:0x0A,extended
1492 *-F*************************************************************************/
1493 void
1495 {
1517 };
1522 {
1524 {
1527 {
1529 {
1531 {
1544 {
1546 {
1552 tok++;
1559 tok++;
1566 device++;
1568 instance++;
1572 tok++;
1574 {
1576 }
1585 {
1588 {
1591 }
1592 }
1600 }
1601 }
1604 }
1605 }
1607 {
1609 }
1611 {
1613 }
1614 else
1615 {
1617 }
1618 }
1619 }
1620 }
1621 }
1623 /*+F*************************************************************************
1624 * Function:
1625 * pause_sequencer
1626 *
1627 * Description:
1628 * Pause the sequencer and wait for it to actually stop - this
1629 * is important since the sequencer can disable pausing for critical
1630 * sections.
1631 *-F*************************************************************************/
1634 {
1637 {
1638 ;
1639 }
1640 }
1642 /*+F*************************************************************************
1643 * Function:
1644 * unpause_sequencer
1645 *
1646 * Description:
1647 * Unpause the sequencer. Unremarkable, yet done often enough to
1648 * warrant an easy way to do it.
1649 *-F*************************************************************************/
1652 {
1656 {
1658 }
1659 }
1661 /*+F*************************************************************************
1662 * Function:
1663 * restart_sequencer
1664 *
1665 * Description:
1666 * Restart the sequencer program from address zero. This assumes
1667 * that the sequencer is already paused.
1668 *-F*************************************************************************/
1671 {
1675 }
1677 /*
1678 * We include the aic7xxx_seq.c file here so that the other defines have
1679 * already been made, and so that it comes before the code that actually
1680 * downloads the instructions (since we don't typically use function
1681 * prototype, our code has to be ordered that way, it's a left-over from
1682 * the original driver days.....I should fix it some time DL).
1683 */
1686 /*+F*************************************************************************
1687 * Function:
1688 * aic7xxx_check_patch
1689 *
1690 * Description:
1691 * See if the next patch to download should be downloaded.
1692 *-F*************************************************************************/
1693 static int
1696 {
1706 {
1708 {
1709 /*
1710 * Start rejecting code.
1711 */
1714 }
1715 else
1716 {
1717 /*
1718 * Found an OK patch. Advance the patch pointer to the next patch
1719 * and wait for our instruction pointer to get here.
1720 */
1721 cur_patch++;
1722 }
1723 }
1727 /*
1728 * Still skipping
1729 */
1732 }
1735 /*+F*************************************************************************
1736 * Function:
1737 * aic7xxx_download_instr
1738 *
1739 * Description:
1740 * Find the next patch to download.
1741 *-F*************************************************************************/
1742 static void
1745 {
1758 /* Pull the opcode */
1761 {
1770 {
1784 {
1787 {
1793 }
1794 else
1795 {
1796 i++;
1797 }
1798 }
1801 /* Fall Through to the next code section */
1802 }
1810 {
1812 }
1814 /* Fall Through to the next code section */
1817 {
1820 /* Calculate odd parity for the instruction */
1822 {
1827 count++;
1828 }
1831 }
1832 else
1833 {
1835 {
1840 }
1841 else
1842 {
1848 }
1849 }
1860 }
1861 }
1864 /*+F*************************************************************************
1865 * Function:
1866 * aic7xxx_loadseq
1867 *
1868 * Description:
1869 * Load the sequencer code into the controller memory.
1870 *-F*************************************************************************/
1871 static void
1873 {
1881 {
1883 }
1884 #if 0
1886 #endif
1897 {
1899 {
1900 /* Skip this instruction for this configuration. */
1902 }
1904 downloaded++;
1905 }
1915 {
1917 }
1920 }
1922 /*+F*************************************************************************
1923 * Function:
1924 * aic7xxx_print_sequencer
1925 *
1926 * Description:
1927 * Print the contents of the sequencer memory to the screen.
1928 *-F*************************************************************************/
1929 static void
1931 {
1940 {
1949 {
1952 }
1953 else
1955 }
1964 }
1966 /*+F*************************************************************************
1967 * Function:
1968 * aic7xxx_delay
1969 *
1970 * Description:
1971 * Delay for specified amount of time. We use mdelay because the timer
1972 * interrupt is not guaranteed to be enabled. This will cause an
1973 * infinite loop since jiffies (clock ticks) is not updated.
1974 *-F*************************************************************************/
1975 static void
1977 {
1979 }
1981 /*+F*************************************************************************
1982 * Function:
1983 * aic7xxx_info
1984 *
1985 * Description:
1986 * Return a string describing the driver.
1987 *-F*************************************************************************/
1990 {
2008 }
2010 /*+F*************************************************************************
2011 * Function:
2012 * aic7xxx_find_syncrate
2013 *
2014 * Description:
2015 * Look up the valid period to SCSIRATE conversion in our table
2016 *-F*************************************************************************/
2020 {
2025 {
2029 {
2032 }
2037 {
2040 }
2041 else
2042 {
2043 /*
2044 * we don't support the Quick Arbitration variants of dual edge
2045 * clocking. As it turns out, we want to send back the
2046 * same basic option, but without the QA attribute.
2047 * We know that we are responding because we would never set
2048 * these options ourself, we would only respond to them.
2049 */
2051 {
2058 }
2059 }
2065 }
2069 {
2071 {
2073 {
2077 {
2079 /*
2080 * oops, we went too low for the CRC/DualEdge signalling, so
2081 * clear the options byte
2082 */
2084 /*
2085 * We'll be sending a reply to this packet to set the options
2086 * properly, so unilaterally set the period as well.
2087 */
2089 }
2090 else
2091 {
2094 {
2096 }
2097 }
2101 {
2104 {
2106 }
2107 }
2109 }
2111 {
2113 }
2114 }
2115 syncrate++;
2116 }
2119 {
2120 /*
2121 * Use async transfers for this target
2122 */
2126 }
2128 }
2131 /*+F*************************************************************************
2132 * Function:
2133 * aic7xxx_find_period
2134 *
2135 * Description:
2136 * Look up the valid SCSIRATE to period conversion in our table
2137 *-F*************************************************************************/
2138 static unsigned int
2141 {
2145 {
2147 }
2148 else
2149 {
2151 }
2155 {
2157 {
2164 }
2166 {
2168 }
2169 syncrate++;
2170 }
2172 }
2174 /*+F*************************************************************************
2175 * Function:
2176 * aic7xxx_validate_offset
2177 *
2178 * Description:
2179 * Set a valid offset value for a particular card in use and transfer
2180 * settings in use.
2181 *-F*************************************************************************/
2182 static void
2185 {
2188 /* Limit offset to what the card (and device) can do */
2190 {
2192 }
2194 {
2196 }
2197 else
2198 {
2201 else
2203 }
2205 }
2207 /*+F*************************************************************************
2208 * Function:
2209 * aic7xxx_set_syncrate
2210 *
2211 * Description:
2212 * Set the actual syncrate down in the card and in our host structs
2213 *-F*************************************************************************/
2214 static void
2218 {
2229 {
2232 }
2240 {
2245 {
2248 {
2250 {
2252 /*
2253 * mask off the CRC bit in the xfer settings
2254 */
2260 }
2261 }
2263 {
2265 }
2267 }
2269 {
2273 {
2275 {
2277 }
2280 }
2282 {
2290 }
2293 }
2295 {
2297 }
2305 {
2307 {
2313 }
2314 else
2315 {
2318 }
2320 }
2321 }
2324 {
2328 }
2331 {
2335 }
2336 }
2338 /*+F*************************************************************************
2339 * Function:
2340 * aic7xxx_set_width
2341 *
2342 * Description:
2343 * Set the actual width down in the card and in our host structs
2344 *-F*************************************************************************/
2345 static void
2348 {
2359 {
2378 {
2381 }
2382 }
2390 {
2392 {
2394 }
2396 {
2398 }
2399 else
2400 {
2402 }
2403 }
2404 }
2406 /*+F*************************************************************************
2407 * Function:
2408 * scbq_init
2409 *
2410 * Description:
2411 * SCB queue initialization.
2412 *
2413 *-F*************************************************************************/
2414 static void
2416 {
2419 }
2421 /*+F*************************************************************************
2422 * Function:
2423 * scbq_insert_head
2424 *
2425 * Description:
2426 * Add an SCB to the head of the list.
2427 *
2428 *-F*************************************************************************/
2431 {
2432 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2434 #endif
2436 DRIVER_LOCK
2441 DRIVER_UNLOCK
2442 }
2444 /*+F*************************************************************************
2445 * Function:
2446 * scbq_remove_head
2447 *
2448 * Description:
2449 * Remove an SCB from the head of the list.
2450 *
2451 *-F*************************************************************************/
2454 {
2456 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2458 #endif
2460 DRIVER_LOCK
2466 DRIVER_UNLOCK
2468 }
2470 /*+F*************************************************************************
2471 * Function:
2472 * scbq_remove
2473 *
2474 * Description:
2475 * Removes an SCB from the list.
2476 *
2477 *-F*************************************************************************/
2480 {
2481 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2483 #endif
2485 DRIVER_LOCK
2487 {
2488 /* At beginning of queue, remove from head. */
2490 }
2491 else
2492 {
2495 /*
2496 * Search until the next scb is the one we're looking for, or
2497 * we run out of queue.
2498 */
2500 {
2502 }
2504 {
2505 /* Found it. */
2508 {
2509 /* Update the tail when removing the tail. */
2511 }
2512 }
2513 }
2514 DRIVER_UNLOCK
2515 }
2517 /*+F*************************************************************************
2518 * Function:
2519 * scbq_insert_tail
2520 *
2521 * Description:
2522 * Add an SCB at the tail of the list.
2523 *
2524 *-F*************************************************************************/
2527 {
2528 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2530 #endif
2532 DRIVER_LOCK
2539 DRIVER_UNLOCK
2540 }
2542 /*+F*************************************************************************
2543 * Function:
2544 * aic7xxx_match_scb
2545 *
2546 * Description:
2547 * Checks to see if an scb matches the target/channel as specified.
2548 * If target is ALL_TARGETS (-1), then we're looking for any device
2549 * on the specified channel; this happens when a channel is going
2550 * to be reset and all devices on that channel must be aborted.
2551 *-F*************************************************************************/
2552 static int
2555 {
2570 }
2572 /*+F*************************************************************************
2573 * Function:
2574 * aic7xxx_add_curscb_to_free_list
2575 *
2576 * Description:
2577 * Adds the current scb (in SCBPTR) to the list of free SCBs.
2578 *-F*************************************************************************/
2579 static void
2581 {
2582 /*
2583 * Invalidate the tag so that aic7xxx_find_scb doesn't think
2584 * it's active
2585 */
2591 }
2593 /*+F*************************************************************************
2594 * Function:
2595 * aic7xxx_rem_scb_from_disc_list
2596 *
2597 * Description:
2598 * Removes the current SCB from the disconnected list and adds it
2599 * to the free list.
2600 *-F*************************************************************************/
2601 static unsigned char
2604 {
2612 {
2615 }
2616 else
2617 {
2619 }
2622 }
2624 /*+F*************************************************************************
2625 * Function:
2626 * aic7xxx_busy_target
2627 *
2628 * Description:
2629 * Set the specified target busy.
2630 *-F*************************************************************************/
2633 {
2635 }
2637 /*+F*************************************************************************
2638 * Function:
2639 * aic7xxx_index_busy_target
2640 *
2641 * Description:
2642 * Returns the index of the busy target, and optionally sets the
2643 * target inactive.
2644 *-F*************************************************************************/
2648 {
2653 {
2655 }
2657 }
2659 /*+F*************************************************************************
2660 * Function:
2661 * aic7xxx_find_scb
2662 *
2663 * Description:
2664 * Look through the SCB array of the card and attempt to find the
2665 * hardware SCB that corresponds to the passed in SCB. Return
2666 * SCB_LIST_NULL if unsuccessful. This routine assumes that the
2667 * card is already paused.
2668 *-F*************************************************************************/
2669 static unsigned char
2671 {
2678 {
2681 {
2683 }
2684 }
2687 {
2689 }
2692 }
2694 /*+F*************************************************************************
2695 * Function:
2696 * aic7xxx_allocate_scb
2697 *
2698 * Description:
2699 * Get an SCB from the free list or by allocating a new one.
2700 *-F*************************************************************************/
2701 static int
2703 {
2716 {
2717 /*
2718 * Calculate the optimal number of SCBs to allocate.
2719 *
2720 * NOTE: This formula works because the sizeof(sg_array) is always
2721 * 1024. Therefore, scb_size * i would always be > PAGE_SIZE *
2722 * (i/step). The (i-1) allows the left hand side of the equation
2723 * to grow into the right hand side to a point of near perfect
2724 * efficiency since scb_size * (i -1) is growing slightly faster
2725 * than the right hand side. If the number of SG array elements
2726 * is changed, this function may not be near so efficient any more.
2727 */
2729 {
2731 {
2734 }
2735 }
2739 {
2740 #ifdef AIC7XXX_VERBOSE_DEBUGGING
2742 {
2746 else
2749 }
2750 #endif
2757 {
2763 /*
2764 * Place in the scb array; never is removed
2765 */
2768 }
2770 }
2771 else
2772 {
2774 }
2775 }
2777 }
2779 /*+F*************************************************************************
2780 * Function:
2781 * aic7xxx_queue_cmd_complete
2782 *
2783 * Description:
2784 * Due to race conditions present in the SCSI subsystem, it is easier
2785 * to queue completed commands, then call scsi_done() on them when
2786 * we're finished. This function queues the completed commands.
2787 *-F*************************************************************************/
2788 static void
2790 {
2793 }
2795 /*+F*************************************************************************
2796 * Function:
2797 * aic7xxx_done_cmds_complete
2798 *
2799 * Description:
2800 * Process the completed command queue.
2801 *-F*************************************************************************/
2802 static void
2804 {
2806 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2808 #endif
2810 DRIVER_LOCK
2812 {
2817 }
2818 DRIVER_UNLOCK
2819 }
2821 /*+F*************************************************************************
2822 * Function:
2823 * aic7xxx_free_scb
2824 *
2825 * Description:
2826 * Free the scb and insert into the free scb list.
2827 *-F*************************************************************************/
2828 static void
2830 {
2842 }
2844 /*+F*************************************************************************
2845 * Function:
2846 * aic7xxx_done
2847 *
2848 * Description:
2849 * Calls the higher level scsi done function and frees the scb.
2850 *-F*************************************************************************/
2851 static void
2853 {
2860 {
2862 }
2864 {
2866 }
2868 {
2870 }
2872 {
2874 {
2879 {
2884 }
2885 else
2886 {
2888 }
2889 #define WIDE_INQUIRY_BITS 0x60
2890 #define SYNC_INQUIRY_BITS 0x10
2891 #define SCSI_VERSION_BITS 0x07
2894 {
2898 }
2899 else
2900 {
2906 AHC_TRANS_GOAL |
2907 AHC_TRANS_CUR) );
2909 }
2911 {
2918 {
2923 else
2925 }
2926 }
2927 else
2928 {
2934 }
2936 {
2938 /*
2939 * OK, we are a SCSI 3 device and we are in need of negotiation.
2940 * Use PPR messages instead of WDTR and SDTR messages.
2941 */
2944 {
2947 }
2952 }
2953 /*
2954 * Get the INQUIRY checksum. We use this on Ultra 160/m
2955 * and older devices both. It allows us to drop speed on any bus type
2956 * while at the same time giving us the needed domain validation for
2957 * Ultra 160/m
2958 *
2959 * Note: We only get the checksum and set the SCANNED bit if this is
2960 * one of our dtr commands. If we don't do this, then we end up
2961 * getting bad checksum results on the mid-level SCSI code's INQUIRY
2962 * commands.
2963 */
2971 {
2973 }
2977 }
2978 #undef WIDE_INQUIRY_BITS
2979 #undef SYNC_INQUIRY_BITS
2980 #undef SCSI_VERSION_BITS
2981 }
2982 }
2984 {
2990 /*
2991 * Check to see if we get an invalid message or a message error
2992 * after failing to negotiate a wide or sync transfer message.
2993 */
2997 {
2999 }
3002 {
3005 {
3008 {
3015 }
3018 }
3019 }
3021 {
3024 {
3027 {
3035 }
3038 }
3039 }
3041 {
3044 {
3047 {
3054 }
3055 /*
3056 * Disable PPR negotiation and revert back to WDTR and SDTR setup
3057 */
3064 }
3065 }
3066 }
3069 {
3072 {
3074 {
3075 /*
3076 * Give extra preference to untagged devices, such as CD-R devices
3077 * This makes it more likely that a drive *won't* stuff up while
3078 * waiting on data at a critical time, such as CD-R writing and
3079 * audio CD ripping operations. Should also benefit tape drives.
3080 */
3082 }
3083 else
3084 {
3086 }
3087 #ifdef AIC7XXX_VERBOSE_DEBUGGING
3091 #endif
3093 {
3097 }
3098 }
3099 }
3101 {
3103 }
3107 {
3110 /*
3111 * XXX: we should actually know how much actually transferred
3112 * XXX: for each command, but apparently that's too difficult.
3113 *
3114 * We set a lower limit of 512 bytes on the transfer length. We
3115 * ignore anything less than this because we don't have a real
3116 * reason to count it. Read/Writes to tapes are usually about 20K
3117 * and disks are a minimum of 512 bytes unless you want to count
3118 * non-read/write commands (such as TEST_UNIT_READY) which we don't
3119 */
3122 {
3124 #ifdef AIC7XXX_PROC_STATS
3131 /*
3132 * For block devices, cmd->request.cmd is always == either READ or
3133 * WRITE. For character devices, this isn't always set properly, so
3134 * we check data_cmnd[0]. This catches the conditions for st.c, but
3135 * I'm still not sure if request.cmd is valid for sg devices.
3136 */
3139 {
3141 #ifdef AIC7XXX_VERBOSE_DEBUGGING
3144 #endif
3145 #ifdef AIC7XXX_PROC_STATS
3148 }
3149 else
3150 {
3152 #ifdef AIC7XXX_VERBOSE_DEBUGGING
3155 #endif
3156 #ifdef AIC7XXX_PROC_STATS
3159 }
3160 #ifdef AIC7XXX_PROC_STATS
3163 {
3165 x++;
3166 }
3168 {
3170 }
3172 {
3174 }
3175 else
3176 {
3178 }
3180 }
3181 }
3185 }
3187 /*+F*************************************************************************
3188 * Function:
3189 * aic7xxx_run_done_queue
3190 *
3191 * Description:
3192 * Calls the aic7xxx_done() for the Scsi_Cmnd of each scb in the
3193 * aborted list, and adds each scb to the free list. If complete
3194 * is TRUE, we also process the commands complete list.
3195 *-F*************************************************************************/
3196 static void
3198 {
3203 {
3206 {
3210 found++;
3212 }
3213 }
3215 {
3218 }
3220 {
3222 }
3223 }
3225 /*+F*************************************************************************
3226 * Function:
3227 * aic7xxx_abort_waiting_scb
3228 *
3229 * Description:
3230 * Manipulate the waiting for selection list and return the
3231 * scb that follows the one that we remove.
3232 *-F*************************************************************************/
3233 static unsigned char
3236 {
3239 /*
3240 * Select the SCB we want to abort and pull the next pointer out of it.
3241 */
3248 /*
3249 * Update the waiting list
3250 */
3252 {
3253 /*
3254 * First in the list
3255 */
3257 }
3258 else
3259 {
3260 /*
3261 * Select the scb that pointed to us and update its next pointer.
3262 */
3265 }
3266 /*
3267 * Point us back at the original scb position and inform the SCSI
3268 * system that the command has been aborted.
3269 */
3272 }
3274 /*+F*************************************************************************
3275 * Function:
3276 * aic7xxx_search_qinfifo
3277 *
3278 * Description:
3279 * Search the queue-in FIFO for matching SCBs and conditionally
3280 * requeue. Returns the number of matching SCBs.
3281 *-F*************************************************************************/
3282 static int
3286 {
3298 {
3301 {
3302 /*
3303 * We found an scb that needs to be removed.
3304 */
3306 {
3308 {
3314 }
3320 {
3322 TRUE);
3323 }
3324 }
3326 {
3328 }
3329 else
3330 {
3331 /*
3332 * Preserve any SCB_RECOVERY_SCB flags on this scb then set the
3333 * flags we were called with, presumeably so aic7xxx_run_done_queue
3334 * can find this scb
3335 */
3339 {
3341 TRUE);
3342 }
3343 }
3344 found++;
3345 }
3346 else
3347 {
3349 }
3350 }
3351 /*
3352 * Now that we've done the work, clear out any left over commands in the
3353 * qinfifo and update the KERNEL_QINPOS down on the card.
3354 *
3355 * NOTE: This routine expect the sequencer to already be paused when
3356 * it is run....make sure it's that way!
3357 */
3360 {
3362 }
3365 else
3369 }
3371 /*+F*************************************************************************
3372 * Function:
3373 * aic7xxx_scb_on_qoutfifo
3374 *
3375 * Description:
3376 * Is the scb that was passed to us currently on the qoutfifo?
3377 *-F*************************************************************************/
3378 static int
3380 {
3384 {
3387 else
3388 i++;
3389 }
3391 }
3394 /*+F*************************************************************************
3395 * Function:
3396 * aic7xxx_reset_device
3397 *
3398 * Description:
3399 * The device at the given target/channel has been reset. Abort
3400 * all active and queued scbs for that target/channel. This function
3401 * need not worry about linked next pointers because if was a MSG_ABORT_TAG
3402 * then we had a tagged command (no linked next), if it was MSG_ABORT or
3403 * MSG_BUS_DEV_RESET then the device won't know about any commands any more
3404 * and no busy commands will exist, and if it was a bus reset, then nothing
3405 * knows about any linked next commands any more. In all cases, we don't
3406 * need to worry about the linked next or busy scb, we just need to clear
3407 * them.
3408 *-F*************************************************************************/
3409 static void
3412 {
3417 /*
3418 * Restore this when we're done
3419 */
3425 /*
3426 * Deal with the busy target and linked next issues.
3427 */
3428 {
3432 /* Make all targets 'relative' to bus A. */
3434 {
3436 {
3450 }
3451 }
3452 else
3453 {
3456 }
3460 {
3462 {
3464 }
3470 {
3478 }
3480 {
3483 else
3488 }
3493 {
3497 {
3504 }
3506 {
3509 {
3512 }
3515 }
3516 }
3518 {
3523 }
3526 {
3531 }
3532 }
3533 }
3540 /*
3541 * Search the waiting_scbs queue for matches, this catches any SCB_QUEUED
3542 * ABORT/RESET commands.
3543 */
3547 {
3554 {
3558 {
3565 }
3567 {
3570 {
3573 }
3576 }
3577 }
3579 {
3584 }
3585 }
3588 /*
3589 * Search waiting for selection list.
3590 */
3594 {
3601 {
3605 {
3606 /*
3607 * No aic7xxx_verbose check here.....we want to see this since it
3608 * means either the kernel driver or the sequencer screwed things up
3609 */
3615 }
3616 else
3617 {
3620 {
3623 {
3626 }
3630 {
3631 /*
3632 * This is either the first scb on the waiting list, or we
3633 * have already yanked the first and haven't left any behind.
3634 * Either way, we need to turn off the selection hardware if
3635 * it isn't already off.
3636 */
3639 }
3640 }
3641 else
3642 {
3645 }
3646 }
3647 }
3649 {
3653 }
3654 }
3656 /*
3657 * Go through disconnected list and remove any entries we have queued
3658 * for completion, zeroing their control byte too.
3659 */
3664 {
3671 {
3675 {
3680 }
3681 else
3682 {
3685 {
3688 {
3691 }
3695 }
3696 else
3697 {
3700 }
3701 }
3702 }
3704 {
3708 }
3709 }
3711 /*
3712 * Walk the free list making sure no entries on the free list have
3713 * a valid SCB_TAG value or SCB_CONTROL byte.
3714 */
3716 {
3722 {
3727 }
3729 {
3732 {
3737 }
3738 else
3739 {
3743 }
3744 }
3746 {
3750 }
3751 }
3753 /*
3754 * Go through the hardware SCB array looking for commands that
3755 * were active but not on any list.
3756 */
3758 {
3762 }
3764 {
3769 {
3774 }
3775 else
3776 {
3779 {
3782 {
3786 }
3787 }
3788 }
3789 }
3791 /*
3792 * Go through the entire SCB array now and look for commands for
3793 * for this target that are stillactive. These are other (most likely
3794 * tagged) commands that were disconnected when the reset occurred.
3795 * Any commands we find here we know this about, it wasn't on any queue,
3796 * it wasn't in the qinfifo, it wasn't in the disconnected or waiting
3797 * lists, so it really must have been a paged out SCB. In that case,
3798 * we shouldn't need to bother with updating any counters, just mark
3799 * the correct flags and go on.
3800 */
3802 {
3807 {
3809 {
3814 }
3817 }
3818 }
3821 }
3824 /*+F*************************************************************************
3825 * Function:
3826 * aic7xxx_clear_intstat
3827 *
3828 * Description:
3829 * Clears the interrupt status.
3830 *-F*************************************************************************/
3831 static void
3833 {
3834 /* Clear any interrupt conditions this may have caused. */
3839 }
3841 /*+F*************************************************************************
3842 * Function:
3843 * aic7xxx_reset_current_bus
3844 *
3845 * Description:
3846 * Reset the current SCSI bus.
3847 *-F*************************************************************************/
3848 static void
3850 {
3852 /* Disable reset interrupts. */
3855 /* Turn off the bus' current operations, after all, we shouldn't have any
3856 * valid commands left to cause a RSELI and SELO once we've tossed the
3857 * bus away with this reset, so we might as well shut down the sequencer
3858 * until the bus is restarted as oppossed to saving the current settings
3859 * and restoring them (which makes no sense to me). */
3861 /* Turn on the bus reset. */
3868 /* Turn off the bus reset. */
3873 /* Re-enable reset interrupts. */
3876 }
3878 /*+F*************************************************************************
3879 * Function:
3880 * aic7xxx_reset_channel
3881 *
3882 * Description:
3883 * Reset the channel.
3884 *-F*************************************************************************/
3885 static void
3887 {
3898 {
3903 }
3904 else
3905 {
3907 {
3908 /* Channel A */
3913 }
3914 else
3915 {
3922 {
3924 }
3925 else
3926 {
3928 }
3929 }
3930 }
3933 {
3934 /*
3935 * Revert to async/narrow transfers until we renegotiate.
3936 */
3939 {
3941 }
3942 offset_min++;
3943 }
3945 /*
3946 * Reset the bus and unpause/restart the controller
3947 */
3951 else
3954 {
3955 /*
3956 * Case 1: Command for another bus is active
3957 */
3961 /*
3962 * Stealthily reset the other bus without upsetting the current bus.
3963 */
3967 {
3969 }
3973 }
3974 else
3975 {
3976 /*
3977 * Case 2: A command from this bus is active or we're idle.
3978 */
3983 SIMODE1);
3988 {
3990 }
3993 }
3996 /*
3997 * Clean up all the state information for the pending transactions
3998 * on this bus.
3999 */
4003 {
4005 }
4008 }
4010 /*+F*************************************************************************
4011 * Function:
4012 * aic7xxx_run_waiting_queues
4013 *
4014 * Description:
4015 * Scan the awaiting_scbs queue downloading and starting as many
4016 * scbs as we can.
4017 *-F*************************************************************************/
4018 static void
4020 {
4024 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
4026 #endif
4034 /*
4035 * First handle SCBs that are waiting but have been assigned a slot.
4036 */
4037 DRIVER_LOCK
4039 {
4042 {
4044 }
4049 {
4051 }
4052 else
4053 {
4058 {
4060 }
4062 sent++;
4063 }
4064 }
4066 {
4069 else
4070 {
4074 }
4077 }
4078 DRIVER_UNLOCK
4079 }
4081 #ifdef CONFIG_PCI
4083 #define DPE 0x80
4084 #define SSE 0x40
4085 #define RMA 0x20
4086 #define RTA 0x10
4087 #define STA 0x08
4088 #define DPR 0x01
4090 /*+F*************************************************************************
4091 * Function:
4092 * aic7xxx_pci_intr
4093 *
4094 * Description:
4095 * Check the scsi card for PCI errors and clear the interrupt
4096 *
4097 * NOTE: If you don't have this function and a 2940 card encounters
4098 * a PCI error condition, the machine will end up locked as the
4099 * interrupt handler gets slammed with non-stop PCI error interrupts
4100 *-F*************************************************************************/
4101 static void
4103 {
4106 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
4108 #else
4111 #endif
4132 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
4134 #else
4137 #endif
4144 }
4147 /*+F*************************************************************************
4148 * Function:
4149 * aic7xxx_timer
4150 *
4151 * Description:
4152 * Take expired extries off of delayed queues and place on waiting queue
4153 * then run waiting queue to start commands.
4154 ***************************************************************************/
4155 static void
4157 {
4162 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
4163 DRIVER_LOCK
4164 #else
4166 #endif
4170 {
4173 }
4175 {
4179 {
4186 {
4188 }
4190 {
4195 /*
4196 * Well, things are screwed now, wait for a reset to clean the junk
4197 * out.
4198 */
4199 }
4200 }
4202 {
4204 {
4206 {
4208 }
4209 }
4210 else
4211 {
4214 }
4215 }
4216 }
4218 {
4220 }
4223 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
4224 DRIVER_UNLOCK
4225 #else
4227 #endif
4228 }
4230 /*+F*************************************************************************
4231 * Function:
4232 * aic7xxx_construct_ppr
4233 *
4234 * Description:
4235 * Build up a Parallel Protocol Request message for use with SCSI-3
4236 * devices.
4237 *-F*************************************************************************/
4238 static void
4240 {
4252 }
4254 /*+F*************************************************************************
4255 * Function:
4256 * aic7xxx_construct_sdtr
4257 *
4258 * Description:
4259 * Constucts a synchronous data transfer message in the message
4260 * buffer on the sequencer.
4261 *-F*************************************************************************/
4262 static void
4265 {
4272 }
4274 /*+F*************************************************************************
4275 * Function:
4276 * aic7xxx_construct_wdtr
4277 *
4278 * Description:
4279 * Constucts a wide data transfer message in the message buffer
4280 * on the sequencer.
4281 *-F*************************************************************************/
4282 static void
4284 {
4290 }
4292 /*+F*************************************************************************
4293 * Function:
4294 * aic7xxx_calc_residual
4295 *
4296 * Description:
4297 * Calculate the residual data not yet transferred.
4298 *-F*************************************************************************/
4299 static void
4301 {
4309 /*
4310 * Don't destroy valid residual information with
4311 * residual coming from a check sense operation.
4312 */
4315 {
4316 /*
4317 * We had an underflow. At this time, there's only
4318 * one other driver that bothers to check for this,
4319 * and cmd->underflow seems to be set rather half-
4320 * heartedly in the higher-level SCSI code.
4321 */
4324 {
4326 }
4332 {
4340 }
4341 }
4343 /*
4344 * Clean out the residual information in the SCB for the
4345 * next consumer.
4346 */
4351 }
4353 /*+F*************************************************************************
4354 * Function:
4355 * aic7xxx_handle_device_reset
4356 *
4357 * Description:
4358 * Interrupt handler for sequencer interrupts (SEQINT).
4359 *-F*************************************************************************/
4360 static void
4362 {
4369 /*
4370 * Go back to async/narrow transfers and renegotiate.
4371 */
4384 }
4386 /*+F*************************************************************************
4387 * Function:
4388 * aic7xxx_handle_seqint
4389 *
4390 * Description:
4391 * Interrupt handler for sequencer interrupts (SEQINT).
4392 *-F*************************************************************************/
4393 static void
4395 {
4405 else
4411 /*
4412 * Go ahead and clear the SEQINT now, that avoids any interrupt race
4413 * conditions later on in case we enable some other interrupt.
4414 */
4417 {
4419 {
4421 SCSISEQ);
4430 }
4434 {
4439 }
4443 {
4444 /*
4445 * The reconnecting target either did not send an identify
4446 * message, or did, but we didn't find an SCB to match and
4447 * before it could respond to our ATN/abort, it hit a dataphase.
4448 * The only safe thing to do is to blow it away with a bus
4449 * reset.
4450 */
4459 }
4464 {
4469 }
4470 else
4471 {
4475 }
4479 {
4484 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4488 #endif
4490 /*
4491 * To actually receive the message, simply turn on
4492 * REQINIT interrupts and let our interrupt handler
4493 * do the rest (REQINIT should already be true).
4494 */
4498 /*
4499 * We don't want the sequencer unpaused yet so we return early
4500 */
4502 }
4505 {
4506 /*
4507 * What we care about here is if we had an outstanding SDTR
4508 * or WDTR message for this target. If we did, this is a
4509 * signal that the target is refusing negotiation.
4510 */
4521 {
4523 {
4524 /*
4525 * OK...the device seems able to accept tagged commands, but
4526 * not ordered tag commands, only simple tag commands. So, we
4527 * disable ordered tag commands and go on with life just like
4528 * normal.
4529 */
4535 /*
4536 * OK..we set the tag type to simple tag command, now we re-assert
4537 * ATNO and hope this will take us into the identify phase again
4538 * so we can resend the tag type and info to the device.
4539 */
4542 }
4544 {
4548 /*
4549 * Hmmmm....the device is flaking out on tagged commands. The
4550 * bad thing is that we already have tagged commands enabled in
4551 * the device struct in the mid level code. We also have a queue
4552 * set according to the tagged queue depth. Gonna have to live
4553 * with it by controlling our queue depth internally and making
4554 * sure we don't set the tagged command flag any more.
4555 */
4560 /*
4561 * We set this command up as a bus device reset. However, we have
4562 * to clear the tag type as it's causing us problems. We shouldnt
4563 * have to worry about any other commands being active, since if
4564 * the device is refusing tagged commands, this should be the
4565 * first tagged command sent to the device, however, we do have
4566 * to worry about any other tagged commands that may already be
4567 * in the qinfifo. The easiest way to do this, is to issue a BDR,
4568 * send all the commands back to the mid level code, then let them
4569 * come back and get rebuilt as untagged commands.
4570 */
4578 {
4581 {
4583 {
4585 reset++;
4586 }
4588 }
4589 }
4591 /*
4592 * Wait until after the for loop to set the busy index since
4593 * aic7xxx_reset_device will clear the busy index during its
4594 * operation.
4595 */
4601 }
4602 }
4604 {
4605 /*
4606 * As per the draft specs, any device capable of supporting any of
4607 * the option values other than 0 are not allowed to reject the
4608 * PPR message. Instead, they must negotiate out what they do
4609 * support instead of rejecting our offering.
4610 */
4621 {
4624 }
4626 {
4631 }
4633 {
4637 {
4640 }
4641 }
4643 {
4646 }
4647 }
4649 {
4650 /*
4651 * note 8bit xfers and clear flag
4652 */
4662 {
4665 }
4667 }
4669 {
4670 /*
4671 * note asynch xfers and clear flag
4672 */
4680 {
4683 }
4684 }
4686 {
4687 /*
4688 * Otherwise, we ignore it.
4689 */
4692 }
4693 }
4697 {
4702 /* The sequencer will notify us when a command has an error that
4703 * would be of interest to the kernel. This allows us to leave
4704 * the sequencer running in the common case of command completes
4705 * without error. The sequencer will have DMA'd the SCB back
4706 * up to us, so we can reference the drivers SCB array.
4707 *
4708 * Set the default return value to 0 indicating not to send
4709 * sense. The sense code will change this if needed and this
4710 * reduces code duplication.
4711 */
4715 {
4719 }
4724 {
4728 }
4729 else
4730 {
4738 {
4748 {
4749 /*
4750 * XXX - How do we save the residual (if there is one).
4751 */
4755 /*
4756 * Send a sense command to the requesting target.
4757 * XXX - revisit this and get rid of the memcopys.
4758 */
4770 /*
4771 * XXX - We should allow disconnection, but can't as it
4772 * might allow overlapped tagged commands.
4773 */
4774 /* hscb->control &= DISCENB; */
4792 /*
4793 * This problem could be caused if the target has lost power
4794 * or found some other way to loose the negotiation settings,
4795 * so if needed, we'll re-negotiate while doing the sense cmd.
4796 * However, if this SCB already was attempting to negotiate,
4797 * then we assume this isn't the problem and skip this part.
4798 */
4802 {
4806 }
4808 {
4809 /*
4810 * This is already a negotiation command, so we must have
4811 * already done PPR, WDTR or SDTR. Since our negotiation
4812 * could have gotten rejected, we don't really know the
4813 * full state of things. Don't do anything here, and allow
4814 * the negotiation_complete() handler to do the right
4815 * thing.
4816 */
4818 /*
4819 * This is the important part though. We are getting sense
4820 * info back from this device. It's going into a fake
4821 * command. We need to put that into the real command
4822 * instead so that the mid level SCSI code can act upon it.
4823 * So, when we set up these fake commands, the next pointer
4824 * is used to point to the real command. Use that to change
4825 * the address of our sense_buffer[] to the real command.
4826 * However, don't do this if the real command is also a
4827 * TEST_UNIT_READY as it will most likely pull down its own
4828 * SENSE information anyway.
4829 */
4831 {
4835 }
4836 }
4838 /*
4839 * Ensure the target is busy since this will be an
4840 * an untagged request.
4841 */
4842 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4844 {
4849 else
4852 }
4853 #endif
4866 {
4869 /*
4870 * We have to look three places for queued commands:
4871 * 1: QINFIFO
4872 * 2: p->waiting_scbs queue
4873 * 3: WAITING_SCBS list on card (for commands that are started
4874 * but haven't yet made it to the device)
4875 */
4881 {
4885 SCB_LIST_NULL) )
4886 {
4889 prev_scbp);
4890 }
4891 }
4897 {
4901 {
4904 SCB_LIST_NULL) )
4905 {
4907 {
4912 }
4914 next_scbp);
4923 {
4924 /* We were first on the list,
4925 * so we kill the selection
4926 * hardware. Let the sequencer
4927 * re-init the hardware itself
4928 */
4932 }
4933 else
4934 {
4937 }
4938 }
4939 else
4940 {
4943 }
4945 }
4948 {
4953 }
4960 {
4963 {
4965 }
4966 else
4967 {
4969 }
4971 {
4975 }
4978 {
4982 }
4983 }
4984 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4987 {
4993 else
4996 }
4997 #endif
4999 {
5002 {
5006 }
5007 else
5008 {
5010 }
5013 {
5023 }
5025 {
5027 {
5032 }
5037 }
5038 else
5039 {
5043 }
5044 }
5046 }
5053 {
5055 }
5059 }
5063 {
5070 /*
5071 * This SCB had a MK_MESSAGE set in its control byte informing
5072 * the sequencer that we wanted to send a special message to
5073 * this target.
5074 */
5079 {
5083 }
5086 {
5092 }
5094 {
5096 {
5098 }
5099 else
5100 {
5102 }
5107 }
5109 {
5114 {
5117 {
5121 MSG_EXT_WDTR_BUS_16_BIT) &&
5123 {
5125 }
5126 else
5127 {
5129 }
5130 }
5131 else
5132 {
5134 }
5135 }
5137 {
5139 }
5140 else
5141 {
5143 }
5149 {
5154 }
5156 }
5158 {
5160 {
5163 }
5165 }
5167 {
5170 /*
5171 * Now that the device is selected, use the bits in SBLKCTL and
5172 * SSTAT2 to determine the max sync rate for this device.
5173 */
5175 {
5178 {
5180 }
5181 else
5182 {
5184 }
5185 }
5187 {
5189 }
5190 else
5191 {
5193 }
5197 {
5202 }
5205 }
5206 else
5207 {
5211 }
5212 /*
5213 * We've set everything up to send our message, now to actually do
5214 * so we need to enable reqinit interrupts and let the interrupt
5215 * handler do the rest. We don't want to unpause the sequencer yet
5216 * though so we'll return early. We also have to make sure that
5217 * we clear the SEQINT *BEFORE* we set the REQINIT handler active
5218 * or else it's possible on VLB cards to loose the first REQINIT
5219 * interrupt. Edge triggered EISA cards could also loose this
5220 * interrupt, although PCI and level triggered cards should not
5221 * have this problem since they continually interrupt the kernel
5222 * until we take care of the situation.
5223 */
5230 }
5234 {
5240 /*
5241 * XXX - What do we really want to do on an overrun? The
5242 * mid-level SCSI code should handle this, but for now,
5243 * we'll just indicate that the command should retried.
5244 * If we retrieved sense info on this target, then the
5245 * base SENSE info should have been saved prior to the
5246 * overrun error. In that case, we return DID_OK and let
5247 * the mid level code pick up on the sense info. Otherwise
5248 * we return DID_ERROR so the command will get retried.
5249 */
5251 {
5259 {
5261 i,
5264 }
5266 }
5267 else
5270 }
5273 #if AIC7XXX_NOT_YET
5275 {
5278 }
5282 {
5285 }
5288 /* XXX Fill these in later */
5295 #endif
5302 }
5304 /*
5305 * Clear the sequencer interrupt and unpause the sequencer.
5306 */
5308 }
5310 /*+F*************************************************************************
5311 * Function:
5312 * aic7xxx_parse_msg
5313 *
5314 * Description:
5315 * Parses incoming messages into actions on behalf of
5316 * aic7xxx_handle_reqinit
5317 *_F*************************************************************************/
5318 static int
5320 {
5334 /*
5335 * Parse as much of the message as is availible,
5336 * rejecting it if we don't support it. When
5337 * the entire message is availible and has been
5338 * handled, return TRUE indicating that we have
5339 * parsed an entire message.
5340 */
5343 {
5345 }
5347 /*
5348 * Just accept the length byte outright and perform
5349 * more checking once we know the message type.
5350 */
5353 {
5355 {
5357 {
5363 {
5366 }
5369 {
5371 }
5377 /*
5378 * Even if we are an Ultra3 card, don't allow Ultra3 sync rates when
5379 * using the SDTR messages. We need the PPR messages to enable the
5380 * higher speeds that include things like Dual Edge clocking.
5381 */
5383 {
5386 {
5388 }
5389 else
5390 {
5392 }
5393 }
5395 {
5397 }
5398 else
5399 {
5401 }
5402 /*
5403 * We might have a device that is starting negotiation with us
5404 * before we can start up negotiation with it....be prepared to
5405 * have a device ask for a higher speed then we want to give it
5406 * in that case
5407 */
5410 {
5414 {
5415 /*
5416 * Not only is the device starting this up, but it also hasn't
5417 * been scanned yet, so this would likely be our TUR or our
5418 * INQUIRY command at scan time, so we need to use the
5419 * settings from the SEEPROM if they existed. Of course, even
5420 * if we didn't find a SEEPROM, we stuffed default values into
5421 * the user settings anyway, so use those in all cases.
5422 */
5426 {
5428 }
5430 {
5432 }
5433 else
5434 {
5436 }
5438 }
5440 {
5443 }
5448 }
5456 /*
5457 * Did we drop to async? Or are we sending a reply? If we are,
5458 * then we have to make sure that the reply value reflects the proper
5459 * settings so we need to set the goal values according to what
5460 * we need to send.
5461 */
5465 {
5468 }
5470 /*
5471 * Did we start this, if not, or if we went to low and had to
5472 * go async, then send an SDTR back to the target
5473 */
5479 {
5486 }
5489 }
5491 {
5495 {
5498 }
5501 {
5503 }
5508 {
5510 {
5512 {
5517 {
5520 }
5523 {
5527 }
5529 {
5531 }
5532 }
5535 }
5536 else
5537 {
5539 {
5540 /*
5541 * Well, we now know the WDTR and SYNC caps of this device since
5542 * it contacted us first, mark it as such and copy the user stuff
5543 * over to the goal stuff.
5544 */
5548 {
5550 {
5552 }
5556 {
5558 }
5559 else
5560 {
5562 }
5563 }
5568 }
5570 {
5573 }
5575 {
5577 {
5580 MSG_EXT_WDTR_BUS_16_BIT) )
5581 {
5584 }
5587 {
5593 }
5594 }
5602 }
5606 /*
5607 * By virtue of the SCSI spec, a WDTR message negates any existing
5608 * SDTR negotiations. So, even if needsdtr isn't marked for this
5609 * device, we still have to do a new SDTR message if the device
5610 * supports SDTR at all. Therefore, we check needsdtr_copy instead
5611 * of needstr.
5612 */
5618 }
5620 {
5627 {
5630 }
5632 /*
5633 * If we aren't on one of the new Ultra3 cards, then reject any PPR
5634 * message since we can't support any option field other than 0
5635 */
5637 {
5640 }
5643 {
5645 }
5653 {
5656 trans_options);
5657 }
5661 {
5663 {
5665 }
5666 else
5667 {
5669 }
5670 }
5671 else
5672 {
5674 }
5675 /*
5676 * We might have a device that is starting negotiation with us
5677 * before we can start up negotiation with it....be prepared to
5678 * have a device ask for a higher speed then we want to give it
5679 * in that case
5680 */
5683 {
5688 {
5689 /*
5690 * Not only is the device starting this up, but it also hasn't
5691 * been scanned yet, so this would likely be our TUR or our
5692 * INQUIRY command at scan time, so we need to use the
5693 * settings from the SEEPROM if they existed. Of course, even
5694 * if we didn't find a SEEPROM, we stuffed default values into
5695 * the user settings anyway, so use those in all cases.
5696 */
5700 {
5702 {
5704 }
5708 {
5710 }
5711 else
5712 {
5714 }
5715 }
5721 }
5723 {
5726 }
5734 {
5736 {
5739 MSG_EXT_WDTR_BUS_16_BIT) )
5740 {
5743 }
5746 {
5752 }
5753 }
5754 }
5755 else
5756 {
5758 {
5760 {
5765 {
5768 }
5771 {
5772 /*
5773 * According to the spec, if we aren't wide, we also can't be
5774 * Dual Edge so clear the options byte
5775 */
5779 }
5781 {
5783 }
5784 }
5785 }
5800 {
5807 }
5811 {
5817 }
5820 }
5822 {
5825 }
5830 {
5834 }
5836 }
5839 /*+F*************************************************************************
5840 * Function:
5841 * aic7xxx_handle_reqinit
5842 *
5843 * Description:
5844 * Interrupt handler for REQINIT interrupts (used to transfer messages to
5845 * and from devices).
5846 *_F*************************************************************************/
5847 static void
5849 {
5855 {
5857 {
5865 {
5866 /* Time to end the message */
5869 /*
5870 * NOTE-TO-MYSELF: If you clear the REQINIT after you
5871 * disable REQINITs, then cases of REJECT_MSG stop working
5872 * and hang the bus
5873 */
5879 {
5882 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5886 #endif
5887 }
5888 else
5889 {
5891 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5895 #endif
5896 }
5898 }
5899 else
5900 {
5901 /*
5902 * Present the byte on the bus (clearing REQINIT) but don't
5903 * unpause the sequencer.
5904 */
5908 }
5910 }
5912 {
5916 {
5918 /* Pull the byte in without acking it */
5921 /* Ack the byte */
5926 }
5928 {
5929 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5931 {
5935 else
5938 }
5939 #endif
5940 /* Time to end our message session */
5947 }
5949 }
5951 {
5954 }
5956 }
5958 /*+F*************************************************************************
5959 * Function:
5960 * aic7xxx_handle_scsiint
5961 *
5962 * Description:
5963 * Interrupt handler for SCSI interrupts (SCSIINT).
5964 *-F*************************************************************************/
5965 static void
5967 {
5976 {
5979 {
5981 }
5982 }
5983 else
5984 {
5986 }
5990 {
5995 else
6003 /*
6004 * Go through and abort all commands for the channel, but do not
6005 * reset the channel again.
6006 */
6010 }
6012 {
6013 /*
6014 * First look at what phase we were last in. If it's message-out,
6015 * chances are pretty good that the bus free was in response to
6016 * one of our abort requests.
6017 */
6026 else
6030 SCSISEQ);
6032 {
6038 {
6047 }
6049 {
6053 }
6054 }
6057 {
6058 /*
6059 * This might be a SCSI-3 device that is dropping the bus due to
6060 * errors and signalling that we should reduce the transfer speed.
6061 * All we have to do is complete this command (since it's a negotiation
6062 * command already) and the checksum routine should flag an error and
6063 * reduce the speed setting and renegotiate. We call the reset routing
6064 * just to clean out the hardware from this scb.
6065 */
6070 }
6072 {
6074 {
6078 {
6080 }
6081 else
6082 {
6084 }
6087 }
6088 else
6089 {
6092 }
6097 }
6100 SIMODE1);
6106 }
6108 {
6115 {
6116 /*
6117 * I'm still trying to track down exactly how this happens, but until
6118 * I find it, this code will make sure we aren't passing bogus values
6119 * into the SCBPTR register, even if that register will just wrap
6120 * things around, we still don't like having out of range variables.
6121 *
6122 * NOTE: Don't check the aic7xxx_verbose variable, I want this message
6123 * to always be displayed.
6124 */
6129 else
6131 }
6137 {
6140 {
6142 }
6143 }
6145 {
6154 }
6155 else
6156 {
6160 /*
6161 * Clear out this hardware SCB
6162 */
6165 /*
6166 * Clear out a few values in the card that are in an undetermined
6167 * state.
6168 */
6171 /*
6172 * Shift the waiting for selection queue forward
6173 */
6177 /*
6178 * Put this SCB back on the free list.
6179 */
6181 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6184 #endif
6186 {
6187 /*
6188 * We know that this particular SCB had to be the queued abort since
6189 * the disconnected SCB would have gotten a reconnect instead.
6190 * What we need to do then is to let the command timeout again so
6191 * we get a reset since this abort just failed.
6192 */
6195 }
6197 {
6198 /*
6199 * Turn off the needsdtr, needwdtr, and needppr bits since this device
6200 * doesn't seem to exist.
6201 */
6208 }
6209 }
6210 /*
6211 * Restarting the sequencer will stop the selection and make sure devices
6212 * are allowed to reselect in.
6213 */
6222 }
6224 {
6231 /*
6232 * Turn off the interrupt and set status to zero, so that it
6233 * falls through the rest of the SCSIINT code.
6234 */
6239 }
6241 {
6242 /*
6243 * Determine the bus phase and queue an appropriate message.
6244 */
6254 {
6279 }
6281 /*
6282 * A parity error has occurred during a data
6283 * transfer phase. Flag it and continue.
6284 */
6286 {
6290 {
6293 }
6295 {
6298 }
6300 {
6303 }
6305 {
6308 }
6309 }
6310 else
6311 {
6314 }
6317 {
6321 /*
6322 * oops, we had a failure, lower the transfer rate and try again. It's
6323 * worth noting here that it might be wise to also check for typical
6324 * wide setting on narrow cable type problems and try disabling wide
6325 * instead of slowing down if those exist. That's hard to do with simple
6326 * checksums though.
6327 */
6329 {
6330 syncrate++;
6333 {
6336 {
6338 }
6339 }
6340 else
6341 {
6345 }
6349 }
6351 }
6352 else
6353 {
6355 }
6357 /*
6358 * We've set the hardware to assert ATN if we get a parity
6359 * error on "in" phases, so all we need to do is stuff the
6360 * message buffer with the appropriate message. "In" phases
6361 * have set mesg_out to something other than MSG_NOP.
6362 */
6364 {
6367 }
6371 }
6374 {
6375 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6379 #endif
6382 }
6383 else
6384 {
6385 /*
6386 * We don't know what's going on. Turn off the
6387 * interrupt source and try to continue.
6388 */
6396 }
6398 {
6400 }
6401 }
6403 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6404 static void
6406 {
6411 #define SCB_NO_LIST 0
6412 #define SCB_FREE_LIST 1
6413 #define SCB_WAITING_LIST 2
6414 #define SCB_DISCONNECTED_LIST 4
6415 #define SCB_CURRENTLY_ACTIVE 8
6417 /*
6418 * Note, these checks will fail on a regular basis once the machine moves
6419 * beyond the bus scan phase. The problem is race conditions concerning
6420 * the scbs and where they are linked in. When you have 30 or so commands
6421 * outstanding on the bus, and run this twice with every interrupt, the
6422 * chances get pretty good that you'll catch the sequencer with an SCB
6423 * only partially linked in. Therefore, once we pass the scan phase
6424 * of the bus, we really should disable this function.
6425 */
6431 {
6434 }
6439 {
6442 }
6443 else
6444 {
6447 {
6449 {
6453 }
6457 }
6458 }
6463 {
6466 }
6467 else
6468 {
6471 {
6473 {
6477 }
6481 }
6482 }
6487 {
6490 }
6491 else
6492 {
6495 {
6497 {
6501 }
6505 }
6506 }
6510 {
6515 {
6518 }
6520 {
6523 }
6525 lost++;
6527 {
6530 }
6531 }
6535 {
6539 }
6541 }
6542 #endif
6544 /*+F*************************************************************************
6545 * Function:
6546 * aic7xxx_isr
6547 *
6548 * Description:
6549 * SCSI controller interrupt handler.
6550 *-F*************************************************************************/
6551 static void
6553 {
6559 /*
6560 * Just a few sanity checks. Make sure that we have an int pending.
6561 * Also, if PCI, then we are going to check for a PCI bus error status
6562 * should we get too many spurious interrupts.
6563 */
6565 {
6566 #ifdef CONFIG_PCI
6569 {
6571 {
6573 }
6575 }
6577 {
6579 }
6580 #endif
6582 }
6586 /*
6587 * Keep track of interrupts for /proc/scsi
6588 */
6591 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6595 #endif
6597 /*
6598 * Handle all the interrupt sources - especially for SCSI
6599 * interrupts, we won't get a second chance at them.
6600 */
6602 {
6607 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6610 #endif
6612 /*
6613 * Clear interrupt status before running the completion loop.
6614 * This eliminates a race condition whereby a command could
6615 * complete between the last check of qoutfifo and the
6616 * CLRCMDINT statement. This would result in us thinking the
6617 * qoutfifo was empty when it wasn't, and in actuality be a lost
6618 * completion interrupt. With multiple devices or tagged queueing
6619 * this could be very bad if we caught all but the last completion
6620 * and no more are imediately sent.
6621 */
6623 /*
6624 * The sequencer will continue running when it
6625 * issues this interrupt. There may be >1 commands
6626 * finished, so loop until we've processed them all.
6627 */
6630 {
6635 else
6638 {
6642 }
6644 {
6649 }
6651 {
6655 {
6658 }
6662 SCB_QUEUED_ABORT);
6664 }
6666 {
6667 /*
6668 * We started to abort this, but it completed on us, let it
6669 * through as successful
6670 */
6672 }
6674 {
6684 {
6686 }
6690 }
6691 }
6692 }
6695 {
6701 {
6703 {
6705 }
6706 }
6711 #ifdef CONFIG_PCI
6714 #endif
6716 {
6719 }
6721 {
6724 }
6725 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6727 {
6730 else
6732 }
6733 #endif
6736 }
6739 {
6741 }
6744 {
6746 }
6748 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6752 #endif
6754 }
6756 /*+F*************************************************************************
6757 * Function:
6758 * do_aic7xxx_isr
6759 *
6760 * Description:
6761 * This is a gross hack to solve a problem in linux kernels 2.1.85 and
6762 * above. Please, children, do not try this at home, and if you ever see
6763 * anything like it, please inform the Gross Hack Police immediately
6764 *-F*************************************************************************/
6765 static void
6767 {
6774 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,95)
6777 {
6779 }
6780 do
6781 {
6788 #else
6790 {
6792 }
6793 DRIVER_LOCK
6794 do
6795 {
6798 DRIVER_UNLOCK
6802 #endif
6803 }
6805 /*+F*************************************************************************
6806 * Function:
6807 * aic7xxx_device_queue_depth
6808 *
6809 * Description:
6810 * Determines the queue depth for a given device. There are two ways
6811 * a queue depth can be obtained for a tagged queueing device. One
6812 * way is the default queue depth which is determined by whether
6813 * AIC7XXX_CMDS_PER_DEVICE is defined. If it is defined, then it is used
6814 * as the default queue depth. Otherwise, we use either 4 or 8 as the
6815 * default queue depth (dependent on the number of hardware SCBs).
6816 * The other way we determine queue depth is through the use of the
6817 * aic7xxx_tag_info array which is enabled by defining
6818 * AIC7XXX_TAGGED_QUEUEING_BY_DEVICE. This array can be initialized
6819 * with queue depths for individual devices. It also allows tagged
6820 * queueing to be [en|dis]abled for a specific adapter.
6821 *-F*************************************************************************/
6822 static void
6824 {
6838 {
6844 {
6849 }
6850 else
6851 {
6853 {
6856 {
6862 }
6864 }
6865 else
6866 {
6869 {
6872 }
6874 {
6876 }
6877 else
6878 {
6881 }
6882 }
6884 {
6886 {
6890 }
6897 }
6898 }
6899 }
6900 }
6902 /*+F*************************************************************************
6903 * Function:
6904 * aic7xxx_select_queue_depth
6905 *
6906 * Description:
6907 * Sets the queue depth for each SCSI device hanging off the input
6908 * host adapter. We use a queue depth of 2 for devices that do not
6909 * support tagged queueing. If AIC7XXX_CMDS_PER_LUN is defined, we
6910 * use that for tagged queueing devices; otherwise we use our own
6911 * algorithm for determining the queue depth based on the maximum
6912 * SCBs for the controller.
6913 *-F*************************************************************************/
6914 static void
6917 {
6924 {
6926 {
6929 }
6930 }
6932 {
6933 /*
6934 * Pre-allocate the needed SCBs to get around the possibility of having
6935 * to allocate some when memory is more or less exhausted and we need
6936 * the SCB in order to perform a swap operation (possible deadlock)
6937 */
6940 }
6941 }
6943 /*+F*************************************************************************
6944 * Function:
6945 * aic7xxx_probe
6946 *
6947 * Description:
6948 * Probing for EISA boards: it looks like the first two bytes
6949 * are a manufacturer code - three characters, five bits each:
6950 *
6951 * BYTE 0 BYTE 1 BYTE 2 BYTE 3
6952 * ?1111122 22233333 PPPPPPPP RRRRRRRR
6953 *
6954 * The characters are baselined off ASCII '@', so add that value
6955 * to each to get the real ASCII code for it. The next two bytes
6956 * appear to be a product and revision number, probably vendor-
6957 * specific. This is what is being searched for at each port,
6958 * and what should probably correspond to the ID= field in the
6959 * ECU's .cfg file for the card - if your card is not detected,
6960 * make sure your signature is listed in the array.
6961 *
6962 * The fourth byte's lowest bit seems to be an enabled/disabled
6963 * flag (rest of the bits are reserved?).
6964 *
6965 * NOTE: This function is only needed on Intel and Alpha platforms,
6966 * the other platforms we support don't have EISA/VLB busses. So,
6967 * we #ifdef this entire function to avoid compiler warnings about
6968 * an unused function.
6969 *-F*************************************************************************/
6970 #if defined(__i386__) || defined(__alpha__)
6971 static int
6973 {
6980 ahc_chip type;
6991 };
6993 /*
6994 * The VL-bus cards need to be primed by
6995 * writing before a signature check.
6996 */
6998 {
7001 }
7004 {
7005 /*
7006 * Signature match on enabled card?
7007 */
7009 {
7011 {
7013 {
7015 }
7016 else
7017 {
7019 }
7021 }
7025 }
7026 }
7029 }
7033 /*+F*************************************************************************
7034 * Function:
7035 * read_2840_seeprom
7036 *
7037 * Description:
7038 * Reads the 2840 serial EEPROM and returns 1 if successful and 0 if
7039 * not successful.
7040 *
7041 * See read_seeprom (for the 2940) for the instruction set of the 93C46
7042 * chip.
7043 *
7044 * The 2840 interface to the 93C46 serial EEPROM is through the
7045 * STATUS_2840 and SEECTL_2840 registers. The CS_2840, CK_2840, and
7046 * DO_2840 bits of the SEECTL_2840 register are connected to the chip
7047 * select, clock, and data out lines respectively of the serial EEPROM.
7048 * The DI_2840 bit of the STATUS_2840 is connected to the data in line
7049 * of the serial EEPROM. The EEPROM_TF bit of STATUS_2840 register is
7050 * useful in that it gives us an 800 nsec timer. After a read from the
7051 * SEECTL_2840 register the timing flag is cleared and goes high 800 nsec
7052 * later.
7053 *-F*************************************************************************/
7054 static int
7056 {
7064 };
7067 #define CLOCK_PULSE(p) \
7068 while ((aic_inb(p, STATUS_2840) & EEPROM_TF) == 0) \
7069 { \
7071 } \
7072 (void) aic_inb(p, SEECTL_2840);
7074 /*
7075 * Read the first 32 registers of the seeprom. For the 2840,
7076 * the 93C46 SEEPROM is a 1024-bit device with 64 16-bit registers
7077 * but only the first 32 are used by Adaptec BIOS. The loop
7078 * will range from 0 to 31.
7079 */
7081 {
7082 /*
7083 * Send chip select for one clock cycle.
7084 */
7088 /*
7089 * Now we're ready to send the read command followed by the
7090 * address of the 16-bit register we want to read.
7091 */
7093 {
7100 }
7101 /*
7102 * Send the 6 bit address (MSB first, LSB last).
7103 */
7105 {
7114 }
7116 /*
7117 * Now read the 16 bit register. An initial 0 precedes the
7118 * register contents which begins with bit 15 (MSB) and ends
7119 * with bit 0 (LSB). The initial 0 will be shifted off the
7120 * top of our word as we let the loop run from 0 to 16.
7121 */
7123 {
7131 }
7132 /*
7133 * The serial EEPROM has a checksum in the last word. Keep a
7134 * running checksum for all words read except for the last
7135 * word. We'll verify the checksum after all words have been
7136 * read.
7137 */
7139 {
7141 }
7143 /*
7144 * Reset the chip select for the next command cycle.
7145 */
7152 }
7154 #if 0
7158 {
7160 {
7162 }
7164 }
7166 #endif
7169 {
7172 }
7175 #undef CLOCK_PULSE
7176 }
7178 /*+F*************************************************************************
7179 * Function:
7180 * acquire_seeprom
7181 *
7182 * Description:
7183 * Acquires access to the memory port on PCI controllers.
7184 *-F*************************************************************************/
7185 static int
7187 {
7190 /*
7191 * Request access of the memory port. When access is
7192 * granted, SEERDY will go high. We use a 1 second
7193 * timeout which should be near 1 second more than
7194 * is needed. Reason: after the 7870 chip reset, there
7195 * should be no contention.
7196 */
7200 {
7201 wait--;
7203 }
7205 {
7208 }
7210 }
7212 /*+F*************************************************************************
7213 * Function:
7214 * release_seeprom
7215 *
7216 * Description:
7217 * Releases access to the memory port on PCI controllers.
7218 *-F*************************************************************************/
7219 static void
7221 {
7223 }
7225 /*+F*************************************************************************
7226 * Function:
7227 * read_seeprom
7228 *
7229 * Description:
7230 * Reads the serial EEPROM and returns 1 if successful and 0 if
7231 * not successful.
7232 *
7233 * The instruction set of the 93C46/56/66 chips is as follows:
7234 *
7235 * Start OP
7236 * Function Bit Code Address Data Description
7237 * -------------------------------------------------------------------
7238 * READ 1 10 A5 - A0 Reads data stored in memory,
7239 * starting at specified address
7240 * EWEN 1 00 11XXXX Write enable must precede
7241 * all programming modes
7242 * ERASE 1 11 A5 - A0 Erase register A5A4A3A2A1A0
7243 * WRITE 1 01 A5 - A0 D15 - D0 Writes register
7244 * ERAL 1 00 10XXXX Erase all registers
7245 * WRAL 1 00 01XXXX D15 - D0 Writes to all registers
7246 * EWDS 1 00 00XXXX Disables all programming
7247 * instructions
7248 * *Note: A value of X for address is a don't care condition.
7249 * *Note: The 93C56 and 93C66 have 8 address bits.
7250 *
7251 *
7252 * The 93C46 has a four wire interface: clock, chip select, data in, and
7253 * data out. In order to perform one of the above functions, you need
7254 * to enable the chip select for a clock period (typically a minimum of
7255 * 1 usec, with the clock high and low a minimum of 750 and 250 nsec
7256 * respectively. While the chip select remains high, you can clock in
7257 * the instructions (above) starting with the start bit, followed by the
7258 * OP code, Address, and Data (if needed). For the READ instruction, the
7259 * requested 16-bit register contents is read from the data out line but
7260 * is preceded by an initial zero (leading 0, followed by 16-bits, MSB
7261 * first). The clock cycling from low to high initiates the next data
7262 * bit to be sent from the chip.
7263 *
7264 * The 78xx interface to the 93C46 serial EEPROM is through the SEECTL
7265 * register. After successful arbitration for the memory port, the
7266 * SEECS bit of the SEECTL register is connected to the chip select.
7267 * The SEECK, SEEDO, and SEEDI are connected to the clock, data out,
7268 * and data in lines respectively. The SEERDY bit of SEECTL is useful
7269 * in that it gives us an 800 nsec timer. After a write to the SEECTL
7270 * register, the SEERDY goes high 800 nsec later. The one exception
7271 * to this is when we first request access to the memory port. The
7272 * SEERDY goes high to signify that access has been granted and, for
7273 * this case, has no implied timing.
7274 *-F*************************************************************************/
7275 static int
7278 {
7285 };
7288 #define CLOCK_PULSE(p) \
7289 while ((aic_inb(p, SEECTL) & SEERDY) == 0) \
7290 { \
7292 }
7294 /*
7295 * Request access of the memory port.
7296 */
7298 {
7300 }
7302 /*
7303 * Read 'len' registers of the seeprom. For the 7870, the 93C46
7304 * SEEPROM is a 1024-bit device with 64 16-bit registers but only
7305 * the first 32 are used by Adaptec BIOS. Some adapters use the
7306 * 93C56 SEEPROM which is a 2048-bit device. The loop will range
7307 * from 0 to 'len' - 1.
7308 */
7310 {
7311 /*
7312 * Send chip select for one clock cycle.
7313 */
7317 /*
7318 * Now we're ready to send the read command followed by the
7319 * address of the 16-bit register we want to read.
7320 */
7322 {
7329 }
7330 /*
7331 * Send the 6 or 8 bit address (MSB first, LSB last).
7332 */
7334 {
7343 }
7345 /*
7346 * Now read the 16 bit register. An initial 0 precedes the
7347 * register contents which begins with bit 15 (MSB) and ends
7348 * with bit 0 (LSB). The initial 0 will be shifted off the
7349 * top of our word as we let the loop run from 0 to 16.
7350 */
7352 {
7360 }
7362 /*
7363 * The serial EEPROM should have a checksum in the last word.
7364 * Keep a running checksum for all words read except for the
7365 * last word. We'll verify the checksum after all words have
7366 * been read.
7367 */
7369 {
7371 }
7373 /*
7374 * Reset the chip select for the next command cycle.
7375 */
7382 }
7384 /*
7385 * Release access to the memory port and the serial EEPROM.
7386 */
7389 #if 0
7394 {
7396 {
7398 }
7400 }
7402 #endif
7404 {
7406 }
7409 #undef CLOCK_PULSE
7410 }
7412 /*+F*************************************************************************
7413 * Function:
7414 * read_brdctl
7415 *
7416 * Description:
7417 * Reads the BRDCTL register.
7418 *-F*************************************************************************/
7419 static unsigned char
7421 {
7425 {
7430 }
7434 {
7436 }
7443 }
7445 /*+F*************************************************************************
7446 * Function:
7447 * write_brdctl
7448 *
7449 * Description:
7450 * Writes a value to the BRDCTL register.
7451 *-F*************************************************************************/
7452 static void
7454 {
7458 {
7469 }
7470 else
7471 {
7475 {
7477 }
7490 }
7491 }
7493 /*+F*************************************************************************
7494 * Function:
7495 * aic785x_cable_detect
7496 *
7497 * Description:
7498 * Detect the cables that are present on aic785x class controller chips
7499 *-F*************************************************************************/
7500 static void
7503 {
7515 }
7517 /*+F*************************************************************************
7518 * Function:
7519 * aic787x_cable_detect
7520 *
7521 * Description:
7522 * Detect the cables that are present on aic787x class controller chips
7523 *
7524 * NOTE: This functions assumes the SEEPROM will have already been aquired
7525 * prior to invocation of this function.
7526 *-F*************************************************************************/
7527 static void
7530 {
7533 /*
7534 * First read the status of our cables. Set the rom bank to
7535 * 0 since the bank setting serves as a multiplexor for the
7536 * cable detection logic. BRDDAT5 controls the bank switch.
7537 */
7540 /*
7541 * Now we read the state of the two internal connectors. BRDDAT6
7542 * is internal 50, BRDDAT7 is internal 68. For each, the cable is
7543 * present if the bit is 0
7544 */
7549 /*
7550 * Set the bank bit in brdctl and then read the external cable state
7551 * and the EEPROM status
7552 */
7559 /*
7560 * We're done, the calling function will release the SEEPROM for us
7561 */
7562 }
7564 /*+F*************************************************************************
7565 * Function:
7566 * aic787x_ultra2_term_detect
7567 *
7568 * Description:
7569 * Detect the termination settings present on ultra2 class controllers
7570 *
7571 * NOTE: This functions assumes the SEEPROM will have already been aquired
7572 * prior to invocation of this function.
7573 *-F*************************************************************************/
7574 static void
7578 {
7588 }
7590 /*+F*************************************************************************
7591 * Function:
7592 * configure_termination
7593 *
7594 * Description:
7595 * Configures the termination settings on PCI adapters that have
7596 * SEEPROMs available.
7597 *-F*************************************************************************/
7598 static void
7600 {
7614 {
7617 else
7623 {
7625 {
7635 }
7636 /* Configure auto termination. */
7639 {
7645 {
7648 }
7650 {
7652 }
7656 }
7658 {
7661 }
7662 else
7663 {
7666 }
7672 {
7674 {
7680 }
7681 else
7682 {
7687 }
7688 }
7693 /*
7694 * Now set the termination based on what we found. BRDDAT6
7695 * controls wide termination enable.
7696 * Flash Enable = BRDDAT7
7697 * SE High Term Enable = BRDDAT6
7698 * SE Low Term Enable = BRDDAT5 (7890)
7699 * LVD High Term Enable = BRDDAT4 (7890)
7700 */
7703 {
7708 /*
7709 * Force termination (low and high byte) on. This is safer than
7710 * leaving it completely off, especially since this message comes
7711 * most often from motherboard controllers that don't even have 3
7712 * connectors, but instead are failing the cable detection.
7713 */
7716 }
7721 {
7727 }
7733 {
7736 else
7742 }
7745 {
7751 }
7754 {
7759 }
7760 }
7761 else
7762 {
7764 {
7767 else
7772 }
7775 {
7780 }
7781 }
7785 }
7786 }
7788 /*+F*************************************************************************
7789 * Function:
7790 * detect_maxscb
7791 *
7792 * Description:
7793 * Detects the maximum number of SCBs for the controller and returns
7794 * the count and a mask in p (p->maxscbs, p->qcntmask).
7795 *-F*************************************************************************/
7796 static void
7798 {
7801 /*
7802 * It's possible that we've already done this for multichannel
7803 * adapters.
7804 */
7806 {
7807 /*
7808 * We haven't initialized the SCB settings yet. Walk the SCBs to
7809 * determince how many there are.
7810 */
7814 {
7831 }
7833 /* Make sure the last SCB terminates the free list. */
7837 /* Ensure we clear the first (0) SCBs control byte. */
7842 /*
7843 * Use direct indexing instead for speed
7844 */
7847 }
7849 }
7851 /*+F*************************************************************************
7852 * Function:
7853 * aic7xxx_register
7854 *
7855 * Description:
7856 * Register a Adaptec aic7xxx chip SCSI controller with the kernel.
7857 *-F*************************************************************************/
7858 static int
7861 {
7868 /*
7869 * Lock out other contenders for our i/o space.
7870 */
7887 {
7889 }
7891 {
7893 }
7910 {
7914 }
7915 /*
7916 * We currently have no commands of any type
7917 */
7922 {
7932 }
7937 {
7948 }
7950 {
7953 }
7954 else
7955 {
7961 {
7965 {
7967 }
7968 }
7970 {
7972 }
7973 else
7974 {
7976 }
7978 }
7986 {
7992 }
7994 #ifdef CONFIG_PCI
7995 /*
7996 * Now that we know our instance number, we can set the flags we need to
7997 * force termination if need be.
7998 */
8000 {
8001 /*
8002 * This option only applies to PCI controllers.
8003 */
8005 {
8008 #if LINUX_KERNEL_VERSION > KERNEL_VERSION(2,1,92)
8010 #else
8013 #endif
8015 {
8019 }
8020 else
8021 {
8025 }
8026 #if LINUX_KERNEL_VERSION > KERNEL_VERSION(2,1,92)
8028 #else
8031 #endif
8032 }
8033 }
8034 #endif
8036 /*
8037 * That took care of devconfig and stpwlev, now for the actual termination
8038 * settings.
8039 */
8041 {
8042 /*
8043 * Again, this only applies to PCI controllers. We don't have problems
8044 * with the termination on 274x controllers to the best of my knowledge.
8045 */
8047 {
8054 {
8056 }
8058 {
8060 }
8062 {
8064 }
8065 }
8066 }
8069 {
8071 {
8073 /*
8074 * Update the settings in sxfrctl1 to match the termination
8075 * settings.
8076 */
8078 }
8080 {
8082 }
8083 }
8085 /*
8086 * Clear out any possible pending interrupts.
8087 */
8090 /*
8091 * Set the SCSI Id, SXFRCTL0, SXFRCTL1, and SIMODE1, for both channels
8092 */
8094 {
8095 /* Select channel B */
8100 else
8112 /* Select channel A */
8114 }
8117 {
8119 }
8120 else
8121 {
8123 }
8126 else
8138 /*
8139 * Look at the information that board initialization or the board
8140 * BIOS has left us. In the lower four bits of each target's
8141 * scratch space any value other than 0 indicates that we should
8142 * initiate synchronous transfers. If it's zero, the user or the
8143 * BIOS has decided to disable synchronous negotiation to that
8144 * target so we don't activate the needsdtr flag.
8145 */
8147 {
8149 }
8150 else
8151 {
8153 }
8156 {
8157 /*
8158 * If we reset the bus, then clear the transfer settings, else leave
8159 * them be
8160 */
8162 {
8165 {
8167 }
8171 }
8173 /*
8174 * If we reset the bus, then clear the transfer settings, else leave
8175 * them be.
8176 */
8180 }
8182 /*
8183 * Allocate enough hardware scbs to handle the maximum number of
8184 * concurrent transactions we can have. We have to make sure that
8185 * the allocated memory is contiguous memory. The Linux kmalloc
8186 * routine should only allocate contiguous memory, but note that
8187 * this could be a problem if kmalloc() is changed.
8188 */
8189 {
8196 {
8197 /*
8198 * A little padding so we can align thing the way we want
8199 */
8201 }
8203 {
8208 }
8209 /*
8210 * Save the actual kmalloc buffer pointer off, then align our
8211 * buffer to a 32 byte boundary
8212 */
8218 /* At least the control byte of each SCB needs to be 0. */
8221 /* Tell the sequencer where it can find the hardware SCB array. */
8228 /* Set up the fifo areas at the same time */
8234 }
8236 /* The Q-FIFOs we just set up are all empty */
8242 {
8247 }
8249 /*
8250 * We don't have any waiting selections or disconnected SCBs.
8251 */
8255 /*
8256 * Message out buffer starts empty
8257 */
8261 /*
8262 * Set all the other asundry items that haven't been set yet.
8263 * This includes just dumping init values to a lot of registers simply
8264 * to make sure they've been touched and are ready for use parity wise
8265 * speaking.
8266 */
8273 /*
8274 * Link us into the list of valid hosts
8275 */
8279 /*
8280 * Clear out any possible pending interrupts, again.
8281 */
8284 /*
8285 * Allocate the first set of scbs for this controller. This is to stream-
8286 * line code elsewhere in the driver. If we have to check for the existence
8287 * of scbs in certain code sections, it slows things down. However, as
8288 * soon as we register the IRQ for this card, we could get an interrupt that
8289 * includes possibly the SCSI_RSTI interrupt. If we catch that interrupt
8290 * then we are likely to segfault if we don't have at least one chunk of
8291 * SCBs allocated or add checks all through the reset code to make sure
8292 * that the SCBs have been allocated which is an invalid running condition
8293 * and therefore I think it's preferable to simply pre-allocate the first
8294 * chunk of SCBs.
8295 */
8298 /*
8299 * Load the sequencer program, then re-enable the board -
8300 * resetting the AIC-7770 disables it, leaving the lights
8301 * on with nobody home.
8302 */
8305 /*
8306 * Make sure the AUTOFLUSHDIS bit is *not* set in the SBLKCTL register
8307 */
8311 {
8313 }
8316 {
8318 {
8324 }
8325 /* Reset SCSI bus A. */
8330 {
8334 }
8336 }
8338 /*
8339 * Some of the new Ultra2 chipsets need a longer delay after a chip
8340 * reset than just the init setup creates, so we have to delay here
8341 * before we go into a reset in order to make the chips happy.
8342 */
8347 /*
8348 * Delay for the reset delay.
8349 */
8352 }
8353 else
8354 {
8356 {
8366 }
8367 }
8369 /*
8370 * Register IRQ with the kernel. Only allow sharing IRQs with
8371 * PCI devices.
8372 */
8374 {
8376 }
8377 else
8378 {
8382 {
8385 }
8386 }
8388 {
8393 }
8398 }
8400 /*+F*************************************************************************
8401 * Function:
8402 * aic7xxx_chip_reset
8403 *
8404 * Description:
8405 * Perform a chip reset on the aic7xxx SCSI controller. The controller
8406 * is paused upon return.
8407 *-F*************************************************************************/
8408 int
8410 {
8414 /*
8415 * For some 274x boards, we must clear the CHIPRST bit and pause
8416 * the sequencer. For some reason, this makes the driver work.
8417 */
8420 /*
8421 * In the future, we may call this function as a last resort for
8422 * error handling. Let's be nice and not do any unecessary delays.
8423 */
8426 {
8428 }
8436 {
8450 }
8452 }
8454 /*+F*************************************************************************
8455 * Function:
8456 * aic7xxx_alloc
8457 *
8458 * Description:
8459 * Allocate and initialize a host structure. Returns NULL upon error
8460 * and a pointer to a aic7xxx_host struct upon success.
8461 *-F*************************************************************************/
8464 {
8469 /*
8470 * Allocate a storage area by registering us with the mid-level
8471 * SCSI layer.
8472 */
8476 {
8484 {
8487 }
8488 else
8489 {
8490 /*
8491 * For some reason we don't have enough memory. Free the
8492 * allocated memory for the aic7xxx_host struct, and return NULL.
8493 */
8497 }
8502 {
8507 }
8508 DRIVER_LOCK_INIT
8509 }
8511 }
8513 /*+F*************************************************************************
8514 * Function:
8515 * aic7xxx_free
8516 *
8517 * Description:
8518 * Frees and releases all resources associated with an instance of
8519 * the driver (struct aic7xxx_host *).
8520 *-F*************************************************************************/
8521 static void
8523 {
8526 /*
8527 * Free the allocated hardware SCB space.
8528 */
8530 {
8532 {
8535 }
8536 /*
8537 * Free the driver SCBs. These were allocated on an as-need
8538 * basis. We allocated these in groups depending on how many
8539 * we could fit into a given amount of RAM. The tail SCB for
8540 * these allocations has a pointer to the alloced area.
8541 */
8543 {
8547 }
8549 /*
8550 * Free the SCB data area.
8551 */
8553 }
8555 /*
8556 * Free any alloced Scsi_Cmnd structures that might be around for
8557 * negotiation purposes....
8558 */
8560 {
8562 {
8564 {
8566 }
8568 }
8569 }
8571 }
8573 /*+F*************************************************************************
8574 * Function:
8575 * aic7xxx_load_seeprom
8576 *
8577 * Description:
8578 * Load the seeprom and configure adapter and target settings.
8579 * Returns 1 if the load was successful and 0 otherwise.
8580 *-F*************************************************************************/
8581 static void
8583 {
8591 {
8593 }
8595 {
8611 {
8615 else
8618 }
8620 {
8625 {
8629 else
8632 }
8633 }
8635 }
8638 {
8640 {
8642 }
8645 {
8651 {
8653 }
8654 }
8656 {
8658 }
8660 {
8664 }
8667 else
8669 }
8670 else
8671 {
8673 {
8675 }
8677 /*
8678 * Note things in our flags
8679 */
8682 /*
8683 * Update the settings in sxfrctl1 to match the termination settings.
8684 */
8687 /*
8688 * Get our SCSI ID from the SEEPROM setting...
8689 */
8692 /*
8693 * First process the settings that are different between the VLB
8694 * and PCI adapter seeproms.
8695 */
8697 {
8698 /* VLB adapter seeproms */
8703 {
8706 }
8707 }
8708 else
8709 {
8710 /* PCI adapter seeproms */
8715 else
8719 {
8722 }
8723 }
8725 }
8729 /*
8730 * Limit to 16 targets just in case. The 2842 for one is known to
8731 * blow the max_targets setting, future cards might also.
8732 */
8736 {
8738 {
8743 {
8746 }
8747 }
8748 }
8751 {
8754 {
8756 {
8757 /*
8758 * OK...the BIOS set things up and left behind the settings we need.
8759 * Just make our sc->device_flags[i] entry match what the card has
8760 * set for this device.
8761 */
8770 {
8772 {
8777 }
8778 }
8779 else
8780 {
8782 {
8787 }
8788 }
8789 }
8790 else
8791 {
8792 /*
8793 * Assume the BIOS has NOT been run on this card and nothing between
8794 * the card and the devices is configured yet.
8795 */
8809 }
8810 }
8812 {
8814 }
8816 {
8818 {
8819 /*
8820 * I know of two different Ultra BIOSes that do this differently.
8821 * One on the Gigabyte 6BXU mb that wants flags[i] & CFXFER to
8822 * be == to 0x03 and SYNCHISULTRA to be true to mean 40MByte/s
8823 * while on the IBM Netfinity 5000 they want the same thing
8824 * to be something else, while flags[i] & CFXFER == 0x03 and
8825 * SYNCHISULTRA false should be 40MByte/s. So, we set both to
8826 * 40MByte/s and the lower speeds be damned. People will have
8827 * to select around the conversely mapped lower speeds in order
8828 * to select lower speeds on these boards.
8829 */
8832 {
8835 }
8837 {
8839 }
8840 }
8844 {
8846 }
8847 }
8849 {
8851 }
8853 {
8863 }
8864 else
8865 {
8867 {
8871 {
8875 {
8879 }
8880 else
8881 {
8883 }
8884 }
8885 else
8886 {
8891 }
8893 AHC_SYNCRATE_ULTRA3);
8896 AHC_SYNCRATE_ULTRA3);
8897 }
8899 {
8907 AHC_SYNCRATE_ULTRA2);
8910 AHC_SYNCRATE_ULTRA2);
8911 }
8912 else
8913 {
8919 {
8924 scsirate,
8926 AHC_SYNCRATE_ULTRA :
8927 AHC_SYNCRATE_FAST);
8931 AHC_SYNCRATE_ULTRA :
8932 AHC_SYNCRATE_FAST);
8933 }
8934 else
8937 }
8939 }
8941 {
8944 }
8945 else
8946 {
8949 }
8953 }
8961 /*
8962 * We set the p->ultraenb from the SEEPROM to begin with, but now we make
8963 * it match what is already down in the card. If we are doing a reset
8964 * on the card then this will get put back to a default state anyway.
8965 * This allows us to not have to pre-emptively negotiate when using the
8966 * no_reset option.
8967 */
8975 {
8980 {
8988 }
8992 }
8993 else
8994 {
8996 }
8998 /*
8999 * Only set the SCSICONF and SCSICONF + 1 registers if we are a PCI card.
9000 * The 2842 and 2742 cards already have these registers set and we don't
9001 * want to muck with them since we don't set all the bits they do.
9002 */
9004 {
9005 /* Set the host ID */
9007 /* In case we are a wide card */
9009 }
9010 }
9012 /*+F*************************************************************************
9013 * Function:
9014 * aic7xxx_detect
9015 *
9016 * Description:
9017 * Try to detect and register an Adaptec 7770 or 7870 SCSI controller.
9018 *
9019 * XXX - This should really be called aic7xxx_probe(). A sequence of
9020 * probe(), attach()/detach(), and init() makes more sense than
9021 * one do-it-all function. This may be useful when (and if) the
9022 * mid-level SCSI code is overhauled.
9023 *-F*************************************************************************/
9024 int
9026 {
9031 #if defined(__i386__) || defined(__alpha__)
9034 #endif
9036 #if defined(__i386__) || defined(__alpha__)
9039 #endif
9041 #ifdef MODULE
9042 /*
9043 * If we are called as a module, the aic7xxx pointer may not be null
9044 * and it would point to our bootup string, just like on the lilo
9045 * command line. IF not NULL, then process this config string with
9046 * aic7xxx_setup
9047 */
9053 "aic7xxx: to see the proper way to specify options to the aic7xxx "
9057 #endif
9063 #if defined(__i386__) || defined(__alpha__)
9064 #ifdef CONFIG_PCI
9065 /*
9066 * PCI-bus chipset probe.
9067 */
9068 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9070 {
9072 PCI_DEVICE_ID_INTEL_82450GX,
9073 NULL))
9076 PCI_DEVICE_ID_INTEL_82451NX,
9077 NULL))
9079 }
9080 #else
9081 #define PCI_DEVICE_ID_INTEL_82451NX 0x84ca
9083 {
9086 PCI_DEVICE_ID_INTEL_82450GX,
9090 PCI_DEVICE_ID_INTEL_82451NX,
9093 }
9096 /*
9097 * EISA/VL-bus card signature probe.
9098 */
9102 {
9106 {
9107 /*
9108 * Some other driver has staked a
9109 * claim to this i/o region already.
9110 */
9111 slot++;
9113 }
9117 {
9118 slot++;
9120 }
9123 {
9125 slot++;
9127 }
9128 /*
9129 * Pause the card preserving the IRQ type. Allow the operator
9130 * to override the IRQ trigger.
9131 */
9136 else
9150 else
9155 {
9168 slot++;
9170 }
9172 /*
9173 * We are commited now, everything has been checked and this card
9174 * has been found, now we just set it up
9175 */
9177 /*
9178 * Insert our new struct into the list at the end
9179 */
9181 {
9183 }
9184 else
9185 {
9190 }
9193 {
9199 /* FALLTHROUGH */
9201 {
9206 /*
9207 * Get the primary channel information. Right now we don't
9208 * do anything with this, but someday we will be able to inform
9209 * the mid-level SCSI code which channel is primary.
9210 */
9212 {
9217 }
9219 {
9221 }
9224 {
9226 }
9227 else
9228 {
9232 {
9235 }
9236 else
9237 {
9240 }
9241 }
9245 {
9248 }
9249 else
9250 {
9253 }
9256 }
9264 else
9274 {
9289 }
9294 }
9296 {
9303 }
9305 /*
9306 * Set the FIFO threshold and the bus off time.
9307 */
9311 slot++;
9312 found++;
9313 }
9317 #ifdef CONFIG_PCI
9318 /*
9319 * PCI-bus probe.
9320 */
9321 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9323 #else
9325 #endif
9326 {
9327 struct
9328 {
9331 ahc_chip chip;
9332 ahc_flag_type flags;
9333 ahc_feature features;
9485 };
9489 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9491 #else
9495 #endif
9498 {
9499 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9503 pdev)))
9504 #else
9509 #endif
9510 {
9512 {
9514 {
9518 }
9519 }
9522 {
9531 /*
9532 * Read sundry information from PCI BIOS.
9533 */
9534 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9543 {
9547 {
9548 /* duplicate PCI entry, skip it */
9551 }
9553 }
9563 {
9566 }
9567 #ifdef AIC7XXX_STRICT_PCI_SETUP
9570 #else
9572 #endif
9577 #ifdef AIC7XXX_STRICT_PCI_SETUP
9580 {
9582 }
9602 {
9606 {
9607 /* duplicate PCI entry, skip it */
9610 }
9612 }
9622 {
9625 }
9626 #ifdef AIC7XXX_STRICT_PCI_SETUP
9629 #else
9631 #endif
9636 #ifdef AIC7XXX_STRICT_PCI_SETUP
9639 {
9641 }
9652 {
9661 }
9663 #ifdef MMAPIO
9667 {
9672 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0)
9674 #else
9676 #endif
9678 {
9680 /*
9681 * We need to check the I/O with the MMAPed address. Some machines
9682 * simply fail to work with MMAPed I/O and certain controllers.
9683 */
9685 {
9686 /*
9687 * OK.....we failed our test....go back to programmed I/O
9688 */
9695 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,0)
9697 #else
9699 #endif
9701 }
9702 }
9703 }
9704 #endif
9706 /*
9707 * We HAVE to make sure the first pause_sequencer() and all other
9708 * subsequent I/O that isn't PCI config space I/O takes place
9709 * after the MMAPed I/O region is configured and tested. The
9710 * problem is the PowerPC architecture that doesn't support
9711 * programmed I/O at all, so we have to have the MMAP I/O set up
9712 * for this pause to even work on those machines.
9713 */
9716 /*
9717 * Clear out any pending PCI error status messages. Also set
9718 * verbose to 0 so that we don't emit strange PCI error messages
9719 * while cleaning out the current status bits.
9720 */
9728 /*
9729 * Remember how the card was setup in case there is no seeprom.
9730 */
9733 else
9735 /*
9736 * Get current termination setting
9737 */
9741 {
9745 }
9747 /*
9748 * We need to set the CHNL? assignments before loading the SEEPROM
9749 * The 3940 and 3985 cards (original stuff, not any of the later
9750 * stuff) are 7870 and 7880 class chips. The Ultra2 stuff falls
9751 * under 7896 and 7897. The 7895 is in a class by itself :)
9752 */
9754 {
9758 {
9760 {
9772 }
9773 }
9779 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9781 {
9783 }
9784 /*
9785 * The 7895 is the only chipset that sets the SCBSIZE32 param
9786 * in the DEVCONFIG register. The Ultra2 chipsets use
9787 * the DSCOMMAND0 register instead.
9788 */
9790 {
9794 }
9795 #else
9797 {
9799 }
9800 /*
9801 * The 7895 is the only chipset that sets the SCBSIZE32 param
9802 * in the DEVCONFIG register. The Ultra2 chipsets use
9803 * the DSCOMMAND0 register instead.
9804 */
9806 {
9811 devconfig);
9812 }
9813 #endif
9817 }
9819 /*
9820 * Loading of the SEEPROM needs to come after we've set the flags
9821 * to indicate possible CHNLB and CHNLC assigments. Otherwise,
9822 * on 394x and 398x cards we'll end up reading the wrong settings
9823 * for channels B and C
9824 */
9826 {
9830 /*
9831 * Switch to the alt mode of the chip...
9832 */
9834 /*
9835 * Set our options...the last two items set our CRC after x byte
9836 * count in target mode...
9837 */
9841 /*
9842 * switch back to normal mode...
9843 */
9847 CRCCONTROL1);
9863 /*
9864 * Set the DSCOMMAND0 register on these cards different from
9865 * on the 789x cards. Also, read the SEEPROM as well.
9866 */
9869 DSCOMMAND0);
9870 /* FALLTHROUGH */
9875 /*
9876 * Check the rev of the chipset before we change DSCOMMAND0
9877 */
9878 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9880 #else
9883 #endif
9885 {
9888 DSCOMMAND0);
9889 }
9892 }
9895 /*
9896 * and then we need another switch based on the type in order to
9897 * make sure the channel B primary flag is set properly on 7895
9898 * controllers....Arrrgggghhh!!! We also have to catch the fact
9899 * that when you disable the BIOS on the 7895 on the Intel DK440LX
9900 * motherboard, and possibly others, it only sets the BIOS disabled
9901 * bit on the A channel...I think I'm starting to lean towards
9902 * going postal....
9903 */
9905 {
9911 {
9915 {
9917 {
9923 }
9924 else
9925 {
9931 }
9932 }
9934 }
9938 }
9940 /*
9941 * We only support external SCB RAM on the 7895/6/7 chipsets.
9942 * We could support it on the 7890/1 easy enough, but I don't
9943 * know of any 7890/1 based cards that have it. I do know
9944 * of 7895/6/7 cards that have it and they work properly.
9945 */
9947 {
9953 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9955 #else
9958 #endif
9960 {
9962 {
9965 DSCOMMAND0);
9968 }
9969 }
9971 {
9975 }
9976 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
9978 #else
9980 devconfig);
9981 #endif
9986 }
9988 /*
9989 * Take the LED out of diagnostic mode
9990 */
9993 SBLKCTL);
9995 /*
9996 * We don't know where this is set in the SEEPROM or by the
9997 * BIOS, so we default to 100%. On Ultra2 controllers, use 75%
9998 * instead.
9999 */
10001 {
10003 }
10004 else
10005 {
10007 }
10010 {
10012 }
10013 else
10014 {
10019 }
10021 found++;
10024 {
10029 }
10033 #endif CONFIG_PCI
10034 /*
10035 * Now, we re-order the probed devices by BIOS address and BUS class.
10036 * In general, we follow this algorithm to make the adapters show up
10037 * in the same order under linux that the computer finds them.
10038 * 1: All VLB/EISA cards with BIOS_ENABLED first, according to BIOS
10039 * address, going from lowest to highest.
10040 * 2: All PCI controllers with BIOS_ENABLED next, according to BIOS
10041 * address, going from lowest to highest.
10042 * 3: Remaining VLB/EISA controllers going in slot order.
10043 * 4: Remaining PCI controllers, going in PCI device order (reversable)
10044 */
10046 {
10057 {
10059 {
10062 {
10066 else
10070 {
10074 }
10075 else
10076 {
10081 {
10084 }
10086 {
10090 }
10091 else
10092 {
10096 }
10097 }
10101 else
10105 }
10107 {
10112 else
10116 {
10120 }
10121 else
10122 {
10126 {
10132 {
10135 }
10136 }
10137 else
10138 {
10144 {
10147 }
10148 }
10149 /*
10150 * Are we dealing with a 7895/6/7/9 where we need to sort the
10151 * channels as well, if so, the bios_address values should
10152 * be the same
10153 */
10158 {
10160 {
10162 {
10165 }
10166 }
10167 else
10168 {
10170 {
10173 }
10174 }
10175 }
10177 {
10181 }
10182 else
10183 {
10187 }
10188 }
10192 else
10196 }
10199 /*
10200 * At this point, the cards have been broken into 4 sorted lists, now
10201 * we run through the lists in order and register each controller
10202 */
10203 {
10208 {
10211 {
10215 {
10218 {
10219 found--;
10222 }
10224 {
10229 }
10230 }
10234 }
10235 }
10236 }
10237 }
10239 }
10244 /*+F*************************************************************************
10245 * Function:
10246 * aic7xxx_allocate_negotiation_command
10247 *
10248 * Description:
10249 * allocate the actual command struct and fill in the gaps...
10250 *-F*************************************************************************/
10254 {
10259 {
10261 }
10263 {
10267 }
10288 }
10290 /*+F*************************************************************************
10291 * Function:
10292 * aic7xxx_negotiation_complete
10293 *
10294 * Description:
10295 * Handle completion events for our Negotiation commands. Clear out the
10296 * struct and get it ready for its next use.
10297 *-F*************************************************************************/
10298 static void
10300 {
10308 /*
10309 * perform our minimalistic domain validation
10310 */
10312 {
10316 {
10318 }
10321 {
10326 {
10327 /*
10328 * oops, we had a failure, lower the transfer rate and try again. It's
10329 * worth noting here that it might be wise to also check for typical
10330 * wide setting on narrow cable type problems and try disabling wide
10331 * instead of slowing down if those exist. That's hard to do with simple
10332 * checksums though.
10333 */
10335 {
10338 }
10340 {
10341 syncrate++;
10344 {
10347 {
10349 }
10350 }
10351 else
10352 {
10356 }
10360 }
10362 }
10363 else
10364 {
10366 {
10369 }
10370 /*
10371 * Update the checksum in case the INQUIRY data has changed, maybe
10372 * in relation to a change in the mode pages, or whatever.
10373 */
10375 /*
10376 * Signal that we are trying out the domain validation
10377 */
10379 /*
10380 * Signal that we need to re-negotiate things, this also gets us our
10381 * INQUIRY command to re-checksum off of.
10382 */
10386 }
10387 }
10388 else
10389 {
10392 {
10395 }
10396 /*
10397 * We successfully did our checksum, so don't leave the needdv flag set
10398 * in case we might have set it last time through.
10399 */
10401 }
10402 }
10405 /*
10406 * This looks recursive in the extreme, but if this was a WDTR negotiation
10407 * and we didn't follow up with SDTR yet, then this will get it started.
10408 * For all other cases, this should work out to be a no-op, unless we are
10409 * doing domain validation and happen to need a new negotiation command.
10410 */
10413 }
10415 /*+F*************************************************************************
10416 * Function:
10417 * aic7xxx_build_negotiation_command
10418 *
10419 * Description:
10420 * Build a Scsi_Cmnd structure to perform negotiation with or else send
10421 * a pre-built command specifically for this purpose.
10422 *-F*************************************************************************/
10423 static void
10426 {
10432 {
10435 {
10437 }
10438 /*
10439 * Before sending this thing out, we also make the cmd->next pointer
10440 * point to the real command so we can stuff any possible SENSE data
10441 * into the real command instead of this fake command. This has to be
10442 * done each time the command is built, not just the first time, hence
10443 * it's outside of the above if()...
10444 */
10446 /*
10447 * Clear the buffer so checksums come out right....
10448 */
10451 /*
10452 * Remove any commands for this particular device that might be on the
10453 * waiting_scbs queue or qinfifo so that this command goes out first.
10454 * This is vital for our implementation of domain validation.
10455 */
10460 {
10465 {
10468 {
10473 }
10474 else
10475 {
10477 }
10478 }
10479 }
10481 aic7xxx_negotiation_complete);
10482 }
10483 }
10485 #ifdef AIC7XXX_VERBOSE_DEBUGGING
10486 /*+F*************************************************************************
10487 * Function:
10488 * aic7xxx_print_scb
10489 *
10490 * Description:
10491 * Dump the byte codes for an about to be sent SCB.
10492 *-F*************************************************************************/
10493 static void
10495 {
10502 {
10504 }
10506 }
10507 #endif
10509 /*+F*************************************************************************
10510 * Function:
10511 * aic7xxx_buildscb
10512 *
10513 * Description:
10514 * Build a SCB.
10515 *-F*************************************************************************/
10516 static void
10519 {
10527 /*
10528 * Setup the control byte if we need negotiation and have not
10529 * already requested it.
10530 */
10534 {
10538 {
10542 {
10545 }
10546 else
10547 {
10549 {
10552 }
10553 else
10554 {
10557 }
10559 }
10560 }
10561 }
10563 {
10567 {
10571 {
10573 }
10575 {
10577 }
10579 {
10581 }
10582 }
10583 }
10588 {
10590 }
10594 /*
10595 * The interpretation of request_buffer and request_bufflen
10596 * changes depending on whether or not use_sg is zero; a
10597 * non-zero use_sg indicates the number of elements in the
10598 * scatter-gather array.
10599 */
10601 /*
10602 * XXX - this relies on the host data being stored in a
10603 * little-endian format.
10604 */
10609 {
10612 /*
10613 * We must build an SG list in adapter format, as the kernel's SG list
10614 * cannot be used directly because of data field size (__alpha__)
10615 * differences and the kernel SG list uses virtual addresses where
10616 * we need physical addresses.
10617 */
10622 /*
10623 * Copy the segments into the SG array. NOTE!!! - We used to
10624 * have the first entry both in the data_pointer area and the first
10625 * SG element. That has changed somewhat. We still have the first
10626 * entry in both places, but now we download the address of
10627 * scb->sg_list[1] instead of 0 to the sg pointer in the hscb.
10628 */
10630 {
10634 }
10635 /* Copy the first SG into the data pointer area. */
10641 }
10642 else
10643 {
10645 {
10654 }
10655 else
10656 {
10663 }
10664 }
10665 }
10667 /*+F*************************************************************************
10668 * Function:
10669 * aic7xxx_queue
10670 *
10671 * Description:
10672 * Queue a SCB to the controller.
10673 *-F*************************************************************************/
10674 int
10676 {
10679 #ifdef AIC7XXX_VERBOSE_DEBUGGING
10681 #endif
10682 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
10684 #endif
10687 /*
10688 * Check to see if channel was scanned.
10689 */
10691 #ifdef AIC7XXX_VERBOSE_DEBUGGING
10693 {
10698 }
10699 else
10700 {
10702 {
10707 }
10708 }
10711 {
10718 }
10719 #endif
10723 {
10724 DRIVER_LOCK
10726 DRIVER_UNLOCK
10728 }
10730 {
10734 DRIVER_LOCK
10736 DRIVER_UNLOCK
10738 }
10739 else
10740 {
10744 /*
10745 * Construct the SCB beforehand, so the sequencer is
10746 * paused a minimal amount of time.
10747 */
10750 /*
10751 * Make sure the Scsi_Cmnd pointer is saved, the struct it points to
10752 * is set up properly, and the parity error flag is reset, then send
10753 * the SCB to the sequencer and watch the fun begin.
10754 */
10764 DRIVER_LOCK
10767 {
10769 }
10770 DRIVER_UNLOCK
10771 }
10773 }
10775 /*+F*************************************************************************
10776 * Function:
10777 * aic7xxx_bus_device_reset
10778 *
10779 * Description:
10780 * Abort or reset the current SCSI command(s). If the scb has not
10781 * previously been aborted, then we attempt to send a BUS_DEVICE_RESET
10782 * message to the target. If the scb has previously been unsuccessfully
10783 * aborted, then we will reset the channel and have all devices renegotiate.
10784 * Returns an enumerated type that indicates the status of the operation.
10785 *-F*************************************************************************/
10786 static int
10788 {
10802 {
10806 {
10826 /*
10827 * We're not in a valid phase, so assume we're idle.
10828 */
10831 }
10837 }
10841 /*
10842 * Send a Device Reset Message:
10843 * The target that is holding up the bus may not be the same as
10844 * the one that triggered this timeout (different commands have
10845 * different timeout lengths). Our strategy here is to queue an
10846 * abort message to the timed out target if it is disconnected.
10847 * Otherwise, if we have an active target we stuff the message buffer
10848 * with an abort message and assert ATN in the hopes that the target
10849 * will let go of the bus and go to the mesgout phase. If this
10850 * fails, we'll get another timeout a few seconds later which will
10851 * attempt a bus reset.
10852 */
10857 {
10859 {
10864 }
10866 {
10868 {
10875 BUS_DEVICE_RESET_PENDING;
10876 /* Send the abort message to the active SCB. */
10880 }
10881 else
10882 {
10883 /* We want to send out the message, but it could screw an already */
10884 /* in place and being used message. Instead, we return an error */
10885 /* to try and start the bus reset phase since this command is */
10886 /* probably hung (aborts failed, and now reset is failing). We */
10887 /* also make sure to set BUS_DEVICE_RESET_PENDING so we won't try */
10888 /* any more on this device, but instead will escalate to a bus or */
10889 /* host reset (additionally, we won't try to abort any more). */
10895 BUS_DEVICE_RESET_PENDING;
10897 }
10898 }
10902 {
10904 }
10905 else
10906 {
10909 {
10911 }
10912 }
10914 {
10915 /*
10916 * Simply set the MK_MESSAGE flag and the SEQINT handler will do
10917 * the rest on a reconnect.
10918 */
10922 BUS_DEVICE_RESET_PENDING;
10924 {
10930 }
10931 /*
10932 * Actually requeue this SCB in case we can select the
10933 * device before it reconnects. If the transaction we
10934 * want to abort is not tagged, then this will be the only
10935 * outstanding command and we can simply shove it on the
10936 * qoutfifo and be done. If it is tagged, then it goes right
10937 * in with all the others, no problem :) We need to add it
10938 * to the qinfifo and let the sequencer know it is there.
10939 * Now, the only problem left to deal with is, *IF* this
10940 * command completes, in spite of the MK_MESSAGE bit in the
10941 * control byte, then we need to pick that up in the interrupt
10942 * routine and clean things up. This *shouldn't* ever happen.
10943 */
10950 else
10954 }
10956 {
10958 }
10961 }
10964 /*+F*************************************************************************
10965 * Function:
10966 * aic7xxx_panic_abort
10967 *
10968 * Description:
10969 * Abort the current SCSI command(s).
10970 *-F*************************************************************************/
10971 void
10973 {
10974 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
10980 #endif
10983 UTS_RELEASE);
10993 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
10995 {
10997 {
11016 }
11017 }
11018 /*
11019 * Search for this command and see if we can't track it down, it's the
11020 * one causing the timeout. Print out this command first, then all other
11021 * active commands afterwords.
11022 */
11025 {
11028 {
11035 }
11036 }
11040 {
11044 }
11052 {
11057 }
11062 {
11067 }
11072 {
11076 }
11080 {
11081 /*
11082 * We haven't found the offending SCB yet, and it should be around
11083 * somewhere, so go look for it in the cards SCBs.
11084 */
11087 {
11092 }
11093 }
11097 {
11100 {
11104 }
11105 }
11106 #endif
11109 }
11111 /*+F*************************************************************************
11112 * Function:
11113 * aic7xxx_abort
11114 *
11115 * Description:
11116 * Abort the current SCSI command(s).
11117 *-F*************************************************************************/
11118 int
11120 {
11125 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
11127 #endif
11133 /*
11134 * I added a new config option to the driver: "panic_on_abort" that will
11135 * cause the driver to panic and the machine to stop on the first abort
11136 * or reset call into the driver. At that point, it prints out a lot of
11137 * usefull information for me which I can then use to try and debug the
11138 * problem. Simply enable the boot time prompt in order to activate this
11139 * code.
11140 */
11144 DRIVER_LOCK
11146 /*
11147 * Run the isr to grab any command in the QOUTFIFO and any other misc.
11148 * assundry tasks. This should also set up the bh handler if there is
11149 * anything to be done, but it won't run until we are done here since
11150 * we are following a straight code path without entering the scheduler
11151 * code.
11152 */
11156 {
11160 }
11163 /* Totally bogus cmd since it points beyond our */
11165 /* timeout serial number. */
11170 DRIVER_UNLOCK
11172 }
11175 /* has already been recycled for another command */
11176 /* Either way, this SCB has nothing to do with this*/
11177 /* command and we need to deal with cmd without */
11178 /* touching the SCB. */
11179 /* The theory here is to return a value that will */
11180 /* make the queued for complete command actually */
11181 /* finish successfully, or to indicate that we */
11182 /* don't have this cmd any more and the mid level */
11183 /* code needs to find it. */
11187 {
11189 {
11195 else
11199 DRIVER_UNLOCK
11201 * completion */
11202 }
11205 }
11210 DRIVER_UNLOCK
11212 }
11214 /* At this point we know the following:
11215 * the SCB pointer is valid
11216 * the command pointer passed in to us and the scb->cmd pointer match
11217 * this then means that the command we need to abort is the same as the
11218 * command held by the scb pointer and is a valid abort request.
11219 * Now, we just have to figure out what to do from here. Current plan is:
11220 * if we have already been here on this command, escalate to a reset
11221 * if scb is on waiting list or QINFIFO, send it back as aborted, but
11222 * we also need to be aware of the possibility that we could be using
11223 * a faked negotiation command that is holding this command up, if
11224 * so we need to take care of that command instead, which means we
11225 * would then treat this one like it was sitting around disconnected
11226 * instead.
11227 * if scb is on WAITING_SCB list in sequencer, free scb and send back
11228 * if scb is disconnected and not completed, abort with abort message
11229 * if scb is currently running, then it may be causing the bus to hang
11230 * so we want a return value that indicates a reset would be appropriate
11231 * if the command does not finish shortly
11232 * if scb is already complete but not on completeq, we're screwed because
11233 * this can't happen (except if the command is in the QOUTFIFO, in which
11234 * case we would like it to complete successfully instead of having to
11235 * to be re-done)
11236 * All other scenarios already dealt with by previous code.
11237 */
11240 {
11245 DRIVER_UNLOCK
11247 }
11250 BUS_DEVICE_RESET_PENDING) )
11251 {
11256 DRIVER_UNLOCK
11258 }
11266 /*
11267 * First, let's check to see if the currently running command is our target
11268 * since if it is, the return is fairly easy and quick since we don't want
11269 * to touch the command in case it might complete, but we do want a timeout
11270 * in case it's actually hung, so we really do nothing, but tell the mid
11271 * level code to reset the timeout.
11272 */
11275 {
11276 /*
11277 * Check to see if the sequencer is just sitting on this command, or
11278 * if it's actively being run.
11279 */
11282 {
11296 DRIVER_UNLOCK /* muck with other SCBs if this */
11301 }
11302 }
11305 {
11312 {
11315 else
11317 }
11318 else
11319 {
11321 }
11323 {
11324 /*
11325 * OK..this means the command we are currently getting an abort
11326 * for has an outstanding negotiation command in front of it.
11327 * We don't really have a way to tie back into the negotiation
11328 * commands, so we just send this back as pending, then it
11329 * will get reset in 2 seconds.
11330 */
11333 DRIVER_UNLOCK
11335 }
11346 }
11348 /*
11349 * We just checked the waiting_q, now for the QINFIFO
11350 */
11352 {
11360 }
11362 /*
11363 * QINFIFO, waitingq, completeq done. Next, check WAITING_SCB list in card
11364 */
11367 {
11373 {
11376 {
11382 {
11384 /* stop the selection since we just
11385 * grabbed the scb out from under the
11386 * card
11387 */
11390 }
11391 else
11392 {
11397 }
11403 }
11406 }
11408 }
11410 /*
11411 * Hmmm...completeq, QOUTFIFO, QINFIFO, WAITING_SCBH, waitingq all checked.
11412 * OK...the sequencer's paused, interrupts are off, and we haven't found the
11413 * command anyplace where it could be easily aborted. Time for the hard
11414 * work. We also know the command is valid. This essentially means the
11415 * command is disconnected, or connected but not into any phases yet, which
11416 * we know due to the tests we ran earlier on the current active scb phase.
11417 * At this point we can queue the abort tag and go on with life.
11418 */
11421 {
11427 {
11433 }
11440 else
11442 }
11444 {
11447 }
11450 DRIVER_UNLOCK
11452 /*
11453 * On the return value. If we found the command and aborted it, then we know
11454 * it's already sent back and there is no reason for a further timeout, so
11455 * we use SCSI_ABORT_SUCCESS. On the queued abort side, we aren't so certain
11456 * there hasn't been a bus hang or something that might keep the abort from
11457 * from completing. Therefore, we use SCSI_ABORT_PENDING. The first time this
11458 * is passed back, the timeout on the command gets extended, the second time
11459 * we pass this back, the mid level SCSI code calls our reset function, which
11460 * would shake loose a hung bus.
11461 */
11464 else
11466 }
11469 /*+F*************************************************************************
11470 * Function:
11471 * aic7xxx_reset
11472 *
11473 * Description:
11474 * Resetting the bus always succeeds - is has to, otherwise the
11475 * kernel will panic! Try a surgical technique - sending a BUS
11476 * DEVICE RESET message - on the offending target before pulling
11477 * the SCSI bus reset line.
11478 *-F*************************************************************************/
11479 int
11481 {
11486 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
11488 #endif
11489 #define DEVICE_RESET 0x01
11490 #define BUS_RESET 0x02
11491 #define HOST_RESET 0x04
11492 #define FAIL 0x08
11493 #define RESET_DELAY 0x10
11499 {
11503 }
11509 /*
11510 * I added a new config option to the driver: "panic_on_abort" that will
11511 * cause the driver to panic and the machine to stop on the first abort
11512 * or reset call into the driver. At that point, it prints out a lot of
11513 * usefull information for me which I can then use to try and debug the
11514 * problem. Simply enable the boot time prompt in order to activate this
11515 * code.
11516 */
11520 DRIVER_LOCK
11524 {
11528 }
11531 {
11536 {
11538 }
11539 else
11540 {
11542 }
11543 }
11545 {
11552 {
11554 {
11559 DRIVER_UNLOCK
11561 }
11564 }
11566 {
11571 DRIVER_UNLOCK
11573 }
11574 else
11575 {
11581 }
11582 }
11583 else
11584 {
11589 {
11596 DRIVER_UNLOCK
11598 }
11600 {
11602 }
11604 {
11606 }
11607 else
11608 {
11610 }
11611 }
11614 {
11619 }
11622 {
11624 {
11629 }
11631 }
11634 {
11639 }
11641 {
11643 }
11646 {
11648 {
11653 }
11655 }
11658 {
11663 }
11664 /*
11665 * By this point, we want to already know what we are going to do and
11666 * only have the following code implement our course of action.
11667 */
11669 {
11672 DRIVER_UNLOCK
11677 DRIVER_UNLOCK
11684 /* We can't rely on run_waiting_queues to unpause the sequencer for
11685 * PCI based controllers since we use AAP */
11689 DRIVER_UNLOCK
11700 {
11705 }
11708 {
11711 }
11714 else
11715 {
11718 SIMODE1);
11724 }
11726 /*
11727 * If this a SCSI_RESET_SYNCHRONOUS then the command we were given is
11728 * in need of being re-started, so send it on through to aic7xxx_queue
11729 * and let it set until the delay is over. This keeps it from dying
11730 * entirely and avoids getting a bogus dead command back through the
11731 * mid-level code due to too many retries.
11732 */
11733 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,132)
11735 {
11738 }
11739 #endif
11741 /*
11742 * We can't rely on run_waiting_queues to unpause the sequencer for
11743 * PCI based controllers since we use AAP. NOTE: this also sets
11744 * the timer for the one command we might have queued in the case
11745 * of a synch reset.
11746 */
11749 DRIVER_UNLOCK
11752 }
11753 }
11755 /*+F*************************************************************************
11756 * Function:
11757 * aic7xxx_biosparam
11758 *
11759 * Description:
11760 * Return the disk geometry for the given SCSI device.
11761 *-F*************************************************************************/
11762 int
11764 {
11773 {
11778 }
11785 {
11789 }
11796 }
11798 /*+F*************************************************************************
11799 * Function:
11800 * aic7xxx_release
11801 *
11802 * Description:
11803 * Free the passed in Scsi_Host memory structures prior to unloading the
11804 * module.
11805 *-F*************************************************************************/
11806 int
11808 {
11815 #ifdef MMAPIO
11817 {
11818 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
11820 #else
11822 #endif
11823 }
11828 {
11830 {
11833 else
11835 }
11836 else
11837 {
11839 }
11841 }
11844 }
11846 /*+F*************************************************************************
11847 * Function:
11848 * aic7xxx_print_card
11849 *
11850 * Description:
11851 * Print out all of the control registers on the card
11852 *
11853 * NOTE: This function is not yet safe for use on the VLB and EISA
11854 * controllers, so it isn't used on those controllers at all.
11855 *-F*************************************************************************/
11856 static void
11858 {
11892 };
11893 #ifdef CONFIG_PCI
11912 };
11913 #endif
11915 /*
11916 * Let's run through the PCI space first....
11917 */
11921 {
11933 }
11935 #ifdef CONFIG_PCI
11936 {
11942 {
11945 j++)
11946 {
11947 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,92)
11949 #else
11951 #endif
11954 {
11957 }
11958 }
11959 }
11960 }
11965 /*
11966 * Now the registers on the card....
11967 */
11971 {
11974 j++)
11975 {
11978 {
11981 }
11982 }
11983 }
11987 {
11993 {
11997 else
11999 }
12000 }
12002 /*
12003 * If this was an Ultra2 controller, then we just hosed the card in terms
12004 * of the QUEUE REGS. This function is only called at init time or by
12005 * the panic_abort function, so it's safe to assume a generic init time
12006 * setting here
12007 */
12010 {
12014 }
12016 }
12018 /*+F*************************************************************************
12019 * Function:
12020 * aic7xxx_print_scratch_ram
12021 *
12022 * Description:
12023 * Print out the scratch RAM values on the card.
12024 *-F*************************************************************************/
12025 static void
12027 {
12033 {
12036 {
12039 }
12040 }
12042 {
12044 {
12047 {
12050 }
12051 }
12052 }
12054 }
12059 #ifdef MODULE
12060 /* Eventually this will go into an include file, but this will be later */
12064 #endif
12066 /*
12067 * Overrides for Emacs so that we almost follow Linus's tabbing style.
12068 * Emacs will notice this stuff at the end of the file and automatically
12069 * adjust the settings for this buffer only. This must remain at the end
12070 * of the file.
12071 * ---------------------------------------------------------------------------
12072 * Local variables:
12073 * c-indent-level: 2
12074 * c-brace-imaginary-offset: 0
12075 * c-brace-offset: -2
12076 * c-argdecl-indent: 2
12077 * c-label-offset: -2
12078 * c-continued-statement-offset: 2
12079 * c-continued-brace-offset: 0
12080 * indent-tabs-mode: nil
12081 * tab-width: 8
12082 * End:
12083 */