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