?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: add PAGE_KERNEL_EXEC_NOCACHE
[wrt350n-kernel.git] / drivers / scsi / eata.c
blob05163cefec12f7f2f806009de76da5d77767a0ed
1 /*
2 * eata.c - Low-level driver for EATA/DMA 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 eata.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 * rs:[y|n] rev_scan=[1|0]
20 * ip:[y|n] isa_probe=[1|0]
21 * ep:[y|n] eisa_probe=[1|0]
22 * pp:[y|n] pci_probe=[1|0]
23 *
24 * A valid example using the new parameter format is:
25 * modprobe eata "eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n"
26 *
27 * which is equivalent to the old format:
28 * modprobe eata io_port=0x7410,0x230 linked_comm=1 tag_mode=0 \
29 * max_queue_depth=4 eisa_probe=0
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 * + The tagged_comm module parameter has been removed, use tag_mode
49 * instead, equivalent to the "tm:" boot option.
50 *
51 * 10 Oct 2002 Rev. 7.70 for linux 2.5.42
52 * + Foreport from revision 6.70.
53 *
54 * 25 Jun 2002 Rev. 6.70 for linux 2.4.19
55 * + This release is the first one tested on a Big Endian platform:
56 * fixed endian-ness problem due to bitfields;
57 * fixed endian-ness problem in read_pio.
58 * + Added new options for selectively probing ISA, EISA and PCI bus:
59 *
60 * Boot option Parameter name Default according to
61 *
62 * ip:[y|n] isa_probe=[1|0] CONFIG_ISA defined
63 * ep:[y|n] eisa_probe=[1|0] CONFIG_EISA defined
64 * pp:[y|n] pci_probe=[1|0] CONFIG_PCI defined
65 *
66 * The default action is to perform probing if the corrisponding
67 * bus is configured and to skip probing otherwise.
68 *
69 * + If pci_probe is in effect and a list of I/O ports is specified
70 * as parameter or boot option, pci_enable_device() is performed
71 * on all pci devices matching PCI_CLASS_STORAGE_SCSI.
72 *
73 * 21 Feb 2002 Rev. 6.52 for linux 2.4.18
74 * + Backport from rev. 7.22 (use io_request_lock).
75 *
76 * 20 Feb 2002 Rev. 7.22 for linux 2.5.5
77 * + Remove any reference to virt_to_bus().
78 * + Fix pio hang while detecting multiple HBAs.
79 * + Fixed a board detection bug: in a system with
80 * multiple ISA/EISA boards, all but the first one
81 * were erroneously detected as PCI.
82 *
83 * 01 Jan 2002 Rev. 7.20 for linux 2.5.1
84 * + Use the dynamic DMA mapping API.
85 *
86 * 19 Dec 2001 Rev. 7.02 for linux 2.5.1
87 * + Use SCpnt->sc_data_direction if set.
88 * + Use sglist.page instead of sglist.address.
89 *
90 * 11 Dec 2001 Rev. 7.00 for linux 2.5.1
91 * + Use host->host_lock instead of io_request_lock.
92 *
93 * 1 May 2001 Rev. 6.05 for linux 2.4.4
94 * + Clean up all pci related routines.
95 * + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d)
96 *
97 * 30 Jan 2001 Rev. 6.04 for linux 2.4.1
98 * + Call pci_resource_start after pci_enable_device.
99 *
100 * 25 Jan 2001 Rev. 6.03 for linux 2.4.0
101 * + "check_region" call replaced by "request_region".
102 *
103 * 22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11
104 * + Return code checked when calling pci_enable_device.
105 * + Removed old scsi error handling support.
106 * + The obsolete boot option flag eh:n is silently ignored.
107 * + Removed error messages while a disk drive is powered up at
108 * boot time.
109 * + Improved boot messages: all tagged capable device are
110 * indicated as "tagged" or "soft-tagged" :
111 * - "soft-tagged" means that the driver is trying to do its
112 * own tagging (i.e. the tc:y option is in effect);
113 * - "tagged" means that the device supports tagged commands,
114 * but the driver lets the HBA be responsible for tagging
115 * support.
116 *
117 * 16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18
118 * + Updated to the new __setup interface for boot command line options.
119 * + When loaded as a module, accepts the new parameter boot_options
120 * which value is a string with the same format of the kernel boot
121 * command line options. A valid example is:
122 * modprobe eata 'boot_options="0x7410,0x230,lc:y,tc:n,mq:4"'
123 *
124 * 9 Sep 1999 Rev. 5.10 for linux 2.2.12 and 2.3.17
125 * + 64bit cleanup for Linux/Alpha platform support
126 * (contribution from H.J. Lu).
127 *
128 * 22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11
129 * + Removed pre-2.2 source code compatibility.
130 * + Added call to pci_set_master.
131 *
132 * 26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111
133 * + Added command line option (rs:[y|n]) to reverse the scan order
134 * of PCI boards. The default is rs:y, which reverses the BIOS order
135 * while registering PCI boards. The default value rs:y generates
136 * the same order of all previous revisions of this driver.
137 * Pls. note that "BIOS order" might have been reversed itself
138 * after the 2.1.9x PCI modifications in the linux kernel.
139 * The rs value is ignored when the explicit list of addresses
140 * is used by the "eata=port0,port1,..." command line option.
141 * + Added command line option (et:[y|n]) to force use of extended
142 * translation (255 heads, 63 sectors) as disk geometry.
143 * The default is et:n, which uses the disk geometry returned
144 * by scsicam_bios_param. The default value et:n is compatible with
145 * all previous revisions of this driver.
146 *
147 * 28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104
148 * Increased busy timeout from 10 msec. to 200 msec. while
149 * processing interrupts.
150 *
151 * 16 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102
152 * Improved abort handling during the eh recovery process.
153 *
154 * 13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101
155 * The driver is now fully SMP safe, including the
156 * abort and reset routines.
157 * Added command line options (eh:[y|n]) to choose between
158 * new_eh_code and the old scsi code.
159 * If linux version >= 2.1.101 the default is eh:y, while the eh
160 * option is ignored for previous releases and the old scsi code
161 * is used.
162 *
163 * 18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97
164 * Reworked interrupt handler.
165 *
166 * 11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95
167 * Major reliability improvement: when a batch with overlapping
168 * requests is detected, requests are queued one at a time
169 * eliminating any possible board or drive reordering.
170 *
171 * 10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95
172 * Improved SMP support (if linux version >= 2.1.95).
173 *
174 * 9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94
175 * Added support for new PCI code and IO-APIC remapping of irqs.
176 * Performance improvement: when sequential i/o is detected,
177 * always use direct sort instead of reverse sort.
178 *
179 * 4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92
180 * io_port is now unsigned long.
181 *
182 * 17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88
183 * Use new scsi error handling code (if linux version >= 2.1.88).
184 * Use new interrupt code.
185 *
186 * 12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55
187 * Use of udelay inside the wait loops to avoid timeout
188 * problems with fast cpus.
189 * Removed check about useless calls to the interrupt service
190 * routine (reported on SMP systems only).
191 * At initialization time "sorted/unsorted" is displayed instead
192 * of "linked/unlinked" to reinforce the fact that "linking" is
193 * nothing but "elevator sorting" in the actual implementation.
194 *
195 * 17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38
196 * Use of serial_number_at_timeout in abort and reset processing.
197 * Use of the __initfunc and __initdata macro in setup code.
198 * Minor cleanups in the list_statistics code.
199 * Increased controller busy timeout in order to better support
200 * slow SCSI devices.
201 *
202 * 24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26
203 * When loading as a module, parameter passing is now supported
204 * both in 2.0 and in 2.1 style.
205 * Fixed data transfer direction for some SCSI opcodes.
206 * Immediate acknowledge to request sense commands.
207 * Linked commands to each disk device are now reordered by elevator
208 * sorting. Rare cases in which reordering of write requests could
209 * cause wrong results are managed.
210 * Fixed spurious timeouts caused by long simple queue tag sequences.
211 * New command line option (tm:[0-3]) to choose the type of tags:
212 * 0 -> mixed (default); 1 -> simple; 2 -> head; 3 -> ordered.
213 *
214 * 18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28
215 * Added command line options to enable/disable linked commands
216 * (lc:[y|n]), tagged commands (tc:[y|n]) and to set the max queue
217 * depth (mq:xx). Default is "eata=lc:n,tc:n,mq:16".
218 * Improved command linking.
219 * Documented how to setup RAID-0 with DPT SmartRAID boards.
220 *
221 * 8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27
222 * Added linked command support.
223 * Improved detection of PCI boards using ISA base addresses.
224 *
225 * 3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27
226 * Added support for tagged commands and queue depth adjustment.
227 *
228 * 22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26
229 * When CONFIG_PCI is defined, BIOS32 is used to include in the
230 * list of i/o ports to be probed all the PCI SCSI controllers.
231 * The list of i/o ports to be probed can be overwritten by the
232 * "eata=port0,port1,...." boot command line option.
233 * Scatter/gather lists are now allocated by a number of kmalloc
234 * calls, in order to avoid the previous size limit of 64Kb.
235 *
236 * 16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25
237 * Added support for EATA 2.0C, PCI, multichannel and wide SCSI.
238 *
239 * 27 Sep 1996 rev. 2.12 for linux 2.1.0
240 * Portability cleanups (virtual/bus addressing, little/big endian
241 * support).
242 *
243 * 09 Jul 1996 rev. 2.11 for linux 2.0.4
244 * Number of internal retries is now limited.
245 *
246 * 16 Apr 1996 rev. 2.10 for linux 1.3.90
247 * New argument "reset_flags" to the reset routine.
248 *
249 * 6 Jul 1995 rev. 2.01 for linux 1.3.7
250 * Update required by the new /proc/scsi support.
251 *
252 * 11 Mar 1995 rev. 2.00 for linux 1.2.0
253 * Fixed a bug which prevented media change detection for removable
254 * disk drives.
255 *
256 * 23 Feb 1995 rev. 1.18 for linux 1.1.94
257 * Added a check for scsi_register returning NULL.
258 *
259 * 11 Feb 1995 rev. 1.17 for linux 1.1.91
260 * Now DEBUG_RESET is disabled by default.
261 * Register a board even if it does not assert DMA protocol support
262 * (DPT SK2011B does not report correctly the dmasup bit).
263 *
264 * 9 Feb 1995 rev. 1.16 for linux 1.1.90
265 * Use host->wish_block instead of host->block.
266 * New list of Data Out SCSI commands.
267 *
268 * 8 Feb 1995 rev. 1.15 for linux 1.1.89
269 * Cleared target_time_out counter while performing a reset.
270 * All external symbols renamed to avoid possible name conflicts.
271 *
272 * 28 Jan 1995 rev. 1.14 for linux 1.1.86
273 * Added module support.
274 * Log and do a retry when a disk drive returns a target status
275 * different from zero on a recovered error.
276 *
277 * 24 Jan 1995 rev. 1.13 for linux 1.1.85
278 * Use optimized board configuration, with a measured performance
279 * increase in the range 10%-20% on i/o throughput.
280 *
281 * 16 Jan 1995 rev. 1.12 for linux 1.1.81
282 * Fix mscp structure comments (no functional change).
283 * Display a message if check_region detects a port address
284 * already in use.
285 *
286 * 17 Dec 1994 rev. 1.11 for linux 1.1.74
287 * Use the scsicam_bios_param routine. This allows an easy
288 * migration path from disk partition tables created using
289 * different SCSI drivers and non optimal disk geometry.
290 *
291 * 15 Dec 1994 rev. 1.10 for linux 1.1.74
292 * Added support for ISA EATA boards (DPT PM2011, DPT PM2021).
293 * The host->block flag is set for all the detected ISA boards.
294 * The detect routine no longer enforces LEVEL triggering
295 * for EISA boards, it just prints a warning message.
296 *
297 * 30 Nov 1994 rev. 1.09 for linux 1.1.68
298 * Redo i/o on target status CHECK_CONDITION for TYPE_DISK only.
299 * Added optional support for using a single board at a time.
300 *
301 * 18 Nov 1994 rev. 1.08 for linux 1.1.64
302 * Forces sg_tablesize = 64 and can_queue = 64 if these
303 * values are not correctly detected (DPT PM2012).
304 *
305 * 14 Nov 1994 rev. 1.07 for linux 1.1.63 Final BETA release.
306 * 04 Aug 1994 rev. 1.00 for linux 1.1.39 First BETA release.
307 *
308 *
309 * This driver is based on the CAM (Common Access Method Committee)
310 * EATA (Enhanced AT Bus Attachment) rev. 2.0A, using DMA protocol.
311 *
312 * Copyright (C) 1994-2003 Dario Ballabio (ballabio_dario@emc.com)
313 *
314 * Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it
315 *
316 * Redistribution and use in source and binary forms, with or without
317 * modification, are permitted provided that redistributions of source
318 * code retain the above copyright notice and this comment without
319 * modification.
320 *
321 */
322
323 /*
324 *
325 * Here is a brief description of the DPT SCSI host adapters.
326 * All these boards provide an EATA/DMA compatible programming interface
327 * and are fully supported by this driver in any configuration, including
328 * multiple SCSI channels:
329 *
330 * PM2011B/9X - Entry Level ISA
331 * PM2021A/9X - High Performance ISA
332 * PM2012A Old EISA
333 * PM2012B Old EISA
334 * PM2022A/9X - Entry Level EISA
335 * PM2122A/9X - High Performance EISA
336 * PM2322A/9X - Extra High Performance EISA
337 * PM3021 - SmartRAID Adapter for ISA
338 * PM3222 - SmartRAID Adapter for EISA (PM3222W is 16-bit wide SCSI)
339 * PM3224 - SmartRAID Adapter for PCI (PM3224W is 16-bit wide SCSI)
340 * PM33340UW - SmartRAID Adapter for PCI ultra wide multichannel
341 *
342 * The above list is just an indication: as a matter of fact all DPT
343 * boards using the EATA/DMA protocol are supported by this driver,
344 * since they use exactely the same programming interface.
345 *
346 * The DPT PM2001 provides only the EATA/PIO interface and hence is not
347 * supported by this driver.
348 *
349 * This code has been tested with up to 3 Distributed Processing Technology
350 * PM2122A/9X (DPT SCSI BIOS v002.D1, firmware v05E.0) EISA controllers,
351 * in any combination of private and shared IRQ.
352 * PCI support has been tested using up to 2 DPT PM3224W (DPT SCSI BIOS
353 * v003.D0, firmware v07G.0).
354 *
355 * DPT SmartRAID boards support "Hardware Array" - a group of disk drives
356 * which are all members of the same RAID-0, RAID-1 or RAID-5 array implemented
357 * in host adapter hardware. Hardware Arrays are fully compatible with this
358 * driver, since they look to it as a single disk drive.
359 *
360 * WARNING: to create a RAID-0 "Hardware Array" you must select "Other Unix"
361 * as the current OS in the DPTMGR "Initial System Installation" menu.
362 * Otherwise RAID-0 is generated as an "Array Group" (i.e. software RAID-0),
363 * which is not supported by the actual SCSI subsystem.
364 * To get the "Array Group" functionality, the Linux MD driver must be used
365 * instead of the DPT "Array Group" feature.
366 *
367 * Multiple ISA, EISA and PCI boards can be configured in the same system.
368 * It is suggested to put all the EISA boards on the same IRQ level, all
369 * the PCI boards on another IRQ level, while ISA boards cannot share
370 * interrupts.
371 *
372 * If you configure multiple boards on the same IRQ, the interrupt must
373 * be _level_ triggered (not _edge_ triggered).
374 *
375 * This driver detects EATA boards by probes at fixed port addresses,
376 * so no BIOS32 or PCI BIOS support is required.
377 * The suggested way to detect a generic EATA PCI board is to force on it
378 * any unused EISA address, even if there are other controllers on the EISA
379 * bus, or even if you system has no EISA bus at all.
380 * Do not force any ISA address on EATA PCI boards.
381 *
382 * If PCI bios support is configured into the kernel, BIOS32 is used to
383 * include in the list of i/o ports to be probed all the PCI SCSI controllers.
384 *
385 * Due to a DPT BIOS "feature", it might not be possible to force an EISA
386 * address on more than a single DPT PCI board, so in this case you have to
387 * let the PCI BIOS assign the addresses.
388 *
389 * The sequence of detection probes is:
390 *
391 * - ISA 0x1F0;
392 * - PCI SCSI controllers (only if BIOS32 is available);
393 * - EISA/PCI 0x1C88 through 0xFC88 (corresponding to EISA slots 1 to 15);
394 * - ISA 0x170, 0x230, 0x330.
395 *
396 * The above list of detection probes can be totally replaced by the
397 * boot command line option: "eata=port0,port1,port2,...", where the
398 * port0, port1... arguments are ISA/EISA/PCI addresses to be probed.
399 * For example using "eata=0x7410,0x7450,0x230", the driver probes
400 * only the two PCI addresses 0x7410 and 0x7450 and the ISA address 0x230,
401 * in this order; "eata=0" totally disables this driver.
402 *
403 * After the optional list of detection probes, other possible command line
404 * options are:
405 *
406 * et:y force use of extended translation (255 heads, 63 sectors);
407 * et:n use disk geometry detected by scsicam_bios_param;
408 * rs:y reverse scan order while detecting PCI boards;
409 * rs:n use BIOS order while detecting PCI boards;
410 * lc:y enables linked commands;
411 * lc:n disables linked commands;
412 * tm:0 disables tagged commands (same as tc:n);
413 * tm:1 use simple queue tags (same as tc:y);
414 * tm:2 use ordered queue tags (same as tc:2);
415 * mq:xx set the max queue depth to the value xx (2 <= xx <= 32).
416 *
417 * The default value is: "eata=lc:n,mq:16,tm:0,et:n,rs:n".
418 * An example using the list of detection probes could be:
419 * "eata=0x7410,0x230,lc:y,tm:2,mq:4,et:n".
420 *
421 * When loading as a module, parameters can be specified as well.
422 * The above example would be (use 1 in place of y and 0 in place of n):
423 *
424 * modprobe eata io_port=0x7410,0x230 linked_comm=1 \
425 * max_queue_depth=4 ext_tran=0 tag_mode=2 \
426 * rev_scan=1
427 *
428 * ----------------------------------------------------------------------------
429 * In this implementation, linked commands are designed to work with any DISK
430 * or CD-ROM, since this linking has only the intent of clustering (time-wise)
431 * and reordering by elevator sorting commands directed to each device,
432 * without any relation with the actual SCSI protocol between the controller
433 * and the device.
434 * If Q is the queue depth reported at boot time for each device (also named
435 * cmds/lun) and Q > 2, whenever there is already an active command to the
436 * device all other commands to the same device (up to Q-1) are kept waiting
437 * in the elevator sorting queue. When the active command completes, the
438 * commands in this queue are sorted by sector address. The sort is chosen
439 * between increasing or decreasing by minimizing the seek distance between
440 * the sector of the commands just completed and the sector of the first
441 * command in the list to be sorted.
442 * Trivial math assures that the unsorted average seek distance when doing
443 * random seeks over S sectors is S/3.
444 * When (Q-1) requests are uniformly distributed over S sectors, the average
445 * distance between two adjacent requests is S/((Q-1) + 1), so the sorted
446 * average seek distance for (Q-1) random requests over S sectors is S/Q.
447 * The elevator sorting hence divides the seek distance by a factor Q/3.
448 * The above pure geometric remarks are valid in all cases and the
449 * driver effectively reduces the seek distance by the predicted factor
450 * when there are Q concurrent read i/o operations on the device, but this
451 * does not necessarily results in a noticeable performance improvement:
452 * your mileage may vary....
453 *
454 * Note: command reordering inside a batch of queued commands could cause
455 * wrong results only if there is at least one write request and the
456 * intersection (sector-wise) of all requests is not empty.
457 * When the driver detects a batch including overlapping requests
458 * (a really rare event) strict serial (pid) order is enforced.
459 * ----------------------------------------------------------------------------
460 * The extended translation option (et:y) is useful when using large physical
461 * disks/arrays. It could also be useful when switching between Adaptec boards
462 * and DPT boards without reformatting the disk.
463 * When a boot disk is partitioned with extended translation, in order to
464 * be able to boot it with a DPT board is could be necessary to add to
465 * lilo.conf additional commands as in the following example:
466 *
467 * fix-table
468 * disk=/dev/sda bios=0x80 sectors=63 heads=128 cylindres=546
469 *
470 * where the above geometry should be replaced with the one reported at
471 * power up by the DPT controller.
472 * ----------------------------------------------------------------------------
473 *
474 * The boards are named EATA0, EATA1,... according to the detection order.
475 *
476 * In order to support multiple ISA boards in a reliable way,
477 * the driver sets host->wish_block = 1 for all ISA boards.
478 */
479
480 #include <linux/string.h>
481 #include <linux/kernel.h>
482 #include <linux/ioport.h>
483 #include <linux/delay.h>
484 #include <linux/proc_fs.h>
485 #include <linux/blkdev.h>
486 #include <linux/interrupt.h>
487 #include <linux/stat.h>
488 #include <linux/pci.h>
489 #include <linux/init.h>
490 #include <linux/ctype.h>
491 #include <linux/spinlock.h>
492 #include <linux/dma-mapping.h>
493 #include <asm/byteorder.h>
494 #include <asm/dma.h>
495 #include <asm/io.h>
496 #include <asm/irq.h>
497
498 #include <scsi/scsi.h>
499 #include <scsi/scsi_cmnd.h>
500 #include <scsi/scsi_device.h>
501 #include <scsi/scsi_host.h>
502 #include <scsi/scsi_tcq.h>
503 #include <scsi/scsicam.h>
504
505 static int eata2x_detect(struct scsi_host_template *);
506 static int eata2x_release(struct Scsi_Host *);
507 static int eata2x_queuecommand(struct scsi_cmnd *,
508 void (*done) (struct scsi_cmnd *));
509 static int eata2x_eh_abort(struct scsi_cmnd *);
510 static int eata2x_eh_host_reset(struct scsi_cmnd *);
511 static int eata2x_bios_param(struct scsi_device *, struct block_device *,
512 sector_t, int *);
513 static int eata2x_slave_configure(struct scsi_device *);
514
515 static struct scsi_host_template driver_template = {
516 .name = "EATA/DMA 2.0x rev. 8.10.00 ",
517 .detect = eata2x_detect,
518 .release = eata2x_release,
519 .queuecommand = eata2x_queuecommand,
520 .eh_abort_handler = eata2x_eh_abort,
521 .eh_host_reset_handler = eata2x_eh_host_reset,
522 .bios_param = eata2x_bios_param,
523 .slave_configure = eata2x_slave_configure,
524 .this_id = 7,
525 .unchecked_isa_dma = 1,
526 .use_clustering = ENABLE_CLUSTERING,
527 .use_sg_chaining = ENABLE_SG_CHAINING,
528 };
529
530 #if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
531 #error "Adjust your <asm/byteorder.h> defines"
532 #endif
533
534 /* Subversion values */
535 #define ISA 0
536 #define ESA 1
537
538 #undef FORCE_CONFIG
539
540 #undef DEBUG_LINKED_COMMANDS
541 #undef DEBUG_DETECT
542 #undef DEBUG_PCI_DETECT
543 #undef DEBUG_INTERRUPT
544 #undef DEBUG_RESET
545 #undef DEBUG_GENERATE_ERRORS
546 #undef DEBUG_GENERATE_ABORTS
547 #undef DEBUG_GEOMETRY
548
549 #define MAX_ISA 4
550 #define MAX_VESA 0
551 #define MAX_EISA 15
552 #define MAX_PCI 16
553 #define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
554 #define MAX_CHANNEL 4
555 #define MAX_LUN 32
556 #define MAX_TARGET 32
557 #define MAX_MAILBOXES 64
558 #define MAX_SGLIST 64
559 #define MAX_LARGE_SGLIST 122
560 #define MAX_INTERNAL_RETRIES 64
561 #define MAX_CMD_PER_LUN 2
562 #define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
563
564 #define SKIP ULONG_MAX
565 #define FREE 0
566 #define IN_USE 1
567 #define LOCKED 2
568 #define IN_RESET 3
569 #define IGNORE 4
570 #define READY 5
571 #define ABORTING 6
572 #define NO_DMA 0xff
573 #define MAXLOOP 10000
574 #define TAG_DISABLED 0
575 #define TAG_SIMPLE 1
576 #define TAG_ORDERED 2
577
578 #define REG_CMD 7
579 #define REG_STATUS 7
580 #define REG_AUX_STATUS 8
581 #define REG_DATA 0
582 #define REG_DATA2 1
583 #define REG_SEE 6
584 #define REG_LOW 2
585 #define REG_LM 3
586 #define REG_MID 4
587 #define REG_MSB 5
588 #define REGION_SIZE 9UL
589 #define MAX_ISA_ADDR 0x03ff
590 #define MIN_EISA_ADDR 0x1c88
591 #define MAX_EISA_ADDR 0xfc88
592 #define BSY_ASSERTED 0x80
593 #define DRQ_ASSERTED 0x08
594 #define ABSY_ASSERTED 0x01
595 #define IRQ_ASSERTED 0x02
596 #define READ_CONFIG_PIO 0xf0
597 #define SET_CONFIG_PIO 0xf1
598 #define SEND_CP_PIO 0xf2
599 #define RECEIVE_SP_PIO 0xf3
600 #define TRUNCATE_XFR_PIO 0xf4
601 #define RESET_PIO 0xf9
602 #define READ_CONFIG_DMA 0xfd
603 #define SET_CONFIG_DMA 0xfe
604 #define SEND_CP_DMA 0xff
605 #define ASOK 0x00
606 #define ASST 0x01
607
608 #define YESNO(a) ((a) ? 'y' : 'n')
609 #define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
610
611 /* "EATA", in Big Endian format */
612 #define EATA_SIG_BE 0x45415441
613
614 /* Number of valid bytes in the board config structure for EATA 2.0x */
615 #define EATA_2_0A_SIZE 28
616 #define EATA_2_0B_SIZE 30
617 #define EATA_2_0C_SIZE 34
618
619 /* Board info structure */
620 struct eata_info {
621 u_int32_t data_len; /* Number of valid bytes after this field */
622 u_int32_t sign; /* ASCII "EATA" signature */
623
624 #if defined(__BIG_ENDIAN_BITFIELD)
625 unchar version : 4,
626 : 4;
627 unchar haaval : 1,
628 ata : 1,
629 drqvld : 1,
630 dmasup : 1,
631 morsup : 1,
632 trnxfr : 1,
633 tarsup : 1,
634 ocsena : 1;
635 #else
636 unchar : 4, /* unused low nibble */
637 version : 4; /* EATA version, should be 0x1 */
638 unchar ocsena : 1, /* Overlap Command Support Enabled */
639 tarsup : 1, /* Target Mode Supported */
640 trnxfr : 1, /* Truncate Transfer Cmd NOT Necessary */
641 morsup : 1, /* More Supported */
642 dmasup : 1, /* DMA Supported */
643 drqvld : 1, /* DRQ Index (DRQX) is valid */
644 ata : 1, /* This is an ATA device */
645 haaval : 1; /* Host Adapter Address Valid */
646 #endif
647
648 ushort cp_pad_len; /* Number of pad bytes after cp_len */
649 unchar host_addr[4]; /* Host Adapter SCSI ID for channels 3, 2, 1, 0 */
650 u_int32_t cp_len; /* Number of valid bytes in cp */
651 u_int32_t sp_len; /* Number of valid bytes in sp */
652 ushort queue_size; /* Max number of cp that can be queued */
653 ushort unused;
654 ushort scatt_size; /* Max number of entries in scatter/gather table */
655
656 #if defined(__BIG_ENDIAN_BITFIELD)
657 unchar drqx : 2,
658 second : 1,
659 irq_tr : 1,
660 irq : 4;
661 unchar sync;
662 unchar : 4,
663 res1 : 1,
664 large_sg : 1,
665 forcaddr : 1,
666 isaena : 1;
667 unchar max_chan : 3,
668 max_id : 5;
669 unchar max_lun;
670 unchar eisa : 1,
671 pci : 1,
672 idquest : 1,
673 m1 : 1,
674 : 4;
675 #else
676 unchar irq : 4, /* Interrupt Request assigned to this controller */
677 irq_tr : 1, /* 0 for edge triggered, 1 for level triggered */
678 second : 1, /* 1 if this is a secondary (not primary) controller */
679 drqx : 2; /* DRQ Index (0=DMA0, 1=DMA7, 2=DMA6, 3=DMA5) */
680 unchar sync; /* 1 if scsi target id 7...0 is running sync scsi */
681
682 /* Structure extension defined in EATA 2.0B */
683 unchar isaena : 1, /* ISA i/o addressing is disabled/enabled */
684 forcaddr : 1, /* Port address has been forced */
685 large_sg : 1, /* 1 if large SG lists are supported */
686 res1 : 1,
687 : 4;
688 unchar max_id : 5, /* Max SCSI target ID number */
689 max_chan : 3; /* Max SCSI channel number on this board */
690
691 /* Structure extension defined in EATA 2.0C */
692 unchar max_lun; /* Max SCSI LUN number */
693 unchar
694 : 4,
695 m1 : 1, /* This is a PCI with an M1 chip installed */
696 idquest : 1, /* RAIDNUM returned is questionable */
697 pci : 1, /* This board is PCI */
698 eisa : 1; /* This board is EISA */
699 #endif
700
701 unchar raidnum; /* Uniquely identifies this HBA in a system */
702 unchar notused;
703
704 ushort ipad[247];
705 };
706
707 /* Board config structure */
708 struct eata_config {
709 ushort len; /* Number of bytes following this field */
710
711 #if defined(__BIG_ENDIAN_BITFIELD)
712 unchar : 4,
713 tarena : 1,
714 mdpena : 1,
715 ocena : 1,
716 edis : 1;
717 #else
718 unchar edis : 1, /* Disable EATA interface after config command */
719 ocena : 1, /* Overlapped Commands Enabled */
720 mdpena : 1, /* Transfer all Modified Data Pointer Messages */
721 tarena : 1, /* Target Mode Enabled for this controller */
722 : 4;
723 #endif
724 unchar cpad[511];
725 };
726
727 /* Returned status packet structure */
728 struct mssp {
729 #if defined(__BIG_ENDIAN_BITFIELD)
730 unchar eoc : 1,
731 adapter_status : 7;
732 #else
733 unchar adapter_status : 7, /* State related to current command */
734 eoc : 1; /* End Of Command (1 = command completed) */
735 #endif
736 unchar target_status; /* SCSI status received after data transfer */
737 unchar unused[2];
738 u_int32_t inv_res_len; /* Number of bytes not transferred */
739 u_int32_t cpp_index; /* Index of address set in cp */
740 char mess[12];
741 };
742
743 struct sg_list {
744 unsigned int address; /* Segment Address */
745 unsigned int num_bytes; /* Segment Length */
746 };
747
748 /* MailBox SCSI Command Packet */
749 struct mscp {
750 #if defined(__BIG_ENDIAN_BITFIELD)
751 unchar din : 1,
752 dout : 1,
753 interp : 1,
754 : 1,
755 sg : 1,
756 reqsen :1,
757 init : 1,
758 sreset : 1;
759 unchar sense_len;
760 unchar unused[3];
761 unchar : 7,
762 fwnest : 1;
763 unchar : 5,
764 hbaci : 1,
765 iat : 1,
766 phsunit : 1;
767 unchar channel : 3,
768 target : 5;
769 unchar one : 1,
770 dispri : 1,
771 luntar : 1,
772 lun : 5;
773 #else
774 unchar sreset :1, /* SCSI Bus Reset Signal should be asserted */
775 init :1, /* Re-initialize controller and self test */
776 reqsen :1, /* Transfer Request Sense Data to addr using DMA */
777 sg :1, /* Use Scatter/Gather */
778 :1,
779 interp :1, /* The controller interprets cp, not the target */
780 dout :1, /* Direction of Transfer is Out (Host to Target) */
781 din :1; /* Direction of Transfer is In (Target to Host) */
782 unchar sense_len; /* Request Sense Length */
783 unchar unused[3];
784 unchar fwnest : 1, /* Send command to a component of an Array Group */
785 : 7;
786 unchar phsunit : 1, /* Send to Target Physical Unit (bypass RAID) */
787 iat : 1, /* Inhibit Address Translation */
788 hbaci : 1, /* Inhibit HBA Caching for this command */
789 : 5;
790 unchar target : 5, /* SCSI target ID */
791 channel : 3; /* SCSI channel number */
792 unchar lun : 5, /* SCSI logical unit number */
793 luntar : 1, /* This cp is for Target (not LUN) */
794 dispri : 1, /* Disconnect Privilege granted */
795 one : 1; /* 1 */
796 #endif
797
798 unchar mess[3]; /* Massage to/from Target */
799 unchar cdb[12]; /* Command Descriptor Block */
800 u_int32_t data_len; /* If sg=0 Data Length, if sg=1 sglist length */
801 u_int32_t cpp_index; /* Index of address to be returned in sp */
802 u_int32_t data_address; /* If sg=0 Data Address, if sg=1 sglist address */
803 u_int32_t sp_dma_addr; /* Address where sp is DMA'ed when cp completes */
804 u_int32_t sense_addr; /* Address where Sense Data is DMA'ed on error */
805
806 /* Additional fields begin here. */
807 struct scsi_cmnd *SCpnt;
808
809 /* All the cp structure is zero filled by queuecommand except the
810 following CP_TAIL_SIZE bytes, initialized by detect */
811 dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
812 struct sg_list *sglist; /* pointer to the allocated SG list */
813 };
814
815 #define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
816
817 struct hostdata {
818 struct mscp cp[MAX_MAILBOXES]; /* Mailboxes for this board */
819 unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
820 unsigned int last_cp_used; /* Index of last mailbox used */
821 unsigned int iocount; /* Total i/o done for this board */
822 int board_number; /* Number of this board */
823 char board_name[16]; /* Name of this board */
824 int in_reset; /* True if board is doing a reset */
825 int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
826 int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If 1 redo i/o on target */
827 unsigned int retries; /* Number of internal retries */
828 unsigned long last_retried_pid; /* Pid of last retried command */
829 unsigned char subversion; /* Bus type, either ISA or EISA/PCI */
830 unsigned char protocol_rev; /* EATA 2.0 rev., 'A' or 'B' or 'C' */
831 unsigned char is_pci; /* 1 is bus type is PCI */
832 struct pci_dev *pdev; /* pdev for PCI bus, NULL otherwise */
833 struct mssp *sp_cpu_addr; /* cpu addr for DMA buffer sp */
834 dma_addr_t sp_dma_addr; /* dma handle for DMA buffer sp */
835 struct mssp sp; /* Local copy of sp buffer */
836 };
837
838 static struct Scsi_Host *sh[MAX_BOARDS];
839 static const char *driver_name = "EATA";
840 static char sha[MAX_BOARDS];
841 static DEFINE_SPINLOCK(driver_lock);
842
843 /* Initialize num_boards so that ihdlr can work while detect is in progress */
844 static unsigned int num_boards = MAX_BOARDS;
845
846 static unsigned long io_port[] = {
847
848 /* Space for MAX_INT_PARAM ports usable while loading as a module */
849 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
850 SKIP, SKIP,
851
852 /* First ISA */
853 0x1f0,
854
855 /* Space for MAX_PCI ports possibly reported by PCI_BIOS */
856 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
857 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
858
859 /* MAX_EISA ports */
860 0x1c88, 0x2c88, 0x3c88, 0x4c88, 0x5c88, 0x6c88, 0x7c88, 0x8c88,
861 0x9c88, 0xac88, 0xbc88, 0xcc88, 0xdc88, 0xec88, 0xfc88,
862
863 /* Other (MAX_ISA - 1) ports */
864 0x170, 0x230, 0x330,
865
866 /* End of list */
867 0x0
868 };
869
870 /* Device is Big Endian */
871 #define H2DEV(x) cpu_to_be32(x)
872 #define DEV2H(x) be32_to_cpu(x)
873 #define H2DEV16(x) cpu_to_be16(x)
874 #define DEV2H16(x) be16_to_cpu(x)
875
876 /* But transfer orientation from the 16 bit data register is Little Endian */
877 #define REG2H(x) le16_to_cpu(x)
878
879 static irqreturn_t do_interrupt_handler(int, void *);
880 static void flush_dev(struct scsi_device *, unsigned long, struct hostdata *,
881 unsigned int);
882 static int do_trace = 0;
883 static int setup_done = 0;
884 static int link_statistics;
885 static int ext_tran = 0;
886 static int rev_scan = 1;
887
888 #if defined(CONFIG_SCSI_EATA_TAGGED_QUEUE)
889 static int tag_mode = TAG_SIMPLE;
890 #else
891 static int tag_mode = TAG_DISABLED;
892 #endif
893
894 #if defined(CONFIG_SCSI_EATA_LINKED_COMMANDS)
895 static int linked_comm = 1;
896 #else
897 static int linked_comm = 0;
898 #endif
899
900 #if defined(CONFIG_SCSI_EATA_MAX_TAGS)
901 static int max_queue_depth = CONFIG_SCSI_EATA_MAX_TAGS;
902 #else
903 static int max_queue_depth = MAX_CMD_PER_LUN;
904 #endif
905
906 #if defined(CONFIG_ISA)
907 static int isa_probe = 1;
908 #else
909 static int isa_probe = 0;
910 #endif
911
912 #if defined(CONFIG_EISA)
913 static int eisa_probe = 1;
914 #else
915 static int eisa_probe = 0;
916 #endif
917
918 #if defined(CONFIG_PCI)
919 static int pci_probe = 1;
920 #else
921 static int pci_probe = 0;
922 #endif
923
924 #define MAX_INT_PARAM 10
925 #define MAX_BOOT_OPTIONS_SIZE 256
926 static char boot_options[MAX_BOOT_OPTIONS_SIZE];
927
928 #if defined(MODULE)
929 #include <linux/module.h>
930 #include <linux/moduleparam.h>
931
932 module_param_string(eata, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
933 MODULE_PARM_DESC(eata, " equivalent to the \"eata=...\" kernel boot option."
934 " Example: modprobe eata \"eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n\"");
935 MODULE_AUTHOR("Dario Ballabio");
936 MODULE_LICENSE("GPL");
937 MODULE_DESCRIPTION("EATA/DMA SCSI Driver");
938
939 #endif
940
941 static int eata2x_slave_configure(struct scsi_device *dev)
942 {
943 int tqd, utqd;
944 char *tag_suffix, *link_suffix;
945
946 utqd = MAX_CMD_PER_LUN;
947 tqd = max_queue_depth;
948
949 if (TLDEV(dev->type) && dev->tagged_supported) {
950 if (tag_mode == TAG_SIMPLE) {
951 scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
952 tag_suffix = ", simple tags";
953 } else if (tag_mode == TAG_ORDERED) {
954 scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
955 tag_suffix = ", ordered tags";
956 } else {
957 scsi_adjust_queue_depth(dev, 0, tqd);
958 tag_suffix = ", no tags";
959 }
960 } else if (TLDEV(dev->type) && linked_comm) {
961 scsi_adjust_queue_depth(dev, 0, tqd);
962 tag_suffix = ", untagged";
963 } else {
964 scsi_adjust_queue_depth(dev, 0, utqd);
965 tag_suffix = "";
966 }
967
968 if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
969 link_suffix = ", sorted";
970 else if (TLDEV(dev->type))
971 link_suffix = ", unsorted";
972 else
973 link_suffix = "";
974
975 sdev_printk(KERN_INFO, dev,
976 "cmds/lun %d%s%s.\n",
977 dev->queue_depth, link_suffix, tag_suffix);
978
979 return 0;
980 }
981
982 static int wait_on_busy(unsigned long iobase, unsigned int loop)
983 {
984 while (inb(iobase + REG_AUX_STATUS) & ABSY_ASSERTED) {
985 udelay(1L);
986 if (--loop == 0)
987 return 1;
988 }
989 return 0;
990 }
991
992 static int do_dma(unsigned long iobase, unsigned long addr, unchar cmd)
993 {
994 unsigned char *byaddr;
995 unsigned long devaddr;
996
997 if (wait_on_busy(iobase, (addr ? MAXLOOP * 100 : MAXLOOP)))
998 return 1;
999
1000 if (addr) {
1001 devaddr = H2DEV(addr);
1002 byaddr = (unsigned char *)&devaddr;
1003 outb(byaddr[3], iobase + REG_LOW);
1004 outb(byaddr[2], iobase + REG_LM);
1005 outb(byaddr[1], iobase + REG_MID);
1006 outb(byaddr[0], iobase + REG_MSB);
1007 }
1008
1009 outb(cmd, iobase + REG_CMD);
1010 return 0;
1011 }
1012
1013 static int read_pio(unsigned long iobase, ushort * start, ushort * end)
1014 {
1015 unsigned int loop = MAXLOOP;
1016 ushort *p;
1017
1018 for (p = start; p <= end; p++) {
1019 while (!(inb(iobase + REG_STATUS) & DRQ_ASSERTED)) {
1020 udelay(1L);
1021 if (--loop == 0)
1022 return 1;
1023 }
1024 loop = MAXLOOP;
1025 *p = REG2H(inw(iobase));
1026 }
1027
1028 return 0;
1029 }
1030
1031 static struct pci_dev *get_pci_dev(unsigned long port_base)
1032 {
1033 #if defined(CONFIG_PCI)
1034 unsigned int addr;
1035 struct pci_dev *dev = NULL;
1036
1037 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1038 addr = pci_resource_start(dev, 0);
1039
1040 #if defined(DEBUG_PCI_DETECT)
1041 printk("%s: get_pci_dev, bus %d, devfn 0x%x, addr 0x%x.\n",
1042 driver_name, dev->bus->number, dev->devfn, addr);
1043 #endif
1044
1045 /* we are in so much trouble for a pci hotplug system with this driver
1046 * anyway, so doing this at least lets people unload the driver and not
1047 * cause memory problems, but in general this is a bad thing to do (this
1048 * driver needs to be converted to the proper PCI api someday... */
1049 pci_dev_put(dev);
1050 if (addr + PCI_BASE_ADDRESS_0 == port_base)
1051 return dev;
1052 }
1053 #endif /* end CONFIG_PCI */
1054 return NULL;
1055 }
1056
1057 static void enable_pci_ports(void)
1058 {
1059 #if defined(CONFIG_PCI)
1060 struct pci_dev *dev = NULL;
1061
1062 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1063 #if defined(DEBUG_PCI_DETECT)
1064 printk("%s: enable_pci_ports, bus %d, devfn 0x%x.\n",
1065 driver_name, dev->bus->number, dev->devfn);
1066 #endif
1067
1068 if (pci_enable_device(dev))
1069 printk
1070 ("%s: warning, pci_enable_device failed, bus %d devfn 0x%x.\n",
1071 driver_name, dev->bus->number, dev->devfn);
1072 }
1073
1074 #endif /* end CONFIG_PCI */
1075 }
1076
1077 static int port_detect(unsigned long port_base, unsigned int j,
1078 struct scsi_host_template *tpnt)
1079 {
1080 unsigned char irq, dma_channel, subversion, i, is_pci = 0;
1081 unsigned char protocol_rev;
1082 struct eata_info info;
1083 char *bus_type, dma_name[16];
1084 struct pci_dev *pdev;
1085 /* Allowed DMA channels for ISA (0 indicates reserved) */
1086 unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
1087 struct Scsi_Host *shost;
1088 struct hostdata *ha;
1089 char name[16];
1090
1091 sprintf(name, "%s%d", driver_name, j);
1092
1093 if (!request_region(port_base, REGION_SIZE, driver_name)) {
1094 #if defined(DEBUG_DETECT)
1095 printk("%s: address 0x%03lx in use, skipping probe.\n", name,
1096 port_base);
1097 #endif
1098 goto fail;
1099 }
1100
1101 spin_lock_irq(&driver_lock);
1102
1103 if (do_dma(port_base, 0, READ_CONFIG_PIO)) {
1104 #if defined(DEBUG_DETECT)
1105 printk("%s: detect, do_dma failed at 0x%03lx.\n", name,
1106 port_base);
1107 #endif
1108 goto freelock;
1109 }
1110
1111 /* Read the info structure */
1112 if (read_pio(port_base, (ushort *) & info, (ushort *) & info.ipad[0])) {
1113 #if defined(DEBUG_DETECT)
1114 printk("%s: detect, read_pio failed at 0x%03lx.\n", name,
1115 port_base);
1116 #endif
1117 goto freelock;
1118 }
1119
1120 info.data_len = DEV2H(info.data_len);
1121 info.sign = DEV2H(info.sign);
1122 info.cp_pad_len = DEV2H16(info.cp_pad_len);
1123 info.cp_len = DEV2H(info.cp_len);
1124 info.sp_len = DEV2H(info.sp_len);
1125 info.scatt_size = DEV2H16(info.scatt_size);
1126 info.queue_size = DEV2H16(info.queue_size);
1127
1128 /* Check the controller "EATA" signature */
1129 if (info.sign != EATA_SIG_BE) {
1130 #if defined(DEBUG_DETECT)
1131 printk("%s: signature 0x%04x discarded.\n", name, info.sign);
1132 #endif
1133 goto freelock;
1134 }
1135
1136 if (info.data_len < EATA_2_0A_SIZE) {
1137 printk
1138 ("%s: config structure size (%d bytes) too short, detaching.\n",
1139 name, info.data_len);
1140 goto freelock;
1141 } else if (info.data_len == EATA_2_0A_SIZE)
1142 protocol_rev = 'A';
1143 else if (info.data_len == EATA_2_0B_SIZE)
1144 protocol_rev = 'B';
1145 else
1146 protocol_rev = 'C';
1147
1148 if (protocol_rev != 'A' && info.forcaddr) {
1149 printk("%s: warning, port address has been forced.\n", name);
1150 bus_type = "PCI";
1151 is_pci = 1;
1152 subversion = ESA;
1153 } else if (port_base > MAX_EISA_ADDR
1154 || (protocol_rev == 'C' && info.pci)) {
1155 bus_type = "PCI";
1156 is_pci = 1;
1157 subversion = ESA;
1158 } else if (port_base >= MIN_EISA_ADDR
1159 || (protocol_rev == 'C' && info.eisa)) {
1160 bus_type = "EISA";
1161 subversion = ESA;
1162 } else if (protocol_rev == 'C' && !info.eisa && !info.pci) {
1163 bus_type = "ISA";
1164 subversion = ISA;
1165 } else if (port_base > MAX_ISA_ADDR) {
1166 bus_type = "PCI";
1167 is_pci = 1;
1168 subversion = ESA;
1169 } else {
1170 bus_type = "ISA";
1171 subversion = ISA;
1172 }
1173
1174 if (!info.haaval || info.ata) {
1175 printk
1176 ("%s: address 0x%03lx, unusable %s board (%d%d), detaching.\n",
1177 name, port_base, bus_type, info.haaval, info.ata);
1178 goto freelock;
1179 }
1180
1181 if (info.drqvld) {
1182 if (subversion == ESA)
1183 printk("%s: warning, weird %s board using DMA.\n", name,
1184 bus_type);
1185
1186 subversion = ISA;
1187 dma_channel = dma_channel_table[3 - info.drqx];
1188 } else {
1189 if (subversion == ISA)
1190 printk("%s: warning, weird %s board not using DMA.\n",
1191 name, bus_type);
1192
1193 subversion = ESA;
1194 dma_channel = NO_DMA;
1195 }
1196
1197 if (!info.dmasup)
1198 printk("%s: warning, DMA protocol support not asserted.\n",
1199 name);
1200
1201 irq = info.irq;
1202
1203 if (subversion == ESA && !info.irq_tr)
1204 printk
1205 ("%s: warning, LEVEL triggering is suggested for IRQ %u.\n",
1206 name, irq);
1207
1208 if (is_pci) {
1209 pdev = get_pci_dev(port_base);
1210 if (!pdev)
1211 printk
1212 ("%s: warning, failed to get pci_dev structure.\n",
1213 name);
1214 } else
1215 pdev = NULL;
1216
1217 if (pdev && (irq != pdev->irq)) {
1218 printk("%s: IRQ %u mapped to IO-APIC IRQ %u.\n", name, irq,
1219 pdev->irq);
1220 irq = pdev->irq;
1221 }
1222
1223 /* Board detected, allocate its IRQ */
1224 if (request_irq(irq, do_interrupt_handler,
1225 IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0),
1226 driver_name, (void *)&sha[j])) {
1227 printk("%s: unable to allocate IRQ %u, detaching.\n", name,
1228 irq);
1229 goto freelock;
1230 }
1231
1232 if (subversion == ISA && request_dma(dma_channel, driver_name)) {
1233 printk("%s: unable to allocate DMA channel %u, detaching.\n",
1234 name, dma_channel);
1235 goto freeirq;
1236 }
1237 #if defined(FORCE_CONFIG)
1238 {
1239 struct eata_config *cf;
1240 dma_addr_t cf_dma_addr;
1241
1242 cf = pci_alloc_consistent(pdev, sizeof(struct eata_config),
1243 &cf_dma_addr);
1244
1245 if (!cf) {
1246 printk
1247 ("%s: config, pci_alloc_consistent failed, detaching.\n",
1248 name);
1249 goto freedma;
1250 }
1251
1252 /* Set board configuration */
1253 memset((char *)cf, 0, sizeof(struct eata_config));
1254 cf->len = (ushort) H2DEV16((ushort) 510);
1255 cf->ocena = 1;
1256
1257 if (do_dma(port_base, cf_dma_addr, SET_CONFIG_DMA)) {
1258 printk
1259 ("%s: busy timeout sending configuration, detaching.\n",
1260 name);
1261 pci_free_consistent(pdev, sizeof(struct eata_config),
1262 cf, cf_dma_addr);
1263 goto freedma;
1264 }
1265
1266 }
1267 #endif
1268
1269 spin_unlock_irq(&driver_lock);
1270 sh[j] = shost = scsi_register(tpnt, sizeof(struct hostdata));
1271 spin_lock_irq(&driver_lock);
1272
1273 if (shost == NULL) {
1274 printk("%s: unable to register host, detaching.\n", name);
1275 goto freedma;
1276 }
1277
1278 shost->io_port = port_base;
1279 shost->unique_id = port_base;
1280 shost->n_io_port = REGION_SIZE;
1281 shost->dma_channel = dma_channel;
1282 shost->irq = irq;
1283 shost->sg_tablesize = (ushort) info.scatt_size;
1284 shost->this_id = (ushort) info.host_addr[3];
1285 shost->can_queue = (ushort) info.queue_size;
1286 shost->cmd_per_lun = MAX_CMD_PER_LUN;
1287
1288 ha = (struct hostdata *)shost->hostdata;
1289
1290 memset(ha, 0, sizeof(struct hostdata));
1291 ha->subversion = subversion;
1292 ha->protocol_rev = protocol_rev;
1293 ha->is_pci = is_pci;
1294 ha->pdev = pdev;
1295 ha->board_number = j;
1296
1297 if (ha->subversion == ESA)
1298 shost->unchecked_isa_dma = 0;
1299 else {
1300 unsigned long flags;
1301 shost->unchecked_isa_dma = 1;
1302
1303 flags = claim_dma_lock();
1304 disable_dma(dma_channel);
1305 clear_dma_ff(dma_channel);
1306 set_dma_mode(dma_channel, DMA_MODE_CASCADE);
1307 enable_dma(dma_channel);
1308 release_dma_lock(flags);
1309
1310 }
1311
1312 strcpy(ha->board_name, name);
1313
1314 /* DPT PM2012 does not allow to detect sg_tablesize correctly */
1315 if (shost->sg_tablesize > MAX_SGLIST || shost->sg_tablesize < 2) {
1316 printk("%s: detect, wrong n. of SG lists %d, fixed.\n",
1317 ha->board_name, shost->sg_tablesize);
1318 shost->sg_tablesize = MAX_SGLIST;
1319 }
1320
1321 /* DPT PM2012 does not allow to detect can_queue correctly */
1322 if (shost->can_queue > MAX_MAILBOXES || shost->can_queue < 2) {
1323 printk("%s: detect, wrong n. of mbox %d, fixed.\n",
1324 ha->board_name, shost->can_queue);
1325 shost->can_queue = MAX_MAILBOXES;
1326 }
1327
1328 if (protocol_rev != 'A') {
1329 if (info.max_chan > 0 && info.max_chan < MAX_CHANNEL)
1330 shost->max_channel = info.max_chan;
1331
1332 if (info.max_id > 7 && info.max_id < MAX_TARGET)
1333 shost->max_id = info.max_id + 1;
1334
1335 if (info.large_sg && shost->sg_tablesize == MAX_SGLIST)
1336 shost->sg_tablesize = MAX_LARGE_SGLIST;
1337 }
1338
1339 if (protocol_rev == 'C') {
1340 if (info.max_lun > 7 && info.max_lun < MAX_LUN)
1341 shost->max_lun = info.max_lun + 1;
1342 }
1343
1344 if (dma_channel == NO_DMA)
1345 sprintf(dma_name, "%s", "BMST");
1346 else
1347 sprintf(dma_name, "DMA %u", dma_channel);
1348
1349 spin_unlock_irq(&driver_lock);
1350
1351 for (i = 0; i < shost->can_queue; i++)
1352 ha->cp[i].cp_dma_addr = pci_map_single(ha->pdev,
1353 &ha->cp[i],
1354 sizeof(struct mscp),
1355 PCI_DMA_BIDIRECTIONAL);
1356
1357 for (i = 0; i < shost->can_queue; i++) {
1358 size_t sz = shost->sg_tablesize *sizeof(struct sg_list);
1359 gfp_t gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
1360 ha->cp[i].sglist = kmalloc(sz, gfp_mask);
1361 if (!ha->cp[i].sglist) {
1362 printk
1363 ("%s: kmalloc SGlist failed, mbox %d, detaching.\n",
1364 ha->board_name, i);
1365 goto release;
1366 }
1367 }
1368
1369 if (!(ha->sp_cpu_addr = pci_alloc_consistent(ha->pdev,
1370 sizeof(struct mssp),
1371 &ha->sp_dma_addr))) {
1372 printk("%s: pci_alloc_consistent failed, detaching.\n", ha->board_name);
1373 goto release;
1374 }
1375
1376 if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
1377 max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
1378
1379 if (max_queue_depth < MAX_CMD_PER_LUN)
1380 max_queue_depth = MAX_CMD_PER_LUN;
1381
1382 if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
1383 tag_mode = TAG_ORDERED;
1384
1385 if (j == 0) {
1386 printk
1387 ("EATA/DMA 2.0x: Copyright (C) 1994-2003 Dario Ballabio.\n");
1388 printk
1389 ("%s config options -> tm:%d, lc:%c, mq:%d, rs:%c, et:%c, "
1390 "ip:%c, ep:%c, pp:%c.\n", driver_name, tag_mode,
1391 YESNO(linked_comm), max_queue_depth, YESNO(rev_scan),
1392 YESNO(ext_tran), YESNO(isa_probe), YESNO(eisa_probe),
1393 YESNO(pci_probe));
1394 }
1395
1396 printk("%s: 2.0%c, %s 0x%03lx, IRQ %u, %s, SG %d, MB %d.\n",
1397 ha->board_name, ha->protocol_rev, bus_type,
1398 (unsigned long)shost->io_port, shost->irq, dma_name,
1399 shost->sg_tablesize, shost->can_queue);
1400
1401 if (shost->max_id > 8 || shost->max_lun > 8)
1402 printk
1403 ("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1404 ha->board_name, shost->max_id, shost->max_lun);
1405
1406 for (i = 0; i <= shost->max_channel; i++)
1407 printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1408 ha->board_name, i, info.host_addr[3 - i]);
1409
1410 #if defined(DEBUG_DETECT)
1411 printk("%s: Vers. 0x%x, ocs %u, tar %u, trnxfr %u, more %u, SYNC 0x%x, "
1412 "sec. %u, infol %d, cpl %d spl %d.\n", name, info.version,
1413 info.ocsena, info.tarsup, info.trnxfr, info.morsup, info.sync,
1414 info.second, info.data_len, info.cp_len, info.sp_len);
1415
1416 if (protocol_rev == 'B' || protocol_rev == 'C')
1417 printk("%s: isaena %u, forcaddr %u, max_id %u, max_chan %u, "
1418 "large_sg %u, res1 %u.\n", name, info.isaena,
1419 info.forcaddr, info.max_id, info.max_chan, info.large_sg,
1420 info.res1);
1421
1422 if (protocol_rev == 'C')
1423 printk("%s: max_lun %u, m1 %u, idquest %u, pci %u, eisa %u, "
1424 "raidnum %u.\n", name, info.max_lun, info.m1,
1425 info.idquest, info.pci, info.eisa, info.raidnum);
1426 #endif
1427
1428 if (ha->pdev) {
1429 pci_set_master(ha->pdev);
1430 if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK))
1431 printk("%s: warning, pci_set_dma_mask failed.\n",
1432 ha->board_name);
1433 }
1434
1435 return 1;
1436
1437 freedma:
1438 if (subversion == ISA)
1439 free_dma(dma_channel);
1440 freeirq:
1441 free_irq(irq, &sha[j]);
1442 freelock:
1443 spin_unlock_irq(&driver_lock);
1444 release_region(port_base, REGION_SIZE);
1445 fail:
1446 return 0;
1447
1448 release:
1449 eata2x_release(shost);
1450 return 0;
1451 }
1452
1453 static void internal_setup(char *str, int *ints)
1454 {
1455 int i, argc = ints[0];
1456 char *cur = str, *pc;
1457
1458 if (argc > 0) {
1459 if (argc > MAX_INT_PARAM)
1460 argc = MAX_INT_PARAM;
1461
1462 for (i = 0; i < argc; i++)
1463 io_port[i] = ints[i + 1];
1464
1465 io_port[i] = 0;
1466 setup_done = 1;
1467 }
1468
1469 while (cur && (pc = strchr(cur, ':'))) {
1470 int val = 0, c = *++pc;
1471
1472 if (c == 'n' || c == 'N')
1473 val = 0;
1474 else if (c == 'y' || c == 'Y')
1475 val = 1;
1476 else
1477 val = (int)simple_strtoul(pc, NULL, 0);
1478
1479 if (!strncmp(cur, "lc:", 3))
1480 linked_comm = val;
1481 else if (!strncmp(cur, "tm:", 3))
1482 tag_mode = val;
1483 else if (!strncmp(cur, "tc:", 3))
1484 tag_mode = val;
1485 else if (!strncmp(cur, "mq:", 3))
1486 max_queue_depth = val;
1487 else if (!strncmp(cur, "ls:", 3))
1488 link_statistics = val;
1489 else if (!strncmp(cur, "et:", 3))
1490 ext_tran = val;
1491 else if (!strncmp(cur, "rs:", 3))
1492 rev_scan = val;
1493 else if (!strncmp(cur, "ip:", 3))
1494 isa_probe = val;
1495 else if (!strncmp(cur, "ep:", 3))
1496 eisa_probe = val;
1497 else if (!strncmp(cur, "pp:", 3))
1498 pci_probe = val;
1499
1500 if ((cur = strchr(cur, ',')))
1501 ++cur;
1502 }
1503
1504 return;
1505 }
1506
1507 static int option_setup(char *str)
1508 {
1509 int ints[MAX_INT_PARAM];
1510 char *cur = str;
1511 int i = 1;
1512
1513 while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
1514 ints[i++] = simple_strtoul(cur, NULL, 0);
1515
1516 if ((cur = strchr(cur, ',')) != NULL)
1517 cur++;
1518 }
1519
1520 ints[0] = i - 1;
1521 internal_setup(cur, ints);
1522 return 1;
1523 }
1524
1525 static void add_pci_ports(void)
1526 {
1527 #if defined(CONFIG_PCI)
1528 unsigned int addr, k;
1529 struct pci_dev *dev = NULL;
1530
1531 for (k = 0; k < MAX_PCI; k++) {
1532
1533 if (!(dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev)))
1534 break;
1535
1536 if (pci_enable_device(dev)) {
1537 #if defined(DEBUG_PCI_DETECT)
1538 printk
1539 ("%s: detect, bus %d, devfn 0x%x, pci_enable_device failed.\n",
1540 driver_name, dev->bus->number, dev->devfn);
1541 #endif
1542
1543 continue;
1544 }
1545
1546 addr = pci_resource_start(dev, 0);
1547
1548 #if defined(DEBUG_PCI_DETECT)
1549 printk("%s: detect, seq. %d, bus %d, devfn 0x%x, addr 0x%x.\n",
1550 driver_name, k, dev->bus->number, dev->devfn, addr);
1551 #endif
1552
1553 /* Order addresses according to rev_scan value */
1554 io_port[MAX_INT_PARAM + (rev_scan ? (MAX_PCI - k) : (1 + k))] =
1555 addr + PCI_BASE_ADDRESS_0;
1556 }
1557
1558 pci_dev_put(dev);
1559 #endif /* end CONFIG_PCI */
1560 }
1561
1562 static int eata2x_detect(struct scsi_host_template *tpnt)
1563 {
1564 unsigned int j = 0, k;
1565
1566 tpnt->proc_name = "eata2x";
1567
1568 if (strlen(boot_options))
1569 option_setup(boot_options);
1570
1571 #if defined(MODULE)
1572 /* io_port could have been modified when loading as a module */
1573 if (io_port[0] != SKIP) {
1574 setup_done = 1;
1575 io_port[MAX_INT_PARAM] = 0;
1576 }
1577 #endif
1578
1579 for (k = MAX_INT_PARAM; io_port[k]; k++)
1580 if (io_port[k] == SKIP)
1581 continue;
1582 else if (io_port[k] <= MAX_ISA_ADDR) {
1583 if (!isa_probe)
1584 io_port[k] = SKIP;
1585 } else if (io_port[k] >= MIN_EISA_ADDR
1586 && io_port[k] <= MAX_EISA_ADDR) {
1587 if (!eisa_probe)
1588 io_port[k] = SKIP;
1589 }
1590
1591 if (pci_probe) {
1592 if (!setup_done)
1593 add_pci_ports();
1594 else
1595 enable_pci_ports();
1596 }
1597
1598 for (k = 0; io_port[k]; k++) {
1599
1600 if (io_port[k] == SKIP)
1601 continue;
1602
1603 if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt))
1604 j++;
1605 }
1606
1607 num_boards = j;
1608 return j;
1609 }
1610
1611 static void map_dma(unsigned int i, struct hostdata *ha)
1612 {
1613 unsigned int k, pci_dir;
1614 int count;
1615 struct scatterlist *sg;
1616 struct mscp *cpp;
1617 struct scsi_cmnd *SCpnt;
1618
1619 cpp = &ha->cp[i];
1620 SCpnt = cpp->SCpnt;
1621 pci_dir = SCpnt->sc_data_direction;
1622
1623 if (SCpnt->sense_buffer)
1624 cpp->sense_addr =
1625 H2DEV(pci_map_single(ha->pdev, SCpnt->sense_buffer,
1626 SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE));
1627
1628 cpp->sense_len = SCSI_SENSE_BUFFERSIZE;
1629
1630 count = scsi_dma_map(SCpnt);
1631 BUG_ON(count < 0);
1632 scsi_for_each_sg(SCpnt, sg, count, k) {
1633 cpp->sglist[k].address = H2DEV(sg_dma_address(sg));
1634 cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(sg));
1635 }
1636
1637 cpp->sg = 1;
1638 cpp->data_address = H2DEV(pci_map_single(ha->pdev, cpp->sglist,
1639 scsi_sg_count(SCpnt) *
1640 sizeof(struct sg_list),
1641 pci_dir));
1642 cpp->data_len = H2DEV((scsi_sg_count(SCpnt) * sizeof(struct sg_list)));
1643 }
1644
1645 static void unmap_dma(unsigned int i, struct hostdata *ha)
1646 {
1647 unsigned int pci_dir;
1648 struct mscp *cpp;
1649 struct scsi_cmnd *SCpnt;
1650
1651 cpp = &ha->cp[i];
1652 SCpnt = cpp->SCpnt;
1653 pci_dir = SCpnt->sc_data_direction;
1654
1655 if (DEV2H(cpp->sense_addr))
1656 pci_unmap_single(ha->pdev, DEV2H(cpp->sense_addr),
1657 DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1658
1659 scsi_dma_unmap(SCpnt);
1660
1661 if (!DEV2H(cpp->data_len))
1662 pci_dir = PCI_DMA_BIDIRECTIONAL;
1663
1664 if (DEV2H(cpp->data_address))
1665 pci_unmap_single(ha->pdev, DEV2H(cpp->data_address),
1666 DEV2H(cpp->data_len), pci_dir);
1667 }
1668
1669 static void sync_dma(unsigned int i, struct hostdata *ha)
1670 {
1671 unsigned int pci_dir;
1672 struct mscp *cpp;
1673 struct scsi_cmnd *SCpnt;
1674
1675 cpp = &ha->cp[i];
1676 SCpnt = cpp->SCpnt;
1677 pci_dir = SCpnt->sc_data_direction;
1678
1679 if (DEV2H(cpp->sense_addr))
1680 pci_dma_sync_single_for_cpu(ha->pdev, DEV2H(cpp->sense_addr),
1681 DEV2H(cpp->sense_len),
1682 PCI_DMA_FROMDEVICE);
1683
1684 if (scsi_sg_count(SCpnt))
1685 pci_dma_sync_sg_for_cpu(ha->pdev, scsi_sglist(SCpnt),
1686 scsi_sg_count(SCpnt), pci_dir);
1687
1688 if (!DEV2H(cpp->data_len))
1689 pci_dir = PCI_DMA_BIDIRECTIONAL;
1690
1691 if (DEV2H(cpp->data_address))
1692 pci_dma_sync_single_for_cpu(ha->pdev,
1693 DEV2H(cpp->data_address),
1694 DEV2H(cpp->data_len), pci_dir);
1695 }
1696
1697 static void scsi_to_dev_dir(unsigned int i, struct hostdata *ha)
1698 {
1699 unsigned int k;
1700
1701 static const unsigned char data_out_cmds[] = {
1702 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1703 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1704 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1705 };
1706
1707 static const unsigned char data_none_cmds[] = {
1708 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1709 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1710 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1711 };
1712
1713 struct mscp *cpp;
1714 struct scsi_cmnd *SCpnt;
1715
1716 cpp = &ha->cp[i];
1717 SCpnt = cpp->SCpnt;
1718
1719 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1720 cpp->din = 1;
1721 cpp->dout = 0;
1722 return;
1723 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1724 cpp->din = 0;
1725 cpp->dout = 1;
1726 return;
1727 } else if (SCpnt->sc_data_direction == DMA_NONE) {
1728 cpp->din = 0;
1729 cpp->dout = 0;
1730 return;
1731 }
1732
1733 if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1734 panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n",
1735 ha->board_name);
1736
1737 for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1738 if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1739 cpp->dout = 1;
1740 break;
1741 }
1742
1743 if ((cpp->din = !cpp->dout))
1744 for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1745 if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1746 cpp->din = 0;
1747 break;
1748 }
1749
1750 }
1751
1752 static int eata2x_queuecommand(struct scsi_cmnd *SCpnt,
1753 void (*done) (struct scsi_cmnd *))
1754 {
1755 struct Scsi_Host *shost = SCpnt->device->host;
1756 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1757 unsigned int i, k;
1758 struct mscp *cpp;
1759
1760 if (SCpnt->host_scribble)
1761 panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
1762 ha->board_name, SCpnt->serial_number, SCpnt);
1763
1764 /* i is the mailbox number, look for the first free mailbox
1765 starting from last_cp_used */
1766 i = ha->last_cp_used + 1;
1767
1768 for (k = 0; k < shost->can_queue; k++, i++) {
1769 if (i >= shost->can_queue)
1770 i = 0;
1771 if (ha->cp_stat[i] == FREE) {
1772 ha->last_cp_used = i;
1773 break;
1774 }
1775 }
1776
1777 if (k == shost->can_queue) {
1778 printk("%s: qcomm, no free mailbox.\n", ha->board_name);
1779 return 1;
1780 }
1781
1782 /* Set pointer to control packet structure */
1783 cpp = &ha->cp[i];
1784
1785 memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1786
1787 /* Set pointer to status packet structure, Big Endian format */
1788 cpp->sp_dma_addr = H2DEV(ha->sp_dma_addr);
1789
1790 SCpnt->scsi_done = done;
1791 cpp->cpp_index = i;
1792 SCpnt->host_scribble = (unsigned char *)&cpp->cpp_index;
1793
1794 if (do_trace)
1795 scmd_printk(KERN_INFO, SCpnt,
1796 "qcomm, mbox %d, pid %ld.\n", i, SCpnt->serial_number);
1797
1798 cpp->reqsen = 1;
1799 cpp->dispri = 1;
1800 #if 0
1801 if (SCpnt->device->type == TYPE_TAPE)
1802 cpp->hbaci = 1;
1803 #endif
1804 cpp->one = 1;
1805 cpp->channel = SCpnt->device->channel;
1806 cpp->target = SCpnt->device->id;
1807 cpp->lun = SCpnt->device->lun;
1808 cpp->SCpnt = SCpnt;
1809 memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1810
1811 /* Use data transfer direction SCpnt->sc_data_direction */
1812 scsi_to_dev_dir(i, ha);
1813
1814 /* Map DMA buffers and SG list */
1815 map_dma(i, ha);
1816
1817 if (linked_comm && SCpnt->device->queue_depth > 2
1818 && TLDEV(SCpnt->device->type)) {
1819 ha->cp_stat[i] = READY;
1820 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0);
1821 return 0;
1822 }
1823
1824 /* Send control packet to the board */
1825 if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
1826 unmap_dma(i, ha);
1827 SCpnt->host_scribble = NULL;
1828 scmd_printk(KERN_INFO, SCpnt,
1829 "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);
1830 return 1;
1831 }
1832
1833 ha->cp_stat[i] = IN_USE;
1834 return 0;
1835 }
1836
1837 static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1838 {
1839 struct Scsi_Host *shost = SCarg->device->host;
1840 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1841 unsigned int i;
1842
1843 if (SCarg->host_scribble == NULL) {
1844 scmd_printk(KERN_INFO, SCarg,
1845 "abort, pid %ld inactive.\n", SCarg->serial_number);
1846 return SUCCESS;
1847 }
1848
1849 i = *(unsigned int *)SCarg->host_scribble;
1850 scmd_printk(KERN_WARNING, SCarg,
1851 "abort, mbox %d, pid %ld.\n", i, SCarg->serial_number);
1852
1853 if (i >= shost->can_queue)
1854 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
1855
1856 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1857 printk("%s: abort, timeout error.\n", ha->board_name);
1858 return FAILED;
1859 }
1860
1861 if (ha->cp_stat[i] == FREE) {
1862 printk("%s: abort, mbox %d is free.\n", ha->board_name, i);
1863 return SUCCESS;
1864 }
1865
1866 if (ha->cp_stat[i] == IN_USE) {
1867 printk("%s: abort, mbox %d is in use.\n", ha->board_name, i);
1868
1869 if (SCarg != ha->cp[i].SCpnt)
1870 panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1871 ha->board_name, i, SCarg, ha->cp[i].SCpnt);
1872
1873 if (inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)
1874 printk("%s: abort, mbox %d, interrupt pending.\n",
1875 ha->board_name, i);
1876
1877 return FAILED;
1878 }
1879
1880 if (ha->cp_stat[i] == IN_RESET) {
1881 printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i);
1882 return FAILED;
1883 }
1884
1885 if (ha->cp_stat[i] == LOCKED) {
1886 printk("%s: abort, mbox %d is locked.\n", ha->board_name, i);
1887 return SUCCESS;
1888 }
1889
1890 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1891 unmap_dma(i, ha);
1892 SCarg->result = DID_ABORT << 16;
1893 SCarg->host_scribble = NULL;
1894 ha->cp_stat[i] = FREE;
1895 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
1896 ha->board_name, i, SCarg->serial_number);
1897 SCarg->scsi_done(SCarg);
1898 return SUCCESS;
1899 }
1900
1901 panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i);
1902 }
1903
1904 static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1905 {
1906 unsigned int i, time, k, c, limit = 0;
1907 int arg_done = 0;
1908 struct scsi_cmnd *SCpnt;
1909 struct Scsi_Host *shost = SCarg->device->host;
1910 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1911
1912 scmd_printk(KERN_INFO, SCarg,
1913 "reset, enter, pid %ld.\n", SCarg->serial_number);
1914
1915 spin_lock_irq(shost->host_lock);
1916
1917 if (SCarg->host_scribble == NULL)
1918 printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->serial_number);
1919
1920 if (ha->in_reset) {
1921 printk("%s: reset, exit, already in reset.\n", ha->board_name);
1922 spin_unlock_irq(shost->host_lock);
1923 return FAILED;
1924 }
1925
1926 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1927 printk("%s: reset, exit, timeout error.\n", ha->board_name);
1928 spin_unlock_irq(shost->host_lock);
1929 return FAILED;
1930 }
1931
1932 ha->retries = 0;
1933
1934 for (c = 0; c <= shost->max_channel; c++)
1935 for (k = 0; k < shost->max_id; k++) {
1936 ha->target_redo[k][c] = 1;
1937 ha->target_to[k][c] = 0;
1938 }
1939
1940 for (i = 0; i < shost->can_queue; i++) {
1941
1942 if (ha->cp_stat[i] == FREE)
1943 continue;
1944
1945 if (ha->cp_stat[i] == LOCKED) {
1946 ha->cp_stat[i] = FREE;
1947 printk("%s: reset, locked mbox %d forced free.\n",
1948 ha->board_name, i);
1949 continue;
1950 }
1951
1952 if (!(SCpnt = ha->cp[i].SCpnt))
1953 panic("%s: reset, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
1954
1955 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1956 ha->cp_stat[i] = ABORTING;
1957 printk("%s: reset, mbox %d aborting, pid %ld.\n",
1958 ha->board_name, i, SCpnt->serial_number);
1959 }
1960
1961 else {
1962 ha->cp_stat[i] = IN_RESET;
1963 printk("%s: reset, mbox %d in reset, pid %ld.\n",
1964 ha->board_name, i, SCpnt->serial_number);
1965 }
1966
1967 if (SCpnt->host_scribble == NULL)
1968 panic("%s: reset, mbox %d, garbled SCpnt.\n", ha->board_name, i);
1969
1970 if (*(unsigned int *)SCpnt->host_scribble != i)
1971 panic("%s: reset, mbox %d, index mismatch.\n", ha->board_name, i);
1972
1973 if (SCpnt->scsi_done == NULL)
1974 panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n",
1975 ha->board_name, i);
1976
1977 if (SCpnt == SCarg)
1978 arg_done = 1;
1979 }
1980
1981 if (do_dma(shost->io_port, 0, RESET_PIO)) {
1982 printk("%s: reset, cannot reset, timeout error.\n", ha->board_name);
1983 spin_unlock_irq(shost->host_lock);
1984 return FAILED;
1985 }
1986
1987 printk("%s: reset, board reset done, enabling interrupts.\n", ha->board_name);
1988
1989 #if defined(DEBUG_RESET)
1990 do_trace = 1;
1991 #endif
1992
1993 ha->in_reset = 1;
1994
1995 spin_unlock_irq(shost->host_lock);
1996
1997 /* FIXME: use a sleep instead */
1998 time = jiffies;
1999 while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
2000 udelay(100L);
2001
2002 spin_lock_irq(shost->host_lock);
2003
2004 printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
2005
2006 for (i = 0; i < shost->can_queue; i++) {
2007
2008 if (ha->cp_stat[i] == IN_RESET) {
2009 SCpnt = ha->cp[i].SCpnt;
2010 unmap_dma(i, ha);
2011 SCpnt->result = DID_RESET << 16;
2012 SCpnt->host_scribble = NULL;
2013
2014 /* This mailbox is still waiting for its interrupt */
2015 ha->cp_stat[i] = LOCKED;
2016
2017 printk
2018 ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
2019 ha->board_name, i, SCpnt->serial_number);
2020 }
2021
2022 else if (ha->cp_stat[i] == ABORTING) {
2023 SCpnt = ha->cp[i].SCpnt;
2024 unmap_dma(i, ha);
2025 SCpnt->result = DID_RESET << 16;
2026 SCpnt->host_scribble = NULL;
2027
2028 /* This mailbox was never queued to the adapter */
2029 ha->cp_stat[i] = FREE;
2030
2031 printk
2032 ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
2033 ha->board_name, i, SCpnt->serial_number);
2034 }
2035
2036 else
2037 /* Any other mailbox has already been set free by interrupt */
2038 continue;
2039
2040 SCpnt->scsi_done(SCpnt);
2041 }
2042
2043 ha->in_reset = 0;
2044 do_trace = 0;
2045
2046 if (arg_done)
2047 printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->serial_number);
2048 else
2049 printk("%s: reset, exit.\n", ha->board_name);
2050
2051 spin_unlock_irq(shost->host_lock);
2052 return SUCCESS;
2053 }
2054
2055 int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2056 sector_t capacity, int *dkinfo)
2057 {
2058 unsigned int size = capacity;
2059
2060 if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
2061 dkinfo[0] = 255;
2062 dkinfo[1] = 63;
2063 dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
2064 }
2065 #if defined (DEBUG_GEOMETRY)
2066 printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
2067 dkinfo[0], dkinfo[1], dkinfo[2]);
2068 #endif
2069
2070 return 0;
2071 }
2072
2073 static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
2074 unsigned int rev)
2075 {
2076 unsigned int i, j, k, y;
2077 unsigned long x;
2078
2079 for (i = 0; i < n - 1; i++) {
2080 k = i;
2081
2082 for (j = k + 1; j < n; j++)
2083 if (rev) {
2084 if (sk[j] > sk[k])
2085 k = j;
2086 } else {
2087 if (sk[j] < sk[k])
2088 k = j;
2089 }
2090
2091 if (k != i) {
2092 x = sk[k];
2093 sk[k] = sk[i];
2094 sk[i] = x;
2095 y = da[k];
2096 da[k] = da[i];
2097 da[i] = y;
2098 }
2099 }
2100
2101 return;
2102 }
2103
2104 static int reorder(struct hostdata *ha, unsigned long cursec,
2105 unsigned int ihdlr, unsigned int il[], unsigned int n_ready)
2106 {
2107 struct scsi_cmnd *SCpnt;
2108 struct mscp *cpp;
2109 unsigned int k, n;
2110 unsigned int rev = 0, s = 1, r = 1;
2111 unsigned int input_only = 1, overlap = 0;
2112 unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
2113 unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
2114 unsigned long ioseek = 0;
2115
2116 static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
2117 static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
2118 static unsigned int readysorted = 0, revcount = 0;
2119 static unsigned long seeksorted = 0, seeknosort = 0;
2120
2121 if (link_statistics && !(++flushcount % link_statistics))
2122 printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
2123 " av %ldK as %ldK.\n", flushcount, batchcount,
2124 inputcount, ovlcount, readycount, readysorted, sortcount,
2125 revcount, seeknosort / (readycount + 1),
2126 seeksorted / (readycount + 1));
2127
2128 if (n_ready <= 1)
2129 return 0;
2130
2131 for (n = 0; n < n_ready; n++) {
2132 k = il[n];
2133 cpp = &ha->cp[k];
2134 SCpnt = cpp->SCpnt;
2135
2136 if (!cpp->din)
2137 input_only = 0;
2138
2139 if (SCpnt->request->sector < minsec)
2140 minsec = SCpnt->request->sector;
2141 if (SCpnt->request->sector > maxsec)
2142 maxsec = SCpnt->request->sector;
2143
2144 sl[n] = SCpnt->request->sector;
2145 ioseek += SCpnt->request->nr_sectors;
2146
2147 if (!n)
2148 continue;
2149
2150 if (sl[n] < sl[n - 1])
2151 s = 0;
2152 if (sl[n] > sl[n - 1])
2153 r = 0;
2154
2155 if (link_statistics) {
2156 if (sl[n] > sl[n - 1])
2157 seek += sl[n] - sl[n - 1];
2158 else
2159 seek += sl[n - 1] - sl[n];
2160 }
2161
2162 }
2163
2164 if (link_statistics) {
2165 if (cursec > sl[0])
2166 seek += cursec - sl[0];
2167 else
2168 seek += sl[0] - cursec;
2169 }
2170
2171 if (cursec > ((maxsec + minsec) / 2))
2172 rev = 1;
2173
2174 if (ioseek > ((maxsec - minsec) / 2))
2175 rev = 0;
2176
2177 if (!((rev && r) || (!rev && s)))
2178 sort(sl, il, n_ready, rev);
2179
2180 if (!input_only)
2181 for (n = 0; n < n_ready; n++) {
2182 k = il[n];
2183 cpp = &ha->cp[k];
2184 SCpnt = cpp->SCpnt;
2185 ll[n] = SCpnt->request->nr_sectors;
2186 pl[n] = SCpnt->serial_number;
2187
2188 if (!n)
2189 continue;
2190
2191 if ((sl[n] == sl[n - 1])
2192 || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
2193 || (rev && ((sl[n] + ll[n]) > sl[n - 1])))
2194 overlap = 1;
2195 }
2196
2197 if (overlap)
2198 sort(pl, il, n_ready, 0);
2199
2200 if (link_statistics) {
2201 if (cursec > sl[0])
2202 iseek = cursec - sl[0];
2203 else
2204 iseek = sl[0] - cursec;
2205 batchcount++;
2206 readycount += n_ready;
2207 seeknosort += seek / 1024;
2208 if (input_only)
2209 inputcount++;
2210 if (overlap) {
2211 ovlcount++;
2212 seeksorted += iseek / 1024;
2213 } else
2214 seeksorted += (iseek + maxsec - minsec) / 1024;
2215 if (rev && !r) {
2216 revcount++;
2217 readysorted += n_ready;
2218 }
2219 if (!rev && !s) {
2220 sortcount++;
2221 readysorted += n_ready;
2222 }
2223 }
2224 #if defined(DEBUG_LINKED_COMMANDS)
2225 if (link_statistics && (overlap || !(flushcount % link_statistics)))
2226 for (n = 0; n < n_ready; n++) {
2227 k = il[n];
2228 cpp = &ha->cp[k];
2229 SCpnt = cpp->SCpnt;
2230 scmd_printk(KERN_INFO, SCpnt,
2231 "%s pid %ld mb %d fc %d nr %d sec %ld ns %ld"
2232 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2233 (ihdlr ? "ihdlr" : "qcomm"),
2234 SCpnt->serial_number, k, flushcount,
2235 n_ready, SCpnt->request->sector,
2236 SCpnt->request->nr_sectors, cursec, YESNO(s),
2237 YESNO(r), YESNO(rev), YESNO(input_only),
2238 YESNO(overlap), cpp->din);
2239 }
2240 #endif
2241 return overlap;
2242 }
2243
2244 static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2245 struct hostdata *ha, unsigned int ihdlr)
2246 {
2247 struct scsi_cmnd *SCpnt;
2248 struct mscp *cpp;
2249 unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
2250
2251 for (k = 0; k < dev->host->can_queue; k++) {
2252
2253 if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE)
2254 continue;
2255
2256 cpp = &ha->cp[k];
2257 SCpnt = cpp->SCpnt;
2258
2259 if (SCpnt->device != dev)
2260 continue;
2261
2262 if (ha->cp_stat[k] == IN_USE)
2263 return;
2264
2265 il[n_ready++] = k;
2266 }
2267
2268 if (reorder(ha, cursec, ihdlr, il, n_ready))
2269 n_ready = 1;
2270
2271 for (n = 0; n < n_ready; n++) {
2272 k = il[n];
2273 cpp = &ha->cp[k];
2274 SCpnt = cpp->SCpnt;
2275
2276 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2277 scmd_printk(KERN_INFO, SCpnt,
2278 "%s, pid %ld, mbox %d, adapter"
2279 " busy, will abort.\n",
2280 (ihdlr ? "ihdlr" : "qcomm"),
2281 SCpnt->serial_number, k);
2282 ha->cp_stat[k] = ABORTING;
2283 continue;
2284 }
2285
2286 ha->cp_stat[k] = IN_USE;
2287 }
2288 }
2289
2290 static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost)
2291 {
2292 struct scsi_cmnd *SCpnt;
2293 unsigned int i, k, c, status, tstatus, reg;
2294 struct mssp *spp;
2295 struct mscp *cpp;
2296 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2297
2298 if (shost->irq != irq)
2299 panic("%s: ihdlr, irq %d, shost->irq %d.\n", ha->board_name, irq,
2300 shost->irq);
2301
2302 /* Check if this board need to be serviced */
2303 if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
2304 goto none;
2305
2306 ha->iocount++;
2307
2308 if (do_trace)
2309 printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq,
2310 ha->iocount);
2311
2312 /* Check if this board is still busy */
2313 if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) {
2314 reg = inb(shost->io_port + REG_STATUS);
2315 printk
2316 ("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n",
2317 ha->board_name, irq, reg, ha->iocount);
2318 goto none;
2319 }
2320
2321 spp = &ha->sp;
2322
2323 /* Make a local copy just before clearing the interrupt indication */
2324 memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp));
2325
2326 /* Clear the completion flag and cp pointer on the dynamic copy of sp */
2327 memset(ha->sp_cpu_addr, 0, sizeof(struct mssp));
2328
2329 /* Read the status register to clear the interrupt indication */
2330 reg = inb(shost->io_port + REG_STATUS);
2331
2332 #if defined (DEBUG_INTERRUPT)
2333 {
2334 unsigned char *bytesp;
2335 int cnt;
2336 bytesp = (unsigned char *)spp;
2337 if (ha->iocount < 200) {
2338 printk("sp[] =");
2339 for (cnt = 0; cnt < 15; cnt++)
2340 printk(" 0x%x", bytesp[cnt]);
2341 printk("\n");
2342 }
2343 }
2344 #endif
2345
2346 /* Reject any sp with supspect data */
2347 if (spp->eoc == 0 && ha->iocount > 1)
2348 printk
2349 ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n",
2350 ha->board_name, irq, reg, ha->iocount);
2351 if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue)
2352 printk
2353 ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n",
2354 ha->board_name, spp->cpp_index, irq, reg, ha->iocount);
2355 if (spp->eoc == 0 || spp->cpp_index < 0
2356 || spp->cpp_index >= shost->can_queue)
2357 goto handled;
2358
2359 /* Find the mailbox to be serviced on this board */
2360 i = spp->cpp_index;
2361
2362 cpp = &(ha->cp[i]);
2363
2364 #if defined(DEBUG_GENERATE_ABORTS)
2365 if ((ha->iocount > 500) && ((ha->iocount % 500) < 3))
2366 goto handled;
2367 #endif
2368
2369 if (ha->cp_stat[i] == IGNORE) {
2370 ha->cp_stat[i] = FREE;
2371 goto handled;
2372 } else if (ha->cp_stat[i] == LOCKED) {
2373 ha->cp_stat[i] = FREE;
2374 printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i,
2375 ha->iocount);
2376 goto handled;
2377 } else if (ha->cp_stat[i] == FREE) {
2378 printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i,
2379 ha->iocount);
2380 goto handled;
2381 } else if (ha->cp_stat[i] == IN_RESET)
2382 printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i);
2383 else if (ha->cp_stat[i] != IN_USE)
2384 panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
2385 ha->board_name, i, ha->cp_stat[i]);
2386
2387 ha->cp_stat[i] = FREE;
2388 SCpnt = cpp->SCpnt;
2389
2390 if (SCpnt == NULL)
2391 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2392
2393 if (SCpnt->host_scribble == NULL)
2394 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,
2395 i, SCpnt->serial_number, SCpnt);
2396
2397 if (*(unsigned int *)SCpnt->host_scribble != i)
2398 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
2399 ha->board_name, i, SCpnt->serial_number,
2400 *(unsigned int *)SCpnt->host_scribble);
2401
2402 sync_dma(i, ha);
2403
2404 if (linked_comm && SCpnt->device->queue_depth > 2
2405 && TLDEV(SCpnt->device->type))
2406 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
2407
2408 tstatus = status_byte(spp->target_status);
2409
2410 #if defined(DEBUG_GENERATE_ERRORS)
2411 if ((ha->iocount > 500) && ((ha->iocount % 200) < 2))
2412 spp->adapter_status = 0x01;
2413 #endif
2414
2415 switch (spp->adapter_status) {
2416 case ASOK: /* status OK */
2417
2418 /* Forces a reset if a disk drive keeps returning BUSY */
2419 if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
2420 status = DID_ERROR << 16;
2421
2422 /* If there was a bus reset, redo operation on each target */
2423 else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
2424 && ha->target_redo[SCpnt->device->id][SCpnt->
2425 device->
2426 channel])
2427 status = DID_BUS_BUSY << 16;
2428
2429 /* Works around a flaw in scsi.c */
2430 else if (tstatus == CHECK_CONDITION
2431 && SCpnt->device->type == TYPE_DISK
2432 && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
2433 status = DID_BUS_BUSY << 16;
2434
2435 else
2436 status = DID_OK << 16;
2437
2438 if (tstatus == GOOD)
2439 ha->target_redo[SCpnt->device->id][SCpnt->device->
2440 channel] = 0;
2441
2442 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2443 (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2444 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2445 printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
2446 "target_status 0x%x, sense key 0x%x.\n",
2447 ha->board_name,
2448 SCpnt->device->channel, SCpnt->device->id,
2449 SCpnt->device->lun, SCpnt->serial_number,
2450 spp->target_status, SCpnt->sense_buffer[2]);
2451
2452 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
2453
2454 if (ha->last_retried_pid == SCpnt->serial_number)
2455 ha->retries = 0;
2456
2457 break;
2458 case ASST: /* Selection Time Out */
2459 case 0x02: /* Command Time Out */
2460
2461 if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
2462 status = DID_ERROR << 16;
2463 else {
2464 status = DID_TIME_OUT << 16;
2465 ha->target_to[SCpnt->device->id][SCpnt->device->
2466 channel]++;
2467 }
2468
2469 break;
2470
2471 /* Perform a limited number of internal retries */
2472 case 0x03: /* SCSI Bus Reset Received */
2473 case 0x04: /* Initial Controller Power-up */
2474
2475 for (c = 0; c <= shost->max_channel; c++)
2476 for (k = 0; k < shost->max_id; k++)
2477 ha->target_redo[k][c] = 1;
2478
2479 if (SCpnt->device->type != TYPE_TAPE
2480 && ha->retries < MAX_INTERNAL_RETRIES) {
2481
2482 #if defined(DID_SOFT_ERROR)
2483 status = DID_SOFT_ERROR << 16;
2484 #else
2485 status = DID_BUS_BUSY << 16;
2486 #endif
2487
2488 ha->retries++;
2489 ha->last_retried_pid = SCpnt->serial_number;
2490 } else
2491 status = DID_ERROR << 16;
2492
2493 break;
2494 case 0x05: /* Unexpected Bus Phase */
2495 case 0x06: /* Unexpected Bus Free */
2496 case 0x07: /* Bus Parity Error */
2497 case 0x08: /* SCSI Hung */
2498 case 0x09: /* Unexpected Message Reject */
2499 case 0x0a: /* SCSI Bus Reset Stuck */
2500 case 0x0b: /* Auto Request-Sense Failed */
2501 case 0x0c: /* Controller Ram Parity Error */
2502 default:
2503 status = DID_ERROR << 16;
2504 break;
2505 }
2506
2507 SCpnt->result = status | spp->target_status;
2508
2509 #if defined(DEBUG_INTERRUPT)
2510 if (SCpnt->result || do_trace)
2511 #else
2512 if ((spp->adapter_status != ASOK && ha->iocount > 1000) ||
2513 (spp->adapter_status != ASOK &&
2514 spp->adapter_status != ASST && ha->iocount <= 1000) ||
2515 do_trace || msg_byte(spp->target_status))
2516 #endif
2517 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"
2518 " pid %ld, reg 0x%x, count %d.\n",
2519 i, spp->adapter_status, spp->target_status,
2520 SCpnt->serial_number, reg, ha->iocount);
2521
2522 unmap_dma(i, ha);
2523
2524 /* Set the command state to inactive */
2525 SCpnt->host_scribble = NULL;
2526
2527 SCpnt->scsi_done(SCpnt);
2528
2529 if (do_trace)
2530 printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name,
2531 irq, ha->iocount);
2532
2533 handled:
2534 return IRQ_HANDLED;
2535 none:
2536 return IRQ_NONE;
2537 }
2538
2539 static irqreturn_t do_interrupt_handler(int irq, void *shap)
2540 {
2541 struct Scsi_Host *shost;
2542 unsigned int j;
2543 unsigned long spin_flags;
2544 irqreturn_t ret;
2545
2546 /* Check if the interrupt must be processed by this handler */
2547 if ((j = (unsigned int)((char *)shap - sha)) >= num_boards)
2548 return IRQ_NONE;
2549 shost = sh[j];
2550
2551 spin_lock_irqsave(shost->host_lock, spin_flags);
2552 ret = ihdlr(irq, shost);
2553 spin_unlock_irqrestore(shost->host_lock, spin_flags);
2554 return ret;
2555 }
2556
2557 static int eata2x_release(struct Scsi_Host *shost)
2558 {
2559 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2560 unsigned int i;
2561
2562 for (i = 0; i < shost->can_queue; i++)
2563 kfree((&ha->cp[i])->sglist);
2564
2565 for (i = 0; i < shost->can_queue; i++)
2566 pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr,
2567 sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
2568
2569 if (ha->sp_cpu_addr)
2570 pci_free_consistent(ha->pdev, sizeof(struct mssp),
2571 ha->sp_cpu_addr, ha->sp_dma_addr);
2572
2573 free_irq(shost->irq, &sha[ha->board_number]);
2574
2575 if (shost->dma_channel != NO_DMA)
2576 free_dma(shost->dma_channel);
2577
2578 release_region(shost->io_port, shost->n_io_port);
2579 scsi_unregister(shost);
2580 return 0;
2581 }
2582
2583 #include "scsi_module.c"
2584
2585 #ifndef MODULE
2586 __setup("eata=", option_setup);
2587 #endif /* end MODULE */
WRT350N Kernel Patches