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