Automatic merge of /spare/repo/netdev-2.6 branch pcnet32
[linux-2.6] / drivers / scsi / u14-34f.c
1 /*
2  *      u14-34f.c - Low-level driver for UltraStor 14F/34F 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 u14-34f.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  *             of:[y|n]       have_old_firmware=[1|0]
20  *
21  *          A valid example using the new parameter format is:
22  *          modprobe u14-34f "u14-34f=0x340,0x330,lc:y,tm:0,mq:4"
23  *
24  *          which is equivalent to the old format:
25  *          modprobe u14-34f io_port=0x340,0x330 linked_comm=1 tag_mode=0 \
26  *                        max_queue_depth=4
27  *
28  *          With actual module code, u14-34f and u14_34f are equivalent
29  *          as module parameter names.
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  *
49  *      10 Oct 2002 Rev. 7.70 for linux 2.5.42
50  *        + Foreport from revision 6.70.
51  *
52  *      25 Jun 2002 Rev. 6.70 for linux 2.4.19
53  *        + Fixed endian-ness problem due to bitfields.
54  *
55  *      21 Feb 2002 Rev. 6.52 for linux 2.4.18
56  *        + Backport from rev. 7.22 (use io_request_lock).
57  *
58  *      20 Feb 2002 Rev. 7.22 for linux 2.5.5
59  *        + Remove any reference to virt_to_bus().
60  *        + Fix pio hang while detecting multiple HBAs.
61  *
62  *      01 Jan 2002 Rev. 7.20 for linux 2.5.1
63  *        + Use the dynamic DMA mapping API.
64  *
65  *      19 Dec 2001 Rev. 7.02 for linux 2.5.1
66  *        + Use SCpnt->sc_data_direction if set.
67  *        + Use sglist.page instead of sglist.address.
68  *
69  *      11 Dec 2001 Rev. 7.00 for linux 2.5.1
70  *        + Use host->host_lock instead of io_request_lock.
71  *
72  *       1 May 2001 Rev. 6.05 for linux 2.4.4
73  *        + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d)
74  *
75  *      25 Jan 2001 Rev. 6.03 for linux 2.4.0
76  *        + "check_region" call replaced by "request_region".
77  *
78  *      22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11
79  *        + Removed old scsi error handling support.
80  *        + The obsolete boot option flag eh:n is silently ignored.
81  *        + Removed error messages while a disk drive is powered up at
82  *          boot time.
83  *        + Improved boot messages: all tagged capable device are
84  *          indicated as "tagged".
85  *
86  *      16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18
87  *        + Updated to the new __setup interface for boot command line options.
88  *        + When loaded as a module, accepts the new parameter boot_options
89  *          which value is a string with the same format of the kernel boot
90  *          command line options. A valid example is:
91  *          modprobe u14-34f 'boot_options="0x230,0x340,lc:y,mq:4"'
92  *
93  *      22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11
94  *        + Removed pre-2.2 source code compatibility.
95  *
96  *      26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111
97  *          Added command line option (et:[y|n]) to use the existing
98  *          translation (returned by scsicam_bios_param) as disk geometry.
99  *          The default is et:n, which uses the disk geometry jumpered
100  *          on the board.
101  *          The default value et:n is compatible with all previous revisions
102  *          of this driver.
103  *
104  *      28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104
105  *          Increased busy timeout from 10 msec. to 200 msec. while
106  *          processing interrupts.
107  *
108  *      18 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102
109  *          Improved abort handling during the eh recovery process.
110  *
111  *      13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101
112  *          The driver is now fully SMP safe, including the
113  *          abort and reset routines.
114  *          Added command line options (eh:[y|n]) to choose between
115  *          new_eh_code and the old scsi code.
116  *          If linux version >= 2.1.101 the default is eh:y, while the eh
117  *          option is ignored for previous releases and the old scsi code
118  *          is used.
119  *
120  *      18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97
121  *          Reworked interrupt handler.
122  *
123  *      11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95
124  *          Major reliability improvement: when a batch with overlapping
125  *          requests is detected, requests are queued one at a time
126  *          eliminating any possible board or drive reordering.
127  *
128  *      10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95
129  *          Improved SMP support (if linux version >= 2.1.95).
130  *
131  *       9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94
132  *          Performance improvement: when sequential i/o is detected,
133  *          always use direct sort instead of reverse sort.
134  *
135  *       4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92
136  *          io_port is now unsigned long.
137  *
138  *      17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88
139  *          Use new scsi error handling code (if linux version >= 2.1.88).
140  *          Use new interrupt code.
141  *
142  *      12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55
143  *          Use of udelay inside the wait loops to avoid timeout
144  *          problems with fast cpus.
145  *          Removed check about useless calls to the interrupt service
146  *          routine (reported on SMP systems only).
147  *          At initialization time "sorted/unsorted" is displayed instead
148  *          of "linked/unlinked" to reinforce the fact that "linking" is
149  *          nothing but "elevator sorting" in the actual implementation.
150  *
151  *      17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38
152  *          Use of serial_number_at_timeout in abort and reset processing.
153  *          Use of the __initfunc and __initdata macro in setup code.
154  *          Minor cleanups in the list_statistics code.
155  *
156  *      24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26
157  *          When loading as a module, parameter passing is now supported
158  *          both in 2.0 and in 2.1 style.
159  *          Fixed data transfer direction for some SCSI opcodes.
160  *          Immediate acknowledge to request sense commands.
161  *          Linked commands to each disk device are now reordered by elevator
162  *          sorting. Rare cases in which reordering of write requests could
163  *          cause wrong results are managed.
164  *
165  *      18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28
166  *          Added command line options to enable/disable linked commands
167  *          (lc:[y|n]), old firmware support (of:[y|n]) and to set the max
168  *          queue depth (mq:xx). Default is "u14-34f=lc:n,of:n,mq:8".
169  *          Improved command linking.
170  *
171  *       8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27
172  *          Added linked command support.
173  *
174  *       3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27
175  *          Added queue depth adjustment.
176  *
177  *      22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26
178  *          The list of i/o ports to be probed can be overwritten by the
179  *          "u14-34f=port0,port1,...." boot command line option.
180  *          Scatter/gather lists are now allocated by a number of kmalloc
181  *          calls, in order to avoid the previous size limit of 64Kb.
182  *
183  *      16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25
184  *          Added multichannel support.
185  *
186  *      27 Sep 1996 rev. 2.12 for linux 2.1.0
187  *          Portability cleanups (virtual/bus addressing, little/big endian
188  *          support).
189  *
190  *      09 Jul 1996 rev. 2.11 for linux 2.0.4
191  *          "Data over/under-run" no longer implies a redo on all targets.
192  *          Number of internal retries is now limited.
193  *
194  *      16 Apr 1996 rev. 2.10 for linux 1.3.90
195  *          New argument "reset_flags" to the reset routine.
196  *
197  *      21 Jul 1995 rev. 2.02 for linux 1.3.11
198  *          Fixed Data Transfer Direction for some SCSI commands.
199  *
200  *      13 Jun 1995 rev. 2.01 for linux 1.2.10
201  *          HAVE_OLD_UX4F_FIRMWARE should be defined for U34F boards when
202  *          the firmware prom is not the latest one (28008-006).
203  *
204  *      11 Mar 1995 rev. 2.00 for linux 1.2.0
205  *          Fixed a bug which prevented media change detection for removable
206  *          disk drives.
207  *
208  *      23 Feb 1995 rev. 1.18 for linux 1.1.94
209  *          Added a check for scsi_register returning NULL.
210  *
211  *      11 Feb 1995 rev. 1.17 for linux 1.1.91
212  *          U14F qualified to run with 32 sglists.
213  *          Now DEBUG_RESET is disabled by default.
214  *
215  *       9 Feb 1995 rev. 1.16 for linux 1.1.90
216  *          Use host->wish_block instead of host->block.
217  *
218  *       8 Feb 1995 rev. 1.15 for linux 1.1.89
219  *          Cleared target_time_out counter while performing a reset.
220  *
221  *      28 Jan 1995 rev. 1.14 for linux 1.1.86
222  *          Added module support.
223  *          Log and do a retry when a disk drive returns a target status
224  *          different from zero on a recovered error.
225  *          Auto detects if U14F boards have an old firmware revision.
226  *          Max number of scatter/gather lists set to 16 for all boards
227  *          (most installation run fine using 33 sglists, while other
228  *          has problems when using more than 16).
229  *
230  *      16 Jan 1995 rev. 1.13 for linux 1.1.81
231  *          Display a message if check_region detects a port address
232  *          already in use.
233  *
234  *      15 Dec 1994 rev. 1.12 for linux 1.1.74
235  *          The host->block flag is set for all the detected ISA boards.
236  *
237  *      30 Nov 1994 rev. 1.11 for linux 1.1.68
238  *          Redo i/o on target status CHECK_CONDITION for TYPE_DISK only.
239  *          Added optional support for using a single board at a time.
240  *
241  *      14 Nov 1994 rev. 1.10 for linux 1.1.63
242  *
243  *      28 Oct 1994 rev. 1.09 for linux 1.1.58  Final BETA release.
244  *      16 Jul 1994 rev. 1.00 for linux 1.1.29  Initial ALPHA release.
245  *
246  *          This driver is a total replacement of the original UltraStor
247  *          scsi driver, but it supports ONLY the 14F and 34F boards.
248  *          It can be configured in the same kernel in which the original
249  *          ultrastor driver is configured to allow the original U24F
250  *          support.
251  *
252  *          Multiple U14F and/or U34F host adapters are supported.
253  *
254  *  Copyright (C) 1994-2003 Dario Ballabio (ballabio_dario@emc.com)
255  *
256  *  Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it
257  *
258  *  Redistribution and use in source and binary forms, with or without
259  *  modification, are permitted provided that redistributions of source
260  *  code retain the above copyright notice and this comment without
261  *  modification.
262  *
263  *      WARNING: if your 14/34F board has an old firmware revision (see below)
264  *               you must change "#undef" into "#define" in the following
265  *               statement.
266  */
267 #undef HAVE_OLD_UX4F_FIRMWARE
268 /*
269  *  The UltraStor 14F, 24F, and 34F are a family of intelligent, high
270  *  performance SCSI-2 host adapters.
271  *  Here is the scoop on the various models:
272  *
273  *  14F - ISA first-party DMA HA with floppy support and WD1003 emulation.
274  *  24F - EISA Bus Master HA with floppy support and WD1003 emulation.
275  *  34F - VESA Local-Bus Bus Master HA (no WD1003 emulation).
276  *
277  *  This code has been tested with up to two U14F boards, using both
278  *  firmware 28004-005/38004-004 (BIOS rev. 2.00) and the latest firmware
279  *  28004-006/38004-005 (BIOS rev. 2.01).
280  *
281  *  The latest firmware is required in order to get reliable operations when
282  *  clustering is enabled. ENABLE_CLUSTERING provides a performance increase
283  *  up to 50% on sequential access.
284  *
285  *  Since the Scsi_Host_Template structure is shared among all 14F and 34F,
286  *  the last setting of use_clustering is in effect for all of these boards.
287  *
288  *  Here a sample configuration using two U14F boards:
289  *
290  U14F0: ISA 0x330, BIOS 0xc8000, IRQ 11, DMA 5, SG 32, MB 16, of:n, lc:y, mq:8.
291  U14F1: ISA 0x340, BIOS 0x00000, IRQ 10, DMA 6, SG 32, MB 16, of:n, lc:y, mq:8.
292  *
293  *  The boot controller must have its BIOS enabled, while other boards can
294  *  have their BIOS disabled, or enabled to an higher address.
295  *  Boards are named Ux4F0, Ux4F1..., according to the port address order in
296  *  the io_port[] array.
297  *
298  *  The following facts are based on real testing results (not on
299  *  documentation) on the above U14F board.
300  *
301  *  - The U14F board should be jumpered for bus on time less or equal to 7
302  *    microseconds, while the default is 11 microseconds. This is order to
303  *    get acceptable performance while using floppy drive and hard disk
304  *    together. The jumpering for 7 microseconds is: JP13 pin 15-16,
305  *    JP14 pin 7-8 and pin 9-10.
306  *    The reduction has a little impact on scsi performance.
307  *
308  *  - If scsi bus length exceeds 3m., the scsi bus speed needs to be reduced
309  *    from 10Mhz to 5Mhz (do this by inserting a jumper on JP13 pin 7-8).
310  *
311  *  - If U14F on board firmware is older than 28004-006/38004-005,
312  *    the U14F board is unable to provide reliable operations if the scsi
313  *    request length exceeds 16Kbyte. When this length is exceeded the
314  *    behavior is:
315  *    - adapter_status equal 0x96 or 0xa3 or 0x93 or 0x94;
316  *    - adapter_status equal 0 and target_status equal 2 on for all targets
317  *      in the next operation following the reset.
318  *    This sequence takes a long time (>3 seconds), so in the meantime
319  *    the SD_TIMEOUT in sd.c could expire giving rise to scsi aborts
320  *    (SD_TIMEOUT has been increased from 3 to 6 seconds in 1.1.31).
321  *    Because of this I had to DISABLE_CLUSTERING and to work around the
322  *    bus reset in the interrupt service routine, returning DID_BUS_BUSY
323  *    so that the operations are retried without complains from the scsi.c
324  *    code.
325  *    Any reset of the scsi bus is going to kill tape operations, since
326  *    no retry is allowed for tapes. Bus resets are more likely when the
327  *    scsi bus is under heavy load.
328  *    Requests using scatter/gather have a maximum length of 16 x 1024 bytes
329  *    when DISABLE_CLUSTERING is in effect, but unscattered requests could be
330  *    larger than 16Kbyte.
331  *
332  *    The new firmware has fixed all the above problems.
333  *
334  *  For U34F boards the latest bios prom is 38008-002 (BIOS rev. 2.01),
335  *  the latest firmware prom is 28008-006. Older firmware 28008-005 has
336  *  problems when using more than 16 scatter/gather lists.
337  *
338  *  The list of i/o ports to be probed can be totally replaced by the
339  *  boot command line option: "u14-34f=port0,port1,port2,...", where the
340  *  port0, port1... arguments are ISA/VESA addresses to be probed.
341  *  For example using "u14-34f=0x230,0x340", the driver probes only the two
342  *  addresses 0x230 and 0x340 in this order; "u14-34f=0" totally disables
343  *  this driver.
344  *
345  *  After the optional list of detection probes, other possible command line
346  *  options are:
347  *
348  *  et:y  use disk geometry returned by scsicam_bios_param;
349  *  et:n  use disk geometry jumpered on the board;
350  *  lc:y  enables linked commands;
351  *  lc:n  disables linked commands;
352  *  tm:0  disables tagged commands (same as tc:n);
353  *  tm:1  use simple queue tags (same as tc:y);
354  *  tm:2  use ordered queue tags (same as tc:2);
355  *  of:y  enables old firmware support;
356  *  of:n  disables old firmware support;
357  *  mq:xx set the max queue depth to the value xx (2 <= xx <= 8).
358  *
359  *  The default value is: "u14-34f=lc:n,of:n,mq:8,tm:0,et:n".
360  *  An example using the list of detection probes could be:
361  *  "u14-34f=0x230,0x340,lc:y,tm:2,of:n,mq:4,et:n".
362  *
363  *  When loading as a module, parameters can be specified as well.
364  *  The above example would be (use 1 in place of y and 0 in place of n):
365  *
366  *  modprobe u14-34f io_port=0x230,0x340 linked_comm=1 have_old_firmware=0 \
367  *                max_queue_depth=4 ext_tran=0 tag_mode=2
368  *
369  *  ----------------------------------------------------------------------------
370  *  In this implementation, linked commands are designed to work with any DISK
371  *  or CD-ROM, since this linking has only the intent of clustering (time-wise)
372  *  and reordering by elevator sorting commands directed to each device,
373  *  without any relation with the actual SCSI protocol between the controller
374  *  and the device.
375  *  If Q is the queue depth reported at boot time for each device (also named
376  *  cmds/lun) and Q > 2, whenever there is already an active command to the
377  *  device all other commands to the same device  (up to Q-1) are kept waiting
378  *  in the elevator sorting queue. When the active command completes, the
379  *  commands in this queue are sorted by sector address. The sort is chosen
380  *  between increasing or decreasing by minimizing the seek distance between
381  *  the sector of the commands just completed and the sector of the first
382  *  command in the list to be sorted.
383  *  Trivial math assures that the unsorted average seek distance when doing
384  *  random seeks over S sectors is S/3.
385  *  When (Q-1) requests are uniformly distributed over S sectors, the average
386  *  distance between two adjacent requests is S/((Q-1) + 1), so the sorted
387  *  average seek distance for (Q-1) random requests over S sectors is S/Q.
388  *  The elevator sorting hence divides the seek distance by a factor Q/3.
389  *  The above pure geometric remarks are valid in all cases and the
390  *  driver effectively reduces the seek distance by the predicted factor
391  *  when there are Q concurrent read i/o operations on the device, but this
392  *  does not necessarily results in a noticeable performance improvement:
393  *  your mileage may vary....
394  *
395  *  Note: command reordering inside a batch of queued commands could cause
396  *        wrong results only if there is at least one write request and the
397  *        intersection (sector-wise) of all requests is not empty.
398  *        When the driver detects a batch including overlapping requests
399  *        (a really rare event) strict serial (pid) order is enforced.
400  *  ----------------------------------------------------------------------------
401  *
402  *  The boards are named Ux4F0, Ux4F1,... according to the detection order.
403  *
404  *  In order to support multiple ISA boards in a reliable way,
405  *  the driver sets host->wish_block = TRUE for all ISA boards.
406  */
407
408 #include <linux/config.h>
409 #include <linux/string.h>
410 #include <linux/kernel.h>
411 #include <linux/ioport.h>
412 #include <linux/delay.h>
413 #include <asm/io.h>
414 #include <asm/system.h>
415 #include <asm/byteorder.h>
416 #include <linux/proc_fs.h>
417 #include <linux/blkdev.h>
418 #include <linux/interrupt.h>
419 #include <linux/stat.h>
420 #include <linux/pci.h>
421 #include <linux/init.h>
422 #include <linux/ctype.h>
423 #include <linux/spinlock.h>
424 #include <asm/dma.h>
425 #include <asm/irq.h>
426
427 #include <scsi/scsi.h>
428 #include <scsi/scsi_cmnd.h>
429 #include <scsi/scsi_device.h>
430 #include <scsi/scsi_host.h>
431 #include <scsi/scsi_tcq.h>
432 #include <scsi/scsicam.h>
433
434 static int u14_34f_detect(struct scsi_host_template *);
435 static int u14_34f_release(struct Scsi_Host *);
436 static int u14_34f_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *));
437 static int u14_34f_eh_abort(struct scsi_cmnd *);
438 static int u14_34f_eh_host_reset(struct scsi_cmnd *);
439 static int u14_34f_bios_param(struct scsi_device *, struct block_device *,
440                               sector_t, int *);
441 static int u14_34f_slave_configure(struct scsi_device *);
442
443 static struct scsi_host_template driver_template = {
444                 .name                    = "UltraStor 14F/34F rev. 8.10.00 ",
445                 .detect                  = u14_34f_detect,
446                 .release                 = u14_34f_release,
447                 .queuecommand            = u14_34f_queuecommand,
448                 .eh_abort_handler        = u14_34f_eh_abort,
449                 .eh_device_reset_handler = NULL,
450                 .eh_bus_reset_handler    = NULL,
451                 .eh_host_reset_handler   = u14_34f_eh_host_reset,
452                 .bios_param              = u14_34f_bios_param,
453                 .slave_configure         = u14_34f_slave_configure,
454                 .this_id                 = 7,
455                 .unchecked_isa_dma       = 1,
456                 .use_clustering          = ENABLE_CLUSTERING
457                 };
458
459 #if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
460 #error "Adjust your <asm/byteorder.h> defines"
461 #endif
462
463 /* Values for the PRODUCT_ID ports for the 14/34F */
464 #define PRODUCT_ID1  0x56
465 #define PRODUCT_ID2  0x40        /* NOTE: Only upper nibble is used */
466
467 /* Subversion values */
468 #define ISA  0
469 #define ESA 1
470
471 #define OP_HOST_ADAPTER   0x1
472 #define OP_SCSI           0x2
473 #define OP_RESET          0x4
474 #define DTD_SCSI          0x0
475 #define DTD_IN            0x1
476 #define DTD_OUT           0x2
477 #define DTD_NONE          0x3
478 #define HA_CMD_INQUIRY    0x1
479 #define HA_CMD_SELF_DIAG  0x2
480 #define HA_CMD_READ_BUFF  0x3
481 #define HA_CMD_WRITE_BUFF 0x4
482
483 #undef  DEBUG_LINKED_COMMANDS
484 #undef  DEBUG_DETECT
485 #undef  DEBUG_INTERRUPT
486 #undef  DEBUG_RESET
487 #undef  DEBUG_GENERATE_ERRORS
488 #undef  DEBUG_GENERATE_ABORTS
489 #undef  DEBUG_GEOMETRY
490
491 #define MAX_ISA 3
492 #define MAX_VESA 1
493 #define MAX_EISA 0
494 #define MAX_PCI 0
495 #define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
496 #define MAX_CHANNEL 1
497 #define MAX_LUN 8
498 #define MAX_TARGET 8
499 #define MAX_MAILBOXES 16
500 #define MAX_SGLIST 32
501 #define MAX_SAFE_SGLIST 16
502 #define MAX_INTERNAL_RETRIES 64
503 #define MAX_CMD_PER_LUN 2
504 #define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
505
506 #define SKIP ULONG_MAX
507 #define FALSE 0
508 #define TRUE 1
509 #define FREE 0
510 #define IN_USE   1
511 #define LOCKED   2
512 #define IN_RESET 3
513 #define IGNORE   4
514 #define READY    5
515 #define ABORTING 6
516 #define NO_DMA  0xff
517 #define MAXLOOP  10000
518 #define TAG_DISABLED 0
519 #define TAG_SIMPLE   1
520 #define TAG_ORDERED  2
521
522 #define REG_LCL_MASK      0
523 #define REG_LCL_INTR      1
524 #define REG_SYS_MASK      2
525 #define REG_SYS_INTR      3
526 #define REG_PRODUCT_ID1   4
527 #define REG_PRODUCT_ID2   5
528 #define REG_CONFIG1       6
529 #define REG_CONFIG2       7
530 #define REG_OGM           8
531 #define REG_ICM           12
532 #define REGION_SIZE       13UL
533 #define BSY_ASSERTED      0x01
534 #define IRQ_ASSERTED      0x01
535 #define CMD_RESET         0xc0
536 #define CMD_OGM_INTR      0x01
537 #define CMD_CLR_INTR      0x01
538 #define CMD_ENA_INTR      0x81
539 #define ASOK              0x00
540 #define ASST              0x91
541
542 #define YESNO(a) ((a) ? 'y' : 'n')
543 #define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
544
545 #define PACKED          __attribute__((packed))
546
547 struct sg_list {
548    unsigned int address;                /* Segment Address */
549    unsigned int num_bytes;              /* Segment Length */
550    };
551
552 /* MailBox SCSI Command Packet */
553 struct mscp {
554
555 #if defined(__BIG_ENDIAN_BITFIELD)
556    unsigned char sg:1, ca:1, dcn:1, xdir:2, opcode:3;
557    unsigned char lun: 3, channel:2, target:3;
558 #else
559    unsigned char opcode: 3,             /* type of command */
560                  xdir: 2,               /* data transfer direction */
561                  dcn: 1,                /* disable disconnect */
562                  ca: 1,                 /* use cache (if available) */
563                  sg: 1;                 /* scatter/gather operation */
564    unsigned char target: 3,             /* SCSI target id */
565                  channel: 2,            /* SCSI channel number */
566                  lun: 3;                /* SCSI logical unit number */
567 #endif
568
569    unsigned int data_address PACKED;    /* transfer data pointer */
570    unsigned int data_len PACKED;        /* length in bytes */
571    unsigned int link_address PACKED;    /* for linking command chains */
572    unsigned char clink_id;              /* identifies command in chain */
573    unsigned char use_sg;                /* (if sg is set) 8 bytes per list */
574    unsigned char sense_len;
575    unsigned char cdb_len;               /* 6, 10, or 12 */
576    unsigned char cdb[12];               /* SCSI Command Descriptor Block */
577    unsigned char adapter_status;        /* non-zero indicates HA error */
578    unsigned char target_status;         /* non-zero indicates target error */
579    unsigned int sense_addr PACKED;
580
581    /* Additional fields begin here. */
582    struct scsi_cmnd *SCpnt;
583    unsigned int cpp_index;              /* cp index */
584
585    /* All the cp structure is zero filled by queuecommand except the
586       following CP_TAIL_SIZE bytes, initialized by detect */
587    dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
588    struct sg_list *sglist; /* pointer to the allocated SG list */
589    };
590
591 #define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
592
593 struct hostdata {
594    struct mscp cp[MAX_MAILBOXES];       /* Mailboxes for this board */
595    unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
596    unsigned int last_cp_used;           /* Index of last mailbox used */
597    unsigned int iocount;                /* Total i/o done for this board */
598    int board_number;                    /* Number of this board */
599    char board_name[16];                 /* Name of this board */
600    int in_reset;                        /* True if board is doing a reset */
601    int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
602    int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If TRUE redo i/o on target */
603    unsigned int retries;                /* Number of internal retries */
604    unsigned long last_retried_pid;      /* Pid of last retried command */
605    unsigned char subversion;            /* Bus type, either ISA or ESA */
606    struct pci_dev *pdev;                /* Always NULL */
607    unsigned char heads;
608    unsigned char sectors;
609    char board_id[256];                  /* data from INQUIRY on this board */
610    };
611
612 static struct Scsi_Host *sh[MAX_BOARDS + 1];
613 static const char *driver_name = "Ux4F";
614 static char sha[MAX_BOARDS];
615 static DEFINE_SPINLOCK(driver_lock);
616
617 /* Initialize num_boards so that ihdlr can work while detect is in progress */
618 static unsigned int num_boards = MAX_BOARDS;
619
620 static unsigned long io_port[] = {
621
622    /* Space for MAX_INT_PARAM ports usable while loading as a module */
623    SKIP,    SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,
624    SKIP,    SKIP,
625
626    /* Possible ISA/VESA ports */
627    0x330, 0x340, 0x230, 0x240, 0x210, 0x130, 0x140,
628
629    /* End of list */
630    0x0
631    };
632
633 #define HD(board) ((struct hostdata *) &sh[board]->hostdata)
634 #define BN(board) (HD(board)->board_name)
635
636 /* Device is Little Endian */
637 #define H2DEV(x) cpu_to_le32(x)
638 #define DEV2H(x) le32_to_cpu(x)
639
640 static irqreturn_t do_interrupt_handler(int, void *, struct pt_regs *);
641 static void flush_dev(struct scsi_device *, unsigned long, unsigned int, unsigned int);
642 static int do_trace = FALSE;
643 static int setup_done = FALSE;
644 static int link_statistics;
645 static int ext_tran = FALSE;
646
647 #if defined(HAVE_OLD_UX4F_FIRMWARE)
648 static int have_old_firmware = TRUE;
649 #else
650 static int have_old_firmware = FALSE;
651 #endif
652
653 #if defined(CONFIG_SCSI_U14_34F_TAGGED_QUEUE)
654 static int tag_mode = TAG_SIMPLE;
655 #else
656 static int tag_mode = TAG_DISABLED;
657 #endif
658
659 #if defined(CONFIG_SCSI_U14_34F_LINKED_COMMANDS)
660 static int linked_comm = TRUE;
661 #else
662 static int linked_comm = FALSE;
663 #endif
664
665 #if defined(CONFIG_SCSI_U14_34F_MAX_TAGS)
666 static int max_queue_depth = CONFIG_SCSI_U14_34F_MAX_TAGS;
667 #else
668 static int max_queue_depth = MAX_CMD_PER_LUN;
669 #endif
670
671 #define MAX_INT_PARAM 10
672 #define MAX_BOOT_OPTIONS_SIZE 256
673 static char boot_options[MAX_BOOT_OPTIONS_SIZE];
674
675 #if defined(MODULE)
676 #include <linux/module.h>
677 #include <linux/moduleparam.h>
678
679 module_param_string(u14_34f, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
680 MODULE_PARM_DESC(u14_34f, " equivalent to the \"u14-34f=...\" kernel boot " \
681 "option." \
682 "      Example: modprobe u14-34f \"u14_34f=0x340,0x330,lc:y,tm:0,mq:4\"");
683 MODULE_AUTHOR("Dario Ballabio");
684 MODULE_LICENSE("GPL");
685 MODULE_DESCRIPTION("UltraStor 14F/34F SCSI Driver");
686
687 #endif
688
689 static int u14_34f_slave_configure(struct scsi_device *dev) {
690    int j, tqd, utqd;
691    char *tag_suffix, *link_suffix;
692    struct Scsi_Host *host = dev->host;
693
694    j = ((struct hostdata *) host->hostdata)->board_number;
695
696    utqd = MAX_CMD_PER_LUN;
697    tqd = max_queue_depth;
698
699    if (TLDEV(dev->type) && dev->tagged_supported)
700
701       if (tag_mode == TAG_SIMPLE) {
702          scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
703          tag_suffix = ", simple tags";
704          }
705       else if (tag_mode == TAG_ORDERED) {
706          scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
707          tag_suffix = ", ordered tags";
708          }
709       else {
710          scsi_adjust_queue_depth(dev, 0, tqd);
711          tag_suffix = ", no tags";
712          }
713
714    else if (TLDEV(dev->type) && linked_comm) {
715       scsi_adjust_queue_depth(dev, 0, tqd);
716       tag_suffix = ", untagged";
717       }
718
719    else {
720       scsi_adjust_queue_depth(dev, 0, utqd);
721       tag_suffix = "";
722       }
723
724    if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
725       link_suffix = ", sorted";
726    else if (TLDEV(dev->type))
727       link_suffix = ", unsorted";
728    else
729       link_suffix = "";
730
731    printk("%s: scsi%d, channel %d, id %d, lun %d, cmds/lun %d%s%s.\n",
732           BN(j), host->host_no, dev->channel, dev->id, dev->lun,
733           dev->queue_depth, link_suffix, tag_suffix);
734
735    return FALSE;
736 }
737
738 static int wait_on_busy(unsigned long iobase, unsigned int loop) {
739
740    while (inb(iobase + REG_LCL_INTR) & BSY_ASSERTED) {
741       udelay(1L);
742       if (--loop == 0) return TRUE;
743       }
744
745    return FALSE;
746 }
747
748 static int board_inquiry(unsigned int j) {
749    struct mscp *cpp;
750    dma_addr_t id_dma_addr;
751    unsigned int time, limit = 0;
752
753    id_dma_addr = pci_map_single(HD(j)->pdev, HD(j)->board_id,
754                     sizeof(HD(j)->board_id), PCI_DMA_BIDIRECTIONAL);
755    cpp = &HD(j)->cp[0];
756    cpp->cp_dma_addr = pci_map_single(HD(j)->pdev, cpp, sizeof(struct mscp),
757                                      PCI_DMA_BIDIRECTIONAL);
758    memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
759    cpp->opcode = OP_HOST_ADAPTER;
760    cpp->xdir = DTD_IN;
761    cpp->data_address = H2DEV(id_dma_addr);
762    cpp->data_len = H2DEV(sizeof(HD(j)->board_id));
763    cpp->cdb_len = 6;
764    cpp->cdb[0] = HA_CMD_INQUIRY;
765
766    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
767       printk("%s: board_inquiry, adapter busy.\n", BN(j));
768       return TRUE;
769       }
770
771    HD(j)->cp_stat[0] = IGNORE;
772
773    /* Clear the interrupt indication */
774    outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
775
776    /* Store pointer in OGM address bytes */
777    outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
778
779    /* Issue OGM interrupt */
780    outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
781
782    spin_unlock_irq(&driver_lock);
783    time = jiffies;
784    while ((jiffies - time) < HZ && limit++ < 20000) udelay(100L);
785    spin_lock_irq(&driver_lock);
786
787    if (cpp->adapter_status || HD(j)->cp_stat[0] != FREE) {
788       HD(j)->cp_stat[0] = FREE;
789       printk("%s: board_inquiry, err 0x%x.\n", BN(j), cpp->adapter_status);
790       return TRUE;
791       }
792
793    pci_unmap_single(HD(j)->pdev, cpp->cp_dma_addr, sizeof(struct mscp),
794                     PCI_DMA_BIDIRECTIONAL);
795    pci_unmap_single(HD(j)->pdev, id_dma_addr, sizeof(HD(j)->board_id),
796                     PCI_DMA_BIDIRECTIONAL);
797    return FALSE;
798 }
799
800 static int port_detect \
801       (unsigned long port_base, unsigned int j, struct scsi_host_template *tpnt) {
802    unsigned char irq, dma_channel, subversion, i;
803    unsigned char in_byte;
804    char *bus_type, dma_name[16];
805
806    /* Allowed BIOS base addresses (NULL indicates reserved) */
807    unsigned long bios_segment_table[8] = {
808       0,
809       0xc4000, 0xc8000, 0xcc000, 0xd0000,
810       0xd4000, 0xd8000, 0xdc000
811       };
812
813    /* Allowed IRQs */
814    unsigned char interrupt_table[4] = { 15, 14, 11, 10 };
815
816    /* Allowed DMA channels for ISA (0 indicates reserved) */
817    unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
818
819    /* Head/sector mappings */
820    struct {
821       unsigned char heads;
822       unsigned char sectors;
823       } mapping_table[4] = {
824            { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 }
825            };
826
827    struct config_1 {
828
829 #if defined(__BIG_ENDIAN_BITFIELD)
830       unsigned char dma_channel: 2, interrupt:2,
831                     removable_disks_as_fixed:1, bios_segment: 3;
832 #else
833       unsigned char bios_segment: 3, removable_disks_as_fixed: 1,
834                     interrupt: 2, dma_channel: 2;
835 #endif
836
837       } config_1;
838
839    struct config_2 {
840
841 #if defined(__BIG_ENDIAN_BITFIELD)
842       unsigned char tfr_port: 2, bios_drive_number: 1,
843                     mapping_mode: 2, ha_scsi_id: 3;
844 #else
845       unsigned char ha_scsi_id: 3, mapping_mode: 2,
846                     bios_drive_number: 1, tfr_port: 2;
847 #endif
848
849       } config_2;
850
851    char name[16];
852
853    sprintf(name, "%s%d", driver_name, j);
854
855    if (!request_region(port_base, REGION_SIZE, driver_name)) {
856 #if defined(DEBUG_DETECT)
857       printk("%s: address 0x%03lx in use, skipping probe.\n", name, port_base);
858 #endif
859       goto fail;
860       }
861
862    spin_lock_irq(&driver_lock);
863
864    if (inb(port_base + REG_PRODUCT_ID1) != PRODUCT_ID1) goto freelock;
865
866    in_byte = inb(port_base + REG_PRODUCT_ID2);
867
868    if ((in_byte & 0xf0) != PRODUCT_ID2) goto freelock;
869
870    *(char *)&config_1 = inb(port_base + REG_CONFIG1);
871    *(char *)&config_2 = inb(port_base + REG_CONFIG2);
872
873    irq = interrupt_table[config_1.interrupt];
874    dma_channel = dma_channel_table[config_1.dma_channel];
875    subversion = (in_byte & 0x0f);
876
877    /* Board detected, allocate its IRQ */
878    if (request_irq(irq, do_interrupt_handler,
879              SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0),
880              driver_name, (void *) &sha[j])) {
881       printk("%s: unable to allocate IRQ %u, detaching.\n", name, irq);
882       goto freelock;
883       }
884
885    if (subversion == ISA && request_dma(dma_channel, driver_name)) {
886       printk("%s: unable to allocate DMA channel %u, detaching.\n",
887              name, dma_channel);
888       goto freeirq;
889       }
890
891    if (have_old_firmware) tpnt->use_clustering = DISABLE_CLUSTERING;
892
893    spin_unlock_irq(&driver_lock);
894    sh[j] = scsi_register(tpnt, sizeof(struct hostdata));
895    spin_lock_irq(&driver_lock);
896
897    if (sh[j] == NULL) {
898       printk("%s: unable to register host, detaching.\n", name);
899       goto freedma;
900       }
901
902    sh[j]->io_port = port_base;
903    sh[j]->unique_id = port_base;
904    sh[j]->n_io_port = REGION_SIZE;
905    sh[j]->base = bios_segment_table[config_1.bios_segment];
906    sh[j]->irq = irq;
907    sh[j]->sg_tablesize = MAX_SGLIST;
908    sh[j]->this_id = config_2.ha_scsi_id;
909    sh[j]->can_queue = MAX_MAILBOXES;
910    sh[j]->cmd_per_lun = MAX_CMD_PER_LUN;
911
912 #if defined(DEBUG_DETECT)
913    {
914    unsigned char sys_mask, lcl_mask;
915
916    sys_mask = inb(sh[j]->io_port + REG_SYS_MASK);
917    lcl_mask = inb(sh[j]->io_port + REG_LCL_MASK);
918    printk("SYS_MASK 0x%x, LCL_MASK 0x%x.\n", sys_mask, lcl_mask);
919    }
920 #endif
921
922    /* Probably a bogus host scsi id, set it to the dummy value */
923    if (sh[j]->this_id == 0) sh[j]->this_id = -1;
924
925    /* If BIOS is disabled, force enable interrupts */
926    if (sh[j]->base == 0) outb(CMD_ENA_INTR, sh[j]->io_port + REG_SYS_MASK);
927
928    memset(HD(j), 0, sizeof(struct hostdata));
929    HD(j)->heads = mapping_table[config_2.mapping_mode].heads;
930    HD(j)->sectors = mapping_table[config_2.mapping_mode].sectors;
931    HD(j)->subversion = subversion;
932    HD(j)->pdev = NULL;
933    HD(j)->board_number = j;
934
935    if (have_old_firmware) sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
936
937    if (HD(j)->subversion == ESA) {
938       sh[j]->unchecked_isa_dma = FALSE;
939       sh[j]->dma_channel = NO_DMA;
940       sprintf(BN(j), "U34F%d", j);
941       bus_type = "VESA";
942       }
943    else {
944       unsigned long flags;
945       sh[j]->unchecked_isa_dma = TRUE;
946
947       flags=claim_dma_lock();
948       disable_dma(dma_channel);
949       clear_dma_ff(dma_channel);
950       set_dma_mode(dma_channel, DMA_MODE_CASCADE);
951       enable_dma(dma_channel);
952       release_dma_lock(flags);
953
954       sh[j]->dma_channel = dma_channel;
955       sprintf(BN(j), "U14F%d", j);
956       bus_type = "ISA";
957       }
958
959    sh[j]->max_channel = MAX_CHANNEL - 1;
960    sh[j]->max_id = MAX_TARGET;
961    sh[j]->max_lun = MAX_LUN;
962
963    if (HD(j)->subversion == ISA && !board_inquiry(j)) {
964       HD(j)->board_id[40] = 0;
965
966       if (strcmp(&HD(j)->board_id[32], "06000600")) {
967          printk("%s: %s.\n", BN(j), &HD(j)->board_id[8]);
968          printk("%s: firmware %s is outdated, FW PROM should be 28004-006.\n",
969                 BN(j), &HD(j)->board_id[32]);
970          sh[j]->hostt->use_clustering = DISABLE_CLUSTERING;
971          sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
972          }
973       }
974
975    if (dma_channel == NO_DMA) sprintf(dma_name, "%s", "BMST");
976    else                       sprintf(dma_name, "DMA %u", dma_channel);
977
978    spin_unlock_irq(&driver_lock);
979
980    for (i = 0; i < sh[j]->can_queue; i++)
981       HD(j)->cp[i].cp_dma_addr = pci_map_single(HD(j)->pdev,
982             &HD(j)->cp[i], sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
983
984    for (i = 0; i < sh[j]->can_queue; i++)
985       if (! ((&HD(j)->cp[i])->sglist = kmalloc(
986             sh[j]->sg_tablesize * sizeof(struct sg_list),
987             (sh[j]->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC))) {
988          printk("%s: kmalloc SGlist failed, mbox %d, detaching.\n", BN(j), i);
989          goto release;
990          }
991
992    if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
993        max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
994
995    if (max_queue_depth < MAX_CMD_PER_LUN) max_queue_depth = MAX_CMD_PER_LUN;
996
997    if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
998       tag_mode = TAG_ORDERED;
999
1000    if (j == 0) {
1001       printk("UltraStor 14F/34F: Copyright (C) 1994-2003 Dario Ballabio.\n");
1002       printk("%s config options -> of:%c, tm:%d, lc:%c, mq:%d, et:%c.\n",
1003              driver_name, YESNO(have_old_firmware), tag_mode,
1004              YESNO(linked_comm), max_queue_depth, YESNO(ext_tran));
1005       }
1006
1007    printk("%s: %s 0x%03lx, BIOS 0x%05x, IRQ %u, %s, SG %d, MB %d.\n",
1008           BN(j), bus_type, (unsigned long)sh[j]->io_port, (int)sh[j]->base,
1009           sh[j]->irq, dma_name, sh[j]->sg_tablesize, sh[j]->can_queue);
1010
1011    if (sh[j]->max_id > 8 || sh[j]->max_lun > 8)
1012       printk("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1013              BN(j), sh[j]->max_id, sh[j]->max_lun);
1014
1015    for (i = 0; i <= sh[j]->max_channel; i++)
1016       printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1017              BN(j), i, sh[j]->this_id);
1018
1019    return TRUE;
1020
1021 freedma:
1022    if (subversion == ISA) free_dma(dma_channel);
1023 freeirq:
1024    free_irq(irq, &sha[j]);
1025 freelock:
1026    spin_unlock_irq(&driver_lock);
1027    release_region(port_base, REGION_SIZE);
1028 fail:
1029    return FALSE;
1030
1031 release:
1032    u14_34f_release(sh[j]);
1033    return FALSE;
1034 }
1035
1036 static void internal_setup(char *str, int *ints) {
1037    int i, argc = ints[0];
1038    char *cur = str, *pc;
1039
1040    if (argc > 0) {
1041
1042       if (argc > MAX_INT_PARAM) argc = MAX_INT_PARAM;
1043
1044       for (i = 0; i < argc; i++) io_port[i] = ints[i + 1];
1045
1046       io_port[i] = 0;
1047       setup_done = TRUE;
1048       }
1049
1050    while (cur && (pc = strchr(cur, ':'))) {
1051       int val = 0, c = *++pc;
1052
1053       if (c == 'n' || c == 'N') val = FALSE;
1054       else if (c == 'y' || c == 'Y') val = TRUE;
1055       else val = (int) simple_strtoul(pc, NULL, 0);
1056
1057       if (!strncmp(cur, "lc:", 3)) linked_comm = val;
1058       else if (!strncmp(cur, "of:", 3)) have_old_firmware = val;
1059       else if (!strncmp(cur, "tm:", 3)) tag_mode = val;
1060       else if (!strncmp(cur, "tc:", 3)) tag_mode = val;
1061       else if (!strncmp(cur, "mq:", 3))  max_queue_depth = val;
1062       else if (!strncmp(cur, "ls:", 3))  link_statistics = val;
1063       else if (!strncmp(cur, "et:", 3))  ext_tran = val;
1064
1065       if ((cur = strchr(cur, ','))) ++cur;
1066       }
1067
1068    return;
1069 }
1070
1071 static int option_setup(char *str) {
1072    int ints[MAX_INT_PARAM];
1073    char *cur = str;
1074    int i = 1;
1075
1076    while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
1077       ints[i++] = simple_strtoul(cur, NULL, 0);
1078
1079       if ((cur = strchr(cur, ',')) != NULL) cur++;
1080    }
1081
1082    ints[0] = i - 1;
1083    internal_setup(cur, ints);
1084    return 1;
1085 }
1086
1087 static int u14_34f_detect(struct scsi_host_template *tpnt) {
1088    unsigned int j = 0, k;
1089
1090    tpnt->proc_name = "u14-34f";
1091
1092    if(strlen(boot_options)) option_setup(boot_options);
1093
1094 #if defined(MODULE)
1095    /* io_port could have been modified when loading as a module */
1096    if(io_port[0] != SKIP) {
1097       setup_done = TRUE;
1098       io_port[MAX_INT_PARAM] = 0;
1099       }
1100 #endif
1101
1102    for (k = 0; k < MAX_BOARDS + 1; k++) sh[k] = NULL;
1103
1104    for (k = 0; io_port[k]; k++) {
1105
1106       if (io_port[k] == SKIP) continue;
1107
1108       if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt)) j++;
1109       }
1110
1111    num_boards = j;
1112    return j;
1113 }
1114
1115 static void map_dma(unsigned int i, unsigned int j) {
1116    unsigned int data_len = 0;
1117    unsigned int k, count, pci_dir;
1118    struct scatterlist *sgpnt;
1119    struct mscp *cpp;
1120    struct scsi_cmnd *SCpnt;
1121
1122    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1123    pci_dir = SCpnt->sc_data_direction;
1124
1125    if (SCpnt->sense_buffer)
1126       cpp->sense_addr = H2DEV(pci_map_single(HD(j)->pdev, SCpnt->sense_buffer,
1127                            sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE));
1128
1129    cpp->sense_len = sizeof SCpnt->sense_buffer;
1130
1131    if (!SCpnt->use_sg) {
1132
1133       /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */
1134       if (!SCpnt->request_bufflen) pci_dir = PCI_DMA_BIDIRECTIONAL;
1135
1136       if (SCpnt->request_buffer)
1137          cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev,
1138                   SCpnt->request_buffer, SCpnt->request_bufflen, pci_dir));
1139
1140       cpp->data_len = H2DEV(SCpnt->request_bufflen);
1141       return;
1142       }
1143
1144    sgpnt = (struct scatterlist *) SCpnt->request_buffer;
1145    count = pci_map_sg(HD(j)->pdev, sgpnt, SCpnt->use_sg, pci_dir);
1146
1147    for (k = 0; k < count; k++) {
1148       cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k]));
1149       cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k]));
1150       data_len += sgpnt[k].length;
1151       }
1152
1153    cpp->sg = TRUE;
1154    cpp->use_sg = SCpnt->use_sg;
1155    cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist,
1156                              SCpnt->use_sg * sizeof(struct sg_list), pci_dir));
1157    cpp->data_len = H2DEV(data_len);
1158 }
1159
1160 static void unmap_dma(unsigned int i, unsigned int j) {
1161    unsigned int pci_dir;
1162    struct mscp *cpp;
1163    struct scsi_cmnd *SCpnt;
1164
1165    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1166    pci_dir = SCpnt->sc_data_direction;
1167
1168    if (DEV2H(cpp->sense_addr))
1169       pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
1170                        DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1171
1172    if (SCpnt->use_sg)
1173       pci_unmap_sg(HD(j)->pdev, SCpnt->request_buffer, SCpnt->use_sg, pci_dir);
1174
1175    if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1176
1177    if (DEV2H(cpp->data_address))
1178       pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address),
1179                        DEV2H(cpp->data_len), pci_dir);
1180 }
1181
1182 static void sync_dma(unsigned int i, unsigned int j) {
1183    unsigned int pci_dir;
1184    struct mscp *cpp;
1185    struct scsi_cmnd *SCpnt;
1186
1187    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1188    pci_dir = SCpnt->sc_data_direction;
1189
1190    if (DEV2H(cpp->sense_addr))
1191       pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr),
1192                           DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1193
1194    if (SCpnt->use_sg)
1195       pci_dma_sync_sg_for_cpu(HD(j)->pdev, SCpnt->request_buffer,
1196                          SCpnt->use_sg, pci_dir);
1197
1198    if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1199
1200    if (DEV2H(cpp->data_address))
1201       pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address),
1202                        DEV2H(cpp->data_len), pci_dir);
1203 }
1204
1205 static void scsi_to_dev_dir(unsigned int i, unsigned int j) {
1206    unsigned int k;
1207
1208    static const unsigned char data_out_cmds[] = {
1209       0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1210       0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1211       0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1212       };
1213
1214    static const unsigned char data_none_cmds[] = {
1215       0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1216       0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1217       0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1218       };
1219
1220    struct mscp *cpp;
1221    struct scsi_cmnd *SCpnt;
1222
1223    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1224
1225    if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1226       cpp->xdir = DTD_IN;
1227       return;
1228       }
1229    else if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1230       cpp->xdir = DTD_OUT;
1231       return;
1232       }
1233    else if (SCpnt->sc_data_direction == DMA_NONE) {
1234       cpp->xdir = DTD_NONE;
1235       return;
1236       }
1237
1238    if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1239       panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", BN(j));
1240
1241    cpp->xdir = DTD_IN;
1242
1243    for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1244       if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1245          cpp->xdir = DTD_OUT;
1246          break;
1247          }
1248
1249    if (cpp->xdir == DTD_IN)
1250       for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1251          if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1252             cpp->xdir = DTD_NONE;
1253             break;
1254             }
1255
1256 }
1257
1258 static int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) {
1259    unsigned int i, j, k;
1260    struct mscp *cpp;
1261
1262    /* j is the board number */
1263    j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
1264
1265    if (SCpnt->host_scribble)
1266       panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
1267             BN(j), SCpnt->pid, SCpnt);
1268
1269    /* i is the mailbox number, look for the first free mailbox
1270       starting from last_cp_used */
1271    i = HD(j)->last_cp_used + 1;
1272
1273    for (k = 0; k < sh[j]->can_queue; k++, i++) {
1274
1275       if (i >= sh[j]->can_queue) i = 0;
1276
1277       if (HD(j)->cp_stat[i] == FREE) {
1278          HD(j)->last_cp_used = i;
1279          break;
1280          }
1281       }
1282
1283    if (k == sh[j]->can_queue) {
1284       printk("%s: qcomm, no free mailbox.\n", BN(j));
1285       return 1;
1286       }
1287
1288    /* Set pointer to control packet structure */
1289    cpp = &HD(j)->cp[i];
1290
1291    memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1292    SCpnt->scsi_done = done;
1293    cpp->cpp_index = i;
1294    SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
1295
1296    if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n",
1297                         BN(j), i, SCpnt->device->channel, SCpnt->device->id,
1298                         SCpnt->device->lun, SCpnt->pid);
1299
1300    cpp->opcode = OP_SCSI;
1301    cpp->channel = SCpnt->device->channel;
1302    cpp->target = SCpnt->device->id;
1303    cpp->lun = SCpnt->device->lun;
1304    cpp->SCpnt = SCpnt;
1305    cpp->cdb_len = SCpnt->cmd_len;
1306    memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1307
1308    /* Use data transfer direction SCpnt->sc_data_direction */
1309    scsi_to_dev_dir(i, j);
1310
1311    /* Map DMA buffers and SG list */
1312    map_dma(i, j);
1313
1314    if (linked_comm && SCpnt->device->queue_depth > 2
1315                                      && TLDEV(SCpnt->device->type)) {
1316       HD(j)->cp_stat[i] = READY;
1317       flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE);
1318       return 0;
1319       }
1320
1321    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1322       unmap_dma(i, j);
1323       SCpnt->host_scribble = NULL;
1324       printk("%s: qcomm, target %d.%d:%d, pid %ld, adapter busy.\n",
1325              BN(j), SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, SCpnt->pid);
1326       return 1;
1327       }
1328
1329    /* Store pointer in OGM address bytes */
1330    outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1331
1332    /* Issue OGM interrupt */
1333    outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1334
1335    HD(j)->cp_stat[i] = IN_USE;
1336    return 0;
1337 }
1338
1339 static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
1340    unsigned int i, j;
1341
1342    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1343
1344    if (SCarg->host_scribble == NULL) {
1345       printk("%s: abort, target %d.%d:%d, pid %ld inactive.\n",
1346              BN(j), SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid);
1347       return SUCCESS;
1348       }
1349
1350    i = *(unsigned int *)SCarg->host_scribble;
1351    printk("%s: abort, mbox %d, target %d.%d:%d, pid %ld.\n",
1352           BN(j), i, SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid);
1353
1354    if (i >= sh[j]->can_queue)
1355       panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
1356
1357    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1358       printk("%s: abort, timeout error.\n", BN(j));
1359       return FAILED;
1360       }
1361
1362    if (HD(j)->cp_stat[i] == FREE) {
1363       printk("%s: abort, mbox %d is free.\n", BN(j), i);
1364       return SUCCESS;
1365       }
1366
1367    if (HD(j)->cp_stat[i] == IN_USE) {
1368       printk("%s: abort, mbox %d is in use.\n", BN(j), i);
1369
1370       if (SCarg != HD(j)->cp[i].SCpnt)
1371          panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1372                BN(j), i, SCarg, HD(j)->cp[i].SCpnt);
1373
1374       if (inb(sh[j]->io_port + REG_SYS_INTR) & IRQ_ASSERTED)
1375          printk("%s: abort, mbox %d, interrupt pending.\n", BN(j), i);
1376
1377       if (SCarg->eh_state == SCSI_STATE_TIMEOUT) {
1378          unmap_dma(i, j);
1379          SCarg->host_scribble = NULL;
1380          HD(j)->cp_stat[i] = FREE;
1381          printk("%s, abort, mbox %d, eh_state timeout, pid %ld.\n",
1382                 BN(j), i, SCarg->pid);
1383          return SUCCESS;
1384          }
1385
1386       return FAILED;
1387       }
1388
1389    if (HD(j)->cp_stat[i] == IN_RESET) {
1390       printk("%s: abort, mbox %d is in reset.\n", BN(j), i);
1391       return FAILED;
1392       }
1393
1394    if (HD(j)->cp_stat[i] == LOCKED) {
1395       printk("%s: abort, mbox %d is locked.\n", BN(j), i);
1396       return SUCCESS;
1397       }
1398
1399    if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1400       unmap_dma(i, j);
1401       SCarg->result = DID_ABORT << 16;
1402       SCarg->host_scribble = NULL;
1403       HD(j)->cp_stat[i] = FREE;
1404       printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
1405              BN(j), i, SCarg->pid);
1406       SCarg->scsi_done(SCarg);
1407       return SUCCESS;
1408       }
1409
1410    panic("%s: abort, mbox %d, invalid cp_stat.\n", BN(j), i);
1411 }
1412
1413 static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1414    unsigned int i, j, time, k, c, limit = 0;
1415    int arg_done = FALSE;
1416    struct scsi_cmnd *SCpnt;
1417
1418    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1419    printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n",
1420           BN(j), SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid);
1421
1422    if (SCarg->host_scribble == NULL)
1423       printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->pid);
1424
1425    if (HD(j)->in_reset) {
1426       printk("%s: reset, exit, already in reset.\n", BN(j));
1427       return FAILED;
1428       }
1429
1430    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1431       printk("%s: reset, exit, timeout error.\n", BN(j));
1432       return FAILED;
1433       }
1434
1435    HD(j)->retries = 0;
1436
1437    for (c = 0; c <= sh[j]->max_channel; c++)
1438       for (k = 0; k < sh[j]->max_id; k++) {
1439          HD(j)->target_redo[k][c] = TRUE;
1440          HD(j)->target_to[k][c] = 0;
1441          }
1442
1443    for (i = 0; i < sh[j]->can_queue; i++) {
1444
1445       if (HD(j)->cp_stat[i] == FREE) continue;
1446
1447       if (HD(j)->cp_stat[i] == LOCKED) {
1448          HD(j)->cp_stat[i] = FREE;
1449          printk("%s: reset, locked mbox %d forced free.\n", BN(j), i);
1450          continue;
1451          }
1452
1453       if (!(SCpnt = HD(j)->cp[i].SCpnt))
1454          panic("%s: reset, mbox %d, SCpnt == NULL.\n", BN(j), i);
1455
1456       if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1457          HD(j)->cp_stat[i] = ABORTING;
1458          printk("%s: reset, mbox %d aborting, pid %ld.\n",
1459                 BN(j), i, SCpnt->pid);
1460          }
1461
1462       else {
1463          HD(j)->cp_stat[i] = IN_RESET;
1464          printk("%s: reset, mbox %d in reset, pid %ld.\n",
1465                 BN(j), i, SCpnt->pid);
1466          }
1467
1468       if (SCpnt->host_scribble == NULL)
1469          panic("%s: reset, mbox %d, garbled SCpnt.\n", BN(j), i);
1470
1471       if (*(unsigned int *)SCpnt->host_scribble != i)
1472          panic("%s: reset, mbox %d, index mismatch.\n", BN(j), i);
1473
1474       if (SCpnt->scsi_done == NULL)
1475          panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", BN(j), i);
1476
1477       if (SCpnt == SCarg) arg_done = TRUE;
1478       }
1479
1480    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1481       printk("%s: reset, cannot reset, timeout error.\n", BN(j));
1482       return FAILED;
1483       }
1484
1485    outb(CMD_RESET, sh[j]->io_port + REG_LCL_INTR);
1486    printk("%s: reset, board reset done, enabling interrupts.\n", BN(j));
1487
1488 #if defined(DEBUG_RESET)
1489    do_trace = TRUE;
1490 #endif
1491
1492    HD(j)->in_reset = TRUE;
1493
1494    spin_unlock_irq(sh[j]->host_lock);
1495    time = jiffies;
1496    while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L);
1497    spin_lock_irq(sh[j]->host_lock);
1498
1499    printk("%s: reset, interrupts disabled, loops %d.\n", BN(j), limit);
1500
1501    for (i = 0; i < sh[j]->can_queue; i++) {
1502
1503       if (HD(j)->cp_stat[i] == IN_RESET) {
1504          SCpnt = HD(j)->cp[i].SCpnt;
1505          unmap_dma(i, j);
1506          SCpnt->result = DID_RESET << 16;
1507          SCpnt->host_scribble = NULL;
1508
1509          /* This mailbox is still waiting for its interrupt */
1510          HD(j)->cp_stat[i] = LOCKED;
1511
1512          printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
1513                 BN(j), i, SCpnt->pid);
1514          }
1515
1516       else if (HD(j)->cp_stat[i] == ABORTING) {
1517          SCpnt = HD(j)->cp[i].SCpnt;
1518          unmap_dma(i, j);
1519          SCpnt->result = DID_RESET << 16;
1520          SCpnt->host_scribble = NULL;
1521
1522          /* This mailbox was never queued to the adapter */
1523          HD(j)->cp_stat[i] = FREE;
1524
1525          printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
1526                 BN(j), i, SCpnt->pid);
1527          }
1528
1529       else
1530
1531          /* Any other mailbox has already been set free by interrupt */
1532          continue;
1533
1534       SCpnt->scsi_done(SCpnt);
1535       }
1536
1537    HD(j)->in_reset = FALSE;
1538    do_trace = FALSE;
1539
1540    if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->pid);
1541    else          printk("%s: reset, exit.\n", BN(j));
1542
1543    return SUCCESS;
1544 }
1545
1546 static int u14_34f_bios_param(struct scsi_device *disk,
1547                  struct block_device *bdev, sector_t capacity, int *dkinfo) {
1548    unsigned int j = 0;
1549    unsigned int size = capacity;
1550
1551    dkinfo[0] = HD(j)->heads;
1552    dkinfo[1] = HD(j)->sectors;
1553    dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
1554
1555    if (ext_tran && (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
1556       dkinfo[0] = 255;
1557       dkinfo[1] = 63;
1558       dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
1559       }
1560
1561 #if defined (DEBUG_GEOMETRY)
1562    printk ("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
1563            dkinfo[0], dkinfo[1], dkinfo[2]);
1564 #endif
1565
1566    return FALSE;
1567 }
1568
1569 static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
1570                  unsigned int rev) {
1571    unsigned int i, j, k, y;
1572    unsigned long x;
1573
1574    for (i = 0; i < n - 1; i++) {
1575       k = i;
1576
1577       for (j = k + 1; j < n; j++)
1578          if (rev) {
1579             if (sk[j] > sk[k]) k = j;
1580             }
1581          else {
1582             if (sk[j] < sk[k]) k = j;
1583             }
1584
1585       if (k != i) {
1586          x = sk[k]; sk[k] = sk[i]; sk[i] = x;
1587          y = da[k]; da[k] = da[i]; da[i] = y;
1588          }
1589       }
1590
1591    return;
1592    }
1593
1594 static int reorder(unsigned int j, unsigned long cursec,
1595                  unsigned int ihdlr, unsigned int il[], unsigned int n_ready) {
1596    struct scsi_cmnd *SCpnt;
1597    struct mscp *cpp;
1598    unsigned int k, n;
1599    unsigned int rev = FALSE, s = TRUE, r = TRUE;
1600    unsigned int input_only = TRUE, overlap = FALSE;
1601    unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
1602    unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
1603    unsigned long ioseek = 0;
1604
1605    static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
1606    static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
1607    static unsigned int readysorted = 0, revcount = 0;
1608    static unsigned long seeksorted = 0, seeknosort = 0;
1609
1610    if (link_statistics && !(++flushcount % link_statistics))
1611       printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"\
1612              " av %ldK as %ldK.\n", flushcount, batchcount, inputcount,
1613              ovlcount, readycount, readysorted, sortcount, revcount,
1614              seeknosort / (readycount + 1),
1615              seeksorted / (readycount + 1));
1616
1617    if (n_ready <= 1) return FALSE;
1618
1619    for (n = 0; n < n_ready; n++) {
1620       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1621
1622       if (!(cpp->xdir == DTD_IN)) input_only = FALSE;
1623
1624       if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector;
1625       if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector;
1626
1627       sl[n] = SCpnt->request->sector;
1628       ioseek += SCpnt->request->nr_sectors;
1629
1630       if (!n) continue;
1631
1632       if (sl[n] < sl[n - 1]) s = FALSE;
1633       if (sl[n] > sl[n - 1]) r = FALSE;
1634
1635       if (link_statistics) {
1636          if (sl[n] > sl[n - 1])
1637             seek += sl[n] - sl[n - 1];
1638          else
1639             seek += sl[n - 1] - sl[n];
1640          }
1641
1642       }
1643
1644    if (link_statistics) {
1645       if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec;
1646       }
1647
1648    if (cursec > ((maxsec + minsec) / 2)) rev = TRUE;
1649
1650    if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE;
1651
1652    if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev);
1653
1654    if (!input_only) for (n = 0; n < n_ready; n++) {
1655       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1656       ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->pid;
1657
1658       if (!n) continue;
1659
1660       if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
1661           || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE;
1662       }
1663
1664    if (overlap) sort(pl, il, n_ready, FALSE);
1665
1666    if (link_statistics) {
1667       if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec;
1668       batchcount++; readycount += n_ready; seeknosort += seek / 1024;
1669       if (input_only) inputcount++;
1670       if (overlap) { ovlcount++; seeksorted += iseek / 1024; }
1671       else seeksorted += (iseek + maxsec - minsec) / 1024;
1672       if (rev && !r)     {  revcount++; readysorted += n_ready; }
1673       if (!rev && !s)    { sortcount++; readysorted += n_ready; }
1674       }
1675
1676 #if defined(DEBUG_LINKED_COMMANDS)
1677    if (link_statistics && (overlap || !(flushcount % link_statistics)))
1678       for (n = 0; n < n_ready; n++) {
1679          k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1680          printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\
1681                 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
1682                 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
1683                 SCpnt->lun, SCpnt->pid, k, flushcount, n_ready,
1684                 SCpnt->request->sector, SCpnt->request->nr_sectors, cursec,
1685                 YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
1686                 YESNO(overlap), cpp->xdir);
1687          }
1688 #endif
1689    return overlap;
1690 }
1691
1692 static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned int j,
1693                       unsigned int ihdlr) {
1694    struct scsi_cmnd *SCpnt;
1695    struct mscp *cpp;
1696    unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
1697
1698    for (k = 0; k < sh[j]->can_queue; k++) {
1699
1700       if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue;
1701
1702       cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1703
1704       if (SCpnt->device != dev) continue;
1705
1706       if (HD(j)->cp_stat[k] == IN_USE) return;
1707
1708       il[n_ready++] = k;
1709       }
1710
1711    if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1;
1712
1713    for (n = 0; n < n_ready; n++) {
1714       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1715
1716       if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1717          printk("%s: %s, target %d.%d:%d, pid %ld, mbox %d, adapter"\
1718                 " busy, will abort.\n", BN(j), (ihdlr ? "ihdlr" : "qcomm"),
1719                 SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, SCpnt->pid, k);
1720          HD(j)->cp_stat[k] = ABORTING;
1721          continue;
1722          }
1723
1724       outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1725       outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1726       HD(j)->cp_stat[k] = IN_USE;
1727       }
1728
1729 }
1730
1731 static irqreturn_t ihdlr(int irq, unsigned int j) {
1732    struct scsi_cmnd *SCpnt;
1733    unsigned int i, k, c, status, tstatus, reg, ret;
1734    struct mscp *spp, *cpp;
1735
1736    if (sh[j]->irq != irq)
1737        panic("%s: ihdlr, irq %d, sh[j]->irq %d.\n", BN(j), irq, sh[j]->irq);
1738
1739    /* Check if this board need to be serviced */
1740    if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none;
1741
1742    HD(j)->iocount++;
1743
1744    if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.\n", BN(j), irq,
1745                         HD(j)->iocount);
1746
1747    /* Check if this board is still busy */
1748    if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) {
1749       outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1750       printk("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.\n",
1751              BN(j), irq, reg, HD(j)->iocount);
1752       goto none;
1753       }
1754
1755    ret = inl(sh[j]->io_port + REG_ICM);
1756
1757    /* Clear interrupt pending flag */
1758    outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1759
1760    /* Find the mailbox to be serviced on this board */
1761    for (i = 0; i < sh[j]->can_queue; i++)
1762       if (H2DEV(HD(j)->cp[i].cp_dma_addr) == ret) break;
1763
1764    if (i >= sh[j]->can_queue)
1765       panic("%s: ihdlr, invalid mscp bus address %p, cp0 %p.\n", BN(j),
1766             (void *)ret, (void *)H2DEV(HD(j)->cp[0].cp_dma_addr));
1767
1768    cpp = &(HD(j)->cp[i]);
1769    spp = cpp;
1770
1771 #if defined(DEBUG_GENERATE_ABORTS)
1772    if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) goto handled;
1773 #endif
1774
1775    if (HD(j)->cp_stat[i] == IGNORE) {
1776       HD(j)->cp_stat[i] = FREE;
1777       goto handled;
1778       }
1779    else if (HD(j)->cp_stat[i] == LOCKED) {
1780       HD(j)->cp_stat[i] = FREE;
1781       printk("%s: ihdlr, mbox %d unlocked, count %d.\n", BN(j), i,
1782              HD(j)->iocount);
1783       goto handled;
1784       }
1785    else if (HD(j)->cp_stat[i] == FREE) {
1786       printk("%s: ihdlr, mbox %d is free, count %d.\n", BN(j), i,
1787              HD(j)->iocount);
1788       goto handled;
1789       }
1790    else if (HD(j)->cp_stat[i] == IN_RESET)
1791       printk("%s: ihdlr, mbox %d is in reset.\n", BN(j), i);
1792    else if (HD(j)->cp_stat[i] != IN_USE)
1793       panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
1794             BN(j), i, HD(j)->cp_stat[i]);
1795
1796    HD(j)->cp_stat[i] = FREE;
1797    SCpnt = cpp->SCpnt;
1798
1799    if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
1800
1801    if (SCpnt->host_scribble == NULL)
1802       panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i,
1803             SCpnt->pid, SCpnt);
1804
1805    if (*(unsigned int *)SCpnt->host_scribble != i)
1806       panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
1807             BN(j), i, SCpnt->pid, *(unsigned int *)SCpnt->host_scribble);
1808
1809    sync_dma(i, j);
1810
1811    if (linked_comm && SCpnt->device->queue_depth > 2
1812                                      && TLDEV(SCpnt->device->type))
1813       flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE);
1814
1815    tstatus = status_byte(spp->target_status);
1816
1817 #if defined(DEBUG_GENERATE_ERRORS)
1818    if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2))
1819                                            spp->adapter_status = 0x01;
1820 #endif
1821
1822    switch (spp->adapter_status) {
1823       case ASOK:     /* status OK */
1824
1825          /* Forces a reset if a disk drive keeps returning BUSY */
1826          if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
1827             status = DID_ERROR << 16;
1828
1829          /* If there was a bus reset, redo operation on each target */
1830          else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
1831                   && HD(j)->target_redo[SCpnt->device->id][SCpnt->device->channel])
1832             status = DID_BUS_BUSY << 16;
1833
1834          /* Works around a flaw in scsi.c */
1835          else if (tstatus == CHECK_CONDITION
1836                   && SCpnt->device->type == TYPE_DISK
1837                   && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
1838             status = DID_BUS_BUSY << 16;
1839
1840          else
1841             status = DID_OK << 16;
1842
1843          if (tstatus == GOOD)
1844             HD(j)->target_redo[SCpnt->device->id][SCpnt->device->channel] = FALSE;
1845
1846          if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
1847              (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
1848                (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
1849             printk("%s: ihdlr, target %d.%d:%d, pid %ld, "\
1850                    "target_status 0x%x, sense key 0x%x.\n", BN(j),
1851                    SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun,
1852                    SCpnt->pid, spp->target_status,
1853                    SCpnt->sense_buffer[2]);
1854
1855          HD(j)->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
1856
1857          if (HD(j)->last_retried_pid == SCpnt->pid) HD(j)->retries = 0;
1858
1859          break;
1860       case ASST:     /* Selection Time Out */
1861
1862          if (HD(j)->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
1863             status = DID_ERROR << 16;
1864          else {
1865             status = DID_TIME_OUT << 16;
1866             HD(j)->target_to[SCpnt->device->id][SCpnt->device->channel]++;
1867             }
1868
1869          break;
1870
1871       /* Perform a limited number of internal retries */
1872       case 0x93:     /* Unexpected bus free */
1873       case 0x94:     /* Target bus phase sequence failure */
1874       case 0x96:     /* Illegal SCSI command */
1875       case 0xa3:     /* SCSI bus reset error */
1876
1877          for (c = 0; c <= sh[j]->max_channel; c++)
1878             for (k = 0; k < sh[j]->max_id; k++)
1879                HD(j)->target_redo[k][c] = TRUE;
1880
1881
1882       case 0x92:     /* Data over/under-run */
1883
1884          if (SCpnt->device->type != TYPE_TAPE
1885              && HD(j)->retries < MAX_INTERNAL_RETRIES) {
1886
1887 #if defined(DID_SOFT_ERROR)
1888             status = DID_SOFT_ERROR << 16;
1889 #else
1890             status = DID_BUS_BUSY << 16;
1891 #endif
1892
1893             HD(j)->retries++;
1894             HD(j)->last_retried_pid = SCpnt->pid;
1895             }
1896          else
1897             status = DID_ERROR << 16;
1898
1899          break;
1900       case 0x01:     /* Invalid command */
1901       case 0x02:     /* Invalid parameters */
1902       case 0x03:     /* Invalid data list */
1903       case 0x84:     /* SCSI bus abort error */
1904       case 0x9b:     /* Auto request sense error */
1905       case 0x9f:     /* Unexpected command complete message error */
1906       case 0xff:     /* Invalid parameter in the S/G list */
1907       default:
1908          status = DID_ERROR << 16;
1909          break;
1910       }
1911
1912    SCpnt->result = status | spp->target_status;
1913
1914 #if defined(DEBUG_INTERRUPT)
1915    if (SCpnt->result || do_trace)
1916 #else
1917    if ((spp->adapter_status != ASOK && HD(j)->iocount >  1000) ||
1918        (spp->adapter_status != ASOK &&
1919         spp->adapter_status != ASST && HD(j)->iocount <= 1000) ||
1920         do_trace || msg_byte(spp->target_status))
1921 #endif
1922       printk("%s: ihdlr, mbox %2d, err 0x%x:%x,"\
1923              " target %d.%d:%d, pid %ld, reg 0x%x, count %d.\n",
1924              BN(j), i, spp->adapter_status, spp->target_status,
1925              SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, SCpnt->pid,
1926              reg, HD(j)->iocount);
1927
1928    unmap_dma(i, j);
1929
1930    /* Set the command state to inactive */
1931    SCpnt->host_scribble = NULL;
1932
1933    SCpnt->scsi_done(SCpnt);
1934
1935    if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.\n", BN(j), irq,
1936                         HD(j)->iocount);
1937
1938 handled:
1939    return IRQ_HANDLED;
1940 none:
1941    return IRQ_NONE;
1942 }
1943
1944 static irqreturn_t do_interrupt_handler(int irq, void *shap,
1945                                         struct pt_regs *regs) {
1946    unsigned int j;
1947    unsigned long spin_flags;
1948    irqreturn_t ret;
1949
1950    /* Check if the interrupt must be processed by this handler */
1951    if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE;
1952
1953    spin_lock_irqsave(sh[j]->host_lock, spin_flags);
1954    ret = ihdlr(irq, j);
1955    spin_unlock_irqrestore(sh[j]->host_lock, spin_flags);
1956    return ret;
1957 }
1958
1959 static int u14_34f_release(struct Scsi_Host *shpnt) {
1960    unsigned int i, j;
1961
1962    for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++);
1963
1964    if (sh[j] == NULL) panic("%s: release, invalid Scsi_Host pointer.\n",
1965                             driver_name);
1966
1967    for (i = 0; i < sh[j]->can_queue; i++)
1968       if ((&HD(j)->cp[i])->sglist) kfree((&HD(j)->cp[i])->sglist);
1969
1970    for (i = 0; i < sh[j]->can_queue; i++)
1971       pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr,
1972                      sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
1973
1974    free_irq(sh[j]->irq, &sha[j]);
1975
1976    if (sh[j]->dma_channel != NO_DMA) free_dma(sh[j]->dma_channel);
1977
1978    release_region(sh[j]->io_port, sh[j]->n_io_port);
1979    scsi_unregister(sh[j]);
1980    return FALSE;
1981 }
1982
1983 #include "scsi_module.c"
1984
1985 #ifndef MODULE
1986 __setup("u14-34f=", option_setup);
1987 #endif /* end MODULE */