Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid
[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 struct 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/string.h>
409 #include <linux/kernel.h>
410 #include <linux/ioport.h>
411 #include <linux/delay.h>
412 #include <asm/io.h>
413 #include <asm/system.h>
414 #include <asm/byteorder.h>
415 #include <linux/proc_fs.h>
416 #include <linux/blkdev.h>
417 #include <linux/interrupt.h>
418 #include <linux/stat.h>
419 #include <linux/pci.h>
420 #include <linux/init.h>
421 #include <linux/ctype.h>
422 #include <linux/spinlock.h>
423 #include <asm/dma.h>
424 #include <asm/irq.h>
425
426 #include <scsi/scsi.h>
427 #include <scsi/scsi_cmnd.h>
428 #include <scsi/scsi_device.h>
429 #include <scsi/scsi_host.h>
430 #include <scsi/scsi_tcq.h>
431 #include <scsi/scsicam.h>
432
433 static int u14_34f_detect(struct scsi_host_template *);
434 static int u14_34f_release(struct Scsi_Host *);
435 static int u14_34f_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *));
436 static int u14_34f_eh_abort(struct scsi_cmnd *);
437 static int u14_34f_eh_host_reset(struct scsi_cmnd *);
438 static int u14_34f_bios_param(struct scsi_device *, struct block_device *,
439                               sector_t, int *);
440 static int u14_34f_slave_configure(struct scsi_device *);
441
442 static struct scsi_host_template driver_template = {
443                 .name                    = "UltraStor 14F/34F rev. 8.10.00 ",
444                 .detect                  = u14_34f_detect,
445                 .release                 = u14_34f_release,
446                 .queuecommand            = u14_34f_queuecommand,
447                 .eh_abort_handler        = u14_34f_eh_abort,
448                 .eh_host_reset_handler   = u14_34f_eh_host_reset,
449                 .bios_param              = u14_34f_bios_param,
450                 .slave_configure         = u14_34f_slave_configure,
451                 .this_id                 = 7,
452                 .unchecked_isa_dma       = 1,
453                 .use_clustering          = ENABLE_CLUSTERING
454                 };
455
456 #if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
457 #error "Adjust your <asm/byteorder.h> defines"
458 #endif
459
460 /* Values for the PRODUCT_ID ports for the 14/34F */
461 #define PRODUCT_ID1  0x56
462 #define PRODUCT_ID2  0x40        /* NOTE: Only upper nibble is used */
463
464 /* Subversion values */
465 #define ISA  0
466 #define ESA 1
467
468 #define OP_HOST_ADAPTER   0x1
469 #define OP_SCSI           0x2
470 #define OP_RESET          0x4
471 #define DTD_SCSI          0x0
472 #define DTD_IN            0x1
473 #define DTD_OUT           0x2
474 #define DTD_NONE          0x3
475 #define HA_CMD_INQUIRY    0x1
476 #define HA_CMD_SELF_DIAG  0x2
477 #define HA_CMD_READ_BUFF  0x3
478 #define HA_CMD_WRITE_BUFF 0x4
479
480 #undef  DEBUG_LINKED_COMMANDS
481 #undef  DEBUG_DETECT
482 #undef  DEBUG_INTERRUPT
483 #undef  DEBUG_RESET
484 #undef  DEBUG_GENERATE_ERRORS
485 #undef  DEBUG_GENERATE_ABORTS
486 #undef  DEBUG_GEOMETRY
487
488 #define MAX_ISA 3
489 #define MAX_VESA 1
490 #define MAX_EISA 0
491 #define MAX_PCI 0
492 #define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
493 #define MAX_CHANNEL 1
494 #define MAX_LUN 8
495 #define MAX_TARGET 8
496 #define MAX_MAILBOXES 16
497 #define MAX_SGLIST 32
498 #define MAX_SAFE_SGLIST 16
499 #define MAX_INTERNAL_RETRIES 64
500 #define MAX_CMD_PER_LUN 2
501 #define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
502
503 #define SKIP ULONG_MAX
504 #define FALSE 0
505 #define TRUE 1
506 #define FREE 0
507 #define IN_USE   1
508 #define LOCKED   2
509 #define IN_RESET 3
510 #define IGNORE   4
511 #define READY    5
512 #define ABORTING 6
513 #define NO_DMA  0xff
514 #define MAXLOOP  10000
515 #define TAG_DISABLED 0
516 #define TAG_SIMPLE   1
517 #define TAG_ORDERED  2
518
519 #define REG_LCL_MASK      0
520 #define REG_LCL_INTR      1
521 #define REG_SYS_MASK      2
522 #define REG_SYS_INTR      3
523 #define REG_PRODUCT_ID1   4
524 #define REG_PRODUCT_ID2   5
525 #define REG_CONFIG1       6
526 #define REG_CONFIG2       7
527 #define REG_OGM           8
528 #define REG_ICM           12
529 #define REGION_SIZE       13UL
530 #define BSY_ASSERTED      0x01
531 #define IRQ_ASSERTED      0x01
532 #define CMD_RESET         0xc0
533 #define CMD_OGM_INTR      0x01
534 #define CMD_CLR_INTR      0x01
535 #define CMD_ENA_INTR      0x81
536 #define ASOK              0x00
537 #define ASST              0x91
538
539 #define YESNO(a) ((a) ? 'y' : 'n')
540 #define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
541
542 #define PACKED          __attribute__((packed))
543
544 struct sg_list {
545    unsigned int address;                /* Segment Address */
546    unsigned int num_bytes;              /* Segment Length */
547    };
548
549 /* MailBox SCSI Command Packet */
550 struct mscp {
551
552 #if defined(__BIG_ENDIAN_BITFIELD)
553    unsigned char sg:1, ca:1, dcn:1, xdir:2, opcode:3;
554    unsigned char lun: 3, channel:2, target:3;
555 #else
556    unsigned char opcode: 3,             /* type of command */
557                  xdir: 2,               /* data transfer direction */
558                  dcn: 1,                /* disable disconnect */
559                  ca: 1,                 /* use cache (if available) */
560                  sg: 1;                 /* scatter/gather operation */
561    unsigned char target: 3,             /* SCSI target id */
562                  channel: 2,            /* SCSI channel number */
563                  lun: 3;                /* SCSI logical unit number */
564 #endif
565
566    unsigned int data_address PACKED;    /* transfer data pointer */
567    unsigned int data_len PACKED;        /* length in bytes */
568    unsigned int link_address PACKED;    /* for linking command chains */
569    unsigned char clink_id;              /* identifies command in chain */
570    unsigned char use_sg;                /* (if sg is set) 8 bytes per list */
571    unsigned char sense_len;
572    unsigned char cdb_len;               /* 6, 10, or 12 */
573    unsigned char cdb[12];               /* SCSI Command Descriptor Block */
574    unsigned char adapter_status;        /* non-zero indicates HA error */
575    unsigned char target_status;         /* non-zero indicates target error */
576    unsigned int sense_addr PACKED;
577
578    /* Additional fields begin here. */
579    struct scsi_cmnd *SCpnt;
580    unsigned int cpp_index;              /* cp index */
581
582    /* All the cp structure is zero filled by queuecommand except the
583       following CP_TAIL_SIZE bytes, initialized by detect */
584    dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
585    struct sg_list *sglist; /* pointer to the allocated SG list */
586    };
587
588 #define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
589
590 struct hostdata {
591    struct mscp cp[MAX_MAILBOXES];       /* Mailboxes for this board */
592    unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
593    unsigned int last_cp_used;           /* Index of last mailbox used */
594    unsigned int iocount;                /* Total i/o done for this board */
595    int board_number;                    /* Number of this board */
596    char board_name[16];                 /* Name of this board */
597    int in_reset;                        /* True if board is doing a reset */
598    int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
599    int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If TRUE redo i/o on target */
600    unsigned int retries;                /* Number of internal retries */
601    unsigned long last_retried_pid;      /* Pid of last retried command */
602    unsigned char subversion;            /* Bus type, either ISA or ESA */
603    struct pci_dev *pdev;                /* Always NULL */
604    unsigned char heads;
605    unsigned char sectors;
606    char board_id[256];                  /* data from INQUIRY on this board */
607    };
608
609 static struct Scsi_Host *sh[MAX_BOARDS + 1];
610 static const char *driver_name = "Ux4F";
611 static char sha[MAX_BOARDS];
612 static DEFINE_SPINLOCK(driver_lock);
613
614 /* Initialize num_boards so that ihdlr can work while detect is in progress */
615 static unsigned int num_boards = MAX_BOARDS;
616
617 static unsigned long io_port[] = {
618
619    /* Space for MAX_INT_PARAM ports usable while loading as a module */
620    SKIP,    SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,
621    SKIP,    SKIP,
622
623    /* Possible ISA/VESA ports */
624    0x330, 0x340, 0x230, 0x240, 0x210, 0x130, 0x140,
625
626    /* End of list */
627    0x0
628    };
629
630 #define HD(board) ((struct hostdata *) &sh[board]->hostdata)
631 #define BN(board) (HD(board)->board_name)
632
633 /* Device is Little Endian */
634 #define H2DEV(x) cpu_to_le32(x)
635 #define DEV2H(x) le32_to_cpu(x)
636
637 static irqreturn_t do_interrupt_handler(int, void *);
638 static void flush_dev(struct scsi_device *, unsigned long, unsigned int, unsigned int);
639 static int do_trace = FALSE;
640 static int setup_done = FALSE;
641 static int link_statistics;
642 static int ext_tran = FALSE;
643
644 #if defined(HAVE_OLD_UX4F_FIRMWARE)
645 static int have_old_firmware = TRUE;
646 #else
647 static int have_old_firmware = FALSE;
648 #endif
649
650 #if defined(CONFIG_SCSI_U14_34F_TAGGED_QUEUE)
651 static int tag_mode = TAG_SIMPLE;
652 #else
653 static int tag_mode = TAG_DISABLED;
654 #endif
655
656 #if defined(CONFIG_SCSI_U14_34F_LINKED_COMMANDS)
657 static int linked_comm = TRUE;
658 #else
659 static int linked_comm = FALSE;
660 #endif
661
662 #if defined(CONFIG_SCSI_U14_34F_MAX_TAGS)
663 static int max_queue_depth = CONFIG_SCSI_U14_34F_MAX_TAGS;
664 #else
665 static int max_queue_depth = MAX_CMD_PER_LUN;
666 #endif
667
668 #define MAX_INT_PARAM 10
669 #define MAX_BOOT_OPTIONS_SIZE 256
670 static char boot_options[MAX_BOOT_OPTIONS_SIZE];
671
672 #if defined(MODULE)
673 #include <linux/module.h>
674 #include <linux/moduleparam.h>
675
676 module_param_string(u14_34f, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
677 MODULE_PARM_DESC(u14_34f, " equivalent to the \"u14-34f=...\" kernel boot " \
678 "option." \
679 "      Example: modprobe u14-34f \"u14_34f=0x340,0x330,lc:y,tm:0,mq:4\"");
680 MODULE_AUTHOR("Dario Ballabio");
681 MODULE_LICENSE("GPL");
682 MODULE_DESCRIPTION("UltraStor 14F/34F SCSI Driver");
683
684 #endif
685
686 static int u14_34f_slave_configure(struct scsi_device *dev) {
687    int j, tqd, utqd;
688    char *tag_suffix, *link_suffix;
689    struct Scsi_Host *host = dev->host;
690
691    j = ((struct hostdata *) host->hostdata)->board_number;
692
693    utqd = MAX_CMD_PER_LUN;
694    tqd = max_queue_depth;
695
696    if (TLDEV(dev->type) && dev->tagged_supported)
697
698       if (tag_mode == TAG_SIMPLE) {
699          scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
700          tag_suffix = ", simple tags";
701          }
702       else if (tag_mode == TAG_ORDERED) {
703          scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
704          tag_suffix = ", ordered tags";
705          }
706       else {
707          scsi_adjust_queue_depth(dev, 0, tqd);
708          tag_suffix = ", no tags";
709          }
710
711    else if (TLDEV(dev->type) && linked_comm) {
712       scsi_adjust_queue_depth(dev, 0, tqd);
713       tag_suffix = ", untagged";
714       }
715
716    else {
717       scsi_adjust_queue_depth(dev, 0, utqd);
718       tag_suffix = "";
719       }
720
721    if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
722       link_suffix = ", sorted";
723    else if (TLDEV(dev->type))
724       link_suffix = ", unsorted";
725    else
726       link_suffix = "";
727
728    sdev_printk(KERN_INFO, dev, "cmds/lun %d%s%s.\n",
729           dev->queue_depth, link_suffix, tag_suffix);
730
731    return FALSE;
732 }
733
734 static int wait_on_busy(unsigned long iobase, unsigned int loop) {
735
736    while (inb(iobase + REG_LCL_INTR) & BSY_ASSERTED) {
737       udelay(1L);
738       if (--loop == 0) return TRUE;
739       }
740
741    return FALSE;
742 }
743
744 static int board_inquiry(unsigned int j) {
745    struct mscp *cpp;
746    dma_addr_t id_dma_addr;
747    unsigned int time, limit = 0;
748
749    id_dma_addr = pci_map_single(HD(j)->pdev, HD(j)->board_id,
750                     sizeof(HD(j)->board_id), PCI_DMA_BIDIRECTIONAL);
751    cpp = &HD(j)->cp[0];
752    cpp->cp_dma_addr = pci_map_single(HD(j)->pdev, cpp, sizeof(struct mscp),
753                                      PCI_DMA_BIDIRECTIONAL);
754    memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
755    cpp->opcode = OP_HOST_ADAPTER;
756    cpp->xdir = DTD_IN;
757    cpp->data_address = H2DEV(id_dma_addr);
758    cpp->data_len = H2DEV(sizeof(HD(j)->board_id));
759    cpp->cdb_len = 6;
760    cpp->cdb[0] = HA_CMD_INQUIRY;
761
762    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
763       printk("%s: board_inquiry, adapter busy.\n", BN(j));
764       return TRUE;
765       }
766
767    HD(j)->cp_stat[0] = IGNORE;
768
769    /* Clear the interrupt indication */
770    outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
771
772    /* Store pointer in OGM address bytes */
773    outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
774
775    /* Issue OGM interrupt */
776    outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
777
778    spin_unlock_irq(&driver_lock);
779    time = jiffies;
780    while ((jiffies - time) < HZ && limit++ < 20000) udelay(100L);
781    spin_lock_irq(&driver_lock);
782
783    if (cpp->adapter_status || HD(j)->cp_stat[0] != FREE) {
784       HD(j)->cp_stat[0] = FREE;
785       printk("%s: board_inquiry, err 0x%x.\n", BN(j), cpp->adapter_status);
786       return TRUE;
787       }
788
789    pci_unmap_single(HD(j)->pdev, cpp->cp_dma_addr, sizeof(struct mscp),
790                     PCI_DMA_BIDIRECTIONAL);
791    pci_unmap_single(HD(j)->pdev, id_dma_addr, sizeof(HD(j)->board_id),
792                     PCI_DMA_BIDIRECTIONAL);
793    return FALSE;
794 }
795
796 static int port_detect \
797       (unsigned long port_base, unsigned int j, struct scsi_host_template *tpnt) {
798    unsigned char irq, dma_channel, subversion, i;
799    unsigned char in_byte;
800    char *bus_type, dma_name[16];
801
802    /* Allowed BIOS base addresses (NULL indicates reserved) */
803    unsigned long bios_segment_table[8] = {
804       0,
805       0xc4000, 0xc8000, 0xcc000, 0xd0000,
806       0xd4000, 0xd8000, 0xdc000
807       };
808
809    /* Allowed IRQs */
810    unsigned char interrupt_table[4] = { 15, 14, 11, 10 };
811
812    /* Allowed DMA channels for ISA (0 indicates reserved) */
813    unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
814
815    /* Head/sector mappings */
816    struct {
817       unsigned char heads;
818       unsigned char sectors;
819       } mapping_table[4] = {
820            { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 }
821            };
822
823    struct config_1 {
824
825 #if defined(__BIG_ENDIAN_BITFIELD)
826       unsigned char dma_channel: 2, interrupt:2,
827                     removable_disks_as_fixed:1, bios_segment: 3;
828 #else
829       unsigned char bios_segment: 3, removable_disks_as_fixed: 1,
830                     interrupt: 2, dma_channel: 2;
831 #endif
832
833       } config_1;
834
835    struct config_2 {
836
837 #if defined(__BIG_ENDIAN_BITFIELD)
838       unsigned char tfr_port: 2, bios_drive_number: 1,
839                     mapping_mode: 2, ha_scsi_id: 3;
840 #else
841       unsigned char ha_scsi_id: 3, mapping_mode: 2,
842                     bios_drive_number: 1, tfr_port: 2;
843 #endif
844
845       } config_2;
846
847    char name[16];
848
849    sprintf(name, "%s%d", driver_name, j);
850
851    if (!request_region(port_base, REGION_SIZE, driver_name)) {
852 #if defined(DEBUG_DETECT)
853       printk("%s: address 0x%03lx in use, skipping probe.\n", name, port_base);
854 #endif
855       goto fail;
856       }
857
858    spin_lock_irq(&driver_lock);
859
860    if (inb(port_base + REG_PRODUCT_ID1) != PRODUCT_ID1) goto freelock;
861
862    in_byte = inb(port_base + REG_PRODUCT_ID2);
863
864    if ((in_byte & 0xf0) != PRODUCT_ID2) goto freelock;
865
866    *(char *)&config_1 = inb(port_base + REG_CONFIG1);
867    *(char *)&config_2 = inb(port_base + REG_CONFIG2);
868
869    irq = interrupt_table[config_1.interrupt];
870    dma_channel = dma_channel_table[config_1.dma_channel];
871    subversion = (in_byte & 0x0f);
872
873    /* Board detected, allocate its IRQ */
874    if (request_irq(irq, do_interrupt_handler,
875              IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0),
876              driver_name, (void *) &sha[j])) {
877       printk("%s: unable to allocate IRQ %u, detaching.\n", name, irq);
878       goto freelock;
879       }
880
881    if (subversion == ISA && request_dma(dma_channel, driver_name)) {
882       printk("%s: unable to allocate DMA channel %u, detaching.\n",
883              name, dma_channel);
884       goto freeirq;
885       }
886
887    if (have_old_firmware) tpnt->use_clustering = DISABLE_CLUSTERING;
888
889    spin_unlock_irq(&driver_lock);
890    sh[j] = scsi_register(tpnt, sizeof(struct hostdata));
891    spin_lock_irq(&driver_lock);
892
893    if (sh[j] == NULL) {
894       printk("%s: unable to register host, detaching.\n", name);
895       goto freedma;
896       }
897
898    sh[j]->io_port = port_base;
899    sh[j]->unique_id = port_base;
900    sh[j]->n_io_port = REGION_SIZE;
901    sh[j]->base = bios_segment_table[config_1.bios_segment];
902    sh[j]->irq = irq;
903    sh[j]->sg_tablesize = MAX_SGLIST;
904    sh[j]->this_id = config_2.ha_scsi_id;
905    sh[j]->can_queue = MAX_MAILBOXES;
906    sh[j]->cmd_per_lun = MAX_CMD_PER_LUN;
907
908 #if defined(DEBUG_DETECT)
909    {
910    unsigned char sys_mask, lcl_mask;
911
912    sys_mask = inb(sh[j]->io_port + REG_SYS_MASK);
913    lcl_mask = inb(sh[j]->io_port + REG_LCL_MASK);
914    printk("SYS_MASK 0x%x, LCL_MASK 0x%x.\n", sys_mask, lcl_mask);
915    }
916 #endif
917
918    /* Probably a bogus host scsi id, set it to the dummy value */
919    if (sh[j]->this_id == 0) sh[j]->this_id = -1;
920
921    /* If BIOS is disabled, force enable interrupts */
922    if (sh[j]->base == 0) outb(CMD_ENA_INTR, sh[j]->io_port + REG_SYS_MASK);
923
924    memset(HD(j), 0, sizeof(struct hostdata));
925    HD(j)->heads = mapping_table[config_2.mapping_mode].heads;
926    HD(j)->sectors = mapping_table[config_2.mapping_mode].sectors;
927    HD(j)->subversion = subversion;
928    HD(j)->pdev = NULL;
929    HD(j)->board_number = j;
930
931    if (have_old_firmware) sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
932
933    if (HD(j)->subversion == ESA) {
934       sh[j]->unchecked_isa_dma = FALSE;
935       sh[j]->dma_channel = NO_DMA;
936       sprintf(BN(j), "U34F%d", j);
937       bus_type = "VESA";
938       }
939    else {
940       unsigned long flags;
941       sh[j]->unchecked_isa_dma = TRUE;
942
943       flags=claim_dma_lock();
944       disable_dma(dma_channel);
945       clear_dma_ff(dma_channel);
946       set_dma_mode(dma_channel, DMA_MODE_CASCADE);
947       enable_dma(dma_channel);
948       release_dma_lock(flags);
949
950       sh[j]->dma_channel = dma_channel;
951       sprintf(BN(j), "U14F%d", j);
952       bus_type = "ISA";
953       }
954
955    sh[j]->max_channel = MAX_CHANNEL - 1;
956    sh[j]->max_id = MAX_TARGET;
957    sh[j]->max_lun = MAX_LUN;
958
959    if (HD(j)->subversion == ISA && !board_inquiry(j)) {
960       HD(j)->board_id[40] = 0;
961
962       if (strcmp(&HD(j)->board_id[32], "06000600")) {
963          printk("%s: %s.\n", BN(j), &HD(j)->board_id[8]);
964          printk("%s: firmware %s is outdated, FW PROM should be 28004-006.\n",
965                 BN(j), &HD(j)->board_id[32]);
966          sh[j]->hostt->use_clustering = DISABLE_CLUSTERING;
967          sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
968          }
969       }
970
971    if (dma_channel == NO_DMA) sprintf(dma_name, "%s", "BMST");
972    else                       sprintf(dma_name, "DMA %u", dma_channel);
973
974    spin_unlock_irq(&driver_lock);
975
976    for (i = 0; i < sh[j]->can_queue; i++)
977       HD(j)->cp[i].cp_dma_addr = pci_map_single(HD(j)->pdev,
978             &HD(j)->cp[i], sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
979
980    for (i = 0; i < sh[j]->can_queue; i++)
981       if (! ((&HD(j)->cp[i])->sglist = kmalloc(
982             sh[j]->sg_tablesize * sizeof(struct sg_list),
983             (sh[j]->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC))) {
984          printk("%s: kmalloc SGlist failed, mbox %d, detaching.\n", BN(j), i);
985          goto release;
986          }
987
988    if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
989        max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
990
991    if (max_queue_depth < MAX_CMD_PER_LUN) max_queue_depth = MAX_CMD_PER_LUN;
992
993    if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
994       tag_mode = TAG_ORDERED;
995
996    if (j == 0) {
997       printk("UltraStor 14F/34F: Copyright (C) 1994-2003 Dario Ballabio.\n");
998       printk("%s config options -> of:%c, tm:%d, lc:%c, mq:%d, et:%c.\n",
999              driver_name, YESNO(have_old_firmware), tag_mode,
1000              YESNO(linked_comm), max_queue_depth, YESNO(ext_tran));
1001       }
1002
1003    printk("%s: %s 0x%03lx, BIOS 0x%05x, IRQ %u, %s, SG %d, MB %d.\n",
1004           BN(j), bus_type, (unsigned long)sh[j]->io_port, (int)sh[j]->base,
1005           sh[j]->irq, dma_name, sh[j]->sg_tablesize, sh[j]->can_queue);
1006
1007    if (sh[j]->max_id > 8 || sh[j]->max_lun > 8)
1008       printk("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1009              BN(j), sh[j]->max_id, sh[j]->max_lun);
1010
1011    for (i = 0; i <= sh[j]->max_channel; i++)
1012       printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1013              BN(j), i, sh[j]->this_id);
1014
1015    return TRUE;
1016
1017 freedma:
1018    if (subversion == ISA) free_dma(dma_channel);
1019 freeirq:
1020    free_irq(irq, &sha[j]);
1021 freelock:
1022    spin_unlock_irq(&driver_lock);
1023    release_region(port_base, REGION_SIZE);
1024 fail:
1025    return FALSE;
1026
1027 release:
1028    u14_34f_release(sh[j]);
1029    return FALSE;
1030 }
1031
1032 static void internal_setup(char *str, int *ints) {
1033    int i, argc = ints[0];
1034    char *cur = str, *pc;
1035
1036    if (argc > 0) {
1037
1038       if (argc > MAX_INT_PARAM) argc = MAX_INT_PARAM;
1039
1040       for (i = 0; i < argc; i++) io_port[i] = ints[i + 1];
1041
1042       io_port[i] = 0;
1043       setup_done = TRUE;
1044       }
1045
1046    while (cur && (pc = strchr(cur, ':'))) {
1047       int val = 0, c = *++pc;
1048
1049       if (c == 'n' || c == 'N') val = FALSE;
1050       else if (c == 'y' || c == 'Y') val = TRUE;
1051       else val = (int) simple_strtoul(pc, NULL, 0);
1052
1053       if (!strncmp(cur, "lc:", 3)) linked_comm = val;
1054       else if (!strncmp(cur, "of:", 3)) have_old_firmware = val;
1055       else if (!strncmp(cur, "tm:", 3)) tag_mode = val;
1056       else if (!strncmp(cur, "tc:", 3)) tag_mode = val;
1057       else if (!strncmp(cur, "mq:", 3))  max_queue_depth = val;
1058       else if (!strncmp(cur, "ls:", 3))  link_statistics = val;
1059       else if (!strncmp(cur, "et:", 3))  ext_tran = val;
1060
1061       if ((cur = strchr(cur, ','))) ++cur;
1062       }
1063
1064    return;
1065 }
1066
1067 static int option_setup(char *str) {
1068    int ints[MAX_INT_PARAM];
1069    char *cur = str;
1070    int i = 1;
1071
1072    while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
1073       ints[i++] = simple_strtoul(cur, NULL, 0);
1074
1075       if ((cur = strchr(cur, ',')) != NULL) cur++;
1076    }
1077
1078    ints[0] = i - 1;
1079    internal_setup(cur, ints);
1080    return 1;
1081 }
1082
1083 static int u14_34f_detect(struct scsi_host_template *tpnt) {
1084    unsigned int j = 0, k;
1085
1086    tpnt->proc_name = "u14-34f";
1087
1088    if(strlen(boot_options)) option_setup(boot_options);
1089
1090 #if defined(MODULE)
1091    /* io_port could have been modified when loading as a module */
1092    if(io_port[0] != SKIP) {
1093       setup_done = TRUE;
1094       io_port[MAX_INT_PARAM] = 0;
1095       }
1096 #endif
1097
1098    for (k = 0; k < MAX_BOARDS + 1; k++) sh[k] = NULL;
1099
1100    for (k = 0; io_port[k]; k++) {
1101
1102       if (io_port[k] == SKIP) continue;
1103
1104       if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt)) j++;
1105       }
1106
1107    num_boards = j;
1108    return j;
1109 }
1110
1111 static void map_dma(unsigned int i, unsigned int j) {
1112    unsigned int data_len = 0;
1113    unsigned int k, count, pci_dir;
1114    struct scatterlist *sgpnt;
1115    struct mscp *cpp;
1116    struct scsi_cmnd *SCpnt;
1117
1118    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1119    pci_dir = SCpnt->sc_data_direction;
1120
1121    if (SCpnt->sense_buffer)
1122       cpp->sense_addr = H2DEV(pci_map_single(HD(j)->pdev, SCpnt->sense_buffer,
1123                            sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE));
1124
1125    cpp->sense_len = sizeof SCpnt->sense_buffer;
1126
1127    if (!SCpnt->use_sg) {
1128
1129       /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */
1130       if (!SCpnt->request_bufflen) pci_dir = PCI_DMA_BIDIRECTIONAL;
1131
1132       if (SCpnt->request_buffer)
1133          cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev,
1134                   SCpnt->request_buffer, SCpnt->request_bufflen, pci_dir));
1135
1136       cpp->data_len = H2DEV(SCpnt->request_bufflen);
1137       return;
1138       }
1139
1140    sgpnt = (struct scatterlist *) SCpnt->request_buffer;
1141    count = pci_map_sg(HD(j)->pdev, sgpnt, SCpnt->use_sg, pci_dir);
1142
1143    for (k = 0; k < count; k++) {
1144       cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k]));
1145       cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k]));
1146       data_len += sgpnt[k].length;
1147       }
1148
1149    cpp->sg = TRUE;
1150    cpp->use_sg = SCpnt->use_sg;
1151    cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist,
1152                              SCpnt->use_sg * sizeof(struct sg_list), pci_dir));
1153    cpp->data_len = H2DEV(data_len);
1154 }
1155
1156 static void unmap_dma(unsigned int i, unsigned int j) {
1157    unsigned int pci_dir;
1158    struct mscp *cpp;
1159    struct scsi_cmnd *SCpnt;
1160
1161    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1162    pci_dir = SCpnt->sc_data_direction;
1163
1164    if (DEV2H(cpp->sense_addr))
1165       pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
1166                        DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1167
1168    if (SCpnt->use_sg)
1169       pci_unmap_sg(HD(j)->pdev, SCpnt->request_buffer, SCpnt->use_sg, pci_dir);
1170
1171    if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1172
1173    if (DEV2H(cpp->data_address))
1174       pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address),
1175                        DEV2H(cpp->data_len), pci_dir);
1176 }
1177
1178 static void sync_dma(unsigned int i, unsigned int j) {
1179    unsigned int pci_dir;
1180    struct mscp *cpp;
1181    struct scsi_cmnd *SCpnt;
1182
1183    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1184    pci_dir = SCpnt->sc_data_direction;
1185
1186    if (DEV2H(cpp->sense_addr))
1187       pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr),
1188                           DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1189
1190    if (SCpnt->use_sg)
1191       pci_dma_sync_sg_for_cpu(HD(j)->pdev, SCpnt->request_buffer,
1192                          SCpnt->use_sg, pci_dir);
1193
1194    if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1195
1196    if (DEV2H(cpp->data_address))
1197       pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address),
1198                        DEV2H(cpp->data_len), pci_dir);
1199 }
1200
1201 static void scsi_to_dev_dir(unsigned int i, unsigned int j) {
1202    unsigned int k;
1203
1204    static const unsigned char data_out_cmds[] = {
1205       0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1206       0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1207       0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1208       };
1209
1210    static const unsigned char data_none_cmds[] = {
1211       0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1212       0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1213       0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1214       };
1215
1216    struct mscp *cpp;
1217    struct scsi_cmnd *SCpnt;
1218
1219    cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1220
1221    if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1222       cpp->xdir = DTD_IN;
1223       return;
1224       }
1225    else if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1226       cpp->xdir = DTD_OUT;
1227       return;
1228       }
1229    else if (SCpnt->sc_data_direction == DMA_NONE) {
1230       cpp->xdir = DTD_NONE;
1231       return;
1232       }
1233
1234    if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1235       panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", BN(j));
1236
1237    cpp->xdir = DTD_IN;
1238
1239    for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1240       if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1241          cpp->xdir = DTD_OUT;
1242          break;
1243          }
1244
1245    if (cpp->xdir == DTD_IN)
1246       for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1247          if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1248             cpp->xdir = DTD_NONE;
1249             break;
1250             }
1251
1252 }
1253
1254 static int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) {
1255    unsigned int i, j, k;
1256    struct mscp *cpp;
1257
1258    /* j is the board number */
1259    j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
1260
1261    if (SCpnt->host_scribble)
1262       panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
1263             BN(j), SCpnt->pid, SCpnt);
1264
1265    /* i is the mailbox number, look for the first free mailbox
1266       starting from last_cp_used */
1267    i = HD(j)->last_cp_used + 1;
1268
1269    for (k = 0; k < sh[j]->can_queue; k++, i++) {
1270
1271       if (i >= sh[j]->can_queue) i = 0;
1272
1273       if (HD(j)->cp_stat[i] == FREE) {
1274          HD(j)->last_cp_used = i;
1275          break;
1276          }
1277       }
1278
1279    if (k == sh[j]->can_queue) {
1280       printk("%s: qcomm, no free mailbox.\n", BN(j));
1281       return 1;
1282       }
1283
1284    /* Set pointer to control packet structure */
1285    cpp = &HD(j)->cp[i];
1286
1287    memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1288    SCpnt->scsi_done = done;
1289    cpp->cpp_index = i;
1290    SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
1291
1292    if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n",
1293                         BN(j), i, SCpnt->device->channel, SCpnt->device->id,
1294                         SCpnt->device->lun, SCpnt->pid);
1295
1296    cpp->opcode = OP_SCSI;
1297    cpp->channel = SCpnt->device->channel;
1298    cpp->target = SCpnt->device->id;
1299    cpp->lun = SCpnt->device->lun;
1300    cpp->SCpnt = SCpnt;
1301    cpp->cdb_len = SCpnt->cmd_len;
1302    memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1303
1304    /* Use data transfer direction SCpnt->sc_data_direction */
1305    scsi_to_dev_dir(i, j);
1306
1307    /* Map DMA buffers and SG list */
1308    map_dma(i, j);
1309
1310    if (linked_comm && SCpnt->device->queue_depth > 2
1311                                      && TLDEV(SCpnt->device->type)) {
1312       HD(j)->cp_stat[i] = READY;
1313       flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE);
1314       return 0;
1315       }
1316
1317    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1318       unmap_dma(i, j);
1319       SCpnt->host_scribble = NULL;
1320       scmd_printk(KERN_INFO, SCpnt,
1321                 "qcomm, pid %ld, adapter busy.\n", SCpnt->pid);
1322       return 1;
1323       }
1324
1325    /* Store pointer in OGM address bytes */
1326    outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1327
1328    /* Issue OGM interrupt */
1329    outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1330
1331    HD(j)->cp_stat[i] = IN_USE;
1332    return 0;
1333 }
1334
1335 static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
1336    unsigned int i, j;
1337
1338    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1339
1340    if (SCarg->host_scribble == NULL) {
1341       scmd_printk(KERN_INFO, SCarg, "abort, pid %ld inactive.\n",
1342              SCarg->pid);
1343       return SUCCESS;
1344       }
1345
1346    i = *(unsigned int *)SCarg->host_scribble;
1347    scmd_printk(KERN_INFO, SCarg, "abort, mbox %d, pid %ld.\n",
1348                i, SCarg->pid);
1349
1350    if (i >= sh[j]->can_queue)
1351       panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
1352
1353    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1354       printk("%s: abort, timeout error.\n", BN(j));
1355       return FAILED;
1356       }
1357
1358    if (HD(j)->cp_stat[i] == FREE) {
1359       printk("%s: abort, mbox %d is free.\n", BN(j), i);
1360       return SUCCESS;
1361       }
1362
1363    if (HD(j)->cp_stat[i] == IN_USE) {
1364       printk("%s: abort, mbox %d is in use.\n", BN(j), i);
1365
1366       if (SCarg != HD(j)->cp[i].SCpnt)
1367          panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1368                BN(j), i, SCarg, HD(j)->cp[i].SCpnt);
1369
1370       if (inb(sh[j]->io_port + REG_SYS_INTR) & IRQ_ASSERTED)
1371          printk("%s: abort, mbox %d, interrupt pending.\n", BN(j), i);
1372
1373       return FAILED;
1374       }
1375
1376    if (HD(j)->cp_stat[i] == IN_RESET) {
1377       printk("%s: abort, mbox %d is in reset.\n", BN(j), i);
1378       return FAILED;
1379       }
1380
1381    if (HD(j)->cp_stat[i] == LOCKED) {
1382       printk("%s: abort, mbox %d is locked.\n", BN(j), i);
1383       return SUCCESS;
1384       }
1385
1386    if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1387       unmap_dma(i, j);
1388       SCarg->result = DID_ABORT << 16;
1389       SCarg->host_scribble = NULL;
1390       HD(j)->cp_stat[i] = FREE;
1391       printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
1392              BN(j), i, SCarg->pid);
1393       SCarg->scsi_done(SCarg);
1394       return SUCCESS;
1395       }
1396
1397    panic("%s: abort, mbox %d, invalid cp_stat.\n", BN(j), i);
1398 }
1399
1400 static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1401    unsigned int i, j, time, k, c, limit = 0;
1402    int arg_done = FALSE;
1403    struct scsi_cmnd *SCpnt;
1404
1405    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1406    scmd_printk(KERN_INFO, SCarg, "reset, enter, pid %ld.\n", SCarg->pid);
1407
1408    spin_lock_irq(sh[j]->host_lock);
1409
1410    if (SCarg->host_scribble == NULL)
1411       printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->pid);
1412
1413    if (HD(j)->in_reset) {
1414       printk("%s: reset, exit, already in reset.\n", BN(j));
1415       spin_unlock_irq(sh[j]->host_lock);
1416       return FAILED;
1417       }
1418
1419    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1420       printk("%s: reset, exit, timeout error.\n", BN(j));
1421       spin_unlock_irq(sh[j]->host_lock);
1422       return FAILED;
1423       }
1424
1425    HD(j)->retries = 0;
1426
1427    for (c = 0; c <= sh[j]->max_channel; c++)
1428       for (k = 0; k < sh[j]->max_id; k++) {
1429          HD(j)->target_redo[k][c] = TRUE;
1430          HD(j)->target_to[k][c] = 0;
1431          }
1432
1433    for (i = 0; i < sh[j]->can_queue; i++) {
1434
1435       if (HD(j)->cp_stat[i] == FREE) continue;
1436
1437       if (HD(j)->cp_stat[i] == LOCKED) {
1438          HD(j)->cp_stat[i] = FREE;
1439          printk("%s: reset, locked mbox %d forced free.\n", BN(j), i);
1440          continue;
1441          }
1442
1443       if (!(SCpnt = HD(j)->cp[i].SCpnt))
1444          panic("%s: reset, mbox %d, SCpnt == NULL.\n", BN(j), i);
1445
1446       if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1447          HD(j)->cp_stat[i] = ABORTING;
1448          printk("%s: reset, mbox %d aborting, pid %ld.\n",
1449                 BN(j), i, SCpnt->pid);
1450          }
1451
1452       else {
1453          HD(j)->cp_stat[i] = IN_RESET;
1454          printk("%s: reset, mbox %d in reset, pid %ld.\n",
1455                 BN(j), i, SCpnt->pid);
1456          }
1457
1458       if (SCpnt->host_scribble == NULL)
1459          panic("%s: reset, mbox %d, garbled SCpnt.\n", BN(j), i);
1460
1461       if (*(unsigned int *)SCpnt->host_scribble != i)
1462          panic("%s: reset, mbox %d, index mismatch.\n", BN(j), i);
1463
1464       if (SCpnt->scsi_done == NULL)
1465          panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", BN(j), i);
1466
1467       if (SCpnt == SCarg) arg_done = TRUE;
1468       }
1469
1470    if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1471       printk("%s: reset, cannot reset, timeout error.\n", BN(j));
1472       spin_unlock_irq(sh[j]->host_lock);
1473       return FAILED;
1474       }
1475
1476    outb(CMD_RESET, sh[j]->io_port + REG_LCL_INTR);
1477    printk("%s: reset, board reset done, enabling interrupts.\n", BN(j));
1478
1479 #if defined(DEBUG_RESET)
1480    do_trace = TRUE;
1481 #endif
1482
1483    HD(j)->in_reset = TRUE;
1484
1485    spin_unlock_irq(sh[j]->host_lock);
1486    time = jiffies;
1487    while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L);
1488    spin_lock_irq(sh[j]->host_lock);
1489
1490    printk("%s: reset, interrupts disabled, loops %d.\n", BN(j), limit);
1491
1492    for (i = 0; i < sh[j]->can_queue; i++) {
1493
1494       if (HD(j)->cp_stat[i] == IN_RESET) {
1495          SCpnt = HD(j)->cp[i].SCpnt;
1496          unmap_dma(i, j);
1497          SCpnt->result = DID_RESET << 16;
1498          SCpnt->host_scribble = NULL;
1499
1500          /* This mailbox is still waiting for its interrupt */
1501          HD(j)->cp_stat[i] = LOCKED;
1502
1503          printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
1504                 BN(j), i, SCpnt->pid);
1505          }
1506
1507       else if (HD(j)->cp_stat[i] == ABORTING) {
1508          SCpnt = HD(j)->cp[i].SCpnt;
1509          unmap_dma(i, j);
1510          SCpnt->result = DID_RESET << 16;
1511          SCpnt->host_scribble = NULL;
1512
1513          /* This mailbox was never queued to the adapter */
1514          HD(j)->cp_stat[i] = FREE;
1515
1516          printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
1517                 BN(j), i, SCpnt->pid);
1518          }
1519
1520       else
1521
1522          /* Any other mailbox has already been set free by interrupt */
1523          continue;
1524
1525       SCpnt->scsi_done(SCpnt);
1526       }
1527
1528    HD(j)->in_reset = FALSE;
1529    do_trace = FALSE;
1530
1531    if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->pid);
1532    else          printk("%s: reset, exit.\n", BN(j));
1533
1534    spin_unlock_irq(sh[j]->host_lock);
1535    return SUCCESS;
1536 }
1537
1538 static int u14_34f_bios_param(struct scsi_device *disk,
1539                  struct block_device *bdev, sector_t capacity, int *dkinfo) {
1540    unsigned int j = 0;
1541    unsigned int size = capacity;
1542
1543    dkinfo[0] = HD(j)->heads;
1544    dkinfo[1] = HD(j)->sectors;
1545    dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
1546
1547    if (ext_tran && (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
1548       dkinfo[0] = 255;
1549       dkinfo[1] = 63;
1550       dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
1551       }
1552
1553 #if defined (DEBUG_GEOMETRY)
1554    printk ("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
1555            dkinfo[0], dkinfo[1], dkinfo[2]);
1556 #endif
1557
1558    return FALSE;
1559 }
1560
1561 static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
1562                  unsigned int rev) {
1563    unsigned int i, j, k, y;
1564    unsigned long x;
1565
1566    for (i = 0; i < n - 1; i++) {
1567       k = i;
1568
1569       for (j = k + 1; j < n; j++)
1570          if (rev) {
1571             if (sk[j] > sk[k]) k = j;
1572             }
1573          else {
1574             if (sk[j] < sk[k]) k = j;
1575             }
1576
1577       if (k != i) {
1578          x = sk[k]; sk[k] = sk[i]; sk[i] = x;
1579          y = da[k]; da[k] = da[i]; da[i] = y;
1580          }
1581       }
1582
1583    return;
1584    }
1585
1586 static int reorder(unsigned int j, unsigned long cursec,
1587                  unsigned int ihdlr, unsigned int il[], unsigned int n_ready) {
1588    struct scsi_cmnd *SCpnt;
1589    struct mscp *cpp;
1590    unsigned int k, n;
1591    unsigned int rev = FALSE, s = TRUE, r = TRUE;
1592    unsigned int input_only = TRUE, overlap = FALSE;
1593    unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
1594    unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
1595    unsigned long ioseek = 0;
1596
1597    static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
1598    static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
1599    static unsigned int readysorted = 0, revcount = 0;
1600    static unsigned long seeksorted = 0, seeknosort = 0;
1601
1602    if (link_statistics && !(++flushcount % link_statistics))
1603       printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"\
1604              " av %ldK as %ldK.\n", flushcount, batchcount, inputcount,
1605              ovlcount, readycount, readysorted, sortcount, revcount,
1606              seeknosort / (readycount + 1),
1607              seeksorted / (readycount + 1));
1608
1609    if (n_ready <= 1) return FALSE;
1610
1611    for (n = 0; n < n_ready; n++) {
1612       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1613
1614       if (!(cpp->xdir == DTD_IN)) input_only = FALSE;
1615
1616       if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector;
1617       if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector;
1618
1619       sl[n] = SCpnt->request->sector;
1620       ioseek += SCpnt->request->nr_sectors;
1621
1622       if (!n) continue;
1623
1624       if (sl[n] < sl[n - 1]) s = FALSE;
1625       if (sl[n] > sl[n - 1]) r = FALSE;
1626
1627       if (link_statistics) {
1628          if (sl[n] > sl[n - 1])
1629             seek += sl[n] - sl[n - 1];
1630          else
1631             seek += sl[n - 1] - sl[n];
1632          }
1633
1634       }
1635
1636    if (link_statistics) {
1637       if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec;
1638       }
1639
1640    if (cursec > ((maxsec + minsec) / 2)) rev = TRUE;
1641
1642    if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE;
1643
1644    if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev);
1645
1646    if (!input_only) for (n = 0; n < n_ready; n++) {
1647       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1648       ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->pid;
1649
1650       if (!n) continue;
1651
1652       if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
1653           || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE;
1654       }
1655
1656    if (overlap) sort(pl, il, n_ready, FALSE);
1657
1658    if (link_statistics) {
1659       if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec;
1660       batchcount++; readycount += n_ready; seeknosort += seek / 1024;
1661       if (input_only) inputcount++;
1662       if (overlap) { ovlcount++; seeksorted += iseek / 1024; }
1663       else seeksorted += (iseek + maxsec - minsec) / 1024;
1664       if (rev && !r)     {  revcount++; readysorted += n_ready; }
1665       if (!rev && !s)    { sortcount++; readysorted += n_ready; }
1666       }
1667
1668 #if defined(DEBUG_LINKED_COMMANDS)
1669    if (link_statistics && (overlap || !(flushcount % link_statistics)))
1670       for (n = 0; n < n_ready; n++) {
1671          k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1672          printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\
1673                 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
1674                 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
1675                 SCpnt->lun, SCpnt->pid, k, flushcount, n_ready,
1676                 SCpnt->request->sector, SCpnt->request->nr_sectors, cursec,
1677                 YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
1678                 YESNO(overlap), cpp->xdir);
1679          }
1680 #endif
1681    return overlap;
1682 }
1683
1684 static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned int j,
1685                       unsigned int ihdlr) {
1686    struct scsi_cmnd *SCpnt;
1687    struct mscp *cpp;
1688    unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
1689
1690    for (k = 0; k < sh[j]->can_queue; k++) {
1691
1692       if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue;
1693
1694       cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1695
1696       if (SCpnt->device != dev) continue;
1697
1698       if (HD(j)->cp_stat[k] == IN_USE) return;
1699
1700       il[n_ready++] = k;
1701       }
1702
1703    if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1;
1704
1705    for (n = 0; n < n_ready; n++) {
1706       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1707
1708       if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1709          scmd_printk(KERN_INFO, SCpnt,
1710                 "%s, pid %ld, mbox %d, adapter"
1711                 " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"),
1712                 SCpnt->pid, k);
1713          HD(j)->cp_stat[k] = ABORTING;
1714          continue;
1715          }
1716
1717       outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1718       outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1719       HD(j)->cp_stat[k] = IN_USE;
1720       }
1721
1722 }
1723
1724 static irqreturn_t ihdlr(int irq, unsigned int j) {
1725    struct scsi_cmnd *SCpnt;
1726    unsigned int i, k, c, status, tstatus, reg, ret;
1727    struct mscp *spp, *cpp;
1728
1729    if (sh[j]->irq != irq)
1730        panic("%s: ihdlr, irq %d, sh[j]->irq %d.\n", BN(j), irq, sh[j]->irq);
1731
1732    /* Check if this board need to be serviced */
1733    if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none;
1734
1735    HD(j)->iocount++;
1736
1737    if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.\n", BN(j), irq,
1738                         HD(j)->iocount);
1739
1740    /* Check if this board is still busy */
1741    if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) {
1742       outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1743       printk("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.\n",
1744              BN(j), irq, reg, HD(j)->iocount);
1745       goto none;
1746       }
1747
1748    ret = inl(sh[j]->io_port + REG_ICM);
1749
1750    /* Clear interrupt pending flag */
1751    outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1752
1753    /* Find the mailbox to be serviced on this board */
1754    for (i = 0; i < sh[j]->can_queue; i++)
1755       if (H2DEV(HD(j)->cp[i].cp_dma_addr) == ret) break;
1756
1757    if (i >= sh[j]->can_queue)
1758       panic("%s: ihdlr, invalid mscp bus address %p, cp0 %p.\n", BN(j),
1759             (void *)ret, (void *)H2DEV(HD(j)->cp[0].cp_dma_addr));
1760
1761    cpp = &(HD(j)->cp[i]);
1762    spp = cpp;
1763
1764 #if defined(DEBUG_GENERATE_ABORTS)
1765    if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) goto handled;
1766 #endif
1767
1768    if (HD(j)->cp_stat[i] == IGNORE) {
1769       HD(j)->cp_stat[i] = FREE;
1770       goto handled;
1771       }
1772    else if (HD(j)->cp_stat[i] == LOCKED) {
1773       HD(j)->cp_stat[i] = FREE;
1774       printk("%s: ihdlr, mbox %d unlocked, count %d.\n", BN(j), i,
1775              HD(j)->iocount);
1776       goto handled;
1777       }
1778    else if (HD(j)->cp_stat[i] == FREE) {
1779       printk("%s: ihdlr, mbox %d is free, count %d.\n", BN(j), i,
1780              HD(j)->iocount);
1781       goto handled;
1782       }
1783    else if (HD(j)->cp_stat[i] == IN_RESET)
1784       printk("%s: ihdlr, mbox %d is in reset.\n", BN(j), i);
1785    else if (HD(j)->cp_stat[i] != IN_USE)
1786       panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
1787             BN(j), i, HD(j)->cp_stat[i]);
1788
1789    HD(j)->cp_stat[i] = FREE;
1790    SCpnt = cpp->SCpnt;
1791
1792    if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
1793
1794    if (SCpnt->host_scribble == NULL)
1795       panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i,
1796             SCpnt->pid, SCpnt);
1797
1798    if (*(unsigned int *)SCpnt->host_scribble != i)
1799       panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
1800             BN(j), i, SCpnt->pid, *(unsigned int *)SCpnt->host_scribble);
1801
1802    sync_dma(i, j);
1803
1804    if (linked_comm && SCpnt->device->queue_depth > 2
1805                                      && TLDEV(SCpnt->device->type))
1806       flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE);
1807
1808    tstatus = status_byte(spp->target_status);
1809
1810 #if defined(DEBUG_GENERATE_ERRORS)
1811    if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2))
1812                                            spp->adapter_status = 0x01;
1813 #endif
1814
1815    switch (spp->adapter_status) {
1816       case ASOK:     /* status OK */
1817
1818          /* Forces a reset if a disk drive keeps returning BUSY */
1819          if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
1820             status = DID_ERROR << 16;
1821
1822          /* If there was a bus reset, redo operation on each target */
1823          else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
1824                   && HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)])
1825             status = DID_BUS_BUSY << 16;
1826
1827          /* Works around a flaw in scsi.c */
1828          else if (tstatus == CHECK_CONDITION
1829                   && SCpnt->device->type == TYPE_DISK
1830                   && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
1831             status = DID_BUS_BUSY << 16;
1832
1833          else
1834             status = DID_OK << 16;
1835
1836          if (tstatus == GOOD)
1837             HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)] = FALSE;
1838
1839          if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
1840              (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
1841                (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
1842             scmd_printk(KERN_INFO, SCpnt,
1843                 "ihdlr, pid %ld, target_status 0x%x, sense key 0x%x.\n",
1844                    SCpnt->pid, spp->target_status,
1845                    SCpnt->sense_buffer[2]);
1846
1847          HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0;
1848
1849          if (HD(j)->last_retried_pid == SCpnt->pid) HD(j)->retries = 0;
1850
1851          break;
1852       case ASST:     /* Selection Time Out */
1853
1854          if (HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] > 1)
1855             status = DID_ERROR << 16;
1856          else {
1857             status = DID_TIME_OUT << 16;
1858             HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)]++;
1859             }
1860
1861          break;
1862
1863       /* Perform a limited number of internal retries */
1864       case 0x93:     /* Unexpected bus free */
1865       case 0x94:     /* Target bus phase sequence failure */
1866       case 0x96:     /* Illegal SCSI command */
1867       case 0xa3:     /* SCSI bus reset error */
1868
1869          for (c = 0; c <= sh[j]->max_channel; c++)
1870             for (k = 0; k < sh[j]->max_id; k++)
1871                HD(j)->target_redo[k][c] = TRUE;
1872
1873
1874       case 0x92:     /* Data over/under-run */
1875
1876          if (SCpnt->device->type != TYPE_TAPE
1877              && HD(j)->retries < MAX_INTERNAL_RETRIES) {
1878
1879 #if defined(DID_SOFT_ERROR)
1880             status = DID_SOFT_ERROR << 16;
1881 #else
1882             status = DID_BUS_BUSY << 16;
1883 #endif
1884
1885             HD(j)->retries++;
1886             HD(j)->last_retried_pid = SCpnt->pid;
1887             }
1888          else
1889             status = DID_ERROR << 16;
1890
1891          break;
1892       case 0x01:     /* Invalid command */
1893       case 0x02:     /* Invalid parameters */
1894       case 0x03:     /* Invalid data list */
1895       case 0x84:     /* SCSI bus abort error */
1896       case 0x9b:     /* Auto request sense error */
1897       case 0x9f:     /* Unexpected command complete message error */
1898       case 0xff:     /* Invalid parameter in the S/G list */
1899       default:
1900          status = DID_ERROR << 16;
1901          break;
1902       }
1903
1904    SCpnt->result = status | spp->target_status;
1905
1906 #if defined(DEBUG_INTERRUPT)
1907    if (SCpnt->result || do_trace)
1908 #else
1909    if ((spp->adapter_status != ASOK && HD(j)->iocount >  1000) ||
1910        (spp->adapter_status != ASOK &&
1911         spp->adapter_status != ASST && HD(j)->iocount <= 1000) ||
1912         do_trace || msg_byte(spp->target_status))
1913 #endif
1914       scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\
1915              " pid %ld, reg 0x%x, count %d.\n",
1916              i, spp->adapter_status, spp->target_status, SCpnt->pid,
1917              reg, HD(j)->iocount);
1918
1919    unmap_dma(i, j);
1920
1921    /* Set the command state to inactive */
1922    SCpnt->host_scribble = NULL;
1923
1924    SCpnt->scsi_done(SCpnt);
1925
1926    if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.\n", BN(j), irq,
1927                         HD(j)->iocount);
1928
1929 handled:
1930    return IRQ_HANDLED;
1931 none:
1932    return IRQ_NONE;
1933 }
1934
1935 static irqreturn_t do_interrupt_handler(int irq, void *shap) {
1936    unsigned int j;
1937    unsigned long spin_flags;
1938    irqreturn_t ret;
1939
1940    /* Check if the interrupt must be processed by this handler */
1941    if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE;
1942
1943    spin_lock_irqsave(sh[j]->host_lock, spin_flags);
1944    ret = ihdlr(irq, j);
1945    spin_unlock_irqrestore(sh[j]->host_lock, spin_flags);
1946    return ret;
1947 }
1948
1949 static int u14_34f_release(struct Scsi_Host *shpnt) {
1950    unsigned int i, j;
1951
1952    for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++);
1953
1954    if (sh[j] == NULL)
1955       panic("%s: release, invalid Scsi_Host pointer.\n", driver_name);
1956
1957    for (i = 0; i < sh[j]->can_queue; i++)
1958       kfree((&HD(j)->cp[i])->sglist);
1959
1960    for (i = 0; i < sh[j]->can_queue; i++)
1961       pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr,
1962                      sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
1963
1964    free_irq(sh[j]->irq, &sha[j]);
1965
1966    if (sh[j]->dma_channel != NO_DMA)
1967       free_dma(sh[j]->dma_channel);
1968
1969    release_region(sh[j]->io_port, sh[j]->n_io_port);
1970    scsi_unregister(sh[j]);
1971    return FALSE;
1972 }
1973
1974 #include "scsi_module.c"
1975
1976 #ifndef MODULE
1977 __setup("u14-34f=", option_setup);
1978 #endif /* end MODULE */