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