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