blob: 1bb8727eea3e5a2a2a7984bc7922451127c93426 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * eata.c - Low-level driver for EATA/DMA SCSI host adapters.
3 *
4 * 03 Jun 2003 Rev. 8.10 for linux-2.5.70
5 * + Update for new IRQ API.
6 * + Use "goto" when appropriate.
7 * + Drop eata.h.
8 * + Update for new module_param API.
9 * + Module parameters can now be specified only in the
10 * same format as the kernel boot options.
11 *
12 * boot option old module param
13 * ----------- ------------------
14 * addr,... io_port=addr,...
15 * lc:[y|n] linked_comm=[1|0]
16 * mq:xx max_queue_depth=xx
17 * tm:[0|1|2] tag_mode=[0|1|2]
18 * et:[y|n] ext_tran=[1|0]
19 * rs:[y|n] rev_scan=[1|0]
20 * ip:[y|n] isa_probe=[1|0]
21 * ep:[y|n] eisa_probe=[1|0]
22 * pp:[y|n] pci_probe=[1|0]
23 *
24 * A valid example using the new parameter format is:
25 * modprobe eata "eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n"
26 *
27 * which is equivalent to the old format:
28 * modprobe eata io_port=0x7410,0x230 linked_comm=1 tag_mode=0 \
29 * max_queue_depth=4 eisa_probe=0
30 *
31 * 12 Feb 2003 Rev. 8.04 for linux 2.5.60
32 * + Release irq before calling scsi_register.
33 *
34 * 12 Nov 2002 Rev. 8.02 for linux 2.5.47
35 * + Release driver_lock before calling scsi_register.
36 *
37 * 11 Nov 2002 Rev. 8.01 for linux 2.5.47
38 * + Fixed bios_param and scsicam_bios_param calling parameters.
39 *
40 * 28 Oct 2002 Rev. 8.00 for linux 2.5.44-ac4
41 * + Use new tcq and adjust_queue_depth api.
42 * + New command line option (tm:[0-2]) to choose the type of tags:
43 * 0 -> disable tagging ; 1 -> simple tags ; 2 -> ordered tags.
44 * Default is tm:0 (tagged commands disabled).
45 * For compatibility the "tc:" option is an alias of the "tm:"
46 * option; tc:n is equivalent to tm:0 and tc:y is equivalent to
47 * tm:1.
48 * + The tagged_comm module parameter has been removed, use tag_mode
49 * instead, equivalent to the "tm:" boot option.
50 *
51 * 10 Oct 2002 Rev. 7.70 for linux 2.5.42
52 * + Foreport from revision 6.70.
53 *
54 * 25 Jun 2002 Rev. 6.70 for linux 2.4.19
55 * + This release is the first one tested on a Big Endian platform:
56 * fixed endian-ness problem due to bitfields;
57 * fixed endian-ness problem in read_pio.
58 * + Added new options for selectively probing ISA, EISA and PCI bus:
59 *
60 * Boot option Parameter name Default according to
61 *
62 * ip:[y|n] isa_probe=[1|0] CONFIG_ISA defined
63 * ep:[y|n] eisa_probe=[1|0] CONFIG_EISA defined
64 * pp:[y|n] pci_probe=[1|0] CONFIG_PCI defined
65 *
66 * The default action is to perform probing if the corrisponding
67 * bus is configured and to skip probing otherwise.
68 *
69 * + If pci_probe is in effect and a list of I/O ports is specified
70 * as parameter or boot option, pci_enable_device() is performed
71 * on all pci devices matching PCI_CLASS_STORAGE_SCSI.
72 *
73 * 21 Feb 2002 Rev. 6.52 for linux 2.4.18
74 * + Backport from rev. 7.22 (use io_request_lock).
75 *
76 * 20 Feb 2002 Rev. 7.22 for linux 2.5.5
77 * + Remove any reference to virt_to_bus().
78 * + Fix pio hang while detecting multiple HBAs.
79 * + Fixed a board detection bug: in a system with
80 * multiple ISA/EISA boards, all but the first one
81 * were erroneously detected as PCI.
82 *
83 * 01 Jan 2002 Rev. 7.20 for linux 2.5.1
84 * + Use the dynamic DMA mapping API.
85 *
86 * 19 Dec 2001 Rev. 7.02 for linux 2.5.1
87 * + Use SCpnt->sc_data_direction if set.
88 * + Use sglist.page instead of sglist.address.
89 *
90 * 11 Dec 2001 Rev. 7.00 for linux 2.5.1
91 * + Use host->host_lock instead of io_request_lock.
92 *
93 * 1 May 2001 Rev. 6.05 for linux 2.4.4
94 * + Clean up all pci related routines.
95 * + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d)
96 *
97 * 30 Jan 2001 Rev. 6.04 for linux 2.4.1
98 * + Call pci_resource_start after pci_enable_device.
99 *
100 * 25 Jan 2001 Rev. 6.03 for linux 2.4.0
101 * + "check_region" call replaced by "request_region".
102 *
103 * 22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11
104 * + Return code checked when calling pci_enable_device.
105 * + Removed old scsi error handling support.
106 * + The obsolete boot option flag eh:n is silently ignored.
107 * + Removed error messages while a disk drive is powered up at
108 * boot time.
109 * + Improved boot messages: all tagged capable device are
110 * indicated as "tagged" or "soft-tagged" :
111 * - "soft-tagged" means that the driver is trying to do its
112 * own tagging (i.e. the tc:y option is in effect);
113 * - "tagged" means that the device supports tagged commands,
114 * but the driver lets the HBA be responsible for tagging
115 * support.
116 *
117 * 16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18
118 * + Updated to the new __setup interface for boot command line options.
119 * + When loaded as a module, accepts the new parameter boot_options
120 * which value is a string with the same format of the kernel boot
121 * command line options. A valid example is:
122 * modprobe eata 'boot_options="0x7410,0x230,lc:y,tc:n,mq:4"'
123 *
124 * 9 Sep 1999 Rev. 5.10 for linux 2.2.12 and 2.3.17
125 * + 64bit cleanup for Linux/Alpha platform support
126 * (contribution from H.J. Lu).
127 *
128 * 22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11
129 * + Removed pre-2.2 source code compatibility.
130 * + Added call to pci_set_master.
131 *
132 * 26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111
133 * + Added command line option (rs:[y|n]) to reverse the scan order
134 * of PCI boards. The default is rs:y, which reverses the BIOS order
135 * while registering PCI boards. The default value rs:y generates
136 * the same order of all previous revisions of this driver.
137 * Pls. note that "BIOS order" might have been reversed itself
138 * after the 2.1.9x PCI modifications in the linux kernel.
139 * The rs value is ignored when the explicit list of addresses
140 * is used by the "eata=port0,port1,..." command line option.
141 * + Added command line option (et:[y|n]) to force use of extended
142 * translation (255 heads, 63 sectors) as disk geometry.
143 * The default is et:n, which uses the disk geometry returned
144 * by scsicam_bios_param. The default value et:n is compatible with
145 * all previous revisions of this driver.
146 *
147 * 28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104
148 * Increased busy timeout from 10 msec. to 200 msec. while
149 * processing interrupts.
150 *
151 * 16 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102
152 * Improved abort handling during the eh recovery process.
153 *
154 * 13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101
155 * The driver is now fully SMP safe, including the
156 * abort and reset routines.
157 * Added command line options (eh:[y|n]) to choose between
158 * new_eh_code and the old scsi code.
159 * If linux version >= 2.1.101 the default is eh:y, while the eh
160 * option is ignored for previous releases and the old scsi code
161 * is used.
162 *
163 * 18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97
164 * Reworked interrupt handler.
165 *
166 * 11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95
167 * Major reliability improvement: when a batch with overlapping
168 * requests is detected, requests are queued one at a time
169 * eliminating any possible board or drive reordering.
170 *
171 * 10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95
172 * Improved SMP support (if linux version >= 2.1.95).
173 *
174 * 9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94
175 * Added support for new PCI code and IO-APIC remapping of irqs.
176 * Performance improvement: when sequential i/o is detected,
177 * always use direct sort instead of reverse sort.
178 *
179 * 4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92
180 * io_port is now unsigned long.
181 *
182 * 17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88
183 * Use new scsi error handling code (if linux version >= 2.1.88).
184 * Use new interrupt code.
185 *
186 * 12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55
187 * Use of udelay inside the wait loops to avoid timeout
188 * problems with fast cpus.
189 * Removed check about useless calls to the interrupt service
190 * routine (reported on SMP systems only).
191 * At initialization time "sorted/unsorted" is displayed instead
192 * of "linked/unlinked" to reinforce the fact that "linking" is
193 * nothing but "elevator sorting" in the actual implementation.
194 *
195 * 17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38
196 * Use of serial_number_at_timeout in abort and reset processing.
197 * Use of the __initfunc and __initdata macro in setup code.
198 * Minor cleanups in the list_statistics code.
199 * Increased controller busy timeout in order to better support
200 * slow SCSI devices.
201 *
202 * 24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26
203 * When loading as a module, parameter passing is now supported
204 * both in 2.0 and in 2.1 style.
205 * Fixed data transfer direction for some SCSI opcodes.
206 * Immediate acknowledge to request sense commands.
207 * Linked commands to each disk device are now reordered by elevator
208 * sorting. Rare cases in which reordering of write requests could
209 * cause wrong results are managed.
210 * Fixed spurious timeouts caused by long simple queue tag sequences.
211 * New command line option (tm:[0-3]) to choose the type of tags:
212 * 0 -> mixed (default); 1 -> simple; 2 -> head; 3 -> ordered.
213 *
214 * 18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28
215 * Added command line options to enable/disable linked commands
216 * (lc:[y|n]), tagged commands (tc:[y|n]) and to set the max queue
217 * depth (mq:xx). Default is "eata=lc:n,tc:n,mq:16".
218 * Improved command linking.
219 * Documented how to setup RAID-0 with DPT SmartRAID boards.
220 *
221 * 8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27
222 * Added linked command support.
223 * Improved detection of PCI boards using ISA base addresses.
224 *
225 * 3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27
226 * Added support for tagged commands and queue depth adjustment.
227 *
228 * 22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26
229 * When CONFIG_PCI is defined, BIOS32 is used to include in the
230 * list of i/o ports to be probed all the PCI SCSI controllers.
231 * The list of i/o ports to be probed can be overwritten by the
232 * "eata=port0,port1,...." boot command line option.
233 * Scatter/gather lists are now allocated by a number of kmalloc
234 * calls, in order to avoid the previous size limit of 64Kb.
235 *
236 * 16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25
237 * Added support for EATA 2.0C, PCI, multichannel and wide SCSI.
238 *
239 * 27 Sep 1996 rev. 2.12 for linux 2.1.0
240 * Portability cleanups (virtual/bus addressing, little/big endian
241 * support).
242 *
243 * 09 Jul 1996 rev. 2.11 for linux 2.0.4
244 * Number of internal retries is now limited.
245 *
246 * 16 Apr 1996 rev. 2.10 for linux 1.3.90
247 * New argument "reset_flags" to the reset routine.
248 *
249 * 6 Jul 1995 rev. 2.01 for linux 1.3.7
250 * Update required by the new /proc/scsi support.
251 *
252 * 11 Mar 1995 rev. 2.00 for linux 1.2.0
253 * Fixed a bug which prevented media change detection for removable
254 * disk drives.
255 *
256 * 23 Feb 1995 rev. 1.18 for linux 1.1.94
257 * Added a check for scsi_register returning NULL.
258 *
259 * 11 Feb 1995 rev. 1.17 for linux 1.1.91
260 * Now DEBUG_RESET is disabled by default.
261 * Register a board even if it does not assert DMA protocol support
262 * (DPT SK2011B does not report correctly the dmasup bit).
263 *
264 * 9 Feb 1995 rev. 1.16 for linux 1.1.90
265 * Use host->wish_block instead of host->block.
266 * New list of Data Out SCSI commands.
267 *
268 * 8 Feb 1995 rev. 1.15 for linux 1.1.89
269 * Cleared target_time_out counter while performing a reset.
270 * All external symbols renamed to avoid possible name conflicts.
271 *
272 * 28 Jan 1995 rev. 1.14 for linux 1.1.86
273 * Added module support.
274 * Log and do a retry when a disk drive returns a target status
275 * different from zero on a recovered error.
276 *
277 * 24 Jan 1995 rev. 1.13 for linux 1.1.85
278 * Use optimized board configuration, with a measured performance
279 * increase in the range 10%-20% on i/o throughput.
280 *
281 * 16 Jan 1995 rev. 1.12 for linux 1.1.81
282 * Fix mscp structure comments (no functional change).
283 * Display a message if check_region detects a port address
284 * already in use.
285 *
286 * 17 Dec 1994 rev. 1.11 for linux 1.1.74
287 * Use the scsicam_bios_param routine. This allows an easy
288 * migration path from disk partition tables created using
289 * different SCSI drivers and non optimal disk geometry.
290 *
291 * 15 Dec 1994 rev. 1.10 for linux 1.1.74
292 * Added support for ISA EATA boards (DPT PM2011, DPT PM2021).
293 * The host->block flag is set for all the detected ISA boards.
294 * The detect routine no longer enforces LEVEL triggering
295 * for EISA boards, it just prints a warning message.
296 *
297 * 30 Nov 1994 rev. 1.09 for linux 1.1.68
298 * Redo i/o on target status CHECK_CONDITION for TYPE_DISK only.
299 * Added optional support for using a single board at a time.
300 *
301 * 18 Nov 1994 rev. 1.08 for linux 1.1.64
302 * Forces sg_tablesize = 64 and can_queue = 64 if these
303 * values are not correctly detected (DPT PM2012).
304 *
305 * 14 Nov 1994 rev. 1.07 for linux 1.1.63 Final BETA release.
306 * 04 Aug 1994 rev. 1.00 for linux 1.1.39 First BETA release.
307 *
308 *
309 * This driver is based on the CAM (Common Access Method Committee)
310 * EATA (Enhanced AT Bus Attachment) rev. 2.0A, using DMA protocol.
311 *
312 * Copyright (C) 1994-2003 Dario Ballabio (ballabio_dario@emc.com)
313 *
314 * Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it
315 *
316 * Redistribution and use in source and binary forms, with or without
317 * modification, are permitted provided that redistributions of source
318 * code retain the above copyright notice and this comment without
319 * modification.
320 *
321 */
322
323/*
324 *
325 * Here is a brief description of the DPT SCSI host adapters.
326 * All these boards provide an EATA/DMA compatible programming interface
327 * and are fully supported by this driver in any configuration, including
328 * multiple SCSI channels:
329 *
330 * PM2011B/9X - Entry Level ISA
331 * PM2021A/9X - High Performance ISA
332 * PM2012A Old EISA
333 * PM2012B Old EISA
334 * PM2022A/9X - Entry Level EISA
335 * PM2122A/9X - High Performance EISA
336 * PM2322A/9X - Extra High Performance EISA
337 * PM3021 - SmartRAID Adapter for ISA
338 * PM3222 - SmartRAID Adapter for EISA (PM3222W is 16-bit wide SCSI)
339 * PM3224 - SmartRAID Adapter for PCI (PM3224W is 16-bit wide SCSI)
340 * PM33340UW - SmartRAID Adapter for PCI ultra wide multichannel
341 *
342 * The above list is just an indication: as a matter of fact all DPT
343 * boards using the EATA/DMA protocol are supported by this driver,
344 * since they use exactely the same programming interface.
345 *
346 * The DPT PM2001 provides only the EATA/PIO interface and hence is not
347 * supported by this driver.
348 *
349 * This code has been tested with up to 3 Distributed Processing Technology
350 * PM2122A/9X (DPT SCSI BIOS v002.D1, firmware v05E.0) EISA controllers,
351 * in any combination of private and shared IRQ.
352 * PCI support has been tested using up to 2 DPT PM3224W (DPT SCSI BIOS
353 * v003.D0, firmware v07G.0).
354 *
355 * DPT SmartRAID boards support "Hardware Array" - a group of disk drives
356 * which are all members of the same RAID-0, RAID-1 or RAID-5 array implemented
357 * in host adapter hardware. Hardware Arrays are fully compatible with this
358 * driver, since they look to it as a single disk drive.
359 *
360 * WARNING: to create a RAID-0 "Hardware Array" you must select "Other Unix"
361 * as the current OS in the DPTMGR "Initial System Installation" menu.
362 * Otherwise RAID-0 is generated as an "Array Group" (i.e. software RAID-0),
363 * which is not supported by the actual SCSI subsystem.
364 * To get the "Array Group" functionality, the Linux MD driver must be used
365 * instead of the DPT "Array Group" feature.
366 *
367 * Multiple ISA, EISA and PCI boards can be configured in the same system.
368 * It is suggested to put all the EISA boards on the same IRQ level, all
369 * the PCI boards on another IRQ level, while ISA boards cannot share
370 * interrupts.
371 *
372 * If you configure multiple boards on the same IRQ, the interrupt must
373 * be _level_ triggered (not _edge_ triggered).
374 *
375 * This driver detects EATA boards by probes at fixed port addresses,
376 * so no BIOS32 or PCI BIOS support is required.
377 * The suggested way to detect a generic EATA PCI board is to force on it
378 * any unused EISA address, even if there are other controllers on the EISA
379 * bus, or even if you system has no EISA bus at all.
380 * Do not force any ISA address on EATA PCI boards.
381 *
382 * If PCI bios support is configured into the kernel, BIOS32 is used to
383 * include in the list of i/o ports to be probed all the PCI SCSI controllers.
384 *
385 * Due to a DPT BIOS "feature", it might not be possible to force an EISA
386 * address on more than a single DPT PCI board, so in this case you have to
387 * let the PCI BIOS assign the addresses.
388 *
389 * The sequence of detection probes is:
390 *
391 * - ISA 0x1F0;
392 * - PCI SCSI controllers (only if BIOS32 is available);
393 * - EISA/PCI 0x1C88 through 0xFC88 (corresponding to EISA slots 1 to 15);
394 * - ISA 0x170, 0x230, 0x330.
395 *
396 * The above list of detection probes can be totally replaced by the
397 * boot command line option: "eata=port0,port1,port2,...", where the
398 * port0, port1... arguments are ISA/EISA/PCI addresses to be probed.
399 * For example using "eata=0x7410,0x7450,0x230", the driver probes
400 * only the two PCI addresses 0x7410 and 0x7450 and the ISA address 0x230,
401 * in this order; "eata=0" totally disables this driver.
402 *
403 * After the optional list of detection probes, other possible command line
404 * options are:
405 *
406 * et:y force use of extended translation (255 heads, 63 sectors);
407 * et:n use disk geometry detected by scsicam_bios_param;
408 * rs:y reverse scan order while detecting PCI boards;
409 * rs:n use BIOS order while detecting PCI boards;
410 * lc:y enables linked commands;
411 * lc:n disables linked commands;
412 * tm:0 disables tagged commands (same as tc:n);
413 * tm:1 use simple queue tags (same as tc:y);
414 * tm:2 use ordered queue tags (same as tc:2);
415 * mq:xx set the max queue depth to the value xx (2 <= xx <= 32).
416 *
417 * The default value is: "eata=lc:n,mq:16,tm:0,et:n,rs:n".
418 * An example using the list of detection probes could be:
419 * "eata=0x7410,0x230,lc:y,tm:2,mq:4,et:n".
420 *
421 * When loading as a module, parameters can be specified as well.
422 * The above example would be (use 1 in place of y and 0 in place of n):
423 *
424 * modprobe eata io_port=0x7410,0x230 linked_comm=1 \
425 * max_queue_depth=4 ext_tran=0 tag_mode=2 \
426 * rev_scan=1
427 *
428 * ----------------------------------------------------------------------------
429 * In this implementation, linked commands are designed to work with any DISK
430 * or CD-ROM, since this linking has only the intent of clustering (time-wise)
431 * and reordering by elevator sorting commands directed to each device,
432 * without any relation with the actual SCSI protocol between the controller
433 * and the device.
434 * If Q is the queue depth reported at boot time for each device (also named
435 * cmds/lun) and Q > 2, whenever there is already an active command to the
436 * device all other commands to the same device (up to Q-1) are kept waiting
437 * in the elevator sorting queue. When the active command completes, the
438 * commands in this queue are sorted by sector address. The sort is chosen
439 * between increasing or decreasing by minimizing the seek distance between
440 * the sector of the commands just completed and the sector of the first
441 * command in the list to be sorted.
442 * Trivial math assures that the unsorted average seek distance when doing
443 * random seeks over S sectors is S/3.
444 * When (Q-1) requests are uniformly distributed over S sectors, the average
445 * distance between two adjacent requests is S/((Q-1) + 1), so the sorted
446 * average seek distance for (Q-1) random requests over S sectors is S/Q.
447 * The elevator sorting hence divides the seek distance by a factor Q/3.
448 * The above pure geometric remarks are valid in all cases and the
449 * driver effectively reduces the seek distance by the predicted factor
450 * when there are Q concurrent read i/o operations on the device, but this
451 * does not necessarily results in a noticeable performance improvement:
452 * your mileage may vary....
453 *
454 * Note: command reordering inside a batch of queued commands could cause
455 * wrong results only if there is at least one write request and the
456 * intersection (sector-wise) of all requests is not empty.
457 * When the driver detects a batch including overlapping requests
458 * (a really rare event) strict serial (pid) order is enforced.
459 * ----------------------------------------------------------------------------
460 * The extended translation option (et:y) is useful when using large physical
461 * disks/arrays. It could also be useful when switching between Adaptec boards
462 * and DPT boards without reformatting the disk.
463 * When a boot disk is partitioned with extended translation, in order to
464 * be able to boot it with a DPT board is could be necessary to add to
465 * lilo.conf additional commands as in the following example:
466 *
467 * fix-table
468 * disk=/dev/sda bios=0x80 sectors=63 heads=128 cylindres=546
469 *
470 * where the above geometry should be replaced with the one reported at
471 * power up by the DPT controller.
472 * ----------------------------------------------------------------------------
473 *
474 * The boards are named EATA0, EATA1,... according to the detection order.
475 *
476 * In order to support multiple ISA boards in a reliable way,
477 * the driver sets host->wish_block = 1 for all ISA boards.
478 */
479
480#include <linux/config.h>
481#include <linux/string.h>
482#include <linux/kernel.h>
483#include <linux/ioport.h>
484#include <linux/delay.h>
485#include <linux/proc_fs.h>
486#include <linux/blkdev.h>
487#include <linux/interrupt.h>
488#include <linux/stat.h>
489#include <linux/pci.h>
490#include <linux/init.h>
491#include <linux/ctype.h>
492#include <linux/spinlock.h>
493#include <asm/byteorder.h>
494#include <asm/dma.h>
495#include <asm/io.h>
496#include <asm/irq.h>
497
498#include <scsi/scsi.h>
499#include <scsi/scsi_cmnd.h>
500#include <scsi/scsi_device.h>
501#include <scsi/scsi_host.h>
502#include <scsi/scsi_tcq.h>
503#include <scsi/scsicam.h>
504
505static int eata2x_detect(struct scsi_host_template *);
506static int eata2x_release(struct Scsi_Host *);
507static int eata2x_queuecommand(struct scsi_cmnd *,
508 void (*done) (struct scsi_cmnd *));
509static int eata2x_eh_abort(struct scsi_cmnd *);
510static int eata2x_eh_host_reset(struct scsi_cmnd *);
511static int eata2x_bios_param(struct scsi_device *, struct block_device *,
512 sector_t, int *);
513static int eata2x_slave_configure(struct scsi_device *);
514
515static struct scsi_host_template driver_template = {
516 .name = "EATA/DMA 2.0x rev. 8.10.00 ",
517 .detect = eata2x_detect,
518 .release = eata2x_release,
519 .queuecommand = eata2x_queuecommand,
520 .eh_abort_handler = eata2x_eh_abort,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 .eh_host_reset_handler = eata2x_eh_host_reset,
522 .bios_param = eata2x_bios_param,
523 .slave_configure = eata2x_slave_configure,
524 .this_id = 7,
525 .unchecked_isa_dma = 1,
526 .use_clustering = ENABLE_CLUSTERING
527};
528
529#if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
530#error "Adjust your <asm/byteorder.h> defines"
531#endif
532
533/* Subversion values */
534#define ISA 0
535#define ESA 1
536
537#undef FORCE_CONFIG
538
539#undef DEBUG_LINKED_COMMANDS
540#undef DEBUG_DETECT
541#undef DEBUG_PCI_DETECT
542#undef DEBUG_INTERRUPT
543#undef DEBUG_RESET
544#undef DEBUG_GENERATE_ERRORS
545#undef DEBUG_GENERATE_ABORTS
546#undef DEBUG_GEOMETRY
547
548#define MAX_ISA 4
549#define MAX_VESA 0
550#define MAX_EISA 15
551#define MAX_PCI 16
552#define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
553#define MAX_CHANNEL 4
554#define MAX_LUN 32
555#define MAX_TARGET 32
556#define MAX_MAILBOXES 64
557#define MAX_SGLIST 64
558#define MAX_LARGE_SGLIST 122
559#define MAX_INTERNAL_RETRIES 64
560#define MAX_CMD_PER_LUN 2
561#define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
562
563#define SKIP ULONG_MAX
564#define FREE 0
565#define IN_USE 1
566#define LOCKED 2
567#define IN_RESET 3
568#define IGNORE 4
569#define READY 5
570#define ABORTING 6
571#define NO_DMA 0xff
572#define MAXLOOP 10000
573#define TAG_DISABLED 0
574#define TAG_SIMPLE 1
575#define TAG_ORDERED 2
576
577#define REG_CMD 7
578#define REG_STATUS 7
579#define REG_AUX_STATUS 8
580#define REG_DATA 0
581#define REG_DATA2 1
582#define REG_SEE 6
583#define REG_LOW 2
584#define REG_LM 3
585#define REG_MID 4
586#define REG_MSB 5
587#define REGION_SIZE 9UL
588#define MAX_ISA_ADDR 0x03ff
589#define MIN_EISA_ADDR 0x1c88
590#define MAX_EISA_ADDR 0xfc88
591#define BSY_ASSERTED 0x80
592#define DRQ_ASSERTED 0x08
593#define ABSY_ASSERTED 0x01
594#define IRQ_ASSERTED 0x02
595#define READ_CONFIG_PIO 0xf0
596#define SET_CONFIG_PIO 0xf1
597#define SEND_CP_PIO 0xf2
598#define RECEIVE_SP_PIO 0xf3
599#define TRUNCATE_XFR_PIO 0xf4
600#define RESET_PIO 0xf9
601#define READ_CONFIG_DMA 0xfd
602#define SET_CONFIG_DMA 0xfe
603#define SEND_CP_DMA 0xff
604#define ASOK 0x00
605#define ASST 0x01
606
607#define YESNO(a) ((a) ? 'y' : 'n')
608#define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
609
610/* "EATA", in Big Endian format */
611#define EATA_SIG_BE 0x45415441
612
613/* Number of valid bytes in the board config structure for EATA 2.0x */
614#define EATA_2_0A_SIZE 28
615#define EATA_2_0B_SIZE 30
616#define EATA_2_0C_SIZE 34
617
618/* Board info structure */
619struct eata_info {
620 u_int32_t data_len; /* Number of valid bytes after this field */
621 u_int32_t sign; /* ASCII "EATA" signature */
622
623#if defined(__BIG_ENDIAN_BITFIELD)
624 unchar version : 4,
625 : 4;
626 unchar haaval : 1,
627 ata : 1,
628 drqvld : 1,
629 dmasup : 1,
630 morsup : 1,
631 trnxfr : 1,
632 tarsup : 1,
633 ocsena : 1;
634#else
635 unchar : 4, /* unused low nibble */
636 version : 4; /* EATA version, should be 0x1 */
637 unchar ocsena : 1, /* Overlap Command Support Enabled */
638 tarsup : 1, /* Target Mode Supported */
639 trnxfr : 1, /* Truncate Transfer Cmd NOT Necessary */
640 morsup : 1, /* More Supported */
641 dmasup : 1, /* DMA Supported */
642 drqvld : 1, /* DRQ Index (DRQX) is valid */
643 ata : 1, /* This is an ATA device */
644 haaval : 1; /* Host Adapter Address Valid */
645#endif
646
647 ushort cp_pad_len; /* Number of pad bytes after cp_len */
648 unchar host_addr[4]; /* Host Adapter SCSI ID for channels 3, 2, 1, 0 */
649 u_int32_t cp_len; /* Number of valid bytes in cp */
650 u_int32_t sp_len; /* Number of valid bytes in sp */
651 ushort queue_size; /* Max number of cp that can be queued */
652 ushort unused;
653 ushort scatt_size; /* Max number of entries in scatter/gather table */
654
655#if defined(__BIG_ENDIAN_BITFIELD)
656 unchar drqx : 2,
657 second : 1,
658 irq_tr : 1,
659 irq : 4;
660 unchar sync;
661 unchar : 4,
662 res1 : 1,
663 large_sg : 1,
664 forcaddr : 1,
665 isaena : 1;
666 unchar max_chan : 3,
667 max_id : 5;
668 unchar max_lun;
669 unchar eisa : 1,
670 pci : 1,
671 idquest : 1,
672 m1 : 1,
673 : 4;
674#else
675 unchar irq : 4, /* Interrupt Request assigned to this controller */
676 irq_tr : 1, /* 0 for edge triggered, 1 for level triggered */
677 second : 1, /* 1 if this is a secondary (not primary) controller */
678 drqx : 2; /* DRQ Index (0=DMA0, 1=DMA7, 2=DMA6, 3=DMA5) */
679 unchar sync; /* 1 if scsi target id 7...0 is running sync scsi */
680
681 /* Structure extension defined in EATA 2.0B */
682 unchar isaena : 1, /* ISA i/o addressing is disabled/enabled */
683 forcaddr : 1, /* Port address has been forced */
684 large_sg : 1, /* 1 if large SG lists are supported */
685 res1 : 1,
686 : 4;
687 unchar max_id : 5, /* Max SCSI target ID number */
688 max_chan : 3; /* Max SCSI channel number on this board */
689
690 /* Structure extension defined in EATA 2.0C */
691 unchar max_lun; /* Max SCSI LUN number */
692 unchar
693 : 4,
694 m1 : 1, /* This is a PCI with an M1 chip installed */
695 idquest : 1, /* RAIDNUM returned is questionable */
696 pci : 1, /* This board is PCI */
697 eisa : 1; /* This board is EISA */
698#endif
699
700 unchar raidnum; /* Uniquely identifies this HBA in a system */
701 unchar notused;
702
703 ushort ipad[247];
704};
705
706/* Board config structure */
707struct eata_config {
708 ushort len; /* Number of bytes following this field */
709
710#if defined(__BIG_ENDIAN_BITFIELD)
711 unchar : 4,
712 tarena : 1,
713 mdpena : 1,
714 ocena : 1,
715 edis : 1;
716#else
717 unchar edis : 1, /* Disable EATA interface after config command */
718 ocena : 1, /* Overlapped Commands Enabled */
719 mdpena : 1, /* Transfer all Modified Data Pointer Messages */
720 tarena : 1, /* Target Mode Enabled for this controller */
721 : 4;
722#endif
723 unchar cpad[511];
724};
725
726/* Returned status packet structure */
727struct mssp {
728#if defined(__BIG_ENDIAN_BITFIELD)
729 unchar eoc : 1,
730 adapter_status : 7;
731#else
732 unchar adapter_status : 7, /* State related to current command */
733 eoc : 1; /* End Of Command (1 = command completed) */
734#endif
735 unchar target_status; /* SCSI status received after data transfer */
736 unchar unused[2];
737 u_int32_t inv_res_len; /* Number of bytes not transferred */
738 u_int32_t cpp_index; /* Index of address set in cp */
739 char mess[12];
740};
741
742struct sg_list {
743 unsigned int address; /* Segment Address */
744 unsigned int num_bytes; /* Segment Length */
745};
746
747/* MailBox SCSI Command Packet */
748struct mscp {
749#if defined(__BIG_ENDIAN_BITFIELD)
750 unchar din : 1,
751 dout : 1,
752 interp : 1,
753 : 1,
754 sg : 1,
755 reqsen :1,
756 init : 1,
757 sreset : 1;
758 unchar sense_len;
759 unchar unused[3];
760 unchar : 7,
761 fwnest : 1;
762 unchar : 5,
763 hbaci : 1,
764 iat : 1,
765 phsunit : 1;
766 unchar channel : 3,
767 target : 5;
768 unchar one : 1,
769 dispri : 1,
770 luntar : 1,
771 lun : 5;
772#else
773 unchar sreset :1, /* SCSI Bus Reset Signal should be asserted */
774 init :1, /* Re-initialize controller and self test */
775 reqsen :1, /* Transfer Request Sense Data to addr using DMA */
776 sg :1, /* Use Scatter/Gather */
777 :1,
778 interp :1, /* The controller interprets cp, not the target */
779 dout :1, /* Direction of Transfer is Out (Host to Target) */
780 din :1; /* Direction of Transfer is In (Target to Host) */
781 unchar sense_len; /* Request Sense Length */
782 unchar unused[3];
783 unchar fwnest : 1, /* Send command to a component of an Array Group */
784 : 7;
785 unchar phsunit : 1, /* Send to Target Physical Unit (bypass RAID) */
786 iat : 1, /* Inhibit Address Translation */
787 hbaci : 1, /* Inhibit HBA Caching for this command */
788 : 5;
789 unchar target : 5, /* SCSI target ID */
790 channel : 3; /* SCSI channel number */
791 unchar lun : 5, /* SCSI logical unit number */
792 luntar : 1, /* This cp is for Target (not LUN) */
793 dispri : 1, /* Disconnect Privilege granted */
794 one : 1; /* 1 */
795#endif
796
797 unchar mess[3]; /* Massage to/from Target */
798 unchar cdb[12]; /* Command Descriptor Block */
799 u_int32_t data_len; /* If sg=0 Data Length, if sg=1 sglist length */
800 u_int32_t cpp_index; /* Index of address to be returned in sp */
801 u_int32_t data_address; /* If sg=0 Data Address, if sg=1 sglist address */
802 u_int32_t sp_dma_addr; /* Address where sp is DMA'ed when cp completes */
803 u_int32_t sense_addr; /* Address where Sense Data is DMA'ed on error */
804
805 /* Additional fields begin here. */
806 struct scsi_cmnd *SCpnt;
807
808 /* All the cp structure is zero filled by queuecommand except the
809 following CP_TAIL_SIZE bytes, initialized by detect */
810 dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
811 struct sg_list *sglist; /* pointer to the allocated SG list */
812};
813
814#define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
815
816struct hostdata {
817 struct mscp cp[MAX_MAILBOXES]; /* Mailboxes for this board */
818 unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
819 unsigned int last_cp_used; /* Index of last mailbox used */
820 unsigned int iocount; /* Total i/o done for this board */
821 int board_number; /* Number of this board */
822 char board_name[16]; /* Name of this board */
823 int in_reset; /* True if board is doing a reset */
824 int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
825 int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If 1 redo i/o on target */
826 unsigned int retries; /* Number of internal retries */
827 unsigned long last_retried_pid; /* Pid of last retried command */
828 unsigned char subversion; /* Bus type, either ISA or EISA/PCI */
829 unsigned char protocol_rev; /* EATA 2.0 rev., 'A' or 'B' or 'C' */
830 unsigned char is_pci; /* 1 is bus type is PCI */
831 struct pci_dev *pdev; /* pdev for PCI bus, NULL otherwise */
832 struct mssp *sp_cpu_addr; /* cpu addr for DMA buffer sp */
833 dma_addr_t sp_dma_addr; /* dma handle for DMA buffer sp */
834 struct mssp sp; /* Local copy of sp buffer */
835};
836
837static struct Scsi_Host *sh[MAX_BOARDS];
838static const char *driver_name = "EATA";
839static char sha[MAX_BOARDS];
840static DEFINE_SPINLOCK(driver_lock);
841
842/* Initialize num_boards so that ihdlr can work while detect is in progress */
843static unsigned int num_boards = MAX_BOARDS;
844
845static unsigned long io_port[] = {
846
847 /* Space for MAX_INT_PARAM ports usable while loading as a module */
848 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
849 SKIP, SKIP,
850
851 /* First ISA */
852 0x1f0,
853
854 /* Space for MAX_PCI ports possibly reported by PCI_BIOS */
855 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
856 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
857
858 /* MAX_EISA ports */
859 0x1c88, 0x2c88, 0x3c88, 0x4c88, 0x5c88, 0x6c88, 0x7c88, 0x8c88,
860 0x9c88, 0xac88, 0xbc88, 0xcc88, 0xdc88, 0xec88, 0xfc88,
861
862 /* Other (MAX_ISA - 1) ports */
863 0x170, 0x230, 0x330,
864
865 /* End of list */
866 0x0
867};
868
869/* Device is Big Endian */
870#define H2DEV(x) cpu_to_be32(x)
871#define DEV2H(x) be32_to_cpu(x)
872#define H2DEV16(x) cpu_to_be16(x)
873#define DEV2H16(x) be16_to_cpu(x)
874
875/* But transfer orientation from the 16 bit data register is Little Endian */
876#define REG2H(x) le16_to_cpu(x)
877
878static irqreturn_t do_interrupt_handler(int, void *, struct pt_regs *);
879static void flush_dev(struct scsi_device *, unsigned long, struct hostdata *,
880 unsigned int);
881static int do_trace = 0;
882static int setup_done = 0;
883static int link_statistics;
884static int ext_tran = 0;
885static int rev_scan = 1;
886
887#if defined(CONFIG_SCSI_EATA_TAGGED_QUEUE)
888static int tag_mode = TAG_SIMPLE;
889#else
890static int tag_mode = TAG_DISABLED;
891#endif
892
893#if defined(CONFIG_SCSI_EATA_LINKED_COMMANDS)
894static int linked_comm = 1;
895#else
896static int linked_comm = 0;
897#endif
898
899#if defined(CONFIG_SCSI_EATA_MAX_TAGS)
900static int max_queue_depth = CONFIG_SCSI_EATA_MAX_TAGS;
901#else
902static int max_queue_depth = MAX_CMD_PER_LUN;
903#endif
904
905#if defined(CONFIG_ISA)
906static int isa_probe = 1;
907#else
908static int isa_probe = 0;
909#endif
910
911#if defined(CONFIG_EISA)
912static int eisa_probe = 1;
913#else
914static int eisa_probe = 0;
915#endif
916
917#if defined(CONFIG_PCI)
918static int pci_probe = 1;
919#else
920static int pci_probe = 0;
921#endif
922
923#define MAX_INT_PARAM 10
924#define MAX_BOOT_OPTIONS_SIZE 256
925static char boot_options[MAX_BOOT_OPTIONS_SIZE];
926
927#if defined(MODULE)
928#include <linux/module.h>
929#include <linux/moduleparam.h>
930
931module_param_string(eata, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
932MODULE_PARM_DESC(eata, " equivalent to the \"eata=...\" kernel boot option."
933 " Example: modprobe eata \"eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n\"");
934MODULE_AUTHOR("Dario Ballabio");
935MODULE_LICENSE("GPL");
936MODULE_DESCRIPTION("EATA/DMA SCSI Driver");
937
938#endif
939
940static int eata2x_slave_configure(struct scsi_device *dev)
941{
942 int tqd, utqd;
943 char *tag_suffix, *link_suffix;
944 struct Scsi_Host *shost = dev->host;
945 struct hostdata *ha = (struct hostdata *)shost->hostdata;
946
947 utqd = MAX_CMD_PER_LUN;
948 tqd = max_queue_depth;
949
950 if (TLDEV(dev->type) && dev->tagged_supported) {
951 if (tag_mode == TAG_SIMPLE) {
952 scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
953 tag_suffix = ", simple tags";
954 } else if (tag_mode == TAG_ORDERED) {
955 scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
956 tag_suffix = ", ordered tags";
957 } else {
958 scsi_adjust_queue_depth(dev, 0, tqd);
959 tag_suffix = ", no tags";
960 }
961 } else if (TLDEV(dev->type) && linked_comm) {
962 scsi_adjust_queue_depth(dev, 0, tqd);
963 tag_suffix = ", untagged";
964 } else {
965 scsi_adjust_queue_depth(dev, 0, utqd);
966 tag_suffix = "";
967 }
968
969 if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
970 link_suffix = ", sorted";
971 else if (TLDEV(dev->type))
972 link_suffix = ", unsorted";
973 else
974 link_suffix = "";
975
976 printk("%s: scsi%d, channel %d, id %d, lun %d, cmds/lun %d%s%s.\n",
977 ha->board_name, shost->host_no, dev->channel, dev->id, dev->lun,
978 dev->queue_depth, link_suffix, tag_suffix);
979
980 return 0;
981}
982
983static int wait_on_busy(unsigned long iobase, unsigned int loop)
984{
985 while (inb(iobase + REG_AUX_STATUS) & ABSY_ASSERTED) {
986 udelay(1L);
987 if (--loop == 0)
988 return 1;
989 }
990 return 0;
991}
992
993static int do_dma(unsigned long iobase, unsigned long addr, unchar cmd)
994{
995 unsigned char *byaddr;
996 unsigned long devaddr;
997
998 if (wait_on_busy(iobase, (addr ? MAXLOOP * 100 : MAXLOOP)))
999 return 1;
1000
1001 if (addr) {
1002 devaddr = H2DEV(addr);
1003 byaddr = (unsigned char *)&devaddr;
1004 outb(byaddr[3], iobase + REG_LOW);
1005 outb(byaddr[2], iobase + REG_LM);
1006 outb(byaddr[1], iobase + REG_MID);
1007 outb(byaddr[0], iobase + REG_MSB);
1008 }
1009
1010 outb(cmd, iobase + REG_CMD);
1011 return 0;
1012}
1013
1014static int read_pio(unsigned long iobase, ushort * start, ushort * end)
1015{
1016 unsigned int loop = MAXLOOP;
1017 ushort *p;
1018
1019 for (p = start; p <= end; p++) {
1020 while (!(inb(iobase + REG_STATUS) & DRQ_ASSERTED)) {
1021 udelay(1L);
1022 if (--loop == 0)
1023 return 1;
1024 }
1025 loop = MAXLOOP;
1026 *p = REG2H(inw(iobase));
1027 }
1028
1029 return 0;
1030}
1031
1032static struct pci_dev *get_pci_dev(unsigned long port_base)
1033{
1034#if defined(CONFIG_PCI)
1035 unsigned int addr;
1036 struct pci_dev *dev = NULL;
1037
1038 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1039 addr = pci_resource_start(dev, 0);
1040
1041#if defined(DEBUG_PCI_DETECT)
1042 printk("%s: get_pci_dev, bus %d, devfn 0x%x, addr 0x%x.\n",
1043 driver_name, dev->bus->number, dev->devfn, addr);
1044#endif
1045
1046 /* we are in so much trouble for a pci hotplug system with this driver
1047 * anyway, so doing this at least lets people unload the driver and not
1048 * cause memory problems, but in general this is a bad thing to do (this
1049 * driver needs to be converted to the proper PCI api someday... */
1050 pci_dev_put(dev);
1051 if (addr + PCI_BASE_ADDRESS_0 == port_base)
1052 return dev;
1053 }
1054#endif /* end CONFIG_PCI */
1055 return NULL;
1056}
1057
1058static void enable_pci_ports(void)
1059{
1060#if defined(CONFIG_PCI)
1061 struct pci_dev *dev = NULL;
1062
1063 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1064#if defined(DEBUG_PCI_DETECT)
1065 printk("%s: enable_pci_ports, bus %d, devfn 0x%x.\n",
1066 driver_name, dev->bus->number, dev->devfn);
1067#endif
1068
1069 if (pci_enable_device(dev))
1070 printk
1071 ("%s: warning, pci_enable_device failed, bus %d devfn 0x%x.\n",
1072 driver_name, dev->bus->number, dev->devfn);
1073 }
1074
1075#endif /* end CONFIG_PCI */
1076}
1077
1078static int port_detect(unsigned long port_base, unsigned int j,
1079 struct scsi_host_template *tpnt)
1080{
1081 unsigned char irq, dma_channel, subversion, i, is_pci = 0;
1082 unsigned char protocol_rev;
1083 struct eata_info info;
1084 char *bus_type, dma_name[16];
1085 struct pci_dev *pdev;
1086 /* Allowed DMA channels for ISA (0 indicates reserved) */
1087 unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
1088 struct Scsi_Host *shost;
1089 struct hostdata *ha;
1090 char name[16];
1091
1092 sprintf(name, "%s%d", driver_name, j);
1093
1094 if (!request_region(port_base, REGION_SIZE, driver_name)) {
1095#if defined(DEBUG_DETECT)
1096 printk("%s: address 0x%03lx in use, skipping probe.\n", name,
1097 port_base);
1098#endif
1099 goto fail;
1100 }
1101
1102 spin_lock_irq(&driver_lock);
1103
1104 if (do_dma(port_base, 0, READ_CONFIG_PIO)) {
1105#if defined(DEBUG_DETECT)
1106 printk("%s: detect, do_dma failed at 0x%03lx.\n", name,
1107 port_base);
1108#endif
1109 goto freelock;
1110 }
1111
1112 /* Read the info structure */
1113 if (read_pio(port_base, (ushort *) & info, (ushort *) & info.ipad[0])) {
1114#if defined(DEBUG_DETECT)
1115 printk("%s: detect, read_pio failed at 0x%03lx.\n", name,
1116 port_base);
1117#endif
1118 goto freelock;
1119 }
1120
1121 info.data_len = DEV2H(info.data_len);
1122 info.sign = DEV2H(info.sign);
1123 info.cp_pad_len = DEV2H16(info.cp_pad_len);
1124 info.cp_len = DEV2H(info.cp_len);
1125 info.sp_len = DEV2H(info.sp_len);
1126 info.scatt_size = DEV2H16(info.scatt_size);
1127 info.queue_size = DEV2H16(info.queue_size);
1128
1129 /* Check the controller "EATA" signature */
1130 if (info.sign != EATA_SIG_BE) {
1131#if defined(DEBUG_DETECT)
1132 printk("%s: signature 0x%04x discarded.\n", name, info.sign);
1133#endif
1134 goto freelock;
1135 }
1136
1137 if (info.data_len < EATA_2_0A_SIZE) {
1138 printk
1139 ("%s: config structure size (%d bytes) too short, detaching.\n",
1140 name, info.data_len);
1141 goto freelock;
1142 } else if (info.data_len == EATA_2_0A_SIZE)
1143 protocol_rev = 'A';
1144 else if (info.data_len == EATA_2_0B_SIZE)
1145 protocol_rev = 'B';
1146 else
1147 protocol_rev = 'C';
1148
1149 if (protocol_rev != 'A' && info.forcaddr) {
1150 printk("%s: warning, port address has been forced.\n", name);
1151 bus_type = "PCI";
1152 is_pci = 1;
1153 subversion = ESA;
1154 } else if (port_base > MAX_EISA_ADDR
1155 || (protocol_rev == 'C' && info.pci)) {
1156 bus_type = "PCI";
1157 is_pci = 1;
1158 subversion = ESA;
1159 } else if (port_base >= MIN_EISA_ADDR
1160 || (protocol_rev == 'C' && info.eisa)) {
1161 bus_type = "EISA";
1162 subversion = ESA;
1163 } else if (protocol_rev == 'C' && !info.eisa && !info.pci) {
1164 bus_type = "ISA";
1165 subversion = ISA;
1166 } else if (port_base > MAX_ISA_ADDR) {
1167 bus_type = "PCI";
1168 is_pci = 1;
1169 subversion = ESA;
1170 } else {
1171 bus_type = "ISA";
1172 subversion = ISA;
1173 }
1174
1175 if (!info.haaval || info.ata) {
1176 printk
1177 ("%s: address 0x%03lx, unusable %s board (%d%d), detaching.\n",
1178 name, port_base, bus_type, info.haaval, info.ata);
1179 goto freelock;
1180 }
1181
1182 if (info.drqvld) {
1183 if (subversion == ESA)
1184 printk("%s: warning, weird %s board using DMA.\n", name,
1185 bus_type);
1186
1187 subversion = ISA;
1188 dma_channel = dma_channel_table[3 - info.drqx];
1189 } else {
1190 if (subversion == ISA)
1191 printk("%s: warning, weird %s board not using DMA.\n",
1192 name, bus_type);
1193
1194 subversion = ESA;
1195 dma_channel = NO_DMA;
1196 }
1197
1198 if (!info.dmasup)
1199 printk("%s: warning, DMA protocol support not asserted.\n",
1200 name);
1201
1202 irq = info.irq;
1203
1204 if (subversion == ESA && !info.irq_tr)
1205 printk
1206 ("%s: warning, LEVEL triggering is suggested for IRQ %u.\n",
1207 name, irq);
1208
1209 if (is_pci) {
1210 pdev = get_pci_dev(port_base);
1211 if (!pdev)
1212 printk
1213 ("%s: warning, failed to get pci_dev structure.\n",
1214 name);
1215 } else
1216 pdev = NULL;
1217
1218 if (pdev && (irq != pdev->irq)) {
1219 printk("%s: IRQ %u mapped to IO-APIC IRQ %u.\n", name, irq,
1220 pdev->irq);
1221 irq = pdev->irq;
1222 }
1223
1224 /* Board detected, allocate its IRQ */
1225 if (request_irq(irq, do_interrupt_handler,
1226 SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0),
1227 driver_name, (void *)&sha[j])) {
1228 printk("%s: unable to allocate IRQ %u, detaching.\n", name,
1229 irq);
1230 goto freelock;
1231 }
1232
1233 if (subversion == ISA && request_dma(dma_channel, driver_name)) {
1234 printk("%s: unable to allocate DMA channel %u, detaching.\n",
1235 name, dma_channel);
1236 goto freeirq;
1237 }
1238#if defined(FORCE_CONFIG)
1239 {
1240 struct eata_config *cf;
1241 dma_addr_t cf_dma_addr;
1242
1243 cf = pci_alloc_consistent(pdev, sizeof(struct eata_config),
1244 &cf_dma_addr);
1245
1246 if (!cf) {
1247 printk
1248 ("%s: config, pci_alloc_consistent failed, detaching.\n",
1249 name);
1250 goto freedma;
1251 }
1252
1253 /* Set board configuration */
1254 memset((char *)cf, 0, sizeof(struct eata_config));
1255 cf->len = (ushort) H2DEV16((ushort) 510);
1256 cf->ocena = 1;
1257
1258 if (do_dma(port_base, cf_dma_addr, SET_CONFIG_DMA)) {
1259 printk
1260 ("%s: busy timeout sending configuration, detaching.\n",
1261 name);
1262 pci_free_consistent(pdev, sizeof(struct eata_config),
1263 cf, cf_dma_addr);
1264 goto freedma;
1265 }
1266
1267 }
1268#endif
1269
1270 spin_unlock_irq(&driver_lock);
1271 sh[j] = shost = scsi_register(tpnt, sizeof(struct hostdata));
1272 spin_lock_irq(&driver_lock);
1273
1274 if (shost == NULL) {
1275 printk("%s: unable to register host, detaching.\n", name);
1276 goto freedma;
1277 }
1278
1279 shost->io_port = port_base;
1280 shost->unique_id = port_base;
1281 shost->n_io_port = REGION_SIZE;
1282 shost->dma_channel = dma_channel;
1283 shost->irq = irq;
1284 shost->sg_tablesize = (ushort) info.scatt_size;
1285 shost->this_id = (ushort) info.host_addr[3];
1286 shost->can_queue = (ushort) info.queue_size;
1287 shost->cmd_per_lun = MAX_CMD_PER_LUN;
1288
1289 ha = (struct hostdata *)shost->hostdata;
1290
1291 memset(ha, 0, sizeof(struct hostdata));
1292 ha->subversion = subversion;
1293 ha->protocol_rev = protocol_rev;
1294 ha->is_pci = is_pci;
1295 ha->pdev = pdev;
1296 ha->board_number = j;
1297
1298 if (ha->subversion == ESA)
1299 shost->unchecked_isa_dma = 0;
1300 else {
1301 unsigned long flags;
1302 shost->unchecked_isa_dma = 1;
1303
1304 flags = claim_dma_lock();
1305 disable_dma(dma_channel);
1306 clear_dma_ff(dma_channel);
1307 set_dma_mode(dma_channel, DMA_MODE_CASCADE);
1308 enable_dma(dma_channel);
1309 release_dma_lock(flags);
1310
1311 }
1312
1313 strcpy(ha->board_name, name);
1314
1315 /* DPT PM2012 does not allow to detect sg_tablesize correctly */
1316 if (shost->sg_tablesize > MAX_SGLIST || shost->sg_tablesize < 2) {
1317 printk("%s: detect, wrong n. of SG lists %d, fixed.\n",
1318 ha->board_name, shost->sg_tablesize);
1319 shost->sg_tablesize = MAX_SGLIST;
1320 }
1321
1322 /* DPT PM2012 does not allow to detect can_queue correctly */
1323 if (shost->can_queue > MAX_MAILBOXES || shost->can_queue < 2) {
1324 printk("%s: detect, wrong n. of mbox %d, fixed.\n",
1325 ha->board_name, shost->can_queue);
1326 shost->can_queue = MAX_MAILBOXES;
1327 }
1328
1329 if (protocol_rev != 'A') {
1330 if (info.max_chan > 0 && info.max_chan < MAX_CHANNEL)
1331 shost->max_channel = info.max_chan;
1332
1333 if (info.max_id > 7 && info.max_id < MAX_TARGET)
1334 shost->max_id = info.max_id + 1;
1335
1336 if (info.large_sg && shost->sg_tablesize == MAX_SGLIST)
1337 shost->sg_tablesize = MAX_LARGE_SGLIST;
1338 }
1339
1340 if (protocol_rev == 'C') {
1341 if (info.max_lun > 7 && info.max_lun < MAX_LUN)
1342 shost->max_lun = info.max_lun + 1;
1343 }
1344
1345 if (dma_channel == NO_DMA)
1346 sprintf(dma_name, "%s", "BMST");
1347 else
1348 sprintf(dma_name, "DMA %u", dma_channel);
1349
1350 spin_unlock_irq(&driver_lock);
1351
1352 for (i = 0; i < shost->can_queue; i++)
1353 ha->cp[i].cp_dma_addr = pci_map_single(ha->pdev,
1354 &ha->cp[i],
1355 sizeof(struct mscp),
1356 PCI_DMA_BIDIRECTIONAL);
1357
1358 for (i = 0; i < shost->can_queue; i++) {
1359 size_t sz = shost->sg_tablesize *sizeof(struct sg_list);
1360 unsigned int gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
1361 ha->cp[i].sglist = kmalloc(sz, gfp_mask);
1362 if (!ha->cp[i].sglist) {
1363 printk
1364 ("%s: kmalloc SGlist failed, mbox %d, detaching.\n",
1365 ha->board_name, i);
1366 goto release;
1367 }
1368 }
1369
1370 if (!(ha->sp_cpu_addr = pci_alloc_consistent(ha->pdev,
1371 sizeof(struct mssp),
1372 &ha->sp_dma_addr))) {
1373 printk("%s: pci_alloc_consistent failed, detaching.\n", ha->board_name);
1374 goto release;
1375 }
1376
1377 if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
1378 max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
1379
1380 if (max_queue_depth < MAX_CMD_PER_LUN)
1381 max_queue_depth = MAX_CMD_PER_LUN;
1382
1383 if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
1384 tag_mode = TAG_ORDERED;
1385
1386 if (j == 0) {
1387 printk
1388 ("EATA/DMA 2.0x: Copyright (C) 1994-2003 Dario Ballabio.\n");
1389 printk
1390 ("%s config options -> tm:%d, lc:%c, mq:%d, rs:%c, et:%c, "
1391 "ip:%c, ep:%c, pp:%c.\n", driver_name, tag_mode,
1392 YESNO(linked_comm), max_queue_depth, YESNO(rev_scan),
1393 YESNO(ext_tran), YESNO(isa_probe), YESNO(eisa_probe),
1394 YESNO(pci_probe));
1395 }
1396
1397 printk("%s: 2.0%c, %s 0x%03lx, IRQ %u, %s, SG %d, MB %d.\n",
1398 ha->board_name, ha->protocol_rev, bus_type,
1399 (unsigned long)shost->io_port, shost->irq, dma_name,
1400 shost->sg_tablesize, shost->can_queue);
1401
1402 if (shost->max_id > 8 || shost->max_lun > 8)
1403 printk
1404 ("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1405 ha->board_name, shost->max_id, shost->max_lun);
1406
1407 for (i = 0; i <= shost->max_channel; i++)
1408 printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1409 ha->board_name, i, info.host_addr[3 - i]);
1410
1411#if defined(DEBUG_DETECT)
1412 printk("%s: Vers. 0x%x, ocs %u, tar %u, trnxfr %u, more %u, SYNC 0x%x, "
1413 "sec. %u, infol %d, cpl %d spl %d.\n", name, info.version,
1414 info.ocsena, info.tarsup, info.trnxfr, info.morsup, info.sync,
1415 info.second, info.data_len, info.cp_len, info.sp_len);
1416
1417 if (protocol_rev == 'B' || protocol_rev == 'C')
1418 printk("%s: isaena %u, forcaddr %u, max_id %u, max_chan %u, "
1419 "large_sg %u, res1 %u.\n", name, info.isaena,
1420 info.forcaddr, info.max_id, info.max_chan, info.large_sg,
1421 info.res1);
1422
1423 if (protocol_rev == 'C')
1424 printk("%s: max_lun %u, m1 %u, idquest %u, pci %u, eisa %u, "
1425 "raidnum %u.\n", name, info.max_lun, info.m1,
1426 info.idquest, info.pci, info.eisa, info.raidnum);
1427#endif
1428
1429 if (ha->pdev) {
1430 pci_set_master(ha->pdev);
1431 if (pci_set_dma_mask(ha->pdev, 0xffffffff))
1432 printk("%s: warning, pci_set_dma_mask failed.\n",
1433 ha->board_name);
1434 }
1435
1436 return 1;
1437
1438 freedma:
1439 if (subversion == ISA)
1440 free_dma(dma_channel);
1441 freeirq:
1442 free_irq(irq, &sha[j]);
1443 freelock:
1444 spin_unlock_irq(&driver_lock);
1445 release_region(port_base, REGION_SIZE);
1446 fail:
1447 return 0;
1448
1449 release:
1450 eata2x_release(shost);
1451 return 0;
1452}
1453
1454static void internal_setup(char *str, int *ints)
1455{
1456 int i, argc = ints[0];
1457 char *cur = str, *pc;
1458
1459 if (argc > 0) {
1460 if (argc > MAX_INT_PARAM)
1461 argc = MAX_INT_PARAM;
1462
1463 for (i = 0; i < argc; i++)
1464 io_port[i] = ints[i + 1];
1465
1466 io_port[i] = 0;
1467 setup_done = 1;
1468 }
1469
1470 while (cur && (pc = strchr(cur, ':'))) {
1471 int val = 0, c = *++pc;
1472
1473 if (c == 'n' || c == 'N')
1474 val = 0;
1475 else if (c == 'y' || c == 'Y')
1476 val = 1;
1477 else
1478 val = (int)simple_strtoul(pc, NULL, 0);
1479
1480 if (!strncmp(cur, "lc:", 3))
1481 linked_comm = val;
1482 else if (!strncmp(cur, "tm:", 3))
1483 tag_mode = val;
1484 else if (!strncmp(cur, "tc:", 3))
1485 tag_mode = val;
1486 else if (!strncmp(cur, "mq:", 3))
1487 max_queue_depth = val;
1488 else if (!strncmp(cur, "ls:", 3))
1489 link_statistics = val;
1490 else if (!strncmp(cur, "et:", 3))
1491 ext_tran = val;
1492 else if (!strncmp(cur, "rs:", 3))
1493 rev_scan = val;
1494 else if (!strncmp(cur, "ip:", 3))
1495 isa_probe = val;
1496 else if (!strncmp(cur, "ep:", 3))
1497 eisa_probe = val;
1498 else if (!strncmp(cur, "pp:", 3))
1499 pci_probe = val;
1500
1501 if ((cur = strchr(cur, ',')))
1502 ++cur;
1503 }
1504
1505 return;
1506}
1507
1508static int option_setup(char *str)
1509{
1510 int ints[MAX_INT_PARAM];
1511 char *cur = str;
1512 int i = 1;
1513
1514 while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
1515 ints[i++] = simple_strtoul(cur, NULL, 0);
1516
1517 if ((cur = strchr(cur, ',')) != NULL)
1518 cur++;
1519 }
1520
1521 ints[0] = i - 1;
1522 internal_setup(cur, ints);
1523 return 1;
1524}
1525
1526static void add_pci_ports(void)
1527{
1528#if defined(CONFIG_PCI)
1529 unsigned int addr, k;
1530 struct pci_dev *dev = NULL;
1531
1532 for (k = 0; k < MAX_PCI; k++) {
1533
1534 if (!(dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev)))
1535 break;
1536
1537 if (pci_enable_device(dev)) {
1538#if defined(DEBUG_PCI_DETECT)
1539 printk
1540 ("%s: detect, bus %d, devfn 0x%x, pci_enable_device failed.\n",
1541 driver_name, dev->bus->number, dev->devfn);
1542#endif
1543
1544 continue;
1545 }
1546
1547 addr = pci_resource_start(dev, 0);
1548
1549#if defined(DEBUG_PCI_DETECT)
1550 printk("%s: detect, seq. %d, bus %d, devfn 0x%x, addr 0x%x.\n",
1551 driver_name, k, dev->bus->number, dev->devfn, addr);
1552#endif
1553
1554 /* Order addresses according to rev_scan value */
1555 io_port[MAX_INT_PARAM + (rev_scan ? (MAX_PCI - k) : (1 + k))] =
1556 addr + PCI_BASE_ADDRESS_0;
1557 }
1558
1559 pci_dev_put(dev);
1560#endif /* end CONFIG_PCI */
1561}
1562
1563static int eata2x_detect(struct scsi_host_template *tpnt)
1564{
1565 unsigned int j = 0, k;
1566
1567 tpnt->proc_name = "eata2x";
1568
1569 if (strlen(boot_options))
1570 option_setup(boot_options);
1571
1572#if defined(MODULE)
1573 /* io_port could have been modified when loading as a module */
1574 if (io_port[0] != SKIP) {
1575 setup_done = 1;
1576 io_port[MAX_INT_PARAM] = 0;
1577 }
1578#endif
1579
1580 for (k = MAX_INT_PARAM; io_port[k]; k++)
1581 if (io_port[k] == SKIP)
1582 continue;
1583 else if (io_port[k] <= MAX_ISA_ADDR) {
1584 if (!isa_probe)
1585 io_port[k] = SKIP;
1586 } else if (io_port[k] >= MIN_EISA_ADDR
1587 && io_port[k] <= MAX_EISA_ADDR) {
1588 if (!eisa_probe)
1589 io_port[k] = SKIP;
1590 }
1591
1592 if (pci_probe) {
1593 if (!setup_done)
1594 add_pci_ports();
1595 else
1596 enable_pci_ports();
1597 }
1598
1599 for (k = 0; io_port[k]; k++) {
1600
1601 if (io_port[k] == SKIP)
1602 continue;
1603
1604 if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt))
1605 j++;
1606 }
1607
1608 num_boards = j;
1609 return j;
1610}
1611
1612static void map_dma(unsigned int i, struct hostdata *ha)
1613{
1614 unsigned int k, count, pci_dir;
1615 struct scatterlist *sgpnt;
1616 struct mscp *cpp;
1617 struct scsi_cmnd *SCpnt;
1618
1619 cpp = &ha->cp[i];
1620 SCpnt = cpp->SCpnt;
1621 pci_dir = SCpnt->sc_data_direction;
1622
1623 if (SCpnt->sense_buffer)
1624 cpp->sense_addr =
1625 H2DEV(pci_map_single(ha->pdev, SCpnt->sense_buffer,
1626 sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE));
1627
1628 cpp->sense_len = sizeof SCpnt->sense_buffer;
1629
1630 if (!SCpnt->use_sg) {
1631
1632 /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */
1633 if (!SCpnt->request_bufflen)
1634 pci_dir = PCI_DMA_BIDIRECTIONAL;
1635
1636 if (SCpnt->request_buffer)
1637 cpp->data_address = H2DEV(pci_map_single(ha->pdev,
1638 SCpnt->
1639 request_buffer,
1640 SCpnt->
1641 request_bufflen,
1642 pci_dir));
1643
1644 cpp->data_len = H2DEV(SCpnt->request_bufflen);
1645 return;
1646 }
1647
1648 sgpnt = (struct scatterlist *)SCpnt->request_buffer;
1649 count = pci_map_sg(ha->pdev, sgpnt, SCpnt->use_sg, pci_dir);
1650
1651 for (k = 0; k < count; k++) {
1652 cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k]));
1653 cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k]));
1654 }
1655
1656 cpp->sg = 1;
1657 cpp->data_address = H2DEV(pci_map_single(ha->pdev, cpp->sglist,
1658 SCpnt->use_sg *
1659 sizeof(struct sg_list),
1660 pci_dir));
1661 cpp->data_len = H2DEV((SCpnt->use_sg * sizeof(struct sg_list)));
1662}
1663
1664static void unmap_dma(unsigned int i, struct hostdata *ha)
1665{
1666 unsigned int pci_dir;
1667 struct mscp *cpp;
1668 struct scsi_cmnd *SCpnt;
1669
1670 cpp = &ha->cp[i];
1671 SCpnt = cpp->SCpnt;
1672 pci_dir = SCpnt->sc_data_direction;
1673
1674 if (DEV2H(cpp->sense_addr))
1675 pci_unmap_single(ha->pdev, DEV2H(cpp->sense_addr),
1676 DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1677
1678 if (SCpnt->use_sg)
1679 pci_unmap_sg(ha->pdev, SCpnt->request_buffer, SCpnt->use_sg,
1680 pci_dir);
1681
1682 if (!DEV2H(cpp->data_len))
1683 pci_dir = PCI_DMA_BIDIRECTIONAL;
1684
1685 if (DEV2H(cpp->data_address))
1686 pci_unmap_single(ha->pdev, DEV2H(cpp->data_address),
1687 DEV2H(cpp->data_len), pci_dir);
1688}
1689
1690static void sync_dma(unsigned int i, struct hostdata *ha)
1691{
1692 unsigned int pci_dir;
1693 struct mscp *cpp;
1694 struct scsi_cmnd *SCpnt;
1695
1696 cpp = &ha->cp[i];
1697 SCpnt = cpp->SCpnt;
1698 pci_dir = SCpnt->sc_data_direction;
1699
1700 if (DEV2H(cpp->sense_addr))
1701 pci_dma_sync_single_for_cpu(ha->pdev, DEV2H(cpp->sense_addr),
1702 DEV2H(cpp->sense_len),
1703 PCI_DMA_FROMDEVICE);
1704
1705 if (SCpnt->use_sg)
1706 pci_dma_sync_sg_for_cpu(ha->pdev, SCpnt->request_buffer,
1707 SCpnt->use_sg, pci_dir);
1708
1709 if (!DEV2H(cpp->data_len))
1710 pci_dir = PCI_DMA_BIDIRECTIONAL;
1711
1712 if (DEV2H(cpp->data_address))
1713 pci_dma_sync_single_for_cpu(ha->pdev,
1714 DEV2H(cpp->data_address),
1715 DEV2H(cpp->data_len), pci_dir);
1716}
1717
1718static void scsi_to_dev_dir(unsigned int i, struct hostdata *ha)
1719{
1720 unsigned int k;
1721
1722 static const unsigned char data_out_cmds[] = {
1723 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1724 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1725 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1726 };
1727
1728 static const unsigned char data_none_cmds[] = {
1729 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1730 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1731 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1732 };
1733
1734 struct mscp *cpp;
1735 struct scsi_cmnd *SCpnt;
1736
1737 cpp = &ha->cp[i];
1738 SCpnt = cpp->SCpnt;
1739
1740 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1741 cpp->din = 1;
1742 cpp->dout = 0;
1743 return;
1744 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1745 cpp->din = 0;
1746 cpp->dout = 1;
1747 return;
1748 } else if (SCpnt->sc_data_direction == DMA_NONE) {
1749 cpp->din = 0;
1750 cpp->dout = 0;
1751 return;
1752 }
1753
1754 if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1755 panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n",
1756 ha->board_name);
1757
1758 for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1759 if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1760 cpp->dout = 1;
1761 break;
1762 }
1763
1764 if ((cpp->din = !cpp->dout))
1765 for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1766 if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1767 cpp->din = 0;
1768 break;
1769 }
1770
1771}
1772
1773static int eata2x_queuecommand(struct scsi_cmnd *SCpnt,
1774 void (*done) (struct scsi_cmnd *))
1775{
1776 struct Scsi_Host *shost = SCpnt->device->host;
1777 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1778 unsigned int i, k;
1779 struct mscp *cpp;
1780
1781 if (SCpnt->host_scribble)
1782 panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
1783 ha->board_name, SCpnt->pid, SCpnt);
1784
1785 /* i is the mailbox number, look for the first free mailbox
1786 starting from last_cp_used */
1787 i = ha->last_cp_used + 1;
1788
1789 for (k = 0; k < shost->can_queue; k++, i++) {
1790 if (i >= shost->can_queue)
1791 i = 0;
1792 if (ha->cp_stat[i] == FREE) {
1793 ha->last_cp_used = i;
1794 break;
1795 }
1796 }
1797
1798 if (k == shost->can_queue) {
1799 printk("%s: qcomm, no free mailbox.\n", ha->board_name);
1800 return 1;
1801 }
1802
1803 /* Set pointer to control packet structure */
1804 cpp = &ha->cp[i];
1805
1806 memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1807
1808 /* Set pointer to status packet structure, Big Endian format */
1809 cpp->sp_dma_addr = H2DEV(ha->sp_dma_addr);
1810
1811 SCpnt->scsi_done = done;
1812 cpp->cpp_index = i;
1813 SCpnt->host_scribble = (unsigned char *)&cpp->cpp_index;
1814
1815 if (do_trace)
1816 printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n",
1817 ha->board_name, i, SCpnt->device->channel, SCpnt->device->id,
1818 SCpnt->device->lun, SCpnt->pid);
1819
1820 cpp->reqsen = 1;
1821 cpp->dispri = 1;
1822#if 0
1823 if (SCpnt->device->type == TYPE_TAPE)
1824 cpp->hbaci = 1;
1825#endif
1826 cpp->one = 1;
1827 cpp->channel = SCpnt->device->channel;
1828 cpp->target = SCpnt->device->id;
1829 cpp->lun = SCpnt->device->lun;
1830 cpp->SCpnt = SCpnt;
1831 memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1832
1833 /* Use data transfer direction SCpnt->sc_data_direction */
1834 scsi_to_dev_dir(i, ha);
1835
1836 /* Map DMA buffers and SG list */
1837 map_dma(i, ha);
1838
1839 if (linked_comm && SCpnt->device->queue_depth > 2
1840 && TLDEV(SCpnt->device->type)) {
1841 ha->cp_stat[i] = READY;
1842 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0);
1843 return 0;
1844 }
1845
1846 /* Send control packet to the board */
1847 if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
1848 unmap_dma(i, ha);
1849 SCpnt->host_scribble = NULL;
1850 printk("%s: qcomm, target %d.%d:%d, pid %ld, adapter busy.\n",
1851 ha->board_name, SCpnt->device->channel, SCpnt->device->id,
1852 SCpnt->device->lun, SCpnt->pid);
1853 return 1;
1854 }
1855
1856 ha->cp_stat[i] = IN_USE;
1857 return 0;
1858}
1859
1860static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1861{
1862 struct Scsi_Host *shost = SCarg->device->host;
1863 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1864 unsigned int i;
1865
1866 if (SCarg->host_scribble == NULL) {
1867 printk("%s: abort, target %d.%d:%d, pid %ld inactive.\n",
1868 ha->board_name, SCarg->device->channel, SCarg->device->id,
1869 SCarg->device->lun, SCarg->pid);
1870 return SUCCESS;
1871 }
1872
1873 i = *(unsigned int *)SCarg->host_scribble;
1874 printk("%s: abort, mbox %d, target %d.%d:%d, pid %ld.\n",
1875 ha->board_name, i, SCarg->device->channel, SCarg->device->id,
1876 SCarg->device->lun, SCarg->pid);
1877
1878 if (i >= shost->can_queue)
1879 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
1880
1881 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1882 printk("%s: abort, timeout error.\n", ha->board_name);
1883 return FAILED;
1884 }
1885
1886 if (ha->cp_stat[i] == FREE) {
1887 printk("%s: abort, mbox %d is free.\n", ha->board_name, i);
1888 return SUCCESS;
1889 }
1890
1891 if (ha->cp_stat[i] == IN_USE) {
1892 printk("%s: abort, mbox %d is in use.\n", ha->board_name, i);
1893
1894 if (SCarg != ha->cp[i].SCpnt)
1895 panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1896 ha->board_name, i, SCarg, ha->cp[i].SCpnt);
1897
1898 if (inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)
1899 printk("%s: abort, mbox %d, interrupt pending.\n",
1900 ha->board_name, i);
1901
1902 if (SCarg->eh_state == SCSI_STATE_TIMEOUT) {
1903 unmap_dma(i, ha);
1904 SCarg->host_scribble = NULL;
1905 ha->cp_stat[i] = FREE;
1906 printk
1907 ("%s, abort, mbox %d, eh_state timeout, pid %ld.\n",
1908 ha->board_name, i, SCarg->pid);
1909 return SUCCESS;
1910 }
1911
1912 return FAILED;
1913 }
1914
1915 if (ha->cp_stat[i] == IN_RESET) {
1916 printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i);
1917 return FAILED;
1918 }
1919
1920 if (ha->cp_stat[i] == LOCKED) {
1921 printk("%s: abort, mbox %d is locked.\n", ha->board_name, i);
1922 return SUCCESS;
1923 }
1924
1925 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1926 unmap_dma(i, ha);
1927 SCarg->result = DID_ABORT << 16;
1928 SCarg->host_scribble = NULL;
1929 ha->cp_stat[i] = FREE;
1930 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
1931 ha->board_name, i, SCarg->pid);
1932 SCarg->scsi_done(SCarg);
1933 return SUCCESS;
1934 }
1935
1936 panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i);
1937}
1938
1939static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1940{
1941 unsigned int i, time, k, c, limit = 0;
1942 int arg_done = 0;
1943 struct scsi_cmnd *SCpnt;
1944 struct Scsi_Host *shost = SCarg->device->host;
1945 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1946
1947 printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n",
1948 ha->board_name, SCarg->device->channel, SCarg->device->id,
1949 SCarg->device->lun, SCarg->pid);
1950
Jeff Garzik df0ae242005-05-28 07:57:14 -04001951 spin_lock_irq(shost->host_lock);
1952
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 if (SCarg->host_scribble == NULL)
1954 printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid);
1955
1956 if (ha->in_reset) {
1957 printk("%s: reset, exit, already in reset.\n", ha->board_name);
Jeff Garzik df0ae242005-05-28 07:57:14 -04001958 spin_unlock_irq(shost->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 return FAILED;
1960 }
1961
1962 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1963 printk("%s: reset, exit, timeout error.\n", ha->board_name);
Jeff Garzik df0ae242005-05-28 07:57:14 -04001964 spin_unlock_irq(shost->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 return FAILED;
1966 }
1967
1968 ha->retries = 0;
1969
1970 for (c = 0; c <= shost->max_channel; c++)
1971 for (k = 0; k < shost->max_id; k++) {
1972 ha->target_redo[k][c] = 1;
1973 ha->target_to[k][c] = 0;
1974 }
1975
1976 for (i = 0; i < shost->can_queue; i++) {
1977
1978 if (ha->cp_stat[i] == FREE)
1979 continue;
1980
1981 if (ha->cp_stat[i] == LOCKED) {
1982 ha->cp_stat[i] = FREE;
1983 printk("%s: reset, locked mbox %d forced free.\n",
1984 ha->board_name, i);
1985 continue;
1986 }
1987
1988 if (!(SCpnt = ha->cp[i].SCpnt))
1989 panic("%s: reset, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
1990
1991 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1992 ha->cp_stat[i] = ABORTING;
1993 printk("%s: reset, mbox %d aborting, pid %ld.\n",
1994 ha->board_name, i, SCpnt->pid);
1995 }
1996
1997 else {
1998 ha->cp_stat[i] = IN_RESET;
1999 printk("%s: reset, mbox %d in reset, pid %ld.\n",
2000 ha->board_name, i, SCpnt->pid);
2001 }
2002
2003 if (SCpnt->host_scribble == NULL)
2004 panic("%s: reset, mbox %d, garbled SCpnt.\n", ha->board_name, i);
2005
2006 if (*(unsigned int *)SCpnt->host_scribble != i)
2007 panic("%s: reset, mbox %d, index mismatch.\n", ha->board_name, i);
2008
2009 if (SCpnt->scsi_done == NULL)
2010 panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n",
2011 ha->board_name, i);
2012
2013 if (SCpnt == SCarg)
2014 arg_done = 1;
2015 }
2016
2017 if (do_dma(shost->io_port, 0, RESET_PIO)) {
2018 printk("%s: reset, cannot reset, timeout error.\n", ha->board_name);
Jeff Garzik df0ae242005-05-28 07:57:14 -04002019 spin_unlock_irq(shost->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 return FAILED;
2021 }
2022
2023 printk("%s: reset, board reset done, enabling interrupts.\n", ha->board_name);
2024
2025#if defined(DEBUG_RESET)
2026 do_trace = 1;
2027#endif
2028
2029 ha->in_reset = 1;
2030
2031 spin_unlock_irq(shost->host_lock);
Jeff Garzik df0ae242005-05-28 07:57:14 -04002032
2033 /* FIXME: use a sleep instead */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 time = jiffies;
2035 while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
2036 udelay(100L);
Jeff Garzik df0ae242005-05-28 07:57:14 -04002037
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 spin_lock_irq(shost->host_lock);
2039
2040 printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
2041
2042 for (i = 0; i < shost->can_queue; i++) {
2043
2044 if (ha->cp_stat[i] == IN_RESET) {
2045 SCpnt = ha->cp[i].SCpnt;
2046 unmap_dma(i, ha);
2047 SCpnt->result = DID_RESET << 16;
2048 SCpnt->host_scribble = NULL;
2049
2050 /* This mailbox is still waiting for its interrupt */
2051 ha->cp_stat[i] = LOCKED;
2052
2053 printk
2054 ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
2055 ha->board_name, i, SCpnt->pid);
2056 }
2057
2058 else if (ha->cp_stat[i] == ABORTING) {
2059 SCpnt = ha->cp[i].SCpnt;
2060 unmap_dma(i, ha);
2061 SCpnt->result = DID_RESET << 16;
2062 SCpnt->host_scribble = NULL;
2063
2064 /* This mailbox was never queued to the adapter */
2065 ha->cp_stat[i] = FREE;
2066
2067 printk
2068 ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
2069 ha->board_name, i, SCpnt->pid);
2070 }
2071
2072 else
2073 /* Any other mailbox has already been set free by interrupt */
2074 continue;
2075
2076 SCpnt->scsi_done(SCpnt);
2077 }
2078
2079 ha->in_reset = 0;
2080 do_trace = 0;
2081
2082 if (arg_done)
2083 printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->pid);
2084 else
2085 printk("%s: reset, exit.\n", ha->board_name);
2086
Jeff Garzik df0ae242005-05-28 07:57:14 -04002087 spin_unlock_irq(shost->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 return SUCCESS;
2089}
2090
2091int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2092 sector_t capacity, int *dkinfo)
2093{
2094 unsigned int size = capacity;
2095
2096 if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
2097 dkinfo[0] = 255;
2098 dkinfo[1] = 63;
2099 dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
2100 }
2101#if defined (DEBUG_GEOMETRY)
2102 printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
2103 dkinfo[0], dkinfo[1], dkinfo[2]);
2104#endif
2105
2106 return 0;
2107}
2108
2109static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
2110 unsigned int rev)
2111{
2112 unsigned int i, j, k, y;
2113 unsigned long x;
2114
2115 for (i = 0; i < n - 1; i++) {
2116 k = i;
2117
2118 for (j = k + 1; j < n; j++)
2119 if (rev) {
2120 if (sk[j] > sk[k])
2121 k = j;
2122 } else {
2123 if (sk[j] < sk[k])
2124 k = j;
2125 }
2126
2127 if (k != i) {
2128 x = sk[k];
2129 sk[k] = sk[i];
2130 sk[i] = x;
2131 y = da[k];
2132 da[k] = da[i];
2133 da[i] = y;
2134 }
2135 }
2136
2137 return;
2138}
2139
2140static int reorder(struct hostdata *ha, unsigned long cursec,
2141 unsigned int ihdlr, unsigned int il[], unsigned int n_ready)
2142{
2143 struct scsi_cmnd *SCpnt;
2144 struct mscp *cpp;
2145 unsigned int k, n;
2146 unsigned int rev = 0, s = 1, r = 1;
2147 unsigned int input_only = 1, overlap = 0;
2148 unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
2149 unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
2150 unsigned long ioseek = 0;
2151
2152 static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
2153 static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
2154 static unsigned int readysorted = 0, revcount = 0;
2155 static unsigned long seeksorted = 0, seeknosort = 0;
2156
2157 if (link_statistics && !(++flushcount % link_statistics))
2158 printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
2159 " av %ldK as %ldK.\n", flushcount, batchcount,
2160 inputcount, ovlcount, readycount, readysorted, sortcount,
2161 revcount, seeknosort / (readycount + 1),
2162 seeksorted / (readycount + 1));
2163
2164 if (n_ready <= 1)
2165 return 0;
2166
2167 for (n = 0; n < n_ready; n++) {
2168 k = il[n];
2169 cpp = &ha->cp[k];
2170 SCpnt = cpp->SCpnt;
2171
2172 if (!cpp->din)
2173 input_only = 0;
2174
2175 if (SCpnt->request->sector < minsec)
2176 minsec = SCpnt->request->sector;
2177 if (SCpnt->request->sector > maxsec)
2178 maxsec = SCpnt->request->sector;
2179
2180 sl[n] = SCpnt->request->sector;
2181 ioseek += SCpnt->request->nr_sectors;
2182
2183 if (!n)
2184 continue;
2185
2186 if (sl[n] < sl[n - 1])
2187 s = 0;
2188 if (sl[n] > sl[n - 1])
2189 r = 0;
2190
2191 if (link_statistics) {
2192 if (sl[n] > sl[n - 1])
2193 seek += sl[n] - sl[n - 1];
2194 else
2195 seek += sl[n - 1] - sl[n];
2196 }
2197
2198 }
2199
2200 if (link_statistics) {
2201 if (cursec > sl[0])
2202 seek += cursec - sl[0];
2203 else
2204 seek += sl[0] - cursec;
2205 }
2206
2207 if (cursec > ((maxsec + minsec) / 2))
2208 rev = 1;
2209
2210 if (ioseek > ((maxsec - minsec) / 2))
2211 rev = 0;
2212
2213 if (!((rev && r) || (!rev && s)))
2214 sort(sl, il, n_ready, rev);
2215
2216 if (!input_only)
2217 for (n = 0; n < n_ready; n++) {
2218 k = il[n];
2219 cpp = &ha->cp[k];
2220 SCpnt = cpp->SCpnt;
2221 ll[n] = SCpnt->request->nr_sectors;
2222 pl[n] = SCpnt->pid;
2223
2224 if (!n)
2225 continue;
2226
2227 if ((sl[n] == sl[n - 1])
2228 || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
2229 || (rev && ((sl[n] + ll[n]) > sl[n - 1])))
2230 overlap = 1;
2231 }
2232
2233 if (overlap)
2234 sort(pl, il, n_ready, 0);
2235
2236 if (link_statistics) {
2237 if (cursec > sl[0])
2238 iseek = cursec - sl[0];
2239 else
2240 iseek = sl[0] - cursec;
2241 batchcount++;
2242 readycount += n_ready;
2243 seeknosort += seek / 1024;
2244 if (input_only)
2245 inputcount++;
2246 if (overlap) {
2247 ovlcount++;
2248 seeksorted += iseek / 1024;
2249 } else
2250 seeksorted += (iseek + maxsec - minsec) / 1024;
2251 if (rev && !r) {
2252 revcount++;
2253 readysorted += n_ready;
2254 }
2255 if (!rev && !s) {
2256 sortcount++;
2257 readysorted += n_ready;
2258 }
2259 }
2260#if defined(DEBUG_LINKED_COMMANDS)
2261 if (link_statistics && (overlap || !(flushcount % link_statistics)))
2262 for (n = 0; n < n_ready; n++) {
2263 k = il[n];
2264 cpp = &ha->cp[k];
2265 SCpnt = cpp->SCpnt;
2266 printk
2267 ("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"
2268 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2269 (ihdlr ? "ihdlr" : "qcomm"),
2270 SCpnt->device->channel, SCpnt->device->id,
2271 SCpnt->device->lun, SCpnt->pid, k, flushcount,
2272 n_ready, SCpnt->request->sector,
2273 SCpnt->request->nr_sectors, cursec, YESNO(s),
2274 YESNO(r), YESNO(rev), YESNO(input_only),
2275 YESNO(overlap), cpp->din);
2276 }
2277#endif
2278 return overlap;
2279}
2280
2281static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2282 struct hostdata *ha, unsigned int ihdlr)
2283{
2284 struct scsi_cmnd *SCpnt;
2285 struct mscp *cpp;
2286 unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
2287
2288 for (k = 0; k < dev->host->can_queue; k++) {
2289
2290 if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE)
2291 continue;
2292
2293 cpp = &ha->cp[k];
2294 SCpnt = cpp->SCpnt;
2295
2296 if (SCpnt->device != dev)
2297 continue;
2298
2299 if (ha->cp_stat[k] == IN_USE)
2300 return;
2301
2302 il[n_ready++] = k;
2303 }
2304
2305 if (reorder(ha, cursec, ihdlr, il, n_ready))
2306 n_ready = 1;
2307
2308 for (n = 0; n < n_ready; n++) {
2309 k = il[n];
2310 cpp = &ha->cp[k];
2311 SCpnt = cpp->SCpnt;
2312
2313 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2314 printk
2315 ("%s: %s, target %d.%d:%d, pid %ld, mbox %d, adapter"
2316 " busy, will abort.\n", ha->board_name,
2317 (ihdlr ? "ihdlr" : "qcomm"),
2318 SCpnt->device->channel, SCpnt->device->id,
2319 SCpnt->device->lun, SCpnt->pid, k);
2320 ha->cp_stat[k] = ABORTING;
2321 continue;
2322 }
2323
2324 ha->cp_stat[k] = IN_USE;
2325 }
2326}
2327
2328static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost)
2329{
2330 struct scsi_cmnd *SCpnt;
2331 unsigned int i, k, c, status, tstatus, reg;
2332 struct mssp *spp;
2333 struct mscp *cpp;
2334 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2335
2336 if (shost->irq != irq)
2337 panic("%s: ihdlr, irq %d, shost->irq %d.\n", ha->board_name, irq,
2338 shost->irq);
2339
2340 /* Check if this board need to be serviced */
2341 if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
2342 goto none;
2343
2344 ha->iocount++;
2345
2346 if (do_trace)
2347 printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq,
2348 ha->iocount);
2349
2350 /* Check if this board is still busy */
2351 if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) {
2352 reg = inb(shost->io_port + REG_STATUS);
2353 printk
2354 ("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n",
2355 ha->board_name, irq, reg, ha->iocount);
2356 goto none;
2357 }
2358
2359 spp = &ha->sp;
2360
2361 /* Make a local copy just before clearing the interrupt indication */
2362 memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp));
2363
2364 /* Clear the completion flag and cp pointer on the dynamic copy of sp */
2365 memset(ha->sp_cpu_addr, 0, sizeof(struct mssp));
2366
2367 /* Read the status register to clear the interrupt indication */
2368 reg = inb(shost->io_port + REG_STATUS);
2369
2370#if defined (DEBUG_INTERRUPT)
2371 {
2372 unsigned char *bytesp;
2373 int cnt;
2374 bytesp = (unsigned char *)spp;
2375 if (ha->iocount < 200) {
2376 printk("sp[] =");
2377 for (cnt = 0; cnt < 15; cnt++)
2378 printk(" 0x%x", bytesp[cnt]);
2379 printk("\n");
2380 }
2381 }
2382#endif
2383
2384 /* Reject any sp with supspect data */
2385 if (spp->eoc == 0 && ha->iocount > 1)
2386 printk
2387 ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n",
2388 ha->board_name, irq, reg, ha->iocount);
2389 if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue)
2390 printk
2391 ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n",
2392 ha->board_name, spp->cpp_index, irq, reg, ha->iocount);
2393 if (spp->eoc == 0 || spp->cpp_index < 0
2394 || spp->cpp_index >= shost->can_queue)
2395 goto handled;
2396
2397 /* Find the mailbox to be serviced on this board */
2398 i = spp->cpp_index;
2399
2400 cpp = &(ha->cp[i]);
2401
2402#if defined(DEBUG_GENERATE_ABORTS)
2403 if ((ha->iocount > 500) && ((ha->iocount % 500) < 3))
2404 goto handled;
2405#endif
2406
2407 if (ha->cp_stat[i] == IGNORE) {
2408 ha->cp_stat[i] = FREE;
2409 goto handled;
2410 } else if (ha->cp_stat[i] == LOCKED) {
2411 ha->cp_stat[i] = FREE;
2412 printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i,
2413 ha->iocount);
2414 goto handled;
2415 } else if (ha->cp_stat[i] == FREE) {
2416 printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i,
2417 ha->iocount);
2418 goto handled;
2419 } else if (ha->cp_stat[i] == IN_RESET)
2420 printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i);
2421 else if (ha->cp_stat[i] != IN_USE)
2422 panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
2423 ha->board_name, i, ha->cp_stat[i]);
2424
2425 ha->cp_stat[i] = FREE;
2426 SCpnt = cpp->SCpnt;
2427
2428 if (SCpnt == NULL)
2429 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2430
2431 if (SCpnt->host_scribble == NULL)
2432 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,
2433 i, SCpnt->pid, SCpnt);
2434
2435 if (*(unsigned int *)SCpnt->host_scribble != i)
2436 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
2437 ha->board_name, i, SCpnt->pid,
2438 *(unsigned int *)SCpnt->host_scribble);
2439
2440 sync_dma(i, ha);
2441
2442 if (linked_comm && SCpnt->device->queue_depth > 2
2443 && TLDEV(SCpnt->device->type))
2444 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
2445
2446 tstatus = status_byte(spp->target_status);
2447
2448#if defined(DEBUG_GENERATE_ERRORS)
2449 if ((ha->iocount > 500) && ((ha->iocount % 200) < 2))
2450 spp->adapter_status = 0x01;
2451#endif
2452
2453 switch (spp->adapter_status) {
2454 case ASOK: /* status OK */
2455
2456 /* Forces a reset if a disk drive keeps returning BUSY */
2457 if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
2458 status = DID_ERROR << 16;
2459
2460 /* If there was a bus reset, redo operation on each target */
2461 else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
2462 && ha->target_redo[SCpnt->device->id][SCpnt->
2463 device->
2464 channel])
2465 status = DID_BUS_BUSY << 16;
2466
2467 /* Works around a flaw in scsi.c */
2468 else if (tstatus == CHECK_CONDITION
2469 && SCpnt->device->type == TYPE_DISK
2470 && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
2471 status = DID_BUS_BUSY << 16;
2472
2473 else
2474 status = DID_OK << 16;
2475
2476 if (tstatus == GOOD)
2477 ha->target_redo[SCpnt->device->id][SCpnt->device->
2478 channel] = 0;
2479
2480 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2481 (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2482 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2483 printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
2484 "target_status 0x%x, sense key 0x%x.\n",
2485 ha->board_name,
2486 SCpnt->device->channel, SCpnt->device->id,
2487 SCpnt->device->lun, SCpnt->pid,
2488 spp->target_status, SCpnt->sense_buffer[2]);
2489
2490 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
2491
2492 if (ha->last_retried_pid == SCpnt->pid)
2493 ha->retries = 0;
2494
2495 break;
2496 case ASST: /* Selection Time Out */
2497 case 0x02: /* Command Time Out */
2498
2499 if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
2500 status = DID_ERROR << 16;
2501 else {
2502 status = DID_TIME_OUT << 16;
2503 ha->target_to[SCpnt->device->id][SCpnt->device->
2504 channel]++;
2505 }
2506
2507 break;
2508
2509 /* Perform a limited number of internal retries */
2510 case 0x03: /* SCSI Bus Reset Received */
2511 case 0x04: /* Initial Controller Power-up */
2512
2513 for (c = 0; c <= shost->max_channel; c++)
2514 for (k = 0; k < shost->max_id; k++)
2515 ha->target_redo[k][c] = 1;
2516
2517 if (SCpnt->device->type != TYPE_TAPE
2518 && ha->retries < MAX_INTERNAL_RETRIES) {
2519
2520#if defined(DID_SOFT_ERROR)
2521 status = DID_SOFT_ERROR << 16;
2522#else
2523 status = DID_BUS_BUSY << 16;
2524#endif
2525
2526 ha->retries++;
2527 ha->last_retried_pid = SCpnt->pid;
2528 } else
2529 status = DID_ERROR << 16;
2530
2531 break;
2532 case 0x05: /* Unexpected Bus Phase */
2533 case 0x06: /* Unexpected Bus Free */
2534 case 0x07: /* Bus Parity Error */
2535 case 0x08: /* SCSI Hung */
2536 case 0x09: /* Unexpected Message Reject */
2537 case 0x0a: /* SCSI Bus Reset Stuck */
2538 case 0x0b: /* Auto Request-Sense Failed */
2539 case 0x0c: /* Controller Ram Parity Error */
2540 default:
2541 status = DID_ERROR << 16;
2542 break;
2543 }
2544
2545 SCpnt->result = status | spp->target_status;
2546
2547#if defined(DEBUG_INTERRUPT)
2548 if (SCpnt->result || do_trace)
2549#else
2550 if ((spp->adapter_status != ASOK && ha->iocount > 1000) ||
2551 (spp->adapter_status != ASOK &&
2552 spp->adapter_status != ASST && ha->iocount <= 1000) ||
2553 do_trace || msg_byte(spp->target_status))
2554#endif
2555 printk("%s: ihdlr, mbox %2d, err 0x%x:%x,"
2556 " target %d.%d:%d, pid %ld, reg 0x%x, count %d.\n",
2557 ha->board_name, i, spp->adapter_status, spp->target_status,
2558 SCpnt->device->channel, SCpnt->device->id,
2559 SCpnt->device->lun, SCpnt->pid, reg, ha->iocount);
2560
2561 unmap_dma(i, ha);
2562
2563 /* Set the command state to inactive */
2564 SCpnt->host_scribble = NULL;
2565
2566 SCpnt->scsi_done(SCpnt);
2567
2568 if (do_trace)
2569 printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name,
2570 irq, ha->iocount);
2571
2572 handled:
2573 return IRQ_HANDLED;
2574 none:
2575 return IRQ_NONE;
2576}
2577
2578static irqreturn_t do_interrupt_handler(int irq, void *shap,
2579 struct pt_regs *regs)
2580{
2581 struct Scsi_Host *shost;
2582 unsigned int j;
2583 unsigned long spin_flags;
2584 irqreturn_t ret;
2585
2586 /* Check if the interrupt must be processed by this handler */
2587 if ((j = (unsigned int)((char *)shap - sha)) >= num_boards)
2588 return IRQ_NONE;
2589 shost = sh[j];
2590
2591 spin_lock_irqsave(shost->host_lock, spin_flags);
2592 ret = ihdlr(irq, shost);
2593 spin_unlock_irqrestore(shost->host_lock, spin_flags);
2594 return ret;
2595}
2596
2597static int eata2x_release(struct Scsi_Host *shost)
2598{
2599 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2600 unsigned int i;
2601
2602 for (i = 0; i < shost->can_queue; i++)
2603 if ((&ha->cp[i])->sglist)
2604 kfree((&ha->cp[i])->sglist);
2605
2606 for (i = 0; i < shost->can_queue; i++)
2607 pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr,
2608 sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
2609
2610 if (ha->sp_cpu_addr)
2611 pci_free_consistent(ha->pdev, sizeof(struct mssp),
2612 ha->sp_cpu_addr, ha->sp_dma_addr);
2613
2614 free_irq(shost->irq, &sha[ha->board_number]);
2615
2616 if (shost->dma_channel != NO_DMA)
2617 free_dma(shost->dma_channel);
2618
2619 release_region(shost->io_port, shost->n_io_port);
2620 scsi_unregister(shost);
2621 return 0;
2622}
2623
2624#include "scsi_module.c"
2625
2626#ifndef MODULE
2627__setup("eata=", option_setup);
2628#endif /* end MODULE */