| blob | 8bb8cd96d99c1ab7eb035063a5113079c157b638 |
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>
245 #include <linux/init.h>
246 #include <linux/spinlock.h>
247 #include <linux/smp.h>
256 #include <scsi/scsicam.h>
258 #include <linux/stat.h>
263 /*
264 * To generate the correct addresses for the controller to issue
265 * on the bus. Originally added for DEC Alpha support.
266 */
267 #define VIRT_TO_BUS(a) (unsigned int)virt_to_bus((void *)(a))
271 #define NUMBER(arr) (sizeof(arr) / sizeof(arr[0]))
272 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
273 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
274 #define ALL_TARGETS -1
275 #define ALL_CHANNELS -1
276 #define ALL_LUNS -1
277 #define MAX_TARGETS 16
278 #define MAX_LUNS 8
279 #ifndef TRUE
280 # define TRUE 1
281 #endif
282 #ifndef FALSE
283 # define FALSE 0
284 #endif
286 #if defined(__powerpc__) || defined(__i386__)
287 # define MMAPIO
288 #endif
290 # if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
291 # define cpuid smp_processor_id()
292 # define DRIVER_LOCK_INIT \
293 spin_lock_init(&p->spin_lock);
294 # define DRIVER_LOCK \
295 if(!p->cpu_lock_count[cpuid]) { \
296 spin_lock_irqsave(&p->spin_lock, cpu_flags); \
297 p->cpu_lock_count[cpuid]++; \
298 } else { \
299 p->cpu_lock_count[cpuid]++; \
300 }
301 # define DRIVER_UNLOCK \
302 if(--p->cpu_lock_count[cpuid] == 0) \
303 spin_unlock_irqrestore(&p->spin_lock, cpu_flags);
304 # else
305 # define DRIVER_LOCK_INIT
306 # define DRIVER_LOCK
307 # define DRIVER_UNLOCK
308 # endif
310 /*
311 * You can try raising me if tagged queueing is enabled, or lowering
312 * me if you only have 4 SCBs.
313 */
314 #ifdef CONFIG_AIC7XXX_CMDS_PER_DEVICE
315 #define AIC7XXX_CMDS_PER_DEVICE CONFIG_AIC7XXX_CMDS_PER_DEVICE
316 #else
317 #define AIC7XXX_CMDS_PER_DEVICE 8
318 #endif
320 /*
321 * Control collection of SCSI transfer statistics for the /proc filesystem.
322 *
323 * NOTE: Do NOT enable this when running on kernels version 1.2.x and below.
324 * NOTE: This does affect performance since it has to maintain statistics.
325 */
326 #ifdef CONFIG_AIC7XXX_PROC_STATS
327 #define AIC7XXX_PROC_STATS
328 #endif
330 /*
331 * *** Determining commands per LUN ***
332 *
333 * When AIC7XXX_CMDS_PER_DEVICE is not defined, the driver will use its
334 * own algorithm to determine the commands/LUN. If SCB paging is
335 * enabled, which is always now, the default is 8 commands per lun
336 * that indicates it supports tagged queueing. All non-tagged devices
337 * use an internal queue depth of 3, with no more than one of those
338 * three commands active at one time.
339 */
342 {
346 /*
347 * Make a define that will tell the driver not to use tagged queueing
348 * by default.
349 */
350 #ifdef CONFIG_AIC7XXX_TCQ_ON_BY_DEFAULT
351 #define DEFAULT_TAG_COMMANDS {0, 0, 0, 0, 0, 0, 0, 0,\
352 0, 0, 0, 0, 0, 0, 0, 0}
353 #else
354 #define DEFAULT_TAG_COMMANDS {255, 255, 255, 255, 255, 255, 255, 255,\
355 255, 255, 255, 255, 255, 255, 255, 255}
356 #endif
358 /*
359 * Modify this as you see fit for your system. By setting tag_commands
360 * to 0, the driver will use it's own algorithm for determining the
361 * number of commands to use (see above). When 255, the driver will
362 * not enable tagged queueing for that particular device. When positive
363 * (> 0) and (< 255) the values in the array are used for the queue_depth.
364 * Note that the maximum value for an entry is 254, but you're insane if
365 * you try to use that many commands on one device.
366 *
367 * In this example, the first line will disable tagged queueing for all
368 * the devices on the first probed aic7xxx adapter.
369 *
370 * The second line enables tagged queueing with 4 commands/LUN for IDs
371 * (1, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
372 * driver to use its own algorithm for ID 1.
373 *
374 * The third line is the same as the first line.
375 *
376 * The fourth line disables tagged queueing for devices 0 and 3. It
377 * enables tagged queueing for the other IDs, with 16 commands/LUN
378 * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
379 * IDs 2, 5-7, and 9-15.
380 */
382 /*
383 * NOTE: The below structure is for reference only, the actual structure
384 * to modify in order to change things is found after this fake one.
385 *
386 adapter_tag_info_t aic7xxx_tag_info[] =
387 {
388 {DEFAULT_TAG_COMMANDS},
389 {{4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 255, 4, 4, 4}},
390 {DEFAULT_TAG_COMMANDS},
391 {{255, 16, 4, 255, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
392 };
393 */
396 {
413 };
416 /*
417 * Define an array of board names that can be indexed by aha_type.
418 * Don't forget to change this when changing the types!
419 */
451 };
453 /*
454 * There should be a specific return value for this in scsi.h, but
455 * it seems that most drivers ignore it.
456 */
457 #define DID_UNDERFLOW DID_ERROR
459 /*
460 * What we want to do is have the higher level scsi driver requeue
461 * the command to us. There is no specific driver status for this
462 * condition, but the higher level scsi driver will requeue the
463 * command on a DID_BUS_BUSY error.
464 *
465 * Upon further inspection and testing, it seems that DID_BUS_BUSY
466 * will *always* retry the command. We can get into an infinite loop
467 * if this happens when we really want some sort of counter that
468 * will automatically abort/reset the command after so many retries.
469 * Using DID_ERROR will do just that. (Made by a suggestion by
470 * Doug Ledford 8/1/96)
471 */
472 #define DID_RETRY_COMMAND DID_ERROR
474 #define HSCSIID 0x07
475 #define SCSI_RESET 0x040
477 /*
478 * EISA/VL-bus stuff
479 */
480 #define MINSLOT 1
481 #define MAXSLOT 15
482 #define SLOTBASE(x) ((x) << 12)
483 #define BASE_TO_SLOT(x) ((x) >> 12)
485 /*
486 * Standard EISA Host ID regs (Offset from slot base)
487 */
493 /*
494 * AIC-7770 I/O range to reserve for a card
495 */
496 #define MINREG 0xC00
497 #define MAXREG 0xCFF
501 /*
502 * AIC-78X0 PCI registers
503 */
504 #define CLASS_PROGIF_REVID 0x08
505 #define DEVREVID 0x000000FFul
506 #define PROGINFC 0x0000FF00ul
507 #define SUBCLASS 0x00FF0000ul
508 #define BASECLASS 0xFF000000ul
510 #define CSIZE_LATTIME 0x0C
512 #define LATTIME 0x0000FF00ul
514 #define DEVCONFIG 0x40
518 #define RAMPSM_ULTRA2 0x00000004
519 #define VOLSENSE 0x00000100ul
520 #define SCBRAMSEL 0x00000080ul
521 #define SCBRAMSEL_ULTRA2 0x00000008
522 #define MRDCEN 0x00000040ul
525 #define BERREN 0x00000008ul
526 #define DACEN 0x00000004ul
527 #define STPWLEVEL 0x00000002ul
533 /*
534 * Define the different types of SEEPROMs on aic7xxx adapters
535 * and make it also represent the address size used in accessing
536 * its registers. The 93C46 chips have 1024 bits organized into
537 * 64 16-bit words, while the 93C56 chips have 2048 bits organized
538 * into 128 16-bit words. The C46 chips use 6 bits to address
539 * each word, while the C56 and C66 (4096 bits) use 8 bits to
540 * address each word.
541 */
544 /*
545 *
546 * Define the format of the SEEPROM registers (16 bits).
547 *
548 */
551 /*
552 * SCSI ID Configuration Flags
553 */
566 /* UNUSED 0x3000 */
569 /*
570 * BIOS Control Bits
571 */
575 /* UNUSED 0x0008 */
578 /* UNUSED 0x0040 */
580 /* UNUSED 0xFF00 */
583 /*
584 * Host Adapter Control Bits
585 */
598 /* UNUSED 0xF280 */
601 /*
602 * Bus Release, Host Adapter ID
603 */
605 /* UNUSED 0x00F0 */
609 /*
610 * Maximum targets
611 */
613 /* UNUSED 0xFF00 */
618 };
620 #define SELBUS_MASK 0x0a
621 #define SELNARROW 0x00
622 #define SELBUSB 0x08
623 #define SINGLE_BUS 0x00
625 #define SCB_TARGET(scb) \
626 (((scb)->hscb->target_channel_lun & TID) >> 4)
627 #define SCB_LUN(scb) \
628 ((scb)->hscb->target_channel_lun & LID)
629 #define SCB_IS_SCSIBUS_B(scb) \
630 (((scb)->hscb->target_channel_lun & SELBUSB) != 0)
632 /*
633 * If an error occurs during a data transfer phase, run the command
634 * to completion - it's easier that way - making a note of the error
635 * condition in this location. This then will modify a DID_OK status
636 * into an appropriate error for the higher-level SCSI code.
637 */
638 #define aic7xxx_error(cmd) ((cmd)->SCp.Status)
640 /*
641 * Keep track of the targets returned status.
642 */
643 #define aic7xxx_status(cmd) ((cmd)->SCp.sent_command)
645 /*
646 * The position of the SCSI commands scb within the scb array.
647 */
648 #define aic7xxx_position(cmd) ((cmd)->SCp.have_data_in)
650 /*
651 * The stored DMA mapping for single-buffer data transfers.
652 */
653 #define aic7xxx_mapping(cmd) ((cmd)->SCp.phase)
655 /*
656 * So we can keep track of our host structs
657 */
660 /*
661 * As of Linux 2.1, the mid-level SCSI code uses virtual addresses
662 * in the scatter-gather lists. We need to convert the virtual
663 * addresses to physical addresses.
664 */
668 };
670 /*
671 * Maximum number of SG segments these cards can support.
672 */
673 #define AIC7XXX_MAX_SG 128
675 /*
676 * The maximum number of SCBs we could have for ANY type
677 * of card. DON'T FORGET TO CHANGE THE SCB MASK IN THE
678 * SEQUENCER CODE IF THIS IS MODIFIED!
679 */
680 #define AIC7XXX_MAXSCB 255
684 /* ------------ Begin hardware supported fields ---------------- */
697 * Also used as the tag for tagged I/O
698 */
700 * via PIO to initialize a transaction.
701 */
703 * or disconnected down in the sequencer.
704 */
707 * Unused by the kernel, but we require
708 * the padding so that the array of
709 * hardware SCBs is alligned on 32 byte
710 * boundaries so the sequencer can index
711 */
712 };
728 SCB_MSGOUT_SENT |
729 SCB_MSGOUT_SDTR |
730 SCB_MSGOUT_WDTR,
753 /*
754 * Here ends the FreeBSD defined flags and here begins the linux defined
755 * flags. NOTE: I did not preserve the old flag name during this change
756 * specifically to force me to evaluate what flags were being used properly
757 * and what flags weren't. This way, I could clean up the flag usage on
758 * a use by use basis. Doug Ledford
759 */
771 #define AHC_IN_ISR_BIT 28
822 #define SCB_DMA_ADDR(scb, addr) ((unsigned long)(addr) + (scb)->scb_dma->dma_offset)
826 * to virtual address to get
827 * dma handle in this region */
829 * for unmap */
831 };
842 * Allocate 6 characters for
843 * sense command.
844 */
847 * don't have to calculate anything
848 * during underflow/overflow/stat code
849 */
852 };
854 /*
855 * Define a linked list of SCBs.
856 */
874 };
876 static unsigned char
881 * SCBs assigned to free slot on
882 * card (no paging required)
883 */
897 };
899 #define AHC_TRANS_CUR 0x0001
900 #define AHC_TRANS_ACTIVE 0x0002
901 #define AHC_TRANS_GOAL 0x0004
902 #define AHC_TRANS_USER 0x0008
903 #define AHC_TRANS_QUITE 0x0010
919 /*
920 * Define a structure used for each host adapter. Note, in order to avoid
921 * problems with architectures I can't test on (because I don't have one,
922 * such as the Alpha based systems) which happen to give faults for
923 * non-aligned memory accesses, care was taken to align this structure
924 * in a way that gauranteed all accesses larger than 8 bits were aligned
925 * on the appropriate boundary. It's also organized to try and be more
926 * cache line efficient. Be careful when changing this lest you might hurt
927 * overall performance and bring down the wrath of the masses.
928 */
930 /*
931 * This is the first 64 bytes in the host struct
932 */
934 /*
935 * We are grouping things here....first, items that get either read or
936 * written with nearly every interrupt
937 */
955 /*
956 * Things read/written on nearly every entry into aic7xxx_queue()
957 */
972 #define DEVICE_PRESENT 0x01
973 #define BUS_DEVICE_RESET_PENDING 0x02
974 #define DEVICE_RESET_DELAY 0x04
975 #define DEVICE_PRINT_DTR 0x08
976 #define DEVICE_PARITY_ERROR 0x10
977 #define DEVICE_WAS_BUSY 0x20
978 #define DEVICE_SCSI_3 0x40
979 #define DEVICE_SCANNED 0x80
989 spinlock_t spin_lock;
1005 #define MSG_TYPE_NONE 0x00
1006 #define MSG_TYPE_INITIATOR_MSGOUT 0x01
1007 #define MSG_TYPE_INITIATOR_MSGIN 0x02
1013 /*
1014 * We put the less frequently used host structure items after the more
1015 * frequently used items to try and ease the burden on the cache subsystem.
1016 * These entries are not *commonly* accessed, whereas the preceding entries
1017 * are accessed very often.
1018 */
1045 /*
1046 * Statistics Kept:
1047 *
1048 * Total Xfers (count for each command that has a data xfer),
1049 * broken down further by reads && writes.
1050 *
1051 * Binned sizes, writes && reads:
1052 * < 512, 512, 1-2K, 2-4K, 4-8K, 8-16K, 16-32K, 32-64K, 64K-128K, > 128K
1053 *
1054 * Total amounts read/written above 512 bytes (amts under ignored)
1055 *
1056 * NOTE: Enabling this feature is likely to cause a noticeable performance
1057 * decrease as the accesses into the stats structures blows apart multiple
1058 * cache lines and is CPU time consuming.
1059 *
1060 * NOTE: Since it doesn't really buy us much, but consumes *tons* of RAM
1061 * and blows apart all sorts of cache lines, I modified this so that we
1062 * no longer look at the LUN. All LUNs now go into the same bin on each
1063 * device for stats purposes.
1064 */
1068 #ifdef AIC7XXX_PROC_STATS
1074 #if 0
1077 #endif
1079 };
1081 /*
1082 * Valid SCSIRATE values. (p. 3-17)
1083 * Provides a mapping of transfer periods in ns/4 to the proper value to
1084 * stick in the SCSIRATE reg to use that transfer rate.
1085 */
1086 #define AHC_SYNCRATE_ULTRA3 0
1087 #define AHC_SYNCRATE_ULTRA2 1
1088 #define AHC_SYNCRATE_ULTRA 3
1089 #define AHC_SYNCRATE_FAST 6
1090 #define AHC_SYNCRATE_CRC 0x40
1091 #define AHC_SYNCRATE_SE 0x10
1093 /* Rates in Ultra mode have bit 8 of sxfr set */
1094 #define ULTRA_SXFR 0x100
1115 };
1117 #define CTL_OF_SCB(scb) (((scb->hscb)->target_channel_lun >> 3) & 0x1), \
1118 (((scb->hscb)->target_channel_lun >> 4) & 0xf), \
1119 ((scb->hscb)->target_channel_lun & 0x07)
1121 #define CTL_OF_CMD(cmd) ((cmd->channel) & 0x01), \
1122 ((cmd->target) & 0x0f), \
1123 ((cmd->lun) & 0x07)
1125 #define TARGET_INDEX(cmd) ((cmd)->target | ((cmd)->channel << 3))
1127 /*
1128 * A nice little define to make doing our printks a little easier
1129 */
1134 /*
1135 * XXX - these options apply unilaterally to _all_ 274x/284x/294x
1136 * cards in the system. This should be fixed. Exceptions to this
1137 * rule are noted in the comments.
1138 */
1141 /*
1142 * Skip the scsi bus reset. Non 0 make us skip the reset at startup. This
1143 * has no effect on any later resets that might occur due to things like
1144 * SCSI bus timeouts.
1145 */
1147 /*
1148 * Certain PCI motherboards will scan PCI devices from highest to lowest,
1149 * others scan from lowest to highest, and they tend to do all kinds of
1150 * strange things when they come into contact with PCI bridge chips. The
1151 * net result of all this is that the PCI card that is actually used to boot
1152 * the machine is very hard to detect. Most motherboards go from lowest
1153 * PCI slot number to highest, and the first SCSI controller found is the
1154 * one you boot from. The only exceptions to this are when a controller
1155 * has its BIOS disabled. So, we by default sort all of our SCSI controllers
1156 * from lowest PCI slot number to highest PCI slot number. We also force
1157 * all controllers with their BIOS disabled to the end of the list. This
1158 * works on *almost* all computers. Where it doesn't work, we have this
1159 * option. Setting this option to non-0 will reverse the order of the sort
1160 * to highest first, then lowest, but will still leave cards with their BIOS
1161 * disabled at the very end. That should fix everyone up unless there are
1162 * really strange cirumstances.
1163 */
1165 /*
1166 * Should we force EXTENDED translation on a controller.
1167 * 0 == Use whatever is in the SEEPROM or default to off
1168 * 1 == Use whatever is in the SEEPROM or default to on
1169 */
1171 /*
1172 * The IRQ trigger method used on EISA controllers. Does not effect PCI cards.
1173 * -1 = Use detected settings.
1174 * 0 = Force Edge triggered mode.
1175 * 1 = Force Level triggered mode.
1176 */
1178 /*
1179 * This variable is used to override the termination settings on a controller.
1180 * This should not be used under normal conditions. However, in the case
1181 * that a controller does not have a readable SEEPROM (so that we can't
1182 * read the SEEPROM settings directly) and that a controller has a buggered
1183 * version of the cable detection logic, this can be used to force the
1184 * correct termination. It is preferable to use the manual termination
1185 * settings in the BIOS if possible, but some motherboard controllers store
1186 * those settings in a format we can't read. In other cases, auto term
1187 * should also work, but the chipset was put together with no auto term
1188 * logic (common on motherboard controllers). In those cases, we have
1189 * 32 bits here to work with. That's good for 8 controllers/channels. The
1190 * bits are organized as 4 bits per channel, with scsi0 getting the lowest
1191 * 4 bits in the int. A 1 in a bit position indicates the termination setting
1192 * that corresponds to that bit should be enabled, a 0 is disabled.
1193 * It looks something like this:
1194 *
1195 * 0x0f = 1111-Single Ended Low Byte Termination on/off
1196 * ||\-Single Ended High Byte Termination on/off
1197 * |\-LVD Low Byte Termination on/off
1198 * \-LVD High Byte Termination on/off
1199 *
1200 * For non-Ultra2 controllers, the upper 2 bits are not important. So, to
1201 * enable both high byte and low byte termination on scsi0, I would need to
1202 * make sure that the override_term variable was set to 0x03 (bits 0011).
1203 * To make sure that all termination is enabled on an Ultra2 controller at
1204 * scsi2 and only high byte termination on scsi1 and high and low byte
1205 * termination on scsi0, I would set override_term=0xf23 (bits 1111 0010 0011)
1206 *
1207 * For the most part, users should never have to use this, that's why I
1208 * left it fairly cryptic instead of easy to understand. If you need it,
1209 * most likely someone will be telling you what your's needs to be set to.
1210 */
1212 /*
1213 * Certain motherboard chipset controllers tend to screw
1214 * up the polarity of the term enable output pin. Use this variable
1215 * to force the correct polarity for your system. This is a bitfield variable
1216 * similar to the previous one, but this one has one bit per channel instead
1217 * of four.
1218 * 0 = Force the setting to active low.
1219 * 1 = Force setting to active high.
1220 * Most Adaptec cards are active high, several motherboards are active low.
1221 * To force a 2940 card at SCSI 0 to active high and a motherboard 7895
1222 * controller at scsi1 and scsi2 to active low, and a 2910 card at scsi3
1223 * to active high, you would need to set stpwlev=0x9 (bits 1001).
1224 *
1225 * People shouldn't need to use this, but if you are experiencing lots of
1226 * SCSI timeout problems, this may help. There is one sure way to test what
1227 * this option needs to be. Using a boot floppy to boot the system, configure
1228 * your system to enable all SCSI termination (in the Adaptec SCSI BIOS) and
1229 * if needed then also pass a value to override_term to make sure that the
1230 * driver is enabling SCSI termination, then set this variable to either 0
1231 * or 1. When the driver boots, make sure there are *NO* SCSI cables
1232 * connected to your controller. If it finds and inits the controller
1233 * without problem, then the setting you passed to stpwlev was correct. If
1234 * the driver goes into a reset loop and hangs the system, then you need the
1235 * other setting for this variable. If neither setting lets the machine
1236 * boot then you have definite termination problems that may not be fixable.
1237 */
1239 /*
1240 * Set this to non-0 in order to force the driver to panic the kernel
1241 * and print out debugging info on a SCSI abort or reset cycle.
1242 */
1244 /*
1245 * PCI bus parity checking of the Adaptec controllers. This is somewhat
1246 * dubious at best. To my knowledge, this option has never actually
1247 * solved a PCI parity problem, but on certain machines with broken PCI
1248 * chipset configurations, it can generate tons of false error messages.
1249 * It's included in the driver for completeness.
1250 * 0 = Shut off PCI parity check
1251 * -1 = Normal polarity pci parity checking
1252 * 1 = reverse polarity pci parity checking
1253 *
1254 * NOTE: you can't actually pass -1 on the lilo prompt. So, to set this
1255 * variable to -1 you would actually want to simply pass the variable
1256 * name without a number. That will invert the 0 which will result in
1257 * -1.
1258 */
1260 /*
1261 * Set this to any non-0 value to cause us to dump the contents of all
1262 * the card's registers in a hex dump format tailored to each model of
1263 * controller.
1264 *
1265 * NOTE: THE CONTROLLER IS LEFT IN AN UNUSEABLE STATE BY THIS OPTION.
1266 * YOU CANNOT BOOT UP WITH THIS OPTION, IT IS FOR DEBUGGING PURPOSES
1267 * ONLY
1268 */
1270 /*
1271 * Set this to a non-0 value to make us dump out the 32 bit instruction
1272 * registers on the card after completing the sequencer download. This
1273 * allows the actual sequencer download to be verified. It is possible
1274 * to use this option and still boot up and run your system. This is
1275 * only intended for debugging purposes.
1276 */
1278 /*
1279 * Certain newer motherboards have put new PCI based devices into the
1280 * IO spaces that used to typically be occupied by VLB or EISA cards.
1281 * This overlap can cause these newer motherboards to lock up when scanned
1282 * for older EISA and VLB devices. Setting this option to non-0 will
1283 * cause the driver to skip scanning for any VLB or EISA controllers and
1284 * only support the PCI controllers. NOTE: this means that if the kernel
1285 * os compiled with PCI support disabled, then setting this to non-0
1286 * would result in never finding any devices :)
1287 */
1289 /*
1290 * On some machines, enabling the external SCB RAM isn't reliable yet. I
1291 * haven't had time to make test patches for things like changing the
1292 * timing mode on that external RAM either. Some of those changes may
1293 * fix the problem. Until then though, we default to external SCB RAM
1294 * off and give a command line option to enable it.
1295 */
1297 /*
1298 * So that we can set how long each device is given as a selection timeout.
1299 * The table of values goes like this:
1300 * 0 - 256ms
1301 * 1 - 128ms
1302 * 2 - 64ms
1303 * 3 - 32ms
1304 * We default to 64ms because it's fast. Some old SCSI-I devices need a
1305 * longer time. The final value has to be left shifted by 3, hence 0x10
1306 * is the final value.
1307 */
1309 /*
1310 * So that insmod can find the variable and make it point to something
1311 */
1312 #ifdef MODULE
1316 /*
1317 * Just in case someone uses commas to separate items on the insmod
1318 * command line, we define a dummy buffer here to avoid having insmod
1319 * write wild stuff into our code segment
1320 */
1323 #endif
1325 #define VERBOSE_NORMAL 0x0000
1326 #define VERBOSE_NEGOTIATION 0x0001
1327 #define VERBOSE_SEQINT 0x0002
1328 #define VERBOSE_SCSIINT 0x0004
1329 #define VERBOSE_PROBE 0x0008
1330 #define VERBOSE_PROBE2 0x0010
1331 #define VERBOSE_NEGOTIATION2 0x0020
1332 #define VERBOSE_MINOR_ERROR 0x0040
1333 #define VERBOSE_TRACING 0x0080
1334 #define VERBOSE_ABORT 0x0f00
1335 #define VERBOSE_ABORT_MID 0x0100
1336 #define VERBOSE_ABORT_FIND 0x0200
1337 #define VERBOSE_ABORT_PROCESS 0x0400
1338 #define VERBOSE_ABORT_RETURN 0x0800
1339 #define VERBOSE_RESET 0xf000
1340 #define VERBOSE_RESET_MID 0x1000
1341 #define VERBOSE_RESET_FIND 0x2000
1342 #define VERBOSE_RESET_PROCESS 0x4000
1343 #define VERBOSE_RESET_RETURN 0x8000
1348 /****************************************************************************
1349 *
1350 * We're going to start putting in function declarations so that order of
1351 * functions is no longer important. As needed, they are added here.
1352 *
1353 ***************************************************************************/
1359 #ifdef AIC7XXX_VERBOSE_DEBUGGING
1361 #endif
1363 /****************************************************************************
1364 *
1365 * These functions are now used. They happen to be wrapped in useless
1366 * inb/outb port read/writes around the real reads and writes because it
1367 * seems that certain very fast CPUs have a problem dealing with us when
1368 * going at full speed.
1369 *
1370 ***************************************************************************/
1374 {
1375 #ifdef MMAPIO
1378 {
1380 }
1381 else
1382 {
1384 }
1386 #else
1388 #endif
1389 }
1393 {
1394 #ifdef MMAPIO
1396 {
1400 }
1401 else
1402 {
1405 }
1406 #else
1409 #endif
1410 }
1412 /*+F*************************************************************************
1413 * Function:
1414 * aic7xxx_setup
1415 *
1416 * Description:
1417 * Handle Linux boot parameters. This routine allows for assigning a value
1418 * to a parameter with a ':' between the parameter and the value.
1419 * ie. aic7xxx=unpause:0x0A,extended
1420 *-F*************************************************************************/
1421 static int
1423 {
1447 };
1452 {
1454 {
1457 {
1459 {
1461 {
1474 {
1476 {
1482 tok++;
1489 tok++;
1496 device++;
1498 instance++;
1502 tok++;
1504 {
1506 }
1515 {
1518 {
1521 }
1522 }
1530 }
1531 }
1534 }
1535 }
1537 {
1540 {
1542 }
1543 }
1545 {
1547 }
1548 else
1549 {
1552 {
1554 }
1555 }
1556 }
1557 }
1558 }
1560 }
1564 /*+F*************************************************************************
1565 * Function:
1566 * pause_sequencer
1567 *
1568 * Description:
1569 * Pause the sequencer and wait for it to actually stop - this
1570 * is important since the sequencer can disable pausing for critical
1571 * sections.
1572 *-F*************************************************************************/
1573 static void
1575 {
1578 {
1579 ;
1580 }
1582 {
1584 }
1585 }
1587 /*+F*************************************************************************
1588 * Function:
1589 * unpause_sequencer
1590 *
1591 * Description:
1592 * Unpause the sequencer. Unremarkable, yet done often enough to
1593 * warrant an easy way to do it.
1594 *-F*************************************************************************/
1595 static void
1597 {
1601 {
1603 }
1604 }
1606 /*+F*************************************************************************
1607 * Function:
1608 * restart_sequencer
1609 *
1610 * Description:
1611 * Restart the sequencer program from address zero. This assumes
1612 * that the sequencer is already paused.
1613 *-F*************************************************************************/
1614 static void
1616 {
1620 }
1622 /*
1623 * We include the aic7xxx_seq.c file here so that the other defines have
1624 * already been made, and so that it comes before the code that actually
1625 * downloads the instructions (since we don't typically use function
1626 * prototype, our code has to be ordered that way, it's a left-over from
1627 * the original driver days.....I should fix it some time DL).
1628 */
1631 /*+F*************************************************************************
1632 * Function:
1633 * aic7xxx_check_patch
1634 *
1635 * Description:
1636 * See if the next patch to download should be downloaded.
1637 *-F*************************************************************************/
1638 static int
1641 {
1651 {
1653 {
1654 /*
1655 * Start rejecting code.
1656 */
1659 }
1660 else
1661 {
1662 /*
1663 * Found an OK patch. Advance the patch pointer to the next patch
1664 * and wait for our instruction pointer to get here.
1665 */
1666 cur_patch++;
1667 }
1668 }
1672 /*
1673 * Still skipping
1674 */
1677 }
1680 /*+F*************************************************************************
1681 * Function:
1682 * aic7xxx_download_instr
1683 *
1684 * Description:
1685 * Find the next patch to download.
1686 *-F*************************************************************************/
1687 static void
1690 {
1703 /* Pull the opcode */
1706 {
1715 {
1729 {
1732 {
1738 }
1739 else
1740 {
1741 i++;
1742 }
1743 }
1746 /* Fall Through to the next code section */
1747 }
1755 {
1757 }
1759 /* Fall Through to the next code section */
1762 {
1765 /* Calculate odd parity for the instruction */
1767 {
1772 count++;
1773 }
1776 }
1777 else
1778 {
1780 {
1785 }
1786 else
1787 {
1793 }
1794 }
1805 }
1806 }
1809 /*+F*************************************************************************
1810 * Function:
1811 * aic7xxx_loadseq
1812 *
1813 * Description:
1814 * Load the sequencer code into the controller memory.
1815 *-F*************************************************************************/
1816 static void
1818 {
1826 {
1828 }
1829 #if 0
1831 #endif
1842 {
1844 {
1845 /* Skip this instruction for this configuration. */
1847 }
1849 downloaded++;
1850 }
1860 {
1862 }
1865 }
1867 /*+F*************************************************************************
1868 * Function:
1869 * aic7xxx_print_sequencer
1870 *
1871 * Description:
1872 * Print the contents of the sequencer memory to the screen.
1873 *-F*************************************************************************/
1874 static void
1876 {
1885 {
1894 {
1897 }
1898 else
1900 }
1909 }
1911 /*+F*************************************************************************
1912 * Function:
1913 * aic7xxx_info
1914 *
1915 * Description:
1916 * Return a string describing the driver.
1917 *-F*************************************************************************/
1920 {
1938 }
1940 /*+F*************************************************************************
1941 * Function:
1942 * aic7xxx_find_syncrate
1943 *
1944 * Description:
1945 * Look up the valid period to SCSIRATE conversion in our table
1946 *-F*************************************************************************/
1950 {
1955 {
1959 {
1962 }
1967 {
1970 }
1971 else
1972 {
1973 /*
1974 * we don't support the Quick Arbitration variants of dual edge
1975 * clocking. As it turns out, we want to send back the
1976 * same basic option, but without the QA attribute.
1977 * We know that we are responding because we would never set
1978 * these options ourself, we would only respond to them.
1979 */
1981 {
1988 }
1989 }
1995 }
1999 {
2001 {
2003 {
2007 {
2009 /*
2010 * oops, we went too low for the CRC/DualEdge signalling, so
2011 * clear the options byte
2012 */
2014 /*
2015 * We'll be sending a reply to this packet to set the options
2016 * properly, so unilaterally set the period as well.
2017 */
2019 }
2020 else
2021 {
2024 {
2026 }
2027 }
2031 {
2034 {
2036 }
2037 }
2039 }
2041 {
2043 }
2044 }
2045 syncrate++;
2046 }
2049 {
2050 /*
2051 * Use async transfers for this target
2052 */
2056 }
2058 }
2061 /*+F*************************************************************************
2062 * Function:
2063 * aic7xxx_find_period
2064 *
2065 * Description:
2066 * Look up the valid SCSIRATE to period conversion in our table
2067 *-F*************************************************************************/
2068 static unsigned int
2071 {
2075 {
2077 }
2078 else
2079 {
2081 }
2085 {
2087 {
2094 }
2096 {
2098 }
2099 syncrate++;
2100 }
2102 }
2104 /*+F*************************************************************************
2105 * Function:
2106 * aic7xxx_validate_offset
2107 *
2108 * Description:
2109 * Set a valid offset value for a particular card in use and transfer
2110 * settings in use.
2111 *-F*************************************************************************/
2112 static void
2115 {
2118 /* Limit offset to what the card (and device) can do */
2120 {
2122 }
2124 {
2126 }
2127 else
2128 {
2131 else
2133 }
2135 }
2137 /*+F*************************************************************************
2138 * Function:
2139 * aic7xxx_set_syncrate
2140 *
2141 * Description:
2142 * Set the actual syncrate down in the card and in our host structs
2143 *-F*************************************************************************/
2144 static void
2148 {
2159 {
2162 }
2170 {
2175 {
2178 {
2180 {
2182 /*
2183 * mask off the CRC bit in the xfer settings
2184 */
2190 }
2191 }
2193 {
2195 }
2197 }
2199 {
2203 {
2205 {
2207 }
2210 }
2212 {
2220 }
2223 }
2225 {
2227 }
2235 {
2237 {
2243 }
2244 else
2245 {
2248 }
2250 }
2251 }
2254 {
2258 }
2261 {
2265 }
2266 }
2268 /*+F*************************************************************************
2269 * Function:
2270 * aic7xxx_set_width
2271 *
2272 * Description:
2273 * Set the actual width down in the card and in our host structs
2274 *-F*************************************************************************/
2275 static void
2278 {
2289 {
2308 {
2311 }
2312 }
2320 {
2322 {
2324 }
2326 {
2328 }
2329 else
2330 {
2332 }
2333 }
2334 }
2336 /*+F*************************************************************************
2337 * Function:
2338 * scbq_init
2339 *
2340 * Description:
2341 * SCB queue initialization.
2342 *
2343 *-F*************************************************************************/
2344 static void
2346 {
2349 }
2351 /*+F*************************************************************************
2352 * Function:
2353 * scbq_insert_head
2354 *
2355 * Description:
2356 * Add an SCB to the head of the list.
2357 *
2358 *-F*************************************************************************/
2361 {
2362 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2364 #endif
2366 DRIVER_LOCK
2371 DRIVER_UNLOCK
2372 }
2374 /*+F*************************************************************************
2375 * Function:
2376 * scbq_remove_head
2377 *
2378 * Description:
2379 * Remove an SCB from the head of the list.
2380 *
2381 *-F*************************************************************************/
2384 {
2386 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2388 #endif
2390 DRIVER_LOCK
2396 DRIVER_UNLOCK
2398 }
2400 /*+F*************************************************************************
2401 * Function:
2402 * scbq_remove
2403 *
2404 * Description:
2405 * Removes an SCB from the list.
2406 *
2407 *-F*************************************************************************/
2410 {
2411 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2413 #endif
2415 DRIVER_LOCK
2417 {
2418 /* At beginning of queue, remove from head. */
2420 }
2421 else
2422 {
2425 /*
2426 * Search until the next scb is the one we're looking for, or
2427 * we run out of queue.
2428 */
2430 {
2432 }
2434 {
2435 /* Found it. */
2438 {
2439 /* Update the tail when removing the tail. */
2441 }
2442 }
2443 }
2444 DRIVER_UNLOCK
2445 }
2447 /*+F*************************************************************************
2448 * Function:
2449 * scbq_insert_tail
2450 *
2451 * Description:
2452 * Add an SCB at the tail of the list.
2453 *
2454 *-F*************************************************************************/
2457 {
2458 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2460 #endif
2462 DRIVER_LOCK
2469 DRIVER_UNLOCK
2470 }
2472 /*+F*************************************************************************
2473 * Function:
2474 * aic7xxx_match_scb
2475 *
2476 * Description:
2477 * Checks to see if an scb matches the target/channel as specified.
2478 * If target is ALL_TARGETS (-1), then we're looking for any device
2479 * on the specified channel; this happens when a channel is going
2480 * to be reset and all devices on that channel must be aborted.
2481 *-F*************************************************************************/
2482 static int
2485 {
2500 }
2502 /*+F*************************************************************************
2503 * Function:
2504 * aic7xxx_add_curscb_to_free_list
2505 *
2506 * Description:
2507 * Adds the current scb (in SCBPTR) to the list of free SCBs.
2508 *-F*************************************************************************/
2509 static void
2511 {
2512 /*
2513 * Invalidate the tag so that aic7xxx_find_scb doesn't think
2514 * it's active
2515 */
2521 }
2523 /*+F*************************************************************************
2524 * Function:
2525 * aic7xxx_rem_scb_from_disc_list
2526 *
2527 * Description:
2528 * Removes the current SCB from the disconnected list and adds it
2529 * to the free list.
2530 *-F*************************************************************************/
2531 static unsigned char
2534 {
2542 {
2545 }
2546 else
2547 {
2549 }
2552 }
2554 /*+F*************************************************************************
2555 * Function:
2556 * aic7xxx_busy_target
2557 *
2558 * Description:
2559 * Set the specified target busy.
2560 *-F*************************************************************************/
2563 {
2565 }
2567 /*+F*************************************************************************
2568 * Function:
2569 * aic7xxx_index_busy_target
2570 *
2571 * Description:
2572 * Returns the index of the busy target, and optionally sets the
2573 * target inactive.
2574 *-F*************************************************************************/
2578 {
2583 {
2585 }
2587 }
2589 /*+F*************************************************************************
2590 * Function:
2591 * aic7xxx_find_scb
2592 *
2593 * Description:
2594 * Look through the SCB array of the card and attempt to find the
2595 * hardware SCB that corresponds to the passed in SCB. Return
2596 * SCB_LIST_NULL if unsuccessful. This routine assumes that the
2597 * card is already paused.
2598 *-F*************************************************************************/
2599 static unsigned char
2601 {
2608 {
2611 {
2613 }
2614 }
2617 {
2619 }
2622 }
2624 /*+F*************************************************************************
2625 * Function:
2626 * aic7xxx_allocate_scb
2627 *
2628 * Description:
2629 * Get an SCB from the free list or by allocating a new one.
2630 *-F*************************************************************************/
2631 static int
2633 {
2645 {
2646 /*
2647 * Calculate the optimal number of SCBs to allocate.
2648 *
2649 * NOTE: This formula works because the sizeof(sg_array) is always
2650 * 1024. Therefore, scb_size * i would always be > PAGE_SIZE *
2651 * (i/step). The (i-1) allows the left hand side of the equation
2652 * to grow into the right hand side to a point of near perfect
2653 * efficiency since scb_size * (i -1) is growing slightly faster
2654 * than the right hand side. If the number of SG array elements
2655 * is changed, this function may not be near so efficient any more.
2656 *
2657 * Since the DMA'able buffers are now allocated in a seperate
2658 * chunk this algorithm has been modified to match. The '12'
2659 * and '6' factors in scb_size are for the DMA'able command byte
2660 * and sensebuffers respectively. -DaveM
2661 */
2663 {
2665 {
2668 }
2669 }
2680 {
2683 }
2685 #ifdef AIC7XXX_VERBOSE_DEBUGGING
2687 {
2691 else
2694 }
2695 #endif
2701 {
2711 /*
2712 * Place in the scb array; never is removed
2713 */
2716 }
2718 }
2720 }
2722 /*+F*************************************************************************
2723 * Function:
2724 * aic7xxx_queue_cmd_complete
2725 *
2726 * Description:
2727 * Due to race conditions present in the SCSI subsystem, it is easier
2728 * to queue completed commands, then call scsi_done() on them when
2729 * we're finished. This function queues the completed commands.
2730 *-F*************************************************************************/
2731 static void
2733 {
2736 }
2738 /*+F*************************************************************************
2739 * Function:
2740 * aic7xxx_done_cmds_complete
2741 *
2742 * Description:
2743 * Process the completed command queue.
2744 *-F*************************************************************************/
2745 static void
2747 {
2749 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2751 #endif
2753 DRIVER_LOCK
2755 {
2760 }
2761 DRIVER_UNLOCK
2762 }
2764 /*+F*************************************************************************
2765 * Function:
2766 * aic7xxx_free_scb
2767 *
2768 * Description:
2769 * Free the scb and insert into the free scb list.
2770 *-F*************************************************************************/
2771 static void
2773 {
2785 }
2787 /*+F*************************************************************************
2788 * Function:
2789 * aic7xxx_done
2790 *
2791 * Description:
2792 * Calls the higher level scsi done function and frees the scb.
2793 *-F*************************************************************************/
2794 static void
2796 {
2803 {
2808 }
2814 {
2818 PCI_DMA_FROMDEVICE);
2819 }
2821 {
2823 }
2825 {
2827 }
2829 {
2831 }
2833 {
2835 {
2840 {
2845 }
2846 else
2847 {
2849 }
2850 #define WIDE_INQUIRY_BITS 0x60
2851 #define SYNC_INQUIRY_BITS 0x10
2852 #define SCSI_VERSION_BITS 0x07
2853 #define SCSI_DT_BIT 0x04
2856 {
2860 }
2861 else
2862 {
2868 AHC_TRANS_GOAL |
2869 AHC_TRANS_CUR) );
2871 }
2874 {
2881 else
2888 {
2896 }
2897 else
2898 {
2904 }
2905 }
2906 else
2907 {
2913 }
2914 /*
2915 * This is needed to work around a sequencer bug for now. Regardless
2916 * of the controller in use, if we have a Quantum drive, we need to
2917 * limit the speed to 80MByte/sec. As soon as I get a fixed version
2918 * of the sequencer, this code will get yanked.
2919 */
2922 {
2932 }
2933 /*
2934 * Get the INQUIRY checksum. We use this on Ultra 160/m
2935 * and older devices both. It allows us to drop speed on any bus type
2936 * while at the same time giving us the needed domain validation for
2937 * Ultra 160/m
2938 *
2939 * Note: We only get the checksum and set the SCANNED bit if this is
2940 * one of our dtr commands. If we don't do this, then we end up
2941 * getting bad checksum results on the mid-level SCSI code's INQUIRY
2942 * commands.
2943 */
2951 {
2953 }
2957 }
2958 #undef WIDE_INQUIRY_BITS
2959 #undef SYNC_INQUIRY_BITS
2960 #undef SCSI_VERSION_BITS
2961 #undef SCSI_DT_BIT
2962 }
2963 }
2965 {
2971 /*
2972 * Check to see if we get an invalid message or a message error
2973 * after failing to negotiate a wide or sync transfer message.
2974 */
2978 {
2980 }
2983 {
2986 {
2989 {
2996 }
2999 }
3000 }
3002 {
3005 {
3008 {
3016 }
3019 }
3020 }
3022 {
3025 {
3028 {
3035 }
3036 /*
3037 * Disable PPR negotiation and revert back to WDTR and SDTR setup
3038 */
3045 }
3046 }
3047 }
3050 {
3053 {
3055 {
3056 /*
3057 * Give extra preference to untagged devices, such as CD-R devices
3058 * This makes it more likely that a drive *won't* stuff up while
3059 * waiting on data at a critical time, such as CD-R writing and
3060 * audio CD ripping operations. Should also benefit tape drives.
3061 */
3063 }
3064 else
3065 {
3067 }
3068 #ifdef AIC7XXX_VERBOSE_DEBUGGING
3072 #endif
3074 {
3078 }
3079 }
3080 }
3082 {
3084 }
3088 {
3091 /*
3092 * XXX: we should actually know how much actually transferred
3093 * XXX: for each command, but apparently that's too difficult.
3094 *
3095 * We set a lower limit of 512 bytes on the transfer length. We
3096 * ignore anything less than this because we don't have a real
3097 * reason to count it. Read/Writes to tapes are usually about 20K
3098 * and disks are a minimum of 512 bytes unless you want to count
3099 * non-read/write commands (such as TEST_UNIT_READY) which we don't
3100 */
3103 {
3105 #ifdef AIC7XXX_PROC_STATS
3112 /*
3113 * For block devices, cmd->request.cmd is always == either READ or
3114 * WRITE. For character devices, this isn't always set properly, so
3115 * we check data_cmnd[0]. This catches the conditions for st.c, but
3116 * I'm still not sure if request.cmd is valid for sg devices.
3117 */
3120 {
3122 #ifdef AIC7XXX_VERBOSE_DEBUGGING
3125 #endif
3126 #ifdef AIC7XXX_PROC_STATS
3129 }
3130 else
3131 {
3133 #ifdef AIC7XXX_VERBOSE_DEBUGGING
3136 #endif
3137 #ifdef AIC7XXX_PROC_STATS
3140 }
3141 #ifdef AIC7XXX_PROC_STATS
3144 {
3146 x++;
3147 }
3149 {
3151 }
3153 {
3155 }
3156 else
3157 {
3159 }
3161 }
3162 }
3166 }
3168 /*+F*************************************************************************
3169 * Function:
3170 * aic7xxx_run_done_queue
3171 *
3172 * Description:
3173 * Calls the aic7xxx_done() for the Scsi_Cmnd of each scb in the
3174 * aborted list, and adds each scb to the free list. If complete
3175 * is TRUE, we also process the commands complete list.
3176 *-F*************************************************************************/
3177 static void
3179 {
3184 {
3187 {
3191 found++;
3193 }
3194 }
3196 {
3199 }
3201 {
3203 }
3204 }
3206 /*+F*************************************************************************
3207 * Function:
3208 * aic7xxx_abort_waiting_scb
3209 *
3210 * Description:
3211 * Manipulate the waiting for selection list and return the
3212 * scb that follows the one that we remove.
3213 *-F*************************************************************************/
3214 static unsigned char
3217 {
3220 /*
3221 * Select the SCB we want to abort and pull the next pointer out of it.
3222 */
3229 /*
3230 * Update the waiting list
3231 */
3233 {
3234 /*
3235 * First in the list
3236 */
3238 }
3239 else
3240 {
3241 /*
3242 * Select the scb that pointed to us and update its next pointer.
3243 */
3246 }
3247 /*
3248 * Point us back at the original scb position and inform the SCSI
3249 * system that the command has been aborted.
3250 */
3253 }
3255 /*+F*************************************************************************
3256 * Function:
3257 * aic7xxx_search_qinfifo
3258 *
3259 * Description:
3260 * Search the queue-in FIFO for matching SCBs and conditionally
3261 * requeue. Returns the number of matching SCBs.
3262 *-F*************************************************************************/
3263 static int
3267 {
3279 {
3282 {
3283 /*
3284 * We found an scb that needs to be removed.
3285 */
3287 {
3289 {
3295 }
3301 {
3303 TRUE);
3304 }
3305 }
3307 {
3309 }
3310 else
3311 {
3312 /*
3313 * Preserve any SCB_RECOVERY_SCB flags on this scb then set the
3314 * flags we were called with, presumeably so aic7xxx_run_done_queue
3315 * can find this scb
3316 */
3320 {
3322 TRUE);
3323 }
3324 }
3325 found++;
3326 }
3327 else
3328 {
3330 }
3331 }
3332 /*
3333 * Now that we've done the work, clear out any left over commands in the
3334 * qinfifo and update the KERNEL_QINPOS down on the card.
3335 *
3336 * NOTE: This routine expect the sequencer to already be paused when
3337 * it is run....make sure it's that way!
3338 */
3341 {
3343 }
3346 else
3350 }
3352 /*+F*************************************************************************
3353 * Function:
3354 * aic7xxx_scb_on_qoutfifo
3355 *
3356 * Description:
3357 * Is the scb that was passed to us currently on the qoutfifo?
3358 *-F*************************************************************************/
3359 static int
3361 {
3365 {
3368 else
3369 i++;
3370 }
3372 }
3375 /*+F*************************************************************************
3376 * Function:
3377 * aic7xxx_reset_device
3378 *
3379 * Description:
3380 * The device at the given target/channel has been reset. Abort
3381 * all active and queued scbs for that target/channel. This function
3382 * need not worry about linked next pointers because if was a MSG_ABORT_TAG
3383 * then we had a tagged command (no linked next), if it was MSG_ABORT or
3384 * MSG_BUS_DEV_RESET then the device won't know about any commands any more
3385 * and no busy commands will exist, and if it was a bus reset, then nothing
3386 * knows about any linked next commands any more. In all cases, we don't
3387 * need to worry about the linked next or busy scb, we just need to clear
3388 * them.
3389 *-F*************************************************************************/
3390 static void
3393 {
3398 /*
3399 * Restore this when we're done
3400 */
3406 /*
3407 * Deal with the busy target and linked next issues.
3408 */
3409 {
3413 /* Make all targets 'relative' to bus A. */
3415 {
3417 {
3431 }
3432 }
3433 else
3434 {
3437 }
3441 {
3443 {
3445 }
3451 {
3459 }
3461 {
3464 else
3469 }
3474 {
3478 {
3485 }
3487 {
3490 {
3493 }
3496 }
3497 }
3499 {
3504 }
3507 {
3510 }
3511 }
3512 }
3519 /*
3520 * Search the waiting_scbs queue for matches, this catches any SCB_QUEUED
3521 * ABORT/RESET commands.
3522 */
3526 {
3533 {
3537 {
3544 }
3546 {
3549 {
3552 }
3555 }
3556 }
3558 {
3563 }
3564 }
3567 /*
3568 * Search waiting for selection list.
3569 */
3573 {
3580 {
3584 {
3585 /*
3586 * No aic7xxx_verbose check here.....we want to see this since it
3587 * means either the kernel driver or the sequencer screwed things up
3588 */
3594 }
3595 else
3596 {
3599 {
3602 {
3605 }
3609 {
3610 /*
3611 * This is either the first scb on the waiting list, or we
3612 * have already yanked the first and haven't left any behind.
3613 * Either way, we need to turn off the selection hardware if
3614 * it isn't already off.
3615 */
3618 }
3619 }
3620 else
3621 {
3624 }
3625 }
3626 }
3628 {
3632 }
3633 }
3635 /*
3636 * Go through disconnected list and remove any entries we have queued
3637 * for completion, zeroing their control byte too.
3638 */
3643 {
3650 {
3654 {
3659 }
3660 else
3661 {
3664 {
3667 {
3670 }
3674 }
3675 else
3676 {
3679 }
3680 }
3681 }
3683 {
3687 }
3688 }
3690 /*
3691 * Walk the free list making sure no entries on the free list have
3692 * a valid SCB_TAG value or SCB_CONTROL byte.
3693 */
3695 {
3701 {
3706 }
3708 {
3711 {
3716 }
3717 else
3718 {
3722 }
3723 }
3725 {
3729 }
3730 }
3732 /*
3733 * Go through the hardware SCB array looking for commands that
3734 * were active but not on any list.
3735 */
3737 {
3741 }
3743 {
3748 {
3753 }
3754 else
3755 {
3758 {
3761 {
3765 }
3766 }
3767 }
3768 }
3770 /*
3771 * Go through the entire SCB array now and look for commands for
3772 * for this target that are stillactive. These are other (most likely
3773 * tagged) commands that were disconnected when the reset occurred.
3774 * Any commands we find here we know this about, it wasn't on any queue,
3775 * it wasn't in the qinfifo, it wasn't in the disconnected or waiting
3776 * lists, so it really must have been a paged out SCB. In that case,
3777 * we shouldn't need to bother with updating any counters, just mark
3778 * the correct flags and go on.
3779 */
3781 {
3786 {
3788 {
3793 }
3796 }
3797 }
3800 }
3803 /*+F*************************************************************************
3804 * Function:
3805 * aic7xxx_clear_intstat
3806 *
3807 * Description:
3808 * Clears the interrupt status.
3809 *-F*************************************************************************/
3810 static void
3812 {
3813 /* Clear any interrupt conditions this may have caused. */
3818 }
3820 /*+F*************************************************************************
3821 * Function:
3822 * aic7xxx_reset_current_bus
3823 *
3824 * Description:
3825 * Reset the current SCSI bus.
3826 *-F*************************************************************************/
3827 static void
3829 {
3831 /* Disable reset interrupts. */
3834 /* Turn off the bus' current operations, after all, we shouldn't have any
3835 * valid commands left to cause a RSELI and SELO once we've tossed the
3836 * bus away with this reset, so we might as well shut down the sequencer
3837 * until the bus is restarted as oppossed to saving the current settings
3838 * and restoring them (which makes no sense to me). */
3840 /* Turn on the bus reset. */
3845 /*
3846 * Some of the new Ultra2 chipsets need a longer delay after a chip
3847 * reset than just the init setup creates, so we have to delay here
3848 * before we go into a reset in order to make the chips happy.
3849 */
3852 else
3855 /* Turn off the bus reset. */
3860 /* Re-enable reset interrupts. */
3863 }
3865 /*+F*************************************************************************
3866 * Function:
3867 * aic7xxx_reset_channel
3868 *
3869 * Description:
3870 * Reset the channel.
3871 *-F*************************************************************************/
3872 static void
3874 {
3885 {
3890 }
3891 else
3892 {
3894 {
3895 /* Channel A */
3900 }
3901 else
3902 {
3909 {
3911 }
3912 else
3913 {
3915 }
3916 }
3917 }
3920 {
3921 /*
3922 * Revert to async/narrow transfers until we renegotiate.
3923 */
3926 {
3928 }
3929 offset_min++;
3930 }
3932 /*
3933 * Reset the bus and unpause/restart the controller
3934 */
3938 else
3941 {
3942 /*
3943 * Case 1: Command for another bus is active
3944 */
3948 /*
3949 * Stealthily reset the other bus without upsetting the current bus.
3950 */
3954 {
3956 }
3960 }
3961 else
3962 {
3963 /*
3964 * Case 2: A command from this bus is active or we're idle.
3965 */
3970 SIMODE1);
3975 {
3977 }
3980 }
3983 /*
3984 * Clean up all the state information for the pending transactions
3985 * on this bus.
3986 */
3990 {
3992 }
3995 }
3997 /*+F*************************************************************************
3998 * Function:
3999 * aic7xxx_run_waiting_queues
4000 *
4001 * Description:
4002 * Scan the awaiting_scbs queue downloading and starting as many
4003 * scbs as we can.
4004 *-F*************************************************************************/
4005 static void
4007 {
4011 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
4013 #endif
4021 /*
4022 * First handle SCBs that are waiting but have been assigned a slot.
4023 */
4024 DRIVER_LOCK
4026 {
4029 {
4031 }
4036 {
4038 }
4039 else
4040 {
4045 {
4047 }
4049 sent++;
4050 }
4051 }
4053 {
4056 else
4057 {
4061 }
4064 }
4065 DRIVER_UNLOCK
4066 }
4068 #ifdef CONFIG_PCI
4070 #define DPE 0x80
4071 #define SSE 0x40
4072 #define RMA 0x20
4073 #define RTA 0x10
4074 #define STA 0x08
4075 #define DPR 0x01
4077 /*+F*************************************************************************
4078 * Function:
4079 * aic7xxx_pci_intr
4080 *
4081 * Description:
4082 * Check the scsi card for PCI errors and clear the interrupt
4083 *
4084 * NOTE: If you don't have this function and a 2940 card encounters
4085 * a PCI error condition, the machine will end up locked as the
4086 * interrupt handler gets slammed with non-stop PCI error interrupts
4087 *-F*************************************************************************/
4088 static void
4090 {
4121 }
4124 /*+F*************************************************************************
4125 * Function:
4126 * aic7xxx_timer
4127 *
4128 * Description:
4129 * Take expired extries off of delayed queues and place on waiting queue
4130 * then run waiting queue to start commands.
4131 ***************************************************************************/
4132 static void
4134 {
4143 {
4146 }
4148 {
4152 {
4159 {
4161 }
4163 {
4168 /*
4169 * Well, things are screwed now, wait for a reset to clean the junk
4170 * out.
4171 */
4172 }
4173 }
4175 {
4177 {
4179 {
4181 }
4182 }
4183 else
4184 {
4187 }
4188 }
4189 }
4191 {
4193 }
4197 }
4199 /*+F*************************************************************************
4200 * Function:
4201 * aic7xxx_construct_ppr
4202 *
4203 * Description:
4204 * Build up a Parallel Protocol Request message for use with SCSI-3
4205 * devices.
4206 *-F*************************************************************************/
4207 static void
4209 {
4221 }
4223 /*+F*************************************************************************
4224 * Function:
4225 * aic7xxx_construct_sdtr
4226 *
4227 * Description:
4228 * Constucts a synchronous data transfer message in the message
4229 * buffer on the sequencer.
4230 *-F*************************************************************************/
4231 static void
4234 {
4241 }
4243 /*+F*************************************************************************
4244 * Function:
4245 * aic7xxx_construct_wdtr
4246 *
4247 * Description:
4248 * Constucts a wide data transfer message in the message buffer
4249 * on the sequencer.
4250 *-F*************************************************************************/
4251 static void
4253 {
4259 }
4261 /*+F*************************************************************************
4262 * Function:
4263 * aic7xxx_calc_residual
4264 *
4265 * Description:
4266 * Calculate the residual data not yet transferred.
4267 *-F*************************************************************************/
4268 static void
4270 {
4278 /*
4279 * Don't destroy valid residual information with
4280 * residual coming from a check sense operation.
4281 */
4284 {
4285 /*
4286 * We had an underflow. At this time, there's only
4287 * one other driver that bothers to check for this,
4288 * and cmd->underflow seems to be set rather half-
4289 * heartedly in the higher-level SCSI code.
4290 */
4293 {
4295 }
4301 {
4309 }
4310 }
4312 /*
4313 * Clean out the residual information in the SCB for the
4314 * next consumer.
4315 */
4320 }
4322 /*+F*************************************************************************
4323 * Function:
4324 * aic7xxx_handle_device_reset
4325 *
4326 * Description:
4327 * Interrupt handler for sequencer interrupts (SEQINT).
4328 *-F*************************************************************************/
4329 static void
4331 {
4338 /*
4339 * Go back to async/narrow transfers and renegotiate.
4340 */
4353 }
4355 /*+F*************************************************************************
4356 * Function:
4357 * aic7xxx_handle_seqint
4358 *
4359 * Description:
4360 * Interrupt handler for sequencer interrupts (SEQINT).
4361 *-F*************************************************************************/
4362 static void
4364 {
4374 else
4380 /*
4381 * Go ahead and clear the SEQINT now, that avoids any interrupt race
4382 * conditions later on in case we enable some other interrupt.
4383 */
4386 {
4388 {
4390 SCSISEQ);
4399 }
4403 {
4408 }
4412 {
4413 /*
4414 * The reconnecting target either did not send an identify
4415 * message, or did, but we didn't find an SCB to match and
4416 * before it could respond to our ATN/abort, it hit a dataphase.
4417 * The only safe thing to do is to blow it away with a bus
4418 * reset.
4419 */
4428 }
4433 {
4438 }
4439 else
4440 {
4444 }
4448 {
4453 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4457 #endif
4459 /*
4460 * To actually receive the message, simply turn on
4461 * REQINIT interrupts and let our interrupt handler
4462 * do the rest (REQINIT should already be true).
4463 */
4467 /*
4468 * We don't want the sequencer unpaused yet so we return early
4469 */
4471 }
4474 {
4475 /*
4476 * What we care about here is if we had an outstanding SDTR
4477 * or WDTR message for this target. If we did, this is a
4478 * signal that the target is refusing negotiation.
4479 */
4490 {
4492 {
4493 /*
4494 * OK...the device seems able to accept tagged commands, but
4495 * not ordered tag commands, only simple tag commands. So, we
4496 * disable ordered tag commands and go on with life just like
4497 * normal.
4498 */
4504 /*
4505 * OK..we set the tag type to simple tag command, now we re-assert
4506 * ATNO and hope this will take us into the identify phase again
4507 * so we can resend the tag type and info to the device.
4508 */
4511 }
4513 {
4517 /*
4518 * Hmmmm....the device is flaking out on tagged commands. The
4519 * bad thing is that we already have tagged commands enabled in
4520 * the device struct in the mid level code. We also have a queue
4521 * set according to the tagged queue depth. Gonna have to live
4522 * with it by controlling our queue depth internally and making
4523 * sure we don't set the tagged command flag any more.
4524 */
4529 /*
4530 * We set this command up as a bus device reset. However, we have
4531 * to clear the tag type as it's causing us problems. We shouldnt
4532 * have to worry about any other commands being active, since if
4533 * the device is refusing tagged commands, this should be the
4534 * first tagged command sent to the device, however, we do have
4535 * to worry about any other tagged commands that may already be
4536 * in the qinfifo. The easiest way to do this, is to issue a BDR,
4537 * send all the commands back to the mid level code, then let them
4538 * come back and get rebuilt as untagged commands.
4539 */
4547 {
4550 {
4552 {
4554 reset++;
4555 }
4557 }
4558 }
4560 /*
4561 * Wait until after the for loop to set the busy index since
4562 * aic7xxx_reset_device will clear the busy index during its
4563 * operation.
4564 */
4570 }
4571 }
4573 {
4574 /*
4575 * As per the draft specs, any device capable of supporting any of
4576 * the option values other than 0 are not allowed to reject the
4577 * PPR message. Instead, they must negotiate out what they do
4578 * support instead of rejecting our offering or else they cause
4579 * a parity error during msg_out phase to signal that they don't
4580 * like our settings.
4581 */
4592 {
4595 }
4597 {
4602 }
4604 {
4608 {
4611 }
4612 }
4614 {
4617 }
4618 }
4620 {
4621 /*
4622 * note 8bit xfers and clear flag
4623 */
4633 {
4636 }
4638 }
4640 {
4641 /*
4642 * note asynch xfers and clear flag
4643 */
4651 {
4654 }
4655 }
4657 {
4658 /*
4659 * Otherwise, we ignore it.
4660 */
4663 }
4664 }
4668 {
4673 /* The sequencer will notify us when a command has an error that
4674 * would be of interest to the kernel. This allows us to leave
4675 * the sequencer running in the common case of command completes
4676 * without error. The sequencer will have DMA'd the SCB back
4677 * up to us, so we can reference the drivers SCB array.
4678 *
4679 * Set the default return value to 0 indicating not to send
4680 * sense. The sense code will change this if needed and this
4681 * reduces code duplication.
4682 */
4686 {
4690 }
4695 {
4699 }
4700 else
4701 {
4709 {
4719 {
4720 /*
4721 * Send a sense command to the requesting target.
4722 * XXX - revisit this and get rid of the memcopys.
4723 */
4735 PCI_DMA_FROMDEVICE));
4737 /*
4738 * XXX - We should allow disconnection, but can't as it
4739 * might allow overlapped tagged commands.
4740 */
4741 /* hscb->control &= DISCENB; */
4760 /*
4761 * Ensure the target is busy since this will be an
4762 * an untagged request.
4763 */
4764 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4766 {
4771 else
4774 }
4775 #endif
4788 {
4791 /*
4792 * We have to look three places for queued commands:
4793 * 1: QINFIFO
4794 * 2: p->waiting_scbs queue
4795 * 3: WAITING_SCBS list on card (for commands that are started
4796 * but haven't yet made it to the device)
4797 */
4803 {
4807 SCB_LIST_NULL) )
4808 {
4811 prev_scbp);
4812 }
4813 }
4819 {
4823 {
4826 SCB_LIST_NULL) )
4827 {
4829 {
4834 }
4836 next_scbp);
4845 {
4846 /* We were first on the list,
4847 * so we kill the selection
4848 * hardware. Let the sequencer
4849 * re-init the hardware itself
4850 */
4854 }
4855 else
4856 {
4859 }
4860 }
4861 else
4862 {
4865 }
4867 }
4870 {
4875 }
4882 {
4885 {
4887 }
4888 else
4889 {
4891 }
4893 {
4897 }
4901 }
4902 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4905 {
4911 else
4914 }
4915 #endif
4917 {
4920 {
4924 }
4925 else
4926 {
4928 }
4931 {
4941 }
4943 {
4945 {
4950 }
4955 }
4956 else
4957 {
4961 }
4962 }
4964 }
4971 {
4973 }
4977 }
4981 {
4988 /*
4989 * This SCB had a MK_MESSAGE set in its control byte informing
4990 * the sequencer that we wanted to send a special message to
4991 * this target.
4992 */
4997 {
5001 }
5004 {
5010 }
5012 {
5014 {
5016 }
5017 else
5018 {
5020 }
5025 }
5027 {
5029 {
5036 }
5038 }
5040 {
5042 {
5045 }
5047 }
5049 {
5052 /*
5053 * Now that the device is selected, use the bits in SBLKCTL and
5054 * SSTAT2 to determine the max sync rate for this device.
5055 */
5057 {
5060 {
5062 }
5063 else
5064 {
5066 }
5067 }
5069 {
5071 }
5072 else
5073 {
5075 }
5079 {
5083 }
5086 }
5087 else
5088 {
5092 }
5093 /*
5094 * We've set everything up to send our message, now to actually do
5095 * so we need to enable reqinit interrupts and let the interrupt
5096 * handler do the rest. We don't want to unpause the sequencer yet
5097 * though so we'll return early. We also have to make sure that
5098 * we clear the SEQINT *BEFORE* we set the REQINIT handler active
5099 * or else it's possible on VLB cards to loose the first REQINIT
5100 * interrupt. Edge triggered EISA cards could also loose this
5101 * interrupt, although PCI and level triggered cards should not
5102 * have this problem since they continually interrupt the kernel
5103 * until we take care of the situation.
5104 */
5111 }
5115 {
5121 /*
5122 * XXX - What do we really want to do on an overrun? The
5123 * mid-level SCSI code should handle this, but for now,
5124 * we'll just indicate that the command should retried.
5125 * If we retrieved sense info on this target, then the
5126 * base SENSE info should have been saved prior to the
5127 * overrun error. In that case, we return DID_OK and let
5128 * the mid level code pick up on the sense info. Otherwise
5129 * we return DID_ERROR so the command will get retried.
5130 */
5132 {
5140 {
5142 i,
5145 }
5147 }
5148 else
5151 }
5155 {
5163 {
5166 /*
5167 * XXX: Add error handling here
5168 */
5170 }
5173 {
5178 }
5180 /*
5181 * We have a valid scb to use on this WIDE_RESIDUE message, so
5182 * we need to walk the sg list looking for this particular sg
5183 * segment, then see if we happen to be at the very beginning of
5184 * the segment. If we are, then we have to back things up to
5185 * the previous segment. If not, then we simply need to remove
5186 * one byte from this segments address and add one to the byte
5187 * count.
5188 */
5198 /*
5199 * Make sure this is a valid sg_seg for the given pointer
5200 */
5203 {
5223 }
5227 {
5228 /*
5229 * We are at the end of the transfer and this is about a byte
5230 * we ignored already (because the sequencer knew this was
5231 * the last segment and set the adapter to ignore any wide
5232 * residue bytes that might come through, which is only done
5233 * on the last scatter gather segment of transfers).
5234 */
5236 }
5238 {
5239 /*
5240 * If our current address matches the sg_seg->address then we
5241 * have to back up the sg array to the previous segment and set
5242 * it up to have only one byte of transfer left to go.
5243 */
5245 {
5249 }
5250 resid_sgcnt++;
5251 index--;
5273 }
5274 else
5275 {
5276 /*
5277 * Back the data pointer up by one and add one to the remaining
5278 * byte count. Then store that in the HCNT and HADDR registers.
5279 */
5280 cur_addr--;
5281 resid_dcnt++;
5292 }
5293 /*
5294 * The sequencer actually wants to find the new address and byte
5295 * count in the SHCNT and SHADDR register sets. These registers
5296 * are a shadow of the regular HCNT and HADDR registers. On the
5297 * Ultra2 controllers, these registers are read only and the way
5298 * we have to set their values is to put the values we want into
5299 * the HCNT and HADDR registers and then output PRELOADEN into
5300 * the DFCNTRL register which causes the card to latch the current
5301 * values in the HADDR and HCNT registers and drop it through to
5302 * the shadow registers. On older cards we copy them directly
5303 * across by hand.
5304 */
5306 {
5311 {
5313 }
5318 {
5320 }
5321 }
5322 else
5323 {
5331 }
5332 }
5336 #if AIC7XXX_NOT_YET
5338 {
5341 }
5345 {
5348 }
5351 /* XXX Fill these in later */
5358 #endif
5365 }
5367 /*
5368 * Clear the sequencer interrupt and unpause the sequencer.
5369 */
5371 }
5373 /*+F*************************************************************************
5374 * Function:
5375 * aic7xxx_parse_msg
5376 *
5377 * Description:
5378 * Parses incoming messages into actions on behalf of
5379 * aic7xxx_handle_reqinit
5380 *_F*************************************************************************/
5381 static int
5383 {
5397 /*
5398 * Parse as much of the message as is availible,
5399 * rejecting it if we don't support it. When
5400 * the entire message is availible and has been
5401 * handled, return TRUE indicating that we have
5402 * parsed an entire message.
5403 */
5406 {
5408 }
5410 /*
5411 * Just accept the length byte outright and perform
5412 * more checking once we know the message type.
5413 */
5416 {
5418 {
5420 {
5426 {
5429 }
5432 {
5434 }
5440 /*
5441 * Even if we are an Ultra3 card, don't allow Ultra3 sync rates when
5442 * using the SDTR messages. We need the PPR messages to enable the
5443 * higher speeds that include things like Dual Edge clocking.
5444 */
5446 {
5449 {
5451 }
5452 else
5453 {
5455 }
5456 }
5458 {
5460 }
5461 else
5462 {
5464 }
5465 /*
5466 * We might have a device that is starting negotiation with us
5467 * before we can start up negotiation with it....be prepared to
5468 * have a device ask for a higher speed then we want to give it
5469 * in that case
5470 */
5473 {
5477 {
5478 /*
5479 * Not only is the device starting this up, but it also hasn't
5480 * been scanned yet, so this would likely be our TUR or our
5481 * INQUIRY command at scan time, so we need to use the
5482 * settings from the SEEPROM if they existed. Of course, even
5483 * if we didn't find a SEEPROM, we stuffed default values into
5484 * the user settings anyway, so use those in all cases.
5485 */
5489 {
5491 }
5493 {
5495 }
5496 else
5497 {
5499 }
5501 }
5503 {
5506 }
5511 }
5519 /*
5520 * Did we drop to async? Or are we sending a reply? If we are,
5521 * then we have to make sure that the reply value reflects the proper
5522 * settings so we need to set the goal values according to what
5523 * we need to send.
5524 */
5528 {
5531 }
5533 /*
5534 * Did we start this, if not, or if we went to low and had to
5535 * go async, then send an SDTR back to the target
5536 */
5542 {
5549 }
5552 }
5554 {
5558 {
5561 }
5564 {
5566 }
5571 {
5573 {
5575 {
5580 {
5583 }
5586 {
5590 }
5592 {
5594 }
5595 }
5598 }
5599 else
5600 {
5602 {
5603 /*
5604 * Well, we now know the WDTR and SYNC caps of this device since
5605 * it contacted us first, mark it as such and copy the user stuff
5606 * over to the goal stuff.
5607 */
5611 {
5613 {
5615 }
5619 {
5621 }
5622 else
5623 {
5625 }
5626 }
5631 }
5633 {
5636 }
5638 {
5640 {
5643 MSG_EXT_WDTR_BUS_16_BIT) )
5644 {
5647 }
5650 {
5656 }
5657 }
5665 }
5669 /*
5670 * By virtue of the SCSI spec, a WDTR message negates any existing
5671 * SDTR negotiations. So, even if needsdtr isn't marked for this
5672 * device, we still have to do a new SDTR message if the device
5673 * supports SDTR at all. Therefore, we check needsdtr_copy instead
5674 * of needstr.
5675 */
5681 }
5683 {
5690 {
5693 }
5696 {
5698 }
5706 {
5709 trans_options);
5710 }
5714 {
5716 {
5718 }
5719 else
5720 {
5722 }
5723 }
5724 else
5725 {
5727 }
5728 /*
5729 * We might have a device that is starting negotiation with us
5730 * before we can start up negotiation with it....be prepared to
5731 * have a device ask for a higher speed then we want to give it
5732 * in that case
5733 */
5736 {
5742 {
5743 /*
5744 * Not only is the device starting this up, but it also hasn't
5745 * been scanned yet, so this would likely be our TUR or our
5746 * INQUIRY command at scan time, so we need to use the
5747 * settings from the SEEPROM if they existed. Of course, even
5748 * if we didn't find a SEEPROM, we stuffed default values into
5749 * the user settings anyway, so use those in all cases.
5750 */
5754 {
5756 {
5758 }
5762 {
5764 }
5765 else
5766 {
5768 }
5769 }
5774 }
5776 {
5779 }
5787 {
5789 {
5792 MSG_EXT_WDTR_BUS_16_BIT) )
5793 {
5796 }
5799 {
5805 }
5806 }
5809 {
5816 {
5819 }
5821 {
5824 }
5825 }
5826 }
5827 else
5828 {
5830 {
5832 {
5837 {
5840 }
5843 {
5844 /*
5845 * According to the spec, if we aren't wide, we also can't be
5846 * Dual Edge so clear the options byte
5847 */
5851 }
5853 {
5855 }
5856 }
5857 }
5860 {
5869 }
5874 {
5880 }
5883 }
5885 {
5888 }
5893 {
5897 }
5899 }
5902 /*+F*************************************************************************
5903 * Function:
5904 * aic7xxx_handle_reqinit
5905 *
5906 * Description:
5907 * Interrupt handler for REQINIT interrupts (used to transfer messages to
5908 * and from devices).
5909 *_F*************************************************************************/
5910 static void
5912 {
5918 {
5920 {
5928 {
5929 /* Time to end the message */
5932 /*
5933 * NOTE-TO-MYSELF: If you clear the REQINIT after you
5934 * disable REQINITs, then cases of REJECT_MSG stop working
5935 * and hang the bus
5936 */
5942 {
5945 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5949 #endif
5950 }
5951 else
5952 {
5954 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5958 #endif
5959 }
5961 }
5962 else
5963 {
5964 /*
5965 * Present the byte on the bus (clearing REQINIT) but don't
5966 * unpause the sequencer.
5967 */
5971 }
5973 }
5975 {
5979 {
5981 /* Pull the byte in without acking it */
5984 /* Ack the byte */
5989 }
5991 {
5992 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5994 {
5998 else
6001 }
6002 #endif
6003 /* Time to end our message session */
6010 }
6012 }
6014 {
6017 }
6019 }
6021 /*+F*************************************************************************
6022 * Function:
6023 * aic7xxx_handle_scsiint
6024 *
6025 * Description:
6026 * Interrupt handler for SCSI interrupts (SCSIINT).
6027 *-F*************************************************************************/
6028 static void
6030 {
6039 {
6042 {
6044 }
6045 }
6046 else
6047 {
6049 }
6053 {
6058 else
6066 /*
6067 * Go through and abort all commands for the channel, but do not
6068 * reset the channel again.
6069 */
6073 }
6075 {
6076 /*
6077 * First look at what phase we were last in. If it's message-out,
6078 * chances are pretty good that the bus free was in response to
6079 * one of our abort requests.
6080 */
6089 else
6093 SCSISEQ);
6095 {
6101 {
6110 }
6112 {
6116 }
6117 }
6120 {
6121 /*
6122 * This might be a SCSI-3 device that is dropping the bus due to
6123 * errors and signalling that we should reduce the transfer speed.
6124 * All we have to do is complete this command (since it's a negotiation
6125 * command already) and the checksum routine should flag an error and
6126 * reduce the speed setting and renegotiate. We call the reset routing
6127 * just to clean out the hardware from this scb.
6128 */
6133 }
6135 {
6137 {
6141 {
6143 }
6144 else
6145 {
6147 }
6150 }
6151 else
6152 {
6155 }
6160 }
6163 SIMODE1);
6169 }
6171 {
6178 {
6179 /*
6180 * I'm still trying to track down exactly how this happens, but until
6181 * I find it, this code will make sure we aren't passing bogus values
6182 * into the SCBPTR register, even if that register will just wrap
6183 * things around, we still don't like having out of range variables.
6184 *
6185 * NOTE: Don't check the aic7xxx_verbose variable, I want this message
6186 * to always be displayed.
6187 */
6192 else
6194 }
6200 {
6203 {
6205 }
6206 }
6208 {
6217 }
6218 else
6219 {
6223 /*
6224 * Clear out this hardware SCB
6225 */
6228 /*
6229 * Clear out a few values in the card that are in an undetermined
6230 * state.
6231 */
6234 /*
6235 * Shift the waiting for selection queue forward
6236 */
6240 /*
6241 * Put this SCB back on the free list.
6242 */
6244 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6247 #endif
6249 {
6250 /*
6251 * We know that this particular SCB had to be the queued abort since
6252 * the disconnected SCB would have gotten a reconnect instead.
6253 * What we need to do then is to let the command timeout again so
6254 * we get a reset since this abort just failed.
6255 */
6258 }
6260 {
6261 /*
6262 * Turn off the needsdtr, needwdtr, and needppr bits since this device
6263 * doesn't seem to exist.
6264 */
6271 }
6272 }
6273 /*
6274 * Keep the sequencer from trying to restart any selections
6275 */
6277 /*
6278 * Make sure the data bits on the bus are released
6279 * Don't do this on 7770 chipsets, it makes them give us
6280 * a BRKADDRINT and kills the card.
6281 */
6285 /*
6286 * Delay for the selection timeout delay period then stop the selection
6287 */
6290 /*
6291 * Clear out all the interrupt status bits
6292 */
6297 /*
6298 * Restarting the sequencer will stop the selection and make sure devices
6299 * are allowed to reselect in.
6300 */
6303 }
6305 {
6312 /*
6313 * Turn off the interrupt and set status to zero, so that it
6314 * falls through the rest of the SCSIINT code.
6315 */
6320 }
6322 {
6323 /*
6324 * Determine the bus phase and queue an appropriate message.
6325 */
6335 {
6360 }
6362 /*
6363 * A parity error has occurred during a data
6364 * transfer phase. Flag it and continue.
6365 */
6369 {
6373 {
6376 }
6378 {
6381 }
6383 {
6386 }
6388 {
6391 }
6392 }
6396 {
6397 /*
6398 * As per the draft specs, any device capable of supporting any of
6399 * the option values other than 0 are not allowed to reject the
6400 * PPR message. Instead, they must negotiate out what they do
6401 * support instead of rejecting our offering or else they cause
6402 * a parity error during msg_out phase to signal that they don't
6403 * like our settings.
6404 */
6408 MSG_EXT_WDTR_BUS_8_BIT,
6416 {
6419 }
6421 {
6424 }
6426 {
6428 {
6430 }
6433 }
6435 }
6437 {
6441 /*
6442 * oops, we had a failure, lower the transfer rate and try again. It's
6443 * worth noting here that it might be wise to also check for typical
6444 * wide setting on narrow cable type problems and try disabling wide
6445 * instead of slowing down if those exist. That's hard to do with simple
6446 * checksums though.
6447 */
6451 {
6452 syncrate++;
6455 {
6458 {
6465 {
6468 }
6469 }
6470 }
6472 {
6483 {
6488 }
6489 else
6490 {
6495 }
6496 }
6497 else
6498 {
6509 }
6510 }
6512 }
6513 else
6514 {
6516 }
6518 /*
6519 * We've set the hardware to assert ATN if we get a parity
6520 * error on "in" phases, so all we need to do is stuff the
6521 * message buffer with the appropriate message. "In" phases
6522 * have set mesg_out to something other than MSG_NOP.
6523 */
6525 {
6529 }
6533 }
6536 {
6537 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6541 #endif
6544 }
6545 else
6546 {
6547 /*
6548 * We don't know what's going on. Turn off the
6549 * interrupt source and try to continue.
6550 */
6558 }
6560 {
6562 }
6563 }
6565 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6566 static void
6568 {
6573 #define SCB_NO_LIST 0
6574 #define SCB_FREE_LIST 1
6575 #define SCB_WAITING_LIST 2
6576 #define SCB_DISCONNECTED_LIST 4
6577 #define SCB_CURRENTLY_ACTIVE 8
6579 /*
6580 * Note, these checks will fail on a regular basis once the machine moves
6581 * beyond the bus scan phase. The problem is race conditions concerning
6582 * the scbs and where they are linked in. When you have 30 or so commands
6583 * outstanding on the bus, and run this twice with every interrupt, the
6584 * chances get pretty good that you'll catch the sequencer with an SCB
6585 * only partially linked in. Therefore, once we pass the scan phase
6586 * of the bus, we really should disable this function.
6587 */
6593 {
6596 }
6601 {
6604 }
6605 else
6606 {
6609 {
6611 {
6615 }
6619 }
6620 }
6625 {
6628 }
6629 else
6630 {
6633 {
6635 {
6639 }
6643 }
6644 }
6649 {
6652 }
6653 else
6654 {
6657 {
6659 {
6663 }
6667 }
6668 }
6672 {
6677 {
6680 }
6682 {
6685 }
6687 lost++;
6689 {
6692 }
6693 }
6697 {
6701 }
6703 }
6704 #endif
6707 /*+F*************************************************************************
6708 * Function:
6709 * aic7xxx_handle_command_completion_intr
6710 *
6711 * Description:
6712 * SCSI command completion interrupt handler.
6713 *-F*************************************************************************/
6714 static void
6716 {
6721 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6724 #endif
6726 /*
6727 * Read the INTSTAT location after clearing the CMDINT bit. This forces
6728 * any posted PCI writes to flush to memory. Gerard Roudier suggested
6729 * this fix to the possible race of clearing the CMDINT bit but not
6730 * having all command bytes flushed onto the qoutfifo.
6731 */
6734 /*
6735 * The sequencer will continue running when it
6736 * issues this interrupt. There may be >1 commands
6737 * finished, so loop until we've processed them all.
6738 */
6741 {
6745 {
6749 }
6752 {
6757 }
6760 {
6764 {
6767 }
6771 SCB_QUEUED_ABORT);
6773 }
6775 {
6776 /*
6777 * We started to abort this, but it completed on us, let it
6778 * through as successful
6779 */
6781 }
6783 {
6786 {
6788 /*
6789 * We have valid sense data, send it back immediately.
6790 */
6803 }
6805 {
6806 /*
6807 * SCSI errors, run domain validation and re-run negotiation
6808 */
6810 /*
6811 * Signal that we need to re-negotiate things, this also gets us our
6812 * INQUIRY command to re-checksum off of.
6813 */
6817 }
6818 }
6820 {
6830 {
6832 }
6836 }
6837 }
6838 }
6840 /*+F*************************************************************************
6841 * Function:
6842 * aic7xxx_isr
6843 *
6844 * Description:
6845 * SCSI controller interrupt handler.
6846 *-F*************************************************************************/
6847 static void
6849 {
6855 /*
6856 * Just a few sanity checks. Make sure that we have an int pending.
6857 * Also, if PCI, then we are going to check for a PCI bus error status
6858 * should we get too many spurious interrupts.
6859 */
6861 {
6862 #ifdef CONFIG_PCI
6865 {
6867 {
6869 }
6871 }
6873 {
6875 }
6876 #endif
6878 }
6882 /*
6883 * Keep track of interrupts for /proc/scsi
6884 */
6887 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6891 #endif
6893 /*
6894 * Handle all the interrupt sources - especially for SCSI
6895 * interrupts, we won't get a second chance at them.
6896 */
6898 {
6900 }
6903 {
6909 {
6911 {
6913 }
6914 }
6919 #ifdef CONFIG_PCI
6922 #endif
6924 {
6927 }
6929 {
6932 }
6933 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6935 {
6938 else
6940 }
6941 #endif
6944 }
6947 {
6948 /*
6949 * Read the CCSCBCTL register to work around a bug in the Ultra2 cards
6950 */
6952 {
6954 }
6956 }
6959 {
6961 }
6963 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6967 #endif
6969 }
6971 /*+F*************************************************************************
6972 * Function:
6973 * do_aic7xxx_isr
6974 *
6975 * Description:
6976 * This is a gross hack to solve a problem in linux kernels 2.1.85 and
6977 * above. Please, children, do not try this at home, and if you ever see
6978 * anything like it, please inform the Gross Hack Police immediately
6979 *-F*************************************************************************/
6980 static void
6982 {
6991 {
6994 }
6995 do
6996 {
7003 }
7005 /*+F*************************************************************************
7006 * Function:
7007 * aic7xxx_device_queue_depth
7008 *
7009 * Description:
7010 * Determines the queue depth for a given device. There are two ways
7011 * a queue depth can be obtained for a tagged queueing device. One
7012 * way is the default queue depth which is determined by whether
7013 * AIC7XXX_CMDS_PER_DEVICE is defined. If it is defined, then it is used
7014 * as the default queue depth. Otherwise, we use either 4 or 8 as the
7015 * default queue depth (dependent on the number of hardware SCBs).
7016 * The other way we determine queue depth is through the use of the
7017 * aic7xxx_tag_info array which is enabled by defining
7018 * AIC7XXX_TAGGED_QUEUEING_BY_DEVICE. This array can be initialized
7019 * with queue depths for individual devices. It also allows tagged
7020 * queueing to be [en|dis]abled for a specific adapter.
7021 *-F*************************************************************************/
7022 static int
7024 {
7033 {
7034 /*
7035 * We've already scanned this device, leave it alone
7036 */
7038 }
7046 {
7052 {
7057 }
7058 else
7059 {
7061 {
7064 {
7070 }
7072 }
7073 else
7074 {
7077 {
7080 }
7082 {
7084 }
7085 else
7086 {
7089 }
7090 }
7092 {
7094 {
7098 }
7105 }
7106 }
7107 }
7109 }
7111 /*+F*************************************************************************
7112 * Function:
7113 * aic7xxx_select_queue_depth
7114 *
7115 * Description:
7116 * Sets the queue depth for each SCSI device hanging off the input
7117 * host adapter. We use a queue depth of 2 for devices that do not
7118 * support tagged queueing. If AIC7XXX_CMDS_PER_LUN is defined, we
7119 * use that for tagged queueing devices; otherwise we use our own
7120 * algorithm for determining the queue depth based on the maximum
7121 * SCBs for the controller.
7122 *-F*************************************************************************/
7123 static void
7126 {
7133 {
7135 {
7137 }
7138 }
7140 {
7141 /*
7142 * Pre-allocate the needed SCBs to get around the possibility of having
7143 * to allocate some when memory is more or less exhausted and we need
7144 * the SCB in order to perform a swap operation (possible deadlock)
7145 */
7148 }
7149 }
7151 /*+F*************************************************************************
7152 * Function:
7153 * aic7xxx_probe
7154 *
7155 * Description:
7156 * Probing for EISA boards: it looks like the first two bytes
7157 * are a manufacturer code - three characters, five bits each:
7158 *
7159 * BYTE 0 BYTE 1 BYTE 2 BYTE 3
7160 * ?1111122 22233333 PPPPPPPP RRRRRRRR
7161 *
7162 * The characters are baselined off ASCII '@', so add that value
7163 * to each to get the real ASCII code for it. The next two bytes
7164 * appear to be a product and revision number, probably vendor-
7165 * specific. This is what is being searched for at each port,
7166 * and what should probably correspond to the ID= field in the
7167 * ECU's .cfg file for the card - if your card is not detected,
7168 * make sure your signature is listed in the array.
7169 *
7170 * The fourth byte's lowest bit seems to be an enabled/disabled
7171 * flag (rest of the bits are reserved?).
7172 *
7173 * NOTE: This function is only needed on Intel and Alpha platforms,
7174 * the other platforms we support don't have EISA/VLB busses. So,
7175 * we #ifdef this entire function to avoid compiler warnings about
7176 * an unused function.
7177 *-F*************************************************************************/
7178 #if defined(__i386__) || defined(__alpha__)
7179 static int
7181 {
7188 ahc_chip type;
7199 };
7201 /*
7202 * The VL-bus cards need to be primed by
7203 * writing before a signature check.
7204 */
7206 {
7209 }
7212 {
7213 /*
7214 * Signature match on enabled card?
7215 */
7217 {
7219 {
7221 {
7223 }
7224 else
7225 {
7227 }
7229 }
7233 }
7234 }
7237 }
7241 /*+F*************************************************************************
7242 * Function:
7243 * read_2840_seeprom
7244 *
7245 * Description:
7246 * Reads the 2840 serial EEPROM and returns 1 if successful and 0 if
7247 * not successful.
7248 *
7249 * See read_seeprom (for the 2940) for the instruction set of the 93C46
7250 * chip.
7251 *
7252 * The 2840 interface to the 93C46 serial EEPROM is through the
7253 * STATUS_2840 and SEECTL_2840 registers. The CS_2840, CK_2840, and
7254 * DO_2840 bits of the SEECTL_2840 register are connected to the chip
7255 * select, clock, and data out lines respectively of the serial EEPROM.
7256 * The DI_2840 bit of the STATUS_2840 is connected to the data in line
7257 * of the serial EEPROM. The EEPROM_TF bit of STATUS_2840 register is
7258 * useful in that it gives us an 800 nsec timer. After a read from the
7259 * SEECTL_2840 register the timing flag is cleared and goes high 800 nsec
7260 * later.
7261 *-F*************************************************************************/
7262 static int
7264 {
7272 };
7275 #define CLOCK_PULSE(p) \
7276 while ((aic_inb(p, STATUS_2840) & EEPROM_TF) == 0) \
7277 { \
7279 } \
7280 (void) aic_inb(p, SEECTL_2840);
7282 /*
7283 * Read the first 32 registers of the seeprom. For the 2840,
7284 * the 93C46 SEEPROM is a 1024-bit device with 64 16-bit registers
7285 * but only the first 32 are used by Adaptec BIOS. The loop
7286 * will range from 0 to 31.
7287 */
7289 {
7290 /*
7291 * Send chip select for one clock cycle.
7292 */
7296 /*
7297 * Now we're ready to send the read command followed by the
7298 * address of the 16-bit register we want to read.
7299 */
7301 {
7308 }
7309 /*
7310 * Send the 6 bit address (MSB first, LSB last).
7311 */
7313 {
7322 }
7324 /*
7325 * Now read the 16 bit register. An initial 0 precedes the
7326 * register contents which begins with bit 15 (MSB) and ends
7327 * with bit 0 (LSB). The initial 0 will be shifted off the
7328 * top of our word as we let the loop run from 0 to 16.
7329 */
7331 {
7339 }
7340 /*
7341 * The serial EEPROM has a checksum in the last word. Keep a
7342 * running checksum for all words read except for the last
7343 * word. We'll verify the checksum after all words have been
7344 * read.
7345 */
7347 {
7349 }
7351 /*
7352 * Reset the chip select for the next command cycle.
7353 */
7360 }
7362 #if 0
7366 {
7368 {
7370 }
7372 }
7374 #endif
7377 {
7380 }
7383 #undef CLOCK_PULSE
7384 }
7386 #define CLOCK_PULSE(p) \
7387 do { \
7388 int limit = 0; \
7389 do { \
7390 mb(); \
7398 } while (((aic_inb(p, SEECTL) & SEERDY) == 0) && (++limit < 1000)); \
7399 } while(0)
7401 /*+F*************************************************************************
7402 * Function:
7403 * acquire_seeprom
7404 *
7405 * Description:
7406 * Acquires access to the memory port on PCI controllers.
7407 *-F*************************************************************************/
7408 static int
7410 {
7412 /*
7413 * Request access of the memory port. When access is
7414 * granted, SEERDY will go high. We use a 1 second
7415 * timeout which should be near 1 second more than
7416 * is needed. Reason: after the 7870 chip reset, there
7417 * should be no contention.
7418 */
7422 {
7425 }
7427 }
7429 /*+F*************************************************************************
7430 * Function:
7431 * release_seeprom
7432 *
7433 * Description:
7434 * Releases access to the memory port on PCI controllers.
7435 *-F*************************************************************************/
7436 static void
7438 {
7439 /*
7440 * Make sure the SEEPROM is ready before we release it.
7441 */
7444 }
7446 /*+F*************************************************************************
7447 * Function:
7448 * read_seeprom
7449 *
7450 * Description:
7451 * Reads the serial EEPROM and returns 1 if successful and 0 if
7452 * not successful.
7453 *
7454 * The instruction set of the 93C46/56/66 chips is as follows:
7455 *
7456 * Start OP
7457 * Function Bit Code Address Data Description
7458 * -------------------------------------------------------------------
7459 * READ 1 10 A5 - A0 Reads data stored in memory,
7460 * starting at specified address
7461 * EWEN 1 00 11XXXX Write enable must precede
7462 * all programming modes
7463 * ERASE 1 11 A5 - A0 Erase register A5A4A3A2A1A0
7464 * WRITE 1 01 A5 - A0 D15 - D0 Writes register
7465 * ERAL 1 00 10XXXX Erase all registers
7466 * WRAL 1 00 01XXXX D15 - D0 Writes to all registers
7467 * EWDS 1 00 00XXXX Disables all programming
7468 * instructions
7469 * *Note: A value of X for address is a don't care condition.
7470 * *Note: The 93C56 and 93C66 have 8 address bits.
7471 *
7472 *
7473 * The 93C46 has a four wire interface: clock, chip select, data in, and
7474 * data out. In order to perform one of the above functions, you need
7475 * to enable the chip select for a clock period (typically a minimum of
7476 * 1 usec, with the clock high and low a minimum of 750 and 250 nsec
7477 * respectively. While the chip select remains high, you can clock in
7478 * the instructions (above) starting with the start bit, followed by the
7479 * OP code, Address, and Data (if needed). For the READ instruction, the
7480 * requested 16-bit register contents is read from the data out line but
7481 * is preceded by an initial zero (leading 0, followed by 16-bits, MSB
7482 * first). The clock cycling from low to high initiates the next data
7483 * bit to be sent from the chip.
7484 *
7485 * The 78xx interface to the 93C46 serial EEPROM is through the SEECTL
7486 * register. After successful arbitration for the memory port, the
7487 * SEECS bit of the SEECTL register is connected to the chip select.
7488 * The SEECK, SEEDO, and SEEDI are connected to the clock, data out,
7489 * and data in lines respectively. The SEERDY bit of SEECTL is useful
7490 * in that it gives us an 800 nsec timer. After a write to the SEECTL
7491 * register, the SEERDY goes high 800 nsec later. The one exception
7492 * to this is when we first request access to the memory port. The
7493 * SEERDY goes high to signify that access has been granted and, for
7494 * this case, has no implied timing.
7495 *-F*************************************************************************/
7496 static int
7499 {
7506 };
7509 /*
7510 * Request access of the memory port.
7511 */
7513 {
7515 }
7517 /*
7518 * Read 'len' registers of the seeprom. For the 7870, the 93C46
7519 * SEEPROM is a 1024-bit device with 64 16-bit registers but only
7520 * the first 32 are used by Adaptec BIOS. Some adapters use the
7521 * 93C56 SEEPROM which is a 2048-bit device. The loop will range
7522 * from 0 to 'len' - 1.
7523 */
7525 {
7526 /*
7527 * Send chip select for one clock cycle.
7528 */
7532 /*
7533 * Now we're ready to send the read command followed by the
7534 * address of the 16-bit register we want to read.
7535 */
7537 {
7544 }
7545 /*
7546 * Send the 6 or 8 bit address (MSB first, LSB last).
7547 */
7549 {
7558 }
7560 /*
7561 * Now read the 16 bit register. An initial 0 precedes the
7562 * register contents which begins with bit 15 (MSB) and ends
7563 * with bit 0 (LSB). The initial 0 will be shifted off the
7564 * top of our word as we let the loop run from 0 to 16.
7565 */
7567 {
7575 }
7577 /*
7578 * The serial EEPROM should have a checksum in the last word.
7579 * Keep a running checksum for all words read except for the
7580 * last word. We'll verify the checksum after all words have
7581 * been read.
7582 */
7584 {
7586 }
7588 /*
7589 * Reset the chip select for the next command cycle.
7590 */
7597 }
7599 /*
7600 * Release access to the memory port and the serial EEPROM.
7601 */
7604 #if 0
7609 {
7611 {
7613 }
7615 }
7617 #endif
7619 {
7621 }
7624 }
7626 /*+F*************************************************************************
7627 * Function:
7628 * read_brdctl
7629 *
7630 * Description:
7631 * Reads the BRDCTL register.
7632 *-F*************************************************************************/
7633 static unsigned char
7635 {
7638 /*
7639 * Make sure the SEEPROM is ready before we access it
7640 */
7643 {
7650 }
7654 {
7656 }
7664 }
7666 /*+F*************************************************************************
7667 * Function:
7668 * write_brdctl
7669 *
7670 * Description:
7671 * Writes a value to the BRDCTL register.
7672 *-F*************************************************************************/
7673 static void
7675 {
7678 /*
7679 * Make sure the SEEPROM is ready before we access it
7680 */
7683 {
7695 }
7696 else
7697 {
7701 {
7703 }
7716 }
7717 }
7719 /*+F*************************************************************************
7720 * Function:
7721 * aic785x_cable_detect
7722 *
7723 * Description:
7724 * Detect the cables that are present on aic785x class controller chips
7725 *-F*************************************************************************/
7726 static void
7729 {
7741 }
7743 #undef CLOCK_PULSE
7745 /*+F*************************************************************************
7746 * Function:
7747 * aic2940_uwpro_cable_detect
7748 *
7749 * Description:
7750 * Detect the cables that are present on the 2940-UWPro cards
7751 *
7752 * NOTE: This function assumes the SEEPROM will have already been acquired
7753 * prior to invocation of this function.
7754 *-F*************************************************************************/
7755 static void
7758 {
7761 /*
7762 * First read the status of our cables. Set the rom bank to
7763 * 0 since the bank setting serves as a multiplexor for the
7764 * cable detection logic. BRDDAT5 controls the bank switch.
7765 */
7768 /*
7769 * Now we read the state of the internal 68 connector. BRDDAT6
7770 * is don't care, BRDDAT7 is internal 68. The cable is
7771 * present if the bit is 0
7772 */
7776 /*
7777 * Set the bank bit in brdctl and then read the external cable state
7778 * and the EEPROM status
7779 */
7786 /*
7787 * We're done, the calling function will release the SEEPROM for us
7788 */
7789 }
7791 /*+F*************************************************************************
7792 * Function:
7793 * aic787x_cable_detect
7794 *
7795 * Description:
7796 * Detect the cables that are present on aic787x class controller chips
7797 *
7798 * NOTE: This function assumes the SEEPROM will have already been acquired
7799 * prior to invocation of this function.
7800 *-F*************************************************************************/
7801 static void
7804 {
7807 /*
7808 * First read the status of our cables. Set the rom bank to
7809 * 0 since the bank setting serves as a multiplexor for the
7810 * cable detection logic. BRDDAT5 controls the bank switch.
7811 */
7814 /*
7815 * Now we read the state of the two internal connectors. BRDDAT6
7816 * is internal 50, BRDDAT7 is internal 68. For each, the cable is
7817 * present if the bit is 0
7818 */
7823 /*
7824 * Set the bank bit in brdctl and then read the external cable state
7825 * and the EEPROM status
7826 */
7833 /*
7834 * We're done, the calling function will release the SEEPROM for us
7835 */
7836 }
7838 /*+F*************************************************************************
7839 * Function:
7840 * aic787x_ultra2_term_detect
7841 *
7842 * Description:
7843 * Detect the termination settings present on ultra2 class controllers
7844 *
7845 * NOTE: This function assumes the SEEPROM will have already been acquired
7846 * prior to invocation of this function.
7847 *-F*************************************************************************/
7848 static void
7852 {
7862 }
7864 /*+F*************************************************************************
7865 * Function:
7866 * configure_termination
7867 *
7868 * Description:
7869 * Configures the termination settings on PCI adapters that have
7870 * SEEPROMs available.
7871 *-F*************************************************************************/
7872 static void
7874 {
7888 {
7891 else
7895 /*
7896 * The termination/cable detection logic is split into three distinct
7897 * groups. Ultra2 and later controllers, 2940UW-Pro controllers, and
7898 * older 7850, 7860, 7870, 7880, and 7895 controllers. Each has its
7899 * own unique way of detecting their cables and writing the results
7900 * back to the card.
7901 */
7903 {
7904 /*
7905 * As long as user hasn't overridden term settings, always check the
7906 * cable detection logic
7907 */
7909 {
7913 }
7915 /*
7916 * If the user is overriding settings, then they have been preserved
7917 * to here as fake adapter_control entries. Parse them and allow
7918 * them to override the detected settings (if we even did detection).
7919 */
7921 {
7924 }
7926 {
7928 }
7930 /*
7931 * Now take those settings that we have and translate them into the
7932 * values that must be written into the registers.
7933 *
7934 * Flash Enable = BRDDAT7
7935 * Secondary High Term Enable = BRDDAT6
7936 * Secondary Low Term Enable = BRDDAT5
7937 * LVD/Primary High Term Enable = BRDDAT4
7938 * LVD/Primary Low Term Enable = STPWEN bit in SXFRCTL1
7939 */
7941 {
7947 }
7950 {
7955 }
7958 {
7963 }
7966 {
7971 }
7972 }
7974 {
7975 /*
7976 * The 50 pin connector termination is controlled by STPWEN in the
7977 * SXFRCTL1 register. Since the Adaptec docs typically say the
7978 * controller is not allowed to be in the middle of a cable and
7979 * this is the only connection on that stub of the bus, there is
7980 * no need to even check for narrow termination, it's simply
7981 * always on.
7982 */
7989 {
8002 {
8008 }
8009 else
8010 {
8016 }
8017 }
8018 else
8019 {
8020 /*
8021 * The termination of the Wide channel is done more like normal
8022 * though, and the setting of this termination is done by writing
8023 * either a 0 or 1 to BRDDAT6 of the BRDDAT register
8024 */
8026 {
8032 }
8033 else
8034 {
8036 }
8037 }
8038 }
8039 else
8040 {
8042 {
8044 {
8054 }
8055 /* Configure auto termination. */
8058 {
8061 }
8062 else
8063 {
8066 }
8072 {
8078 }
8079 else
8080 {
8085 }
8090 /*
8091 * Now set the termination based on what we found. BRDDAT6
8092 * controls wide termination enable.
8093 * Flash Enable = BRDDAT7
8094 * SE High Term Enable = BRDDAT6
8095 */
8097 {
8102 /*
8103 * Force termination (low and high byte) on. This is safer than
8104 * leaving it completely off, especially since this message comes
8105 * most often from motherboard controllers that don't even have 3
8106 * connectors, but instead are failing the cable detection.
8107 */
8110 }
8114 {
8120 }
8125 {
8131 }
8132 }
8134 {
8136 {
8141 }
8144 {
8149 }
8150 }
8151 }
8156 }
8157 }
8159 /*+F*************************************************************************
8160 * Function:
8161 * detect_maxscb
8162 *
8163 * Description:
8164 * Detects the maximum number of SCBs for the controller and returns
8165 * the count and a mask in p (p->maxscbs, p->qcntmask).
8166 *-F*************************************************************************/
8167 static void
8169 {
8172 /*
8173 * It's possible that we've already done this for multichannel
8174 * adapters.
8175 */
8177 {
8178 /*
8179 * We haven't initialized the SCB settings yet. Walk the SCBs to
8180 * determince how many there are.
8181 */
8185 {
8202 }
8204 /* Make sure the last SCB terminates the free list. */
8208 /* Ensure we clear the first (0) SCBs control byte. */
8213 /*
8214 * Use direct indexing instead for speed
8215 */
8218 }
8220 }
8222 /*+F*************************************************************************
8223 * Function:
8224 * aic7xxx_register
8225 *
8226 * Description:
8227 * Register a Adaptec aic7xxx chip SCSI controller with the kernel.
8228 *-F*************************************************************************/
8229 static int
8232 {
8252 {
8254 }
8256 {
8258 }
8274 /*
8275 * We currently have no commands of any type
8276 */
8281 {
8291 }
8296 {
8307 }
8309 {
8312 }
8313 else
8314 {
8320 {
8324 {
8326 }
8327 }
8329 {
8331 }
8332 else
8333 {
8335 }
8337 }
8344 {
8350 }
8352 #ifdef CONFIG_PCI
8353 /*
8354 * Now that we know our instance number, we can set the flags we need to
8355 * force termination if need be.
8356 */
8358 {
8359 /*
8360 * This option only applies to PCI controllers.
8361 */
8363 {
8368 {
8372 }
8373 else
8374 {
8378 }
8380 }
8381 }
8382 #endif
8384 /*
8385 * That took care of devconfig and stpwlev, now for the actual termination
8386 * settings.
8387 */
8389 {
8390 /*
8391 * Again, this only applies to PCI controllers. We don't have problems
8392 * with the termination on 274x controllers to the best of my knowledge.
8393 */
8395 {
8402 {
8404 }
8406 {
8408 }
8410 {
8412 }
8413 }
8414 }
8417 {
8419 {
8421 /*
8422 * Update the settings in sxfrctl1 to match the termination
8423 * settings.
8424 */
8426 }
8428 {
8430 }
8431 }
8433 /*
8434 * Set the SCSI Id, SXFRCTL0, SXFRCTL1, and SIMODE1, for both channels
8435 */
8437 {
8438 /* Select channel B */
8443 else
8455 /* Select channel A */
8457 }
8460 {
8462 }
8463 else
8464 {
8466 }
8469 else
8476 /*
8477 * If we are a cardbus adapter then don't enable SCSI reset detection.
8478 * We shouldn't likely be sharing SCSI busses with someone else, and
8479 * if we don't have a cable currently plugged into the controller then
8480 * we won't have a power source for the SCSI termination, which means
8481 * we'll see infinite incoming bus resets.
8482 */
8485 else
8491 /*
8492 * Look at the information that board initialization or the board
8493 * BIOS has left us. In the lower four bits of each target's
8494 * scratch space any value other than 0 indicates that we should
8495 * initiate synchronous transfers. If it's zero, the user or the
8496 * BIOS has decided to disable synchronous negotiation to that
8497 * target so we don't activate the needsdtr flag.
8498 */
8500 {
8502 }
8503 else
8504 {
8506 }
8509 {
8510 /*
8511 * If we reset the bus, then clear the transfer settings, else leave
8512 * them be
8513 */
8515 {
8518 {
8520 }
8524 }
8526 /*
8527 * If we reset the bus, then clear the transfer settings, else leave
8528 * them be.
8529 */
8533 }
8535 /*
8536 * Allocate enough hardware scbs to handle the maximum number of
8537 * concurrent transactions we can have. We have to make sure that
8538 * the allocated memory is contiguous memory. The Linux kmalloc
8539 * routine should only allocate contiguous memory, but note that
8540 * this could be a problem if kmalloc() is changed.
8541 */
8542 {
8548 {
8549 /* pci_alloc_consistent enforces the alignment already and
8550 * clears the area as well.
8551 */
8554 /* We have to use pci_free_consistent, not kfree */
8557 }
8559 {
8565 }
8573 /* Set up the fifo areas at the same time */
8576 {
8581 }
8586 {
8590 }
8597 }
8599 /* The Q-FIFOs we just set up are all empty */
8605 {
8610 }
8612 /*
8613 * We don't have any waiting selections or disconnected SCBs.
8614 */
8618 /*
8619 * Message out buffer starts empty
8620 */
8624 /*
8625 * Set all the other asundry items that haven't been set yet.
8626 * This includes just dumping init values to a lot of registers simply
8627 * to make sure they've been touched and are ready for use parity wise
8628 * speaking.
8629 */
8636 /*
8637 * Link us into the list of valid hosts
8638 */
8642 /*
8643 * Allocate the first set of scbs for this controller. This is to stream-
8644 * line code elsewhere in the driver. If we have to check for the existence
8645 * of scbs in certain code sections, it slows things down. However, as
8646 * soon as we register the IRQ for this card, we could get an interrupt that
8647 * includes possibly the SCSI_RSTI interrupt. If we catch that interrupt
8648 * then we are likely to segfault if we don't have at least one chunk of
8649 * SCBs allocated or add checks all through the reset code to make sure
8650 * that the SCBs have been allocated which is an invalid running condition
8651 * and therefore I think it's preferable to simply pre-allocate the first
8652 * chunk of SCBs.
8653 */
8656 /*
8657 * Load the sequencer program, then re-enable the board -
8658 * resetting the AIC-7770 disables it, leaving the lights
8659 * on with nobody home.
8660 */
8663 /*
8664 * Make sure the AUTOFLUSHDIS bit is *not* set in the SBLKCTL register
8665 */
8669 {
8671 }
8674 {
8676 {
8682 }
8683 /* Reset SCSI bus A. */
8688 {
8692 }
8694 }
8698 /*
8699 * Delay for the reset delay by setting the timer, this will delay
8700 * future commands sent to any devices.
8701 */
8704 {
8707 }
8711 }
8712 else
8713 {
8715 {
8720 }
8721 }
8723 /*
8724 * Register IRQ with the kernel. Only allow sharing IRQs with
8725 * PCI devices.
8726 */
8728 {
8730 }
8731 else
8732 {
8736 {
8739 }
8740 }
8742 {
8748 }
8758 }
8760 /*+F*************************************************************************
8761 * Function:
8762 * aic7xxx_chip_reset
8763 *
8764 * Description:
8765 * Perform a chip reset on the aic7xxx SCSI controller. The controller
8766 * is paused upon return.
8767 *-F*************************************************************************/
8768 int
8770 {
8774 /*
8775 * For some 274x boards, we must clear the CHIPRST bit and pause
8776 * the sequencer. For some reason, this makes the driver work.
8777 */
8780 /*
8781 * In the future, we may call this function as a last resort for
8782 * error handling. Let's be nice and not do any unecessary delays.
8783 */
8786 {
8788 }
8796 {
8810 }
8812 }
8814 /*+F*************************************************************************
8815 * Function:
8816 * aic7xxx_alloc
8817 *
8818 * Description:
8819 * Allocate and initialize a host structure. Returns NULL upon error
8820 * and a pointer to a aic7xxx_host struct upon success.
8821 *-F*************************************************************************/
8824 {
8829 /*
8830 * Allocate a storage area by registering us with the mid-level
8831 * SCSI layer.
8832 */
8836 {
8844 {
8847 }
8848 else
8849 {
8850 /*
8851 * For some reason we don't have enough memory. Free the
8852 * allocated memory for the aic7xxx_host struct, and return NULL.
8853 */
8857 }
8862 {
8867 }
8868 DRIVER_LOCK_INIT
8869 }
8871 }
8873 /*+F*************************************************************************
8874 * Function:
8875 * aic7xxx_free
8876 *
8877 * Description:
8878 * Frees and releases all resources associated with an instance of
8879 * the driver (struct aic7xxx_host *).
8880 *-F*************************************************************************/
8881 static void
8883 {
8886 /*
8887 * Free the allocated hardware SCB space.
8888 */
8890 {
8893 {
8897 }
8898 /*
8899 * Free the driver SCBs. These were allocated on an as-need
8900 * basis. We allocated these in groups depending on how many
8901 * we could fit into a given amount of RAM. The tail SCB for
8902 * these allocations has a pointer to the alloced area.
8903 */
8905 {
8907 {
8913 }
8917 }
8919 /*
8920 * Free the SCB data area.
8921 */
8923 }
8925 /*
8926 * Free any alloced Scsi_Cmnd structures that might be around for
8927 * negotiation purposes....
8928 */
8930 {
8932 {
8934 {
8936 }
8938 }
8939 }
8942 }
8944 /*+F*************************************************************************
8945 * Function:
8946 * aic7xxx_load_seeprom
8947 *
8948 * Description:
8949 * Load the seeprom and configure adapter and target settings.
8950 * Returns 1 if the load was successful and 0 otherwise.
8951 *-F*************************************************************************/
8952 static void
8954 {
8962 {
8964 }
8966 {
8982 {
8986 else
8989 }
8991 {
8996 {
9000 else
9003 }
9004 }
9006 }
9009 {
9011 {
9013 }
9016 {
9022 {
9024 }
9025 }
9027 {
9029 }
9031 {
9035 }
9038 else
9040 }
9041 else
9042 {
9044 {
9046 }
9048 /*
9049 * Note things in our flags
9050 */
9053 /*
9054 * Update the settings in sxfrctl1 to match the termination settings.
9055 */
9058 /*
9059 * Get our SCSI ID from the SEEPROM setting...
9060 */
9063 /*
9064 * First process the settings that are different between the VLB
9065 * and PCI adapter seeproms.
9066 */
9068 {
9069 /* VLB adapter seeproms */
9074 {
9077 }
9078 }
9079 else
9080 {
9081 /* PCI adapter seeproms */
9086 else
9090 {
9093 }
9094 }
9096 }
9100 /*
9101 * Limit to 16 targets just in case. The 2842 for one is known to
9102 * blow the max_targets setting, future cards might also.
9103 */
9107 {
9109 {
9114 {
9117 }
9118 }
9119 }
9122 {
9125 {
9127 {
9128 /*
9129 * OK...the BIOS set things up and left behind the settings we need.
9130 * Just make our sc->device_flags[i] entry match what the card has
9131 * set for this device.
9132 */
9141 {
9143 {
9148 }
9149 }
9150 else
9151 {
9153 {
9158 }
9159 }
9160 }
9161 else
9162 {
9163 /*
9164 * Assume the BIOS has NOT been run on this card and nothing between
9165 * the card and the devices is configured yet.
9166 */
9180 }
9181 }
9183 {
9185 }
9187 {
9189 {
9190 /*
9191 * I know of two different Ultra BIOSes that do this differently.
9192 * One on the Gigabyte 6BXU mb that wants flags[i] & CFXFER to
9193 * be == to 0x03 and SYNCHISULTRA to be true to mean 40MByte/s
9194 * while on the IBM Netfinity 5000 they want the same thing
9195 * to be something else, while flags[i] & CFXFER == 0x03 and
9196 * SYNCHISULTRA false should be 40MByte/s. So, we set both to
9197 * 40MByte/s and the lower speeds be damned. People will have
9198 * to select around the conversely mapped lower speeds in order
9199 * to select lower speeds on these boards.
9200 */
9203 {
9206 }
9208 {
9210 }
9211 }
9215 {
9217 }
9218 }
9220 {
9222 }
9224 {
9234 }
9235 else
9236 {
9238 {
9242 {
9246 {
9250 }
9251 else
9252 {
9254 }
9255 }
9256 else
9257 {
9262 }
9264 AHC_SYNCRATE_ULTRA3);
9267 AHC_SYNCRATE_ULTRA3);
9268 }
9270 {
9278 AHC_SYNCRATE_ULTRA2);
9281 AHC_SYNCRATE_ULTRA2);
9282 }
9283 else
9284 {
9290 {
9295 scsirate,
9297 AHC_SYNCRATE_ULTRA :
9298 AHC_SYNCRATE_FAST);
9302 AHC_SYNCRATE_ULTRA :
9303 AHC_SYNCRATE_FAST);
9304 }
9305 else
9308 }
9310 }
9312 {
9315 }
9316 else
9317 {
9320 }
9324 }
9332 /*
9333 * We set the p->ultraenb from the SEEPROM to begin with, but now we make
9334 * it match what is already down in the card. If we are doing a reset
9335 * on the card then this will get put back to a default state anyway.
9336 * This allows us to not have to pre-emptively negotiate when using the
9337 * no_reset option.
9338 */
9346 {
9351 {
9359 }
9363 }
9364 else
9365 {
9367 }
9369 /*
9370 * Only set the SCSICONF and SCSICONF + 1 registers if we are a PCI card.
9371 * The 2842 and 2742 cards already have these registers set and we don't
9372 * want to muck with them since we don't set all the bits they do.
9373 */
9375 {
9376 /* Set the host ID */
9378 /* In case we are a wide card */
9380 }
9381 }
9383 /*+F*************************************************************************
9384 * Function:
9385 * aic7xxx_detect
9386 *
9387 * Description:
9388 * Try to detect and register an Adaptec 7770 or 7870 SCSI controller.
9389 *
9390 * XXX - This should really be called aic7xxx_probe(). A sequence of
9391 * probe(), attach()/detach(), and init() makes more sense than
9392 * one do-it-all function. This may be useful when (and if) the
9393 * mid-level SCSI code is overhauled.
9394 *-F*************************************************************************/
9395 int
9397 {
9402 #if defined(__i386__) || defined(__alpha__)
9405 #endif
9407 #if defined(__i386__) || defined(__alpha__)
9410 #endif
9412 #ifdef MODULE
9413 /*
9414 * If we are called as a module, the aic7xxx pointer may not be null
9415 * and it would point to our bootup string, just like on the lilo
9416 * command line. IF not NULL, then process this config string with
9417 * aic7xxx_setup
9418 */
9424 "aic7xxx: to see the proper way to specify options to the aic7xxx "
9428 #endif
9434 #ifdef CONFIG_PCI
9435 /*
9436 * PCI-bus probe.
9437 */
9439 {
9440 struct
9441 {
9444 ahc_chip chip;
9445 ahc_flag_type flags;
9446 ahc_feature features;
9600 };
9607 {
9611 pdev))) {
9615 {
9617 {
9621 }
9622 }
9625 {
9634 /*
9635 * Read sundry information from PCI BIOS.
9636 */
9645 {
9650 {
9651 /* duplicate PCI entry, skip it */
9654 }
9656 }
9666 {
9669 }
9670 #ifdef AIC7XXX_STRICT_PCI_SETUP
9673 #else
9675 #endif
9680 #ifdef AIC7XXX_STRICT_PCI_SETUP
9683 {
9685 }
9691 {
9701 }
9708 {
9718 }
9720 #ifdef MMAPIO
9724 {
9731 {
9733 /*
9734 * We need to check the I/O with the MMAPed address. Some machines
9735 * simply fail to work with MMAPed I/O and certain controllers.
9736 */
9738 {
9739 /*
9740 * OK.....we failed our test....go back to programmed I/O
9741 */
9752 {
9762 }
9763 }
9764 }
9765 }
9766 #endif
9768 /*
9769 * Lock out other contenders for our i/o space.
9770 */
9774 /*
9775 * We HAVE to make sure the first pause_sequencer() and all other
9776 * subsequent I/O that isn't PCI config space I/O takes place
9777 * after the MMAPed I/O region is configured and tested. The
9778 * problem is the PowerPC architecture that doesn't support
9779 * programmed I/O at all, so we have to have the MMAP I/O set up
9780 * for this pause to even work on those machines.
9781 */
9784 /*
9785 * Clear out any pending PCI error status messages. Also set
9786 * verbose to 0 so that we don't emit strange PCI error messages
9787 * while cleaning out the current status bits.
9788 */
9796 /*
9797 * Remember how the card was setup in case there is no seeprom.
9798 */
9801 else
9803 /*
9804 * Get current termination setting
9805 */
9809 {
9814 }
9815 /*
9816 * Very quickly put the term setting back into the register since
9817 * the chip reset may cause odd things to happen. This is to keep
9818 * LVD busses with lots of drives from draining the power out of
9819 * the diffsense line before we get around to running the
9820 * configure_termination() function. Also restore the STPWLEVEL
9821 * bit of DEVCONFIG
9822 */
9827 /*
9828 * We need to set the CHNL? assignments before loading the SEEPROM
9829 * The 3940 and 3985 cards (original stuff, not any of the later
9830 * stuff) are 7870 and 7880 class chips. The Ultra2 stuff falls
9831 * under 7896 and 7897. The 7895 is in a class by itself :)
9832 */
9834 {
9838 {
9840 {
9852 }
9853 }
9860 {
9862 }
9863 /*
9864 * The 7895 is the only chipset that sets the SCBSIZE32 param
9865 * in the DEVCONFIG register. The Ultra2 chipsets use
9866 * the DSCOMMAND0 register instead.
9867 */
9869 {
9873 }
9877 }
9879 /*
9880 * Loading of the SEEPROM needs to come after we've set the flags
9881 * to indicate possible CHNLB and CHNLC assigments. Otherwise,
9882 * on 394x and 398x cards we'll end up reading the wrong settings
9883 * for channels B and C
9884 */
9886 {
9890 /*
9891 * Switch to the alt mode of the chip...
9892 */
9894 /*
9895 * Set our options...the last two items set our CRC after x byte
9896 * count in target mode...
9897 */
9901 /*
9902 * switch back to normal mode...
9903 */
9907 CRCCONTROL1);
9923 /*
9924 * Set the DSCOMMAND0 register on these cards different from
9925 * on the 789x cards. Also, read the SEEPROM as well.
9926 */
9929 DSCOMMAND0);
9930 /* FALLTHROUGH */
9935 /*
9936 * Check the rev of the chipset before we change DSCOMMAND0
9937 */
9940 {
9943 DSCOMMAND0);
9944 }
9947 }
9950 /*
9951 * and then we need another switch based on the type in order to
9952 * make sure the channel B primary flag is set properly on 7895
9953 * controllers....Arrrgggghhh!!! We also have to catch the fact
9954 * that when you disable the BIOS on the 7895 on the Intel DK440LX
9955 * motherboard, and possibly others, it only sets the BIOS disabled
9956 * bit on the A channel...I think I'm starting to lean towards
9957 * going postal....
9958 */
9960 {
9966 {
9970 {
9972 {
9978 }
9979 else
9980 {
9986 }
9987 }
9989 }
9993 }
9995 /*
9996 * We only support external SCB RAM on the 7895/6/7 chipsets.
9997 * We could support it on the 7890/1 easy enough, but I don't
9998 * know of any 7890/1 based cards that have it. I do know
9999 * of 7895/6/7 cards that have it and they work properly.
10000 */
10002 {
10010 {
10013 {
10016 DSCOMMAND0);
10019 }
10021 {
10029 }
10030 }
10031 else
10032 {
10034 {
10038 }
10040 {
10048 }
10049 }
10055 }
10057 /*
10058 * Take the LED out of diagnostic mode
10059 */
10062 SBLKCTL);
10064 /*
10065 * We don't know where this is set in the SEEPROM or by the
10066 * BIOS, so we default to 100%. On Ultra2 controllers, use 75%
10067 * instead.
10068 */
10070 {
10072 }
10073 else
10074 {
10076 }
10079 {
10081 }
10082 else
10083 {
10088 }
10090 found++;
10093 {
10098 }
10102 #endif CONFIG_PCI
10104 #if defined(__i386__) || defined(__alpha__)
10105 /*
10106 * EISA/VL-bus card signature probe.
10107 */
10111 {
10115 {
10116 /*
10117 * Some other driver has staked a
10118 * claim to this i/o region already.
10119 */
10120 slot++;
10122 }
10126 {
10127 slot++;
10129 }
10132 {
10134 slot++;
10136 }
10137 /*
10138 * Lock out other contenders for our i/o space.
10139 */
10142 /*
10143 * Pause the card preserving the IRQ type. Allow the operator
10144 * to override the IRQ trigger.
10145 */
10150 else
10164 else
10169 {
10183 slot++;
10185 }
10187 /*
10188 * We are commited now, everything has been checked and this card
10189 * has been found, now we just set it up
10190 */
10192 /*
10193 * Insert our new struct into the list at the end
10194 */
10196 {
10198 }
10199 else
10200 {
10205 }
10208 {
10214 /* FALLTHROUGH */
10216 {
10221 /*
10222 * Get the primary channel information. Right now we don't
10223 * do anything with this, but someday we will be able to inform
10224 * the mid-level SCSI code which channel is primary.
10225 */
10227 {
10232 }
10234 {
10236 }
10239 {
10241 }
10242 else
10243 {
10247 {
10250 }
10251 else
10252 {
10255 }
10256 }
10260 {
10263 }
10264 else
10265 {
10268 }
10271 }
10279 else
10289 {
10304 }
10309 }
10311 {
10318 }
10320 /*
10321 * Set the FIFO threshold and the bus off time.
10322 */
10326 slot++;
10327 found++;
10328 }
10332 /*
10333 * Now, we re-order the probed devices by BIOS address and BUS class.
10334 * In general, we follow this algorithm to make the adapters show up
10335 * in the same order under linux that the computer finds them.
10336 * 1: All VLB/EISA cards with BIOS_ENABLED first, according to BIOS
10337 * address, going from lowest to highest.
10338 * 2: All PCI controllers with BIOS_ENABLED next, according to BIOS
10339 * address, going from lowest to highest.
10340 * 3: Remaining VLB/EISA controllers going in slot order.
10341 * 4: Remaining PCI controllers, going in PCI device order (reversable)
10342 */
10344 {
10355 {
10357 {
10360 {
10364 else
10368 {
10372 }
10373 else
10374 {
10379 {
10382 }
10384 {
10388 }
10389 else
10390 {
10394 }
10395 }
10399 else
10403 }
10405 {
10410 else
10414 {
10418 }
10419 else
10420 {
10424 {
10430 {
10433 }
10434 }
10435 else
10436 {
10442 {
10445 }
10446 }
10447 /*
10448 * Are we dealing with a 7895/6/7/9 where we need to sort the
10449 * channels as well, if so, the bios_address values should
10450 * be the same
10451 */
10456 {
10458 {
10460 {
10463 }
10464 }
10465 else
10466 {
10468 {
10471 }
10472 }
10473 }
10475 {
10479 }
10480 else
10481 {
10485 }
10486 }
10490 else
10494 }
10497 /*
10498 * At this point, the cards have been broken into 4 sorted lists, now
10499 * we run through the lists in order and register each controller
10500 */
10501 {
10506 {
10509 {
10513 {
10516 {
10517 found--;
10520 }
10522 {
10527 }
10528 }
10532 }
10533 }
10534 }
10535 }
10537 }
10542 /*+F*************************************************************************
10543 * Function:
10544 * aic7xxx_allocate_negotiation_command
10545 *
10546 * Description:
10547 * allocate the actual command struct and fill in the gaps...
10548 *-F*************************************************************************/
10552 {
10557 {
10559 }
10561 {
10565 }
10587 }
10589 /*+F*************************************************************************
10590 * Function:
10591 * aic7xxx_negotiation_complete
10592 *
10593 * Description:
10594 * Handle completion events for our Negotiation commands. Clear out the
10595 * struct and get it ready for its next use.
10596 *-F*************************************************************************/
10597 static void
10599 {
10607 /*
10608 * perform our minimalistic domain validation
10609 */
10611 {
10615 {
10617 }
10620 {
10625 {
10626 /*
10627 * oops, we had a failure, lower the transfer rate and try again. It's
10628 * worth noting here that it might be wise to also check for typical
10629 * wide setting on narrow cable type problems and try disabling wide
10630 * instead of slowing down if those exist. That's hard to do with simple
10631 * checksums though.
10632 */
10634 {
10637 }
10639 {
10640 syncrate++;
10643 {
10646 {
10653 {
10656 }
10657 }
10658 }
10660 {
10671 {
10676 }
10677 else
10678 {
10683 }
10684 }
10685 else
10686 {
10697 }
10698 }
10700 }
10701 else
10702 {
10704 {
10707 }
10708 /*
10709 * Update the checksum in case the INQUIRY data has changed, maybe
10710 * in relation to a change in the mode pages, or whatever.
10711 */
10713 /*
10714 * Signal that we are trying out the domain validation
10715 */
10717 /*
10718 * Signal that we need to re-negotiate things, this also gets us our
10719 * INQUIRY command to re-checksum off of.
10720 */
10724 }
10725 }
10726 else
10727 {
10730 {
10733 }
10734 /*
10735 * We successfully did our checksum, so don't leave the needdv flag set
10736 * in case we might have set it last time through.
10737 */
10739 }
10740 }
10743 /*
10744 * This looks recursive in the extreme, but if this was a WDTR negotiation
10745 * and we didn't follow up with SDTR yet, then this will get it started.
10746 * For all other cases, this should work out to be a no-op, unless we are
10747 * doing domain validation and happen to need a new negotiation command.
10748 *
10749 * In case we don't want this to go any further, the cmdcmplt interrupt
10750 * handler will NULL out the cmd->next entry so that the real SCSI command
10751 * can be sent back to the mid layer code with SENSE data intact. We'll
10752 * finish things up when the cmd gets sent back down to us, so no worries.
10753 */
10755 {
10757 }
10759 }
10761 /*+F*************************************************************************
10762 * Function:
10763 * aic7xxx_build_negotiation_command
10764 *
10765 * Description:
10766 * Build a Scsi_Cmnd structure to perform negotiation with or else send
10767 * a pre-built command specifically for this purpose.
10768 *-F*************************************************************************/
10769 static void
10772 {
10778 {
10781 {
10783 }
10784 /*
10785 * Before sending this thing out, we also make the cmd->next pointer
10786 * point to the real command so we can stuff any possible SENSE data
10787 * into the real command instead of this fake command. This has to be
10788 * done each time the command is built, not just the first time, hence
10789 * it's outside of the above if()...
10790 */
10792 /*
10793 * Clear the buffer so checksums come out right....
10794 */
10797 /*
10798 * Remove any commands for this particular device that might be on the
10799 * waiting_scbs queue or qinfifo so that this command goes out first.
10800 * This is vital for our implementation of domain validation.
10801 */
10806 {
10811 {
10814 {
10819 }
10820 else
10821 {
10823 }
10824 }
10825 }
10827 aic7xxx_negotiation_complete);
10828 }
10829 }
10831 #ifdef AIC7XXX_VERBOSE_DEBUGGING
10832 /*+F*************************************************************************
10833 * Function:
10834 * aic7xxx_print_scb
10835 *
10836 * Description:
10837 * Dump the byte codes for an about to be sent SCB.
10838 *-F*************************************************************************/
10839 static void
10841 {
10848 {
10850 }
10852 }
10853 #endif
10855 /*+F*************************************************************************
10856 * Function:
10857 * aic7xxx_buildscb
10858 *
10859 * Description:
10860 * Build a SCB.
10861 *-F*************************************************************************/
10862 static void
10865 {
10873 /*
10874 * Setup the control byte if we need negotiation and have not
10875 * already requested it.
10876 */
10881 {
10885 {
10888 {
10891 }
10892 else
10893 {
10895 {
10898 }
10899 else
10900 {
10903 }
10905 }
10906 }
10907 }
10909 {
10913 {
10917 {
10919 }
10921 {
10923 }
10925 {
10927 }
10928 }
10929 }
10934 {
10936 }
10940 /*
10941 * The interpretation of request_buffer and request_bufflen
10942 * changes depending on whether or not use_sg is zero; a
10943 * non-zero use_sg indicates the number of elements in the
10944 * scatter-gather array.
10945 */
10947 /*
10948 * XXX - this relies on the host data being stored in a
10949 * little-endian format.
10950 */
10956 {
10959 /*
10960 * We must build an SG list in adapter format, as the kernel's SG list
10961 * cannot be used directly because of data field size (__alpha__)
10962 * differences and the kernel SG list uses virtual addresses where
10963 * we need physical addresses.
10964 */
10970 /*
10971 * Copy the segments into the SG array. NOTE!!! - We used to
10972 * have the first entry both in the data_pointer area and the first
10973 * SG element. That has changed somewhat. We still have the first
10974 * entry in both places, but now we download the address of
10975 * scb->sg_list[1] instead of 0 to the sg pointer in the hscb.
10976 */
10978 {
10983 }
10984 /* Copy the first SG into the data pointer area. */
10990 }
10991 else
10992 {
10994 {
11007 }
11008 else
11009 {
11016 }
11017 }
11018 }
11020 /*+F*************************************************************************
11021 * Function:
11022 * aic7xxx_queue
11023 *
11024 * Description:
11025 * Queue a SCB to the controller.
11026 *-F*************************************************************************/
11027 int
11029 {
11032 #ifdef AIC7XXX_VERBOSE_DEBUGGING
11034 #endif
11035 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
11037 #endif
11040 /*
11041 * Check to see if channel was scanned.
11042 */
11044 #ifdef AIC7XXX_VERBOSE_DEBUGGING
11046 {
11051 }
11052 else
11053 {
11055 {
11060 }
11061 }
11064 {
11071 }
11072 #endif
11076 {
11077 DRIVER_LOCK
11079 DRIVER_UNLOCK
11081 }
11083 {
11087 DRIVER_LOCK
11089 DRIVER_UNLOCK
11091 }
11092 else
11093 {
11097 /*
11098 * Construct the SCB beforehand, so the sequencer is
11099 * paused a minimal amount of time.
11100 */
11103 /*
11104 * Make sure the Scsi_Cmnd pointer is saved, the struct it points to
11105 * is set up properly, and the parity error flag is reset, then send
11106 * the SCB to the sequencer and watch the fun begin.
11107 */
11117 DRIVER_LOCK
11120 {
11122 }
11123 DRIVER_UNLOCK
11124 }
11126 }
11128 /*+F*************************************************************************
11129 * Function:
11130 * aic7xxx_bus_device_reset
11131 *
11132 * Description:
11133 * Abort or reset the current SCSI command(s). If the scb has not
11134 * previously been aborted, then we attempt to send a BUS_DEVICE_RESET
11135 * message to the target. If the scb has previously been unsuccessfully
11136 * aborted, then we will reset the channel and have all devices renegotiate.
11137 * Returns an enumerated type that indicates the status of the operation.
11138 *-F*************************************************************************/
11139 static int
11141 {
11155 {
11159 {
11179 /*
11180 * We're not in a valid phase, so assume we're idle.
11181 */
11184 }
11190 }
11194 /*
11195 * Send a Device Reset Message:
11196 * The target that is holding up the bus may not be the same as
11197 * the one that triggered this timeout (different commands have
11198 * different timeout lengths). Our strategy here is to queue an
11199 * abort message to the timed out target if it is disconnected.
11200 * Otherwise, if we have an active target we stuff the message buffer
11201 * with an abort message and assert ATN in the hopes that the target
11202 * will let go of the bus and go to the mesgout phase. If this
11203 * fails, we'll get another timeout a few seconds later which will
11204 * attempt a bus reset.
11205 */
11210 {
11212 {
11217 }
11219 {
11221 {
11228 BUS_DEVICE_RESET_PENDING;
11229 /* Send the abort message to the active SCB. */
11233 }
11234 else
11235 {
11236 /* We want to send out the message, but it could screw an already */
11237 /* in place and being used message. Instead, we return an error */
11238 /* to try and start the bus reset phase since this command is */
11239 /* probably hung (aborts failed, and now reset is failing). We */
11240 /* also make sure to set BUS_DEVICE_RESET_PENDING so we won't try */
11241 /* any more on this device, but instead will escalate to a bus or */
11242 /* host reset (additionally, we won't try to abort any more). */
11248 BUS_DEVICE_RESET_PENDING;
11250 }
11251 }
11255 {
11257 }
11258 else
11259 {
11262 {
11264 }
11265 }
11267 {
11268 /*
11269 * Simply set the MK_MESSAGE flag and the SEQINT handler will do
11270 * the rest on a reconnect.
11271 */
11275 BUS_DEVICE_RESET_PENDING;
11277 {
11283 }
11284 /*
11285 * Actually requeue this SCB in case we can select the
11286 * device before it reconnects. If the transaction we
11287 * want to abort is not tagged, then this will be the only
11288 * outstanding command and we can simply shove it on the
11289 * qoutfifo and be done. If it is tagged, then it goes right
11290 * in with all the others, no problem :) We need to add it
11291 * to the qinfifo and let the sequencer know it is there.
11292 * Now, the only problem left to deal with is, *IF* this
11293 * command completes, in spite of the MK_MESSAGE bit in the
11294 * control byte, then we need to pick that up in the interrupt
11295 * routine and clean things up. This *shouldn't* ever happen.
11296 */
11303 else
11307 }
11309 {
11311 }
11314 }
11317 /*+F*************************************************************************
11318 * Function:
11319 * aic7xxx_panic_abort
11320 *
11321 * Description:
11322 * Abort the current SCSI command(s).
11323 *-F*************************************************************************/
11324 void
11326 {
11329 UTS_RELEASE);
11341 }
11343 /*+F*************************************************************************
11344 * Function:
11345 * aic7xxx_abort
11346 *
11347 * Description:
11348 * Abort the current SCSI command(s).
11349 *-F*************************************************************************/
11350 int
11352 {
11357 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
11359 #endif
11365 /*
11366 * I added a new config option to the driver: "panic_on_abort" that will
11367 * cause the driver to panic and the machine to stop on the first abort
11368 * or reset call into the driver. At that point, it prints out a lot of
11369 * usefull information for me which I can then use to try and debug the
11370 * problem. Simply enable the boot time prompt in order to activate this
11371 * code.
11372 */
11376 DRIVER_LOCK
11378 /*
11379 * Run the isr to grab any command in the QOUTFIFO and any other misc.
11380 * assundry tasks. This should also set up the bh handler if there is
11381 * anything to be done, but it won't run until we are done here since
11382 * we are following a straight code path without entering the scheduler
11383 * code.
11384 */
11387 {
11391 }
11394 /* Totally bogus cmd since it points beyond our */
11396 /* timeout serial number. */
11401 DRIVER_UNLOCK
11403 }
11406 /* has already been recycled for another command */
11407 /* Either way, this SCB has nothing to do with this*/
11408 /* command and we need to deal with cmd without */
11409 /* touching the SCB. */
11410 /* The theory here is to return a value that will */
11411 /* make the queued for complete command actually */
11412 /* finish successfully, or to indicate that we */
11413 /* don't have this cmd any more and the mid level */
11414 /* code needs to find it. */
11418 {
11420 {
11426 else
11430 DRIVER_UNLOCK
11432 * completion */
11433 }
11436 }
11441 DRIVER_UNLOCK
11443 }
11445 /* At this point we know the following:
11446 * the SCB pointer is valid
11447 * the command pointer passed in to us and the scb->cmd pointer match
11448 * this then means that the command we need to abort is the same as the
11449 * command held by the scb pointer and is a valid abort request.
11450 * Now, we just have to figure out what to do from here. Current plan is:
11451 * if we have already been here on this command, escalate to a reset
11452 * if scb is on waiting list or QINFIFO, send it back as aborted, but
11453 * we also need to be aware of the possibility that we could be using
11454 * a faked negotiation command that is holding this command up, if
11455 * so we need to take care of that command instead, which means we
11456 * would then treat this one like it was sitting around disconnected
11457 * instead.
11458 * if scb is on WAITING_SCB list in sequencer, free scb and send back
11459 * if scb is disconnected and not completed, abort with abort message
11460 * if scb is currently running, then it may be causing the bus to hang
11461 * so we want a return value that indicates a reset would be appropriate
11462 * if the command does not finish shortly
11463 * if scb is already complete but not on completeq, we're screwed because
11464 * this can't happen (except if the command is in the QOUTFIFO, in which
11465 * case we would like it to complete successfully instead of having to
11466 * to be re-done)
11467 * All other scenarios already dealt with by previous code.
11468 */
11471 {
11476 DRIVER_UNLOCK
11478 }
11481 BUS_DEVICE_RESET_PENDING) )
11482 {
11487 DRIVER_UNLOCK
11489 }
11497 /*
11498 * First, let's check to see if the currently running command is our target
11499 * since if it is, the return is fairly easy and quick since we don't want
11500 * to touch the command in case it might complete, but we do want a timeout
11501 * in case it's actually hung, so we really do nothing, but tell the mid
11502 * level code to reset the timeout.
11503 */
11506 {
11507 /*
11508 * Check to see if the sequencer is just sitting on this command, or
11509 * if it's actively being run.
11510 */
11513 {
11527 DRIVER_UNLOCK /* muck with other SCBs if this */
11532 }
11533 }
11536 {
11543 {
11546 else
11548 }
11549 else
11550 {
11552 }
11554 {
11555 /*
11556 * OK..this means the command we are currently getting an abort
11557 * for has an outstanding negotiation command in front of it.
11558 * We don't really have a way to tie back into the negotiation
11559 * commands, so we just send this back as pending, then it
11560 * will get reset in 2 seconds.
11561 */
11564 DRIVER_UNLOCK
11566 }
11577 }
11579 /*
11580 * We just checked the waiting_q, now for the QINFIFO
11581 */
11583 {
11591 }
11593 /*
11594 * QINFIFO, waitingq, completeq done. Next, check WAITING_SCB list in card
11595 */
11598 {
11604 {
11607 {
11613 {
11615 /* stop the selection since we just
11616 * grabbed the scb out from under the
11617 * card
11618 */
11621 }
11622 else
11623 {
11628 }
11634 }
11637 }
11639 }
11641 /*
11642 * Hmmm...completeq, QOUTFIFO, QINFIFO, WAITING_SCBH, waitingq all checked.
11643 * OK...the sequencer's paused, interrupts are off, and we haven't found the
11644 * command anyplace where it could be easily aborted. Time for the hard
11645 * work. We also know the command is valid. This essentially means the
11646 * command is disconnected, or connected but not into any phases yet, which
11647 * we know due to the tests we ran earlier on the current active scb phase.
11648 * At this point we can queue the abort tag and go on with life.
11649 */
11652 {
11658 {
11664 }
11671 else
11673 }
11675 {
11678 }
11681 DRIVER_UNLOCK
11683 /*
11684 * On the return value. If we found the command and aborted it, then we know
11685 * it's already sent back and there is no reason for a further timeout, so
11686 * we use SCSI_ABORT_SUCCESS. On the queued abort side, we aren't so certain
11687 * there hasn't been a bus hang or something that might keep the abort from
11688 * from completing. Therefore, we use SCSI_ABORT_PENDING. The first time this
11689 * is passed back, the timeout on the command gets extended, the second time
11690 * we pass this back, the mid level SCSI code calls our reset function, which
11691 * would shake loose a hung bus.
11692 */
11695 else
11697 }
11700 /*+F*************************************************************************
11701 * Function:
11702 * aic7xxx_reset
11703 *
11704 * Description:
11705 * Resetting the bus always succeeds - is has to, otherwise the
11706 * kernel will panic! Try a surgical technique - sending a BUS
11707 * DEVICE RESET message - on the offending target before pulling
11708 * the SCSI bus reset line.
11709 *-F*************************************************************************/
11710 int
11712 {
11717 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
11719 #endif
11720 #define DEVICE_RESET 0x01
11721 #define BUS_RESET 0x02
11722 #define HOST_RESET 0x04
11723 #define FAIL 0x08
11724 #define RESET_DELAY 0x10
11730 {
11734 }
11740 /*
11741 * I added a new config option to the driver: "panic_on_abort" that will
11742 * cause the driver to panic and the machine to stop on the first abort
11743 * or reset call into the driver. At that point, it prints out a lot of
11744 * usefull information for me which I can then use to try and debug the
11745 * problem. Simply enable the boot time prompt in order to activate this
11746 * code.
11747 */
11751 DRIVER_LOCK
11755 {
11759 }
11762 {
11767 {
11769 }
11770 else
11771 {
11773 }
11774 }
11776 {
11783 {
11785 {
11790 DRIVER_UNLOCK
11792 }
11795 }
11797 {
11802 DRIVER_UNLOCK
11804 }
11805 else
11806 {
11812 }
11813 }
11814 else
11815 {
11820 {
11831 DRIVER_UNLOCK
11833 }
11835 {
11837 }
11839 {
11841 }
11842 else
11843 {
11845 }
11846 }
11849 {
11854 }
11857 {
11859 {
11864 }
11866 }
11869 {
11874 }
11876 {
11878 }
11881 {
11883 {
11888 }
11890 }
11893 {
11898 }
11899 /*
11900 * By this point, we want to already know what we are going to do and
11901 * only have the following code implement our course of action.
11902 */
11904 {
11907 DRIVER_UNLOCK
11912 DRIVER_UNLOCK
11919 /* We can't rely on run_waiting_queues to unpause the sequencer for
11920 * PCI based controllers since we use AAP */
11924 DRIVER_UNLOCK
11935 {
11938 }
11941 {
11944 }
11947 else
11948 {
11951 SIMODE1);
11957 }
11959 /*
11960 * If this a SCSI_RESET_SYNCHRONOUS then the command we were given is
11961 * in need of being re-started, so send it on through to aic7xxx_queue
11962 * and let it set until the delay is over. This keeps it from dying
11963 * entirely and avoids getting a bogus dead command back through the
11964 * mid-level code due to too many retries.
11965 */
11966 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,132)
11968 {
11971 }
11972 #endif
11974 /*
11975 * We can't rely on run_waiting_queues to unpause the sequencer for
11976 * PCI based controllers since we use AAP. NOTE: this also sets
11977 * the timer for the one command we might have queued in the case
11978 * of a synch reset.
11979 */
11982 DRIVER_UNLOCK
11985 }
11986 }
11988 /*+F*************************************************************************
11989 * Function:
11990 * aic7xxx_biosparam
11991 *
11992 * Description:
11993 * Return the disk geometry for the given SCSI device.
11994 *-F*************************************************************************/
11995 int
11997 {
12006 {
12011 }
12018 {
12022 }
12029 }
12031 /*+F*************************************************************************
12032 * Function:
12033 * aic7xxx_release
12034 *
12035 * Description:
12036 * Free the passed in Scsi_Host memory structures prior to unloading the
12037 * module.
12038 *-F*************************************************************************/
12039 int
12041 {
12049 #ifdef MMAPIO
12051 {
12053 }
12058 {
12060 {
12063 else
12065 }
12066 else
12067 {
12069 }
12071 }
12074 }
12076 /*+F*************************************************************************
12077 * Function:
12078 * aic7xxx_print_card
12079 *
12080 * Description:
12081 * Print out all of the control registers on the card
12082 *
12083 * NOTE: This function is not yet safe for use on the VLB and EISA
12084 * controllers, so it isn't used on those controllers at all.
12085 *-F*************************************************************************/
12086 static void
12088 {
12122 };
12127 {
12139 }
12141 /*
12142 * the registers on the card....
12143 */
12147 {
12150 j++)
12151 {
12154 {
12157 }
12158 }
12159 }
12163 /*
12164 * If this was an Ultra2 controller, then we just hosed the card in terms
12165 * of the QUEUE REGS. This function is only called at init time or by
12166 * the panic_abort function, so it's safe to assume a generic init time
12167 * setting here
12168 */
12171 {
12175 }
12177 }
12179 /*+F*************************************************************************
12180 * Function:
12181 * aic7xxx_print_scratch_ram
12182 *
12183 * Description:
12184 * Print out the scratch RAM values on the card.
12185 *-F*************************************************************************/
12186 static void
12188 {
12194 {
12197 {
12200 }
12201 }
12203 {
12205 {
12208 {
12211 }
12212 }
12213 }
12215 }
12220 /* Eventually this will go into an include file, but this will be later */
12225 /*
12226 * Overrides for Emacs so that we almost follow Linus's tabbing style.
12227 * Emacs will notice this stuff at the end of the file and automatically
12228 * adjust the settings for this buffer only. This must remain at the end
12229 * of the file.
12230 * ---------------------------------------------------------------------------
12231 * Local variables:
12232 * c-indent-level: 2
12233 * c-brace-imaginary-offset: 0
12234 * c-brace-offset: -2
12235 * c-argdecl-indent: 2
12236 * c-label-offset: -2
12237 * c-continued-statement-offset: 2
12238 * c-continued-brace-offset: 0
12239 * indent-tabs-mode: nil
12240 * tab-width: 8
12241 * End:
12242 */