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