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