?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] cciss 2.6 DMA mapping
[linux-2.6.22.y-op.git] / drivers / scsi / eata.c
blob81d16cfbe69e29143e58ba0dbc118dbf389d6d14
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/config.h>
481 #include <linux/string.h>
482 #include <linux/kernel.h>
483 #include <linux/ioport.h>
484 #include <linux/delay.h>
485 #include <linux/proc_fs.h>
486 #include <linux/blkdev.h>
487 #include <linux/interrupt.h>
488 #include <linux/stat.h>
489 #include <linux/pci.h>
490 #include <linux/init.h>
491 #include <linux/ctype.h>
492 #include <linux/spinlock.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_device_reset_handler = NULL,
522 .eh_bus_reset_handler = NULL,
523 .eh_host_reset_handler = eata2x_eh_host_reset,
524 .bios_param = eata2x_bios_param,
525 .slave_configure = eata2x_slave_configure,
526 .this_id = 7,
527 .unchecked_isa_dma = 1,
528 .use_clustering = ENABLE_CLUSTERING
529 };
530
531 #if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
532 #error "Adjust your <asm/byteorder.h> defines"
533 #endif
534
535 /* Subversion values */
536 #define ISA 0
537 #define ESA 1
538
539 #undef FORCE_CONFIG
540
541 #undef DEBUG_LINKED_COMMANDS
542 #undef DEBUG_DETECT
543 #undef DEBUG_PCI_DETECT
544 #undef DEBUG_INTERRUPT
545 #undef DEBUG_RESET
546 #undef DEBUG_GENERATE_ERRORS
547 #undef DEBUG_GENERATE_ABORTS
548 #undef DEBUG_GEOMETRY
549
550 #define MAX_ISA 4
551 #define MAX_VESA 0
552 #define MAX_EISA 15
553 #define MAX_PCI 16
554 #define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
555 #define MAX_CHANNEL 4
556 #define MAX_LUN 32
557 #define MAX_TARGET 32
558 #define MAX_MAILBOXES 64
559 #define MAX_SGLIST 64
560 #define MAX_LARGE_SGLIST 122
561 #define MAX_INTERNAL_RETRIES 64
562 #define MAX_CMD_PER_LUN 2
563 #define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
564
565 #define SKIP ULONG_MAX
566 #define FREE 0
567 #define IN_USE 1
568 #define LOCKED 2
569 #define IN_RESET 3
570 #define IGNORE 4
571 #define READY 5
572 #define ABORTING 6
573 #define NO_DMA 0xff
574 #define MAXLOOP 10000
575 #define TAG_DISABLED 0
576 #define TAG_SIMPLE 1
577 #define TAG_ORDERED 2
578
579 #define REG_CMD 7
580 #define REG_STATUS 7
581 #define REG_AUX_STATUS 8
582 #define REG_DATA 0
583 #define REG_DATA2 1
584 #define REG_SEE 6
585 #define REG_LOW 2
586 #define REG_LM 3
587 #define REG_MID 4
588 #define REG_MSB 5
589 #define REGION_SIZE 9UL
590 #define MAX_ISA_ADDR 0x03ff
591 #define MIN_EISA_ADDR 0x1c88
592 #define MAX_EISA_ADDR 0xfc88
593 #define BSY_ASSERTED 0x80
594 #define DRQ_ASSERTED 0x08
595 #define ABSY_ASSERTED 0x01
596 #define IRQ_ASSERTED 0x02
597 #define READ_CONFIG_PIO 0xf0
598 #define SET_CONFIG_PIO 0xf1
599 #define SEND_CP_PIO 0xf2
600 #define RECEIVE_SP_PIO 0xf3
601 #define TRUNCATE_XFR_PIO 0xf4
602 #define RESET_PIO 0xf9
603 #define READ_CONFIG_DMA 0xfd
604 #define SET_CONFIG_DMA 0xfe
605 #define SEND_CP_DMA 0xff
606 #define ASOK 0x00
607 #define ASST 0x01
608
609 #define YESNO(a) ((a) ? 'y' : 'n')
610 #define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
611
612 /* "EATA", in Big Endian format */
613 #define EATA_SIG_BE 0x45415441
614
615 /* Number of valid bytes in the board config structure for EATA 2.0x */
616 #define EATA_2_0A_SIZE 28
617 #define EATA_2_0B_SIZE 30
618 #define EATA_2_0C_SIZE 34
619
620 /* Board info structure */
621 struct eata_info {
622 u_int32_t data_len; /* Number of valid bytes after this field */
623 u_int32_t sign; /* ASCII "EATA" signature */
624
625 #if defined(__BIG_ENDIAN_BITFIELD)
626 unchar version : 4,
627 : 4;
628 unchar haaval : 1,
629 ata : 1,
630 drqvld : 1,
631 dmasup : 1,
632 morsup : 1,
633 trnxfr : 1,
634 tarsup : 1,
635 ocsena : 1;
636 #else
637 unchar : 4, /* unused low nibble */
638 version : 4; /* EATA version, should be 0x1 */
639 unchar ocsena : 1, /* Overlap Command Support Enabled */
640 tarsup : 1, /* Target Mode Supported */
641 trnxfr : 1, /* Truncate Transfer Cmd NOT Necessary */
642 morsup : 1, /* More Supported */
643 dmasup : 1, /* DMA Supported */
644 drqvld : 1, /* DRQ Index (DRQX) is valid */
645 ata : 1, /* This is an ATA device */
646 haaval : 1; /* Host Adapter Address Valid */
647 #endif
648
649 ushort cp_pad_len; /* Number of pad bytes after cp_len */
650 unchar host_addr[4]; /* Host Adapter SCSI ID for channels 3, 2, 1, 0 */
651 u_int32_t cp_len; /* Number of valid bytes in cp */
652 u_int32_t sp_len; /* Number of valid bytes in sp */
653 ushort queue_size; /* Max number of cp that can be queued */
654 ushort unused;
655 ushort scatt_size; /* Max number of entries in scatter/gather table */
656
657 #if defined(__BIG_ENDIAN_BITFIELD)
658 unchar drqx : 2,
659 second : 1,
660 irq_tr : 1,
661 irq : 4;
662 unchar sync;
663 unchar : 4,
664 res1 : 1,
665 large_sg : 1,
666 forcaddr : 1,
667 isaena : 1;
668 unchar max_chan : 3,
669 max_id : 5;
670 unchar max_lun;
671 unchar eisa : 1,
672 pci : 1,
673 idquest : 1,
674 m1 : 1,
675 : 4;
676 #else
677 unchar irq : 4, /* Interrupt Request assigned to this controller */
678 irq_tr : 1, /* 0 for edge triggered, 1 for level triggered */
679 second : 1, /* 1 if this is a secondary (not primary) controller */
680 drqx : 2; /* DRQ Index (0=DMA0, 1=DMA7, 2=DMA6, 3=DMA5) */
681 unchar sync; /* 1 if scsi target id 7...0 is running sync scsi */
682
683 /* Structure extension defined in EATA 2.0B */
684 unchar isaena : 1, /* ISA i/o addressing is disabled/enabled */
685 forcaddr : 1, /* Port address has been forced */
686 large_sg : 1, /* 1 if large SG lists are supported */
687 res1 : 1,
688 : 4;
689 unchar max_id : 5, /* Max SCSI target ID number */
690 max_chan : 3; /* Max SCSI channel number on this board */
691
692 /* Structure extension defined in EATA 2.0C */
693 unchar max_lun; /* Max SCSI LUN number */
694 unchar
695 : 4,
696 m1 : 1, /* This is a PCI with an M1 chip installed */
697 idquest : 1, /* RAIDNUM returned is questionable */
698 pci : 1, /* This board is PCI */
699 eisa : 1; /* This board is EISA */
700 #endif
701
702 unchar raidnum; /* Uniquely identifies this HBA in a system */
703 unchar notused;
704
705 ushort ipad[247];
706 };
707
708 /* Board config structure */
709 struct eata_config {
710 ushort len; /* Number of bytes following this field */
711
712 #if defined(__BIG_ENDIAN_BITFIELD)
713 unchar : 4,
714 tarena : 1,
715 mdpena : 1,
716 ocena : 1,
717 edis : 1;
718 #else
719 unchar edis : 1, /* Disable EATA interface after config command */
720 ocena : 1, /* Overlapped Commands Enabled */
721 mdpena : 1, /* Transfer all Modified Data Pointer Messages */
722 tarena : 1, /* Target Mode Enabled for this controller */
723 : 4;
724 #endif
725 unchar cpad[511];
726 };
727
728 /* Returned status packet structure */
729 struct mssp {
730 #if defined(__BIG_ENDIAN_BITFIELD)
731 unchar eoc : 1,
732 adapter_status : 7;
733 #else
734 unchar adapter_status : 7, /* State related to current command */
735 eoc : 1; /* End Of Command (1 = command completed) */
736 #endif
737 unchar target_status; /* SCSI status received after data transfer */
738 unchar unused[2];
739 u_int32_t inv_res_len; /* Number of bytes not transferred */
740 u_int32_t cpp_index; /* Index of address set in cp */
741 char mess[12];
742 };
743
744 struct sg_list {
745 unsigned int address; /* Segment Address */
746 unsigned int num_bytes; /* Segment Length */
747 };
748
749 /* MailBox SCSI Command Packet */
750 struct mscp {
751 #if defined(__BIG_ENDIAN_BITFIELD)
752 unchar din : 1,
753 dout : 1,
754 interp : 1,
755 : 1,
756 sg : 1,
757 reqsen :1,
758 init : 1,
759 sreset : 1;
760 unchar sense_len;
761 unchar unused[3];
762 unchar : 7,
763 fwnest : 1;
764 unchar : 5,
765 hbaci : 1,
766 iat : 1,
767 phsunit : 1;
768 unchar channel : 3,
769 target : 5;
770 unchar one : 1,
771 dispri : 1,
772 luntar : 1,
773 lun : 5;
774 #else
775 unchar sreset :1, /* SCSI Bus Reset Signal should be asserted */
776 init :1, /* Re-initialize controller and self test */
777 reqsen :1, /* Transfer Request Sense Data to addr using DMA */
778 sg :1, /* Use Scatter/Gather */
779 :1,
780 interp :1, /* The controller interprets cp, not the target */
781 dout :1, /* Direction of Transfer is Out (Host to Target) */
782 din :1; /* Direction of Transfer is In (Target to Host) */
783 unchar sense_len; /* Request Sense Length */
784 unchar unused[3];
785 unchar fwnest : 1, /* Send command to a component of an Array Group */
786 : 7;
787 unchar phsunit : 1, /* Send to Target Physical Unit (bypass RAID) */
788 iat : 1, /* Inhibit Address Translation */
789 hbaci : 1, /* Inhibit HBA Caching for this command */
790 : 5;
791 unchar target : 5, /* SCSI target ID */
792 channel : 3; /* SCSI channel number */
793 unchar lun : 5, /* SCSI logical unit number */
794 luntar : 1, /* This cp is for Target (not LUN) */
795 dispri : 1, /* Disconnect Privilege granted */
796 one : 1; /* 1 */
797 #endif
798
799 unchar mess[3]; /* Massage to/from Target */
800 unchar cdb[12]; /* Command Descriptor Block */
801 u_int32_t data_len; /* If sg=0 Data Length, if sg=1 sglist length */
802 u_int32_t cpp_index; /* Index of address to be returned in sp */
803 u_int32_t data_address; /* If sg=0 Data Address, if sg=1 sglist address */
804 u_int32_t sp_dma_addr; /* Address where sp is DMA'ed when cp completes */
805 u_int32_t sense_addr; /* Address where Sense Data is DMA'ed on error */
806
807 /* Additional fields begin here. */
808 struct scsi_cmnd *SCpnt;
809
810 /* All the cp structure is zero filled by queuecommand except the
811 following CP_TAIL_SIZE bytes, initialized by detect */
812 dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
813 struct sg_list *sglist; /* pointer to the allocated SG list */
814 };
815
816 #define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
817
818 struct hostdata {
819 struct mscp cp[MAX_MAILBOXES]; /* Mailboxes for this board */
820 unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
821 unsigned int last_cp_used; /* Index of last mailbox used */
822 unsigned int iocount; /* Total i/o done for this board */
823 int board_number; /* Number of this board */
824 char board_name[16]; /* Name of this board */
825 int in_reset; /* True if board is doing a reset */
826 int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
827 int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If 1 redo i/o on target */
828 unsigned int retries; /* Number of internal retries */
829 unsigned long last_retried_pid; /* Pid of last retried command */
830 unsigned char subversion; /* Bus type, either ISA or EISA/PCI */
831 unsigned char protocol_rev; /* EATA 2.0 rev., 'A' or 'B' or 'C' */
832 unsigned char is_pci; /* 1 is bus type is PCI */
833 struct pci_dev *pdev; /* pdev for PCI bus, NULL otherwise */
834 struct mssp *sp_cpu_addr; /* cpu addr for DMA buffer sp */
835 dma_addr_t sp_dma_addr; /* dma handle for DMA buffer sp */
836 struct mssp sp; /* Local copy of sp buffer */
837 };
838
839 static struct Scsi_Host *sh[MAX_BOARDS];
840 static const char *driver_name = "EATA";
841 static char sha[MAX_BOARDS];
842 static DEFINE_SPINLOCK(driver_lock);
843
844 /* Initialize num_boards so that ihdlr can work while detect is in progress */
845 static unsigned int num_boards = MAX_BOARDS;
846
847 static unsigned long io_port[] = {
848
849 /* Space for MAX_INT_PARAM ports usable while loading as a module */
850 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
851 SKIP, SKIP,
852
853 /* First ISA */
854 0x1f0,
855
856 /* Space for MAX_PCI ports possibly reported by PCI_BIOS */
857 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
858 SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
859
860 /* MAX_EISA ports */
861 0x1c88, 0x2c88, 0x3c88, 0x4c88, 0x5c88, 0x6c88, 0x7c88, 0x8c88,
862 0x9c88, 0xac88, 0xbc88, 0xcc88, 0xdc88, 0xec88, 0xfc88,
863
864 /* Other (MAX_ISA - 1) ports */
865 0x170, 0x230, 0x330,
866
867 /* End of list */
868 0x0
869 };
870
871 /* Device is Big Endian */
872 #define H2DEV(x) cpu_to_be32(x)
873 #define DEV2H(x) be32_to_cpu(x)
874 #define H2DEV16(x) cpu_to_be16(x)
875 #define DEV2H16(x) be16_to_cpu(x)
876
877 /* But transfer orientation from the 16 bit data register is Little Endian */
878 #define REG2H(x) le16_to_cpu(x)
879
880 static irqreturn_t do_interrupt_handler(int, void *, struct pt_regs *);
881 static void flush_dev(struct scsi_device *, unsigned long, struct hostdata *,
882 unsigned int);
883 static int do_trace = 0;
884 static int setup_done = 0;
885 static int link_statistics;
886 static int ext_tran = 0;
887 static int rev_scan = 1;
888
889 #if defined(CONFIG_SCSI_EATA_TAGGED_QUEUE)
890 static int tag_mode = TAG_SIMPLE;
891 #else
892 static int tag_mode = TAG_DISABLED;
893 #endif
894
895 #if defined(CONFIG_SCSI_EATA_LINKED_COMMANDS)
896 static int linked_comm = 1;
897 #else
898 static int linked_comm = 0;
899 #endif
900
901 #if defined(CONFIG_SCSI_EATA_MAX_TAGS)
902 static int max_queue_depth = CONFIG_SCSI_EATA_MAX_TAGS;
903 #else
904 static int max_queue_depth = MAX_CMD_PER_LUN;
905 #endif
906
907 #if defined(CONFIG_ISA)
908 static int isa_probe = 1;
909 #else
910 static int isa_probe = 0;
911 #endif
912
913 #if defined(CONFIG_EISA)
914 static int eisa_probe = 1;
915 #else
916 static int eisa_probe = 0;
917 #endif
918
919 #if defined(CONFIG_PCI)
920 static int pci_probe = 1;
921 #else
922 static int pci_probe = 0;
923 #endif
924
925 #define MAX_INT_PARAM 10
926 #define MAX_BOOT_OPTIONS_SIZE 256
927 static char boot_options[MAX_BOOT_OPTIONS_SIZE];
928
929 #if defined(MODULE)
930 #include <linux/module.h>
931 #include <linux/moduleparam.h>
932
933 module_param_string(eata, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
934 MODULE_PARM_DESC(eata, " equivalent to the \"eata=...\" kernel boot option."
935 " Example: modprobe eata \"eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n\"");
936 MODULE_AUTHOR("Dario Ballabio");
937 MODULE_LICENSE("GPL");
938 MODULE_DESCRIPTION("EATA/DMA SCSI Driver");
939
940 #endif
941
942 static int eata2x_slave_configure(struct scsi_device *dev)
943 {
944 int tqd, utqd;
945 char *tag_suffix, *link_suffix;
946 struct Scsi_Host *shost = dev->host;
947 struct hostdata *ha = (struct hostdata *)shost->hostdata;
948
949 utqd = MAX_CMD_PER_LUN;
950 tqd = max_queue_depth;
951
952 if (TLDEV(dev->type) && dev->tagged_supported) {
953 if (tag_mode == TAG_SIMPLE) {
954 scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
955 tag_suffix = ", simple tags";
956 } else if (tag_mode == TAG_ORDERED) {
957 scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
958 tag_suffix = ", ordered tags";
959 } else {
960 scsi_adjust_queue_depth(dev, 0, tqd);
961 tag_suffix = ", no tags";
962 }
963 } else if (TLDEV(dev->type) && linked_comm) {
964 scsi_adjust_queue_depth(dev, 0, tqd);
965 tag_suffix = ", untagged";
966 } else {
967 scsi_adjust_queue_depth(dev, 0, utqd);
968 tag_suffix = "";
969 }
970
971 if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
972 link_suffix = ", sorted";
973 else if (TLDEV(dev->type))
974 link_suffix = ", unsorted";
975 else
976 link_suffix = "";
977
978 printk("%s: scsi%d, channel %d, id %d, lun %d, cmds/lun %d%s%s.\n",
979 ha->board_name, shost->host_no, dev->channel, dev->id, dev->lun,
980 dev->queue_depth, link_suffix, tag_suffix);
981
982 return 0;
983 }
984
985 static int wait_on_busy(unsigned long iobase, unsigned int loop)
986 {
987 while (inb(iobase + REG_AUX_STATUS) & ABSY_ASSERTED) {
988 udelay(1L);
989 if (--loop == 0)
990 return 1;
991 }
992 return 0;
993 }
994
995 static int do_dma(unsigned long iobase, unsigned long addr, unchar cmd)
996 {
997 unsigned char *byaddr;
998 unsigned long devaddr;
999
1000 if (wait_on_busy(iobase, (addr ? MAXLOOP * 100 : MAXLOOP)))
1001 return 1;
1002
1003 if (addr) {
1004 devaddr = H2DEV(addr);
1005 byaddr = (unsigned char *)&devaddr;
1006 outb(byaddr[3], iobase + REG_LOW);
1007 outb(byaddr[2], iobase + REG_LM);
1008 outb(byaddr[1], iobase + REG_MID);
1009 outb(byaddr[0], iobase + REG_MSB);
1010 }
1011
1012 outb(cmd, iobase + REG_CMD);
1013 return 0;
1014 }
1015
1016 static int read_pio(unsigned long iobase, ushort * start, ushort * end)
1017 {
1018 unsigned int loop = MAXLOOP;
1019 ushort *p;
1020
1021 for (p = start; p <= end; p++) {
1022 while (!(inb(iobase + REG_STATUS) & DRQ_ASSERTED)) {
1023 udelay(1L);
1024 if (--loop == 0)
1025 return 1;
1026 }
1027 loop = MAXLOOP;
1028 *p = REG2H(inw(iobase));
1029 }
1030
1031 return 0;
1032 }
1033
1034 static struct pci_dev *get_pci_dev(unsigned long port_base)
1035 {
1036 #if defined(CONFIG_PCI)
1037 unsigned int addr;
1038 struct pci_dev *dev = NULL;
1039
1040 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1041 addr = pci_resource_start(dev, 0);
1042
1043 #if defined(DEBUG_PCI_DETECT)
1044 printk("%s: get_pci_dev, bus %d, devfn 0x%x, addr 0x%x.\n",
1045 driver_name, dev->bus->number, dev->devfn, addr);
1046 #endif
1047
1048 /* we are in so much trouble for a pci hotplug system with this driver
1049 * anyway, so doing this at least lets people unload the driver and not
1050 * cause memory problems, but in general this is a bad thing to do (this
1051 * driver needs to be converted to the proper PCI api someday... */
1052 pci_dev_put(dev);
1053 if (addr + PCI_BASE_ADDRESS_0 == port_base)
1054 return dev;
1055 }
1056 #endif /* end CONFIG_PCI */
1057 return NULL;
1058 }
1059
1060 static void enable_pci_ports(void)
1061 {
1062 #if defined(CONFIG_PCI)
1063 struct pci_dev *dev = NULL;
1064
1065 while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1066 #if defined(DEBUG_PCI_DETECT)
1067 printk("%s: enable_pci_ports, bus %d, devfn 0x%x.\n",
1068 driver_name, dev->bus->number, dev->devfn);
1069 #endif
1070
1071 if (pci_enable_device(dev))
1072 printk
1073 ("%s: warning, pci_enable_device failed, bus %d devfn 0x%x.\n",
1074 driver_name, dev->bus->number, dev->devfn);
1075 }
1076
1077 #endif /* end CONFIG_PCI */
1078 }
1079
1080 static int port_detect(unsigned long port_base, unsigned int j,
1081 struct scsi_host_template *tpnt)
1082 {
1083 unsigned char irq, dma_channel, subversion, i, is_pci = 0;
1084 unsigned char protocol_rev;
1085 struct eata_info info;
1086 char *bus_type, dma_name[16];
1087 struct pci_dev *pdev;
1088 /* Allowed DMA channels for ISA (0 indicates reserved) */
1089 unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
1090 struct Scsi_Host *shost;
1091 struct hostdata *ha;
1092 char name[16];
1093
1094 sprintf(name, "%s%d", driver_name, j);
1095
1096 if (!request_region(port_base, REGION_SIZE, driver_name)) {
1097 #if defined(DEBUG_DETECT)
1098 printk("%s: address 0x%03lx in use, skipping probe.\n", name,
1099 port_base);
1100 #endif
1101 goto fail;
1102 }
1103
1104 spin_lock_irq(&driver_lock);
1105
1106 if (do_dma(port_base, 0, READ_CONFIG_PIO)) {
1107 #if defined(DEBUG_DETECT)
1108 printk("%s: detect, do_dma failed at 0x%03lx.\n", name,
1109 port_base);
1110 #endif
1111 goto freelock;
1112 }
1113
1114 /* Read the info structure */
1115 if (read_pio(port_base, (ushort *) & info, (ushort *) & info.ipad[0])) {
1116 #if defined(DEBUG_DETECT)
1117 printk("%s: detect, read_pio failed at 0x%03lx.\n", name,
1118 port_base);
1119 #endif
1120 goto freelock;
1121 }
1122
1123 info.data_len = DEV2H(info.data_len);
1124 info.sign = DEV2H(info.sign);
1125 info.cp_pad_len = DEV2H16(info.cp_pad_len);
1126 info.cp_len = DEV2H(info.cp_len);
1127 info.sp_len = DEV2H(info.sp_len);
1128 info.scatt_size = DEV2H16(info.scatt_size);
1129 info.queue_size = DEV2H16(info.queue_size);
1130
1131 /* Check the controller "EATA" signature */
1132 if (info.sign != EATA_SIG_BE) {
1133 #if defined(DEBUG_DETECT)
1134 printk("%s: signature 0x%04x discarded.\n", name, info.sign);
1135 #endif
1136 goto freelock;
1137 }
1138
1139 if (info.data_len < EATA_2_0A_SIZE) {
1140 printk
1141 ("%s: config structure size (%d bytes) too short, detaching.\n",
1142 name, info.data_len);
1143 goto freelock;
1144 } else if (info.data_len == EATA_2_0A_SIZE)
1145 protocol_rev = 'A';
1146 else if (info.data_len == EATA_2_0B_SIZE)
1147 protocol_rev = 'B';
1148 else
1149 protocol_rev = 'C';
1150
1151 if (protocol_rev != 'A' && info.forcaddr) {
1152 printk("%s: warning, port address has been forced.\n", name);
1153 bus_type = "PCI";
1154 is_pci = 1;
1155 subversion = ESA;
1156 } else if (port_base > MAX_EISA_ADDR
1157 || (protocol_rev == 'C' && info.pci)) {
1158 bus_type = "PCI";
1159 is_pci = 1;
1160 subversion = ESA;
1161 } else if (port_base >= MIN_EISA_ADDR
1162 || (protocol_rev == 'C' && info.eisa)) {
1163 bus_type = "EISA";
1164 subversion = ESA;
1165 } else if (protocol_rev == 'C' && !info.eisa && !info.pci) {
1166 bus_type = "ISA";
1167 subversion = ISA;
1168 } else if (port_base > MAX_ISA_ADDR) {
1169 bus_type = "PCI";
1170 is_pci = 1;
1171 subversion = ESA;
1172 } else {
1173 bus_type = "ISA";
1174 subversion = ISA;
1175 }
1176
1177 if (!info.haaval || info.ata) {
1178 printk
1179 ("%s: address 0x%03lx, unusable %s board (%d%d), detaching.\n",
1180 name, port_base, bus_type, info.haaval, info.ata);
1181 goto freelock;
1182 }
1183
1184 if (info.drqvld) {
1185 if (subversion == ESA)
1186 printk("%s: warning, weird %s board using DMA.\n", name,
1187 bus_type);
1188
1189 subversion = ISA;
1190 dma_channel = dma_channel_table[3 - info.drqx];
1191 } else {
1192 if (subversion == ISA)
1193 printk("%s: warning, weird %s board not using DMA.\n",
1194 name, bus_type);
1195
1196 subversion = ESA;
1197 dma_channel = NO_DMA;
1198 }
1199
1200 if (!info.dmasup)
1201 printk("%s: warning, DMA protocol support not asserted.\n",
1202 name);
1203
1204 irq = info.irq;
1205
1206 if (subversion == ESA && !info.irq_tr)
1207 printk
1208 ("%s: warning, LEVEL triggering is suggested for IRQ %u.\n",
1209 name, irq);
1210
1211 if (is_pci) {
1212 pdev = get_pci_dev(port_base);
1213 if (!pdev)
1214 printk
1215 ("%s: warning, failed to get pci_dev structure.\n",
1216 name);
1217 } else
1218 pdev = NULL;
1219
1220 if (pdev && (irq != pdev->irq)) {
1221 printk("%s: IRQ %u mapped to IO-APIC IRQ %u.\n", name, irq,
1222 pdev->irq);
1223 irq = pdev->irq;
1224 }
1225
1226 /* Board detected, allocate its IRQ */
1227 if (request_irq(irq, do_interrupt_handler,
1228 SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0),
1229 driver_name, (void *)&sha[j])) {
1230 printk("%s: unable to allocate IRQ %u, detaching.\n", name,
1231 irq);
1232 goto freelock;
1233 }
1234
1235 if (subversion == ISA && request_dma(dma_channel, driver_name)) {
1236 printk("%s: unable to allocate DMA channel %u, detaching.\n",
1237 name, dma_channel);
1238 goto freeirq;
1239 }
1240 #if defined(FORCE_CONFIG)
1241 {
1242 struct eata_config *cf;
1243 dma_addr_t cf_dma_addr;
1244
1245 cf = pci_alloc_consistent(pdev, sizeof(struct eata_config),
1246 &cf_dma_addr);
1247
1248 if (!cf) {
1249 printk
1250 ("%s: config, pci_alloc_consistent failed, detaching.\n",
1251 name);
1252 goto freedma;
1253 }
1254
1255 /* Set board configuration */
1256 memset((char *)cf, 0, sizeof(struct eata_config));
1257 cf->len = (ushort) H2DEV16((ushort) 510);
1258 cf->ocena = 1;
1259
1260 if (do_dma(port_base, cf_dma_addr, SET_CONFIG_DMA)) {
1261 printk
1262 ("%s: busy timeout sending configuration, detaching.\n",
1263 name);
1264 pci_free_consistent(pdev, sizeof(struct eata_config),
1265 cf, cf_dma_addr);
1266 goto freedma;
1267 }
1268
1269 }
1270 #endif
1271
1272 spin_unlock_irq(&driver_lock);
1273 sh[j] = shost = scsi_register(tpnt, sizeof(struct hostdata));
1274 spin_lock_irq(&driver_lock);
1275
1276 if (shost == NULL) {
1277 printk("%s: unable to register host, detaching.\n", name);
1278 goto freedma;
1279 }
1280
1281 shost->io_port = port_base;
1282 shost->unique_id = port_base;
1283 shost->n_io_port = REGION_SIZE;
1284 shost->dma_channel = dma_channel;
1285 shost->irq = irq;
1286 shost->sg_tablesize = (ushort) info.scatt_size;
1287 shost->this_id = (ushort) info.host_addr[3];
1288 shost->can_queue = (ushort) info.queue_size;
1289 shost->cmd_per_lun = MAX_CMD_PER_LUN;
1290
1291 ha = (struct hostdata *)shost->hostdata;
1292
1293 memset(ha, 0, sizeof(struct hostdata));
1294 ha->subversion = subversion;
1295 ha->protocol_rev = protocol_rev;
1296 ha->is_pci = is_pci;
1297 ha->pdev = pdev;
1298 ha->board_number = j;
1299
1300 if (ha->subversion == ESA)
1301 shost->unchecked_isa_dma = 0;
1302 else {
1303 unsigned long flags;
1304 shost->unchecked_isa_dma = 1;
1305
1306 flags = claim_dma_lock();
1307 disable_dma(dma_channel);
1308 clear_dma_ff(dma_channel);
1309 set_dma_mode(dma_channel, DMA_MODE_CASCADE);
1310 enable_dma(dma_channel);
1311 release_dma_lock(flags);
1312
1313 }
1314
1315 strcpy(ha->board_name, name);
1316
1317 /* DPT PM2012 does not allow to detect sg_tablesize correctly */
1318 if (shost->sg_tablesize > MAX_SGLIST || shost->sg_tablesize < 2) {
1319 printk("%s: detect, wrong n. of SG lists %d, fixed.\n",
1320 ha->board_name, shost->sg_tablesize);
1321 shost->sg_tablesize = MAX_SGLIST;
1322 }
1323
1324 /* DPT PM2012 does not allow to detect can_queue correctly */
1325 if (shost->can_queue > MAX_MAILBOXES || shost->can_queue < 2) {
1326 printk("%s: detect, wrong n. of mbox %d, fixed.\n",
1327 ha->board_name, shost->can_queue);
1328 shost->can_queue = MAX_MAILBOXES;
1329 }
1330
1331 if (protocol_rev != 'A') {
1332 if (info.max_chan > 0 && info.max_chan < MAX_CHANNEL)
1333 shost->max_channel = info.max_chan;
1334
1335 if (info.max_id > 7 && info.max_id < MAX_TARGET)
1336 shost->max_id = info.max_id + 1;
1337
1338 if (info.large_sg && shost->sg_tablesize == MAX_SGLIST)
1339 shost->sg_tablesize = MAX_LARGE_SGLIST;
1340 }
1341
1342 if (protocol_rev == 'C') {
1343 if (info.max_lun > 7 && info.max_lun < MAX_LUN)
1344 shost->max_lun = info.max_lun + 1;
1345 }
1346
1347 if (dma_channel == NO_DMA)
1348 sprintf(dma_name, "%s", "BMST");
1349 else
1350 sprintf(dma_name, "DMA %u", dma_channel);
1351
1352 spin_unlock_irq(&driver_lock);
1353
1354 for (i = 0; i < shost->can_queue; i++)
1355 ha->cp[i].cp_dma_addr = pci_map_single(ha->pdev,
1356 &ha->cp[i],
1357 sizeof(struct mscp),
1358 PCI_DMA_BIDIRECTIONAL);
1359
1360 for (i = 0; i < shost->can_queue; i++) {
1361 size_t sz = shost->sg_tablesize *sizeof(struct sg_list);
1362 unsigned int gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
1363 ha->cp[i].sglist = kmalloc(sz, gfp_mask);
1364 if (!ha->cp[i].sglist) {
1365 printk
1366 ("%s: kmalloc SGlist failed, mbox %d, detaching.\n",
1367 ha->board_name, i);
1368 goto release;
1369 }
1370 }
1371
1372 if (!(ha->sp_cpu_addr = pci_alloc_consistent(ha->pdev,
1373 sizeof(struct mssp),
1374 &ha->sp_dma_addr))) {
1375 printk("%s: pci_alloc_consistent failed, detaching.\n", ha->board_name);
1376 goto release;
1377 }
1378
1379 if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
1380 max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
1381
1382 if (max_queue_depth < MAX_CMD_PER_LUN)
1383 max_queue_depth = MAX_CMD_PER_LUN;
1384
1385 if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
1386 tag_mode = TAG_ORDERED;
1387
1388 if (j == 0) {
1389 printk
1390 ("EATA/DMA 2.0x: Copyright (C) 1994-2003 Dario Ballabio.\n");
1391 printk
1392 ("%s config options -> tm:%d, lc:%c, mq:%d, rs:%c, et:%c, "
1393 "ip:%c, ep:%c, pp:%c.\n", driver_name, tag_mode,
1394 YESNO(linked_comm), max_queue_depth, YESNO(rev_scan),
1395 YESNO(ext_tran), YESNO(isa_probe), YESNO(eisa_probe),
1396 YESNO(pci_probe));
1397 }
1398
1399 printk("%s: 2.0%c, %s 0x%03lx, IRQ %u, %s, SG %d, MB %d.\n",
1400 ha->board_name, ha->protocol_rev, bus_type,
1401 (unsigned long)shost->io_port, shost->irq, dma_name,
1402 shost->sg_tablesize, shost->can_queue);
1403
1404 if (shost->max_id > 8 || shost->max_lun > 8)
1405 printk
1406 ("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1407 ha->board_name, shost->max_id, shost->max_lun);
1408
1409 for (i = 0; i <= shost->max_channel; i++)
1410 printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1411 ha->board_name, i, info.host_addr[3 - i]);
1412
1413 #if defined(DEBUG_DETECT)
1414 printk("%s: Vers. 0x%x, ocs %u, tar %u, trnxfr %u, more %u, SYNC 0x%x, "
1415 "sec. %u, infol %d, cpl %d spl %d.\n", name, info.version,
1416 info.ocsena, info.tarsup, info.trnxfr, info.morsup, info.sync,
1417 info.second, info.data_len, info.cp_len, info.sp_len);
1418
1419 if (protocol_rev == 'B' || protocol_rev == 'C')
1420 printk("%s: isaena %u, forcaddr %u, max_id %u, max_chan %u, "
1421 "large_sg %u, res1 %u.\n", name, info.isaena,
1422 info.forcaddr, info.max_id, info.max_chan, info.large_sg,
1423 info.res1);
1424
1425 if (protocol_rev == 'C')
1426 printk("%s: max_lun %u, m1 %u, idquest %u, pci %u, eisa %u, "
1427 "raidnum %u.\n", name, info.max_lun, info.m1,
1428 info.idquest, info.pci, info.eisa, info.raidnum);
1429 #endif
1430
1431 if (ha->pdev) {
1432 pci_set_master(ha->pdev);
1433 if (pci_set_dma_mask(ha->pdev, 0xffffffff))
1434 printk("%s: warning, pci_set_dma_mask failed.\n",
1435 ha->board_name);
1436 }
1437
1438 return 1;
1439
1440 freedma:
1441 if (subversion == ISA)
1442 free_dma(dma_channel);
1443 freeirq:
1444 free_irq(irq, &sha[j]);
1445 freelock:
1446 spin_unlock_irq(&driver_lock);
1447 release_region(port_base, REGION_SIZE);
1448 fail:
1449 return 0;
1450
1451 release:
1452 eata2x_release(shost);
1453 return 0;
1454 }
1455
1456 static void internal_setup(char *str, int *ints)
1457 {
1458 int i, argc = ints[0];
1459 char *cur = str, *pc;
1460
1461 if (argc > 0) {
1462 if (argc > MAX_INT_PARAM)
1463 argc = MAX_INT_PARAM;
1464
1465 for (i = 0; i < argc; i++)
1466 io_port[i] = ints[i + 1];
1467
1468 io_port[i] = 0;
1469 setup_done = 1;
1470 }
1471
1472 while (cur && (pc = strchr(cur, ':'))) {
1473 int val = 0, c = *++pc;
1474
1475 if (c == 'n' || c == 'N')
1476 val = 0;
1477 else if (c == 'y' || c == 'Y')
1478 val = 1;
1479 else
1480 val = (int)simple_strtoul(pc, NULL, 0);
1481
1482 if (!strncmp(cur, "lc:", 3))
1483 linked_comm = val;
1484 else if (!strncmp(cur, "tm:", 3))
1485 tag_mode = val;
1486 else if (!strncmp(cur, "tc:", 3))
1487 tag_mode = val;
1488 else if (!strncmp(cur, "mq:", 3))
1489 max_queue_depth = val;
1490 else if (!strncmp(cur, "ls:", 3))
1491 link_statistics = val;
1492 else if (!strncmp(cur, "et:", 3))
1493 ext_tran = val;
1494 else if (!strncmp(cur, "rs:", 3))
1495 rev_scan = val;
1496 else if (!strncmp(cur, "ip:", 3))
1497 isa_probe = val;
1498 else if (!strncmp(cur, "ep:", 3))
1499 eisa_probe = val;
1500 else if (!strncmp(cur, "pp:", 3))
1501 pci_probe = val;
1502
1503 if ((cur = strchr(cur, ',')))
1504 ++cur;
1505 }
1506
1507 return;
1508 }
1509
1510 static int option_setup(char *str)
1511 {
1512 int ints[MAX_INT_PARAM];
1513 char *cur = str;
1514 int i = 1;
1515
1516 while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
1517 ints[i++] = simple_strtoul(cur, NULL, 0);
1518
1519 if ((cur = strchr(cur, ',')) != NULL)
1520 cur++;
1521 }
1522
1523 ints[0] = i - 1;
1524 internal_setup(cur, ints);
1525 return 1;
1526 }
1527
1528 static void add_pci_ports(void)
1529 {
1530 #if defined(CONFIG_PCI)
1531 unsigned int addr, k;
1532 struct pci_dev *dev = NULL;
1533
1534 for (k = 0; k < MAX_PCI; k++) {
1535
1536 if (!(dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev)))
1537 break;
1538
1539 if (pci_enable_device(dev)) {
1540 #if defined(DEBUG_PCI_DETECT)
1541 printk
1542 ("%s: detect, bus %d, devfn 0x%x, pci_enable_device failed.\n",
1543 driver_name, dev->bus->number, dev->devfn);
1544 #endif
1545
1546 continue;
1547 }
1548
1549 addr = pci_resource_start(dev, 0);
1550
1551 #if defined(DEBUG_PCI_DETECT)
1552 printk("%s: detect, seq. %d, bus %d, devfn 0x%x, addr 0x%x.\n",
1553 driver_name, k, dev->bus->number, dev->devfn, addr);
1554 #endif
1555
1556 /* Order addresses according to rev_scan value */
1557 io_port[MAX_INT_PARAM + (rev_scan ? (MAX_PCI - k) : (1 + k))] =
1558 addr + PCI_BASE_ADDRESS_0;
1559 }
1560
1561 pci_dev_put(dev);
1562 #endif /* end CONFIG_PCI */
1563 }
1564
1565 static int eata2x_detect(struct scsi_host_template *tpnt)
1566 {
1567 unsigned int j = 0, k;
1568
1569 tpnt->proc_name = "eata2x";
1570
1571 if (strlen(boot_options))
1572 option_setup(boot_options);
1573
1574 #if defined(MODULE)
1575 /* io_port could have been modified when loading as a module */
1576 if (io_port[0] != SKIP) {
1577 setup_done = 1;
1578 io_port[MAX_INT_PARAM] = 0;
1579 }
1580 #endif
1581
1582 for (k = MAX_INT_PARAM; io_port[k]; k++)
1583 if (io_port[k] == SKIP)
1584 continue;
1585 else if (io_port[k] <= MAX_ISA_ADDR) {
1586 if (!isa_probe)
1587 io_port[k] = SKIP;
1588 } else if (io_port[k] >= MIN_EISA_ADDR
1589 && io_port[k] <= MAX_EISA_ADDR) {
1590 if (!eisa_probe)
1591 io_port[k] = SKIP;
1592 }
1593
1594 if (pci_probe) {
1595 if (!setup_done)
1596 add_pci_ports();
1597 else
1598 enable_pci_ports();
1599 }
1600
1601 for (k = 0; io_port[k]; k++) {
1602
1603 if (io_port[k] == SKIP)
1604 continue;
1605
1606 if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt))
1607 j++;
1608 }
1609
1610 num_boards = j;
1611 return j;
1612 }
1613
1614 static void map_dma(unsigned int i, struct hostdata *ha)
1615 {
1616 unsigned int k, count, pci_dir;
1617 struct scatterlist *sgpnt;
1618 struct mscp *cpp;
1619 struct scsi_cmnd *SCpnt;
1620
1621 cpp = &ha->cp[i];
1622 SCpnt = cpp->SCpnt;
1623 pci_dir = SCpnt->sc_data_direction;
1624
1625 if (SCpnt->sense_buffer)
1626 cpp->sense_addr =
1627 H2DEV(pci_map_single(ha->pdev, SCpnt->sense_buffer,
1628 sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE));
1629
1630 cpp->sense_len = sizeof SCpnt->sense_buffer;
1631
1632 if (!SCpnt->use_sg) {
1633
1634 /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */
1635 if (!SCpnt->request_bufflen)
1636 pci_dir = PCI_DMA_BIDIRECTIONAL;
1637
1638 if (SCpnt->request_buffer)
1639 cpp->data_address = H2DEV(pci_map_single(ha->pdev,
1640 SCpnt->
1641 request_buffer,
1642 SCpnt->
1643 request_bufflen,
1644 pci_dir));
1645
1646 cpp->data_len = H2DEV(SCpnt->request_bufflen);
1647 return;
1648 }
1649
1650 sgpnt = (struct scatterlist *)SCpnt->request_buffer;
1651 count = pci_map_sg(ha->pdev, sgpnt, SCpnt->use_sg, pci_dir);
1652
1653 for (k = 0; k < count; k++) {
1654 cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k]));
1655 cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k]));
1656 }
1657
1658 cpp->sg = 1;
1659 cpp->data_address = H2DEV(pci_map_single(ha->pdev, cpp->sglist,
1660 SCpnt->use_sg *
1661 sizeof(struct sg_list),
1662 pci_dir));
1663 cpp->data_len = H2DEV((SCpnt->use_sg * sizeof(struct sg_list)));
1664 }
1665
1666 static void unmap_dma(unsigned int i, struct hostdata *ha)
1667 {
1668 unsigned int pci_dir;
1669 struct mscp *cpp;
1670 struct scsi_cmnd *SCpnt;
1671
1672 cpp = &ha->cp[i];
1673 SCpnt = cpp->SCpnt;
1674 pci_dir = SCpnt->sc_data_direction;
1675
1676 if (DEV2H(cpp->sense_addr))
1677 pci_unmap_single(ha->pdev, DEV2H(cpp->sense_addr),
1678 DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1679
1680 if (SCpnt->use_sg)
1681 pci_unmap_sg(ha->pdev, SCpnt->request_buffer, SCpnt->use_sg,
1682 pci_dir);
1683
1684 if (!DEV2H(cpp->data_len))
1685 pci_dir = PCI_DMA_BIDIRECTIONAL;
1686
1687 if (DEV2H(cpp->data_address))
1688 pci_unmap_single(ha->pdev, DEV2H(cpp->data_address),
1689 DEV2H(cpp->data_len), pci_dir);
1690 }
1691
1692 static void sync_dma(unsigned int i, struct hostdata *ha)
1693 {
1694 unsigned int pci_dir;
1695 struct mscp *cpp;
1696 struct scsi_cmnd *SCpnt;
1697
1698 cpp = &ha->cp[i];
1699 SCpnt = cpp->SCpnt;
1700 pci_dir = SCpnt->sc_data_direction;
1701
1702 if (DEV2H(cpp->sense_addr))
1703 pci_dma_sync_single_for_cpu(ha->pdev, DEV2H(cpp->sense_addr),
1704 DEV2H(cpp->sense_len),
1705 PCI_DMA_FROMDEVICE);
1706
1707 if (SCpnt->use_sg)
1708 pci_dma_sync_sg_for_cpu(ha->pdev, SCpnt->request_buffer,
1709 SCpnt->use_sg, pci_dir);
1710
1711 if (!DEV2H(cpp->data_len))
1712 pci_dir = PCI_DMA_BIDIRECTIONAL;
1713
1714 if (DEV2H(cpp->data_address))
1715 pci_dma_sync_single_for_cpu(ha->pdev,
1716 DEV2H(cpp->data_address),
1717 DEV2H(cpp->data_len), pci_dir);
1718 }
1719
1720 static void scsi_to_dev_dir(unsigned int i, struct hostdata *ha)
1721 {
1722 unsigned int k;
1723
1724 static const unsigned char data_out_cmds[] = {
1725 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1726 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1727 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1728 };
1729
1730 static const unsigned char data_none_cmds[] = {
1731 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1732 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1733 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1734 };
1735
1736 struct mscp *cpp;
1737 struct scsi_cmnd *SCpnt;
1738
1739 cpp = &ha->cp[i];
1740 SCpnt = cpp->SCpnt;
1741
1742 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1743 cpp->din = 1;
1744 cpp->dout = 0;
1745 return;
1746 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1747 cpp->din = 0;
1748 cpp->dout = 1;
1749 return;
1750 } else if (SCpnt->sc_data_direction == DMA_NONE) {
1751 cpp->din = 0;
1752 cpp->dout = 0;
1753 return;
1754 }
1755
1756 if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1757 panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n",
1758 ha->board_name);
1759
1760 for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1761 if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1762 cpp->dout = 1;
1763 break;
1764 }
1765
1766 if ((cpp->din = !cpp->dout))
1767 for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1768 if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1769 cpp->din = 0;
1770 break;
1771 }
1772
1773 }
1774
1775 static int eata2x_queuecommand(struct scsi_cmnd *SCpnt,
1776 void (*done) (struct scsi_cmnd *))
1777 {
1778 struct Scsi_Host *shost = SCpnt->device->host;
1779 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1780 unsigned int i, k;
1781 struct mscp *cpp;
1782
1783 if (SCpnt->host_scribble)
1784 panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
1785 ha->board_name, SCpnt->pid, SCpnt);
1786
1787 /* i is the mailbox number, look for the first free mailbox
1788 starting from last_cp_used */
1789 i = ha->last_cp_used + 1;
1790
1791 for (k = 0; k < shost->can_queue; k++, i++) {
1792 if (i >= shost->can_queue)
1793 i = 0;
1794 if (ha->cp_stat[i] == FREE) {
1795 ha->last_cp_used = i;
1796 break;
1797 }
1798 }
1799
1800 if (k == shost->can_queue) {
1801 printk("%s: qcomm, no free mailbox.\n", ha->board_name);
1802 return 1;
1803 }
1804
1805 /* Set pointer to control packet structure */
1806 cpp = &ha->cp[i];
1807
1808 memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1809
1810 /* Set pointer to status packet structure, Big Endian format */
1811 cpp->sp_dma_addr = H2DEV(ha->sp_dma_addr);
1812
1813 SCpnt->scsi_done = done;
1814 cpp->cpp_index = i;
1815 SCpnt->host_scribble = (unsigned char *)&cpp->cpp_index;
1816
1817 if (do_trace)
1818 printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n",
1819 ha->board_name, i, SCpnt->device->channel, SCpnt->device->id,
1820 SCpnt->device->lun, SCpnt->pid);
1821
1822 cpp->reqsen = 1;
1823 cpp->dispri = 1;
1824 #if 0
1825 if (SCpnt->device->type == TYPE_TAPE)
1826 cpp->hbaci = 1;
1827 #endif
1828 cpp->one = 1;
1829 cpp->channel = SCpnt->device->channel;
1830 cpp->target = SCpnt->device->id;
1831 cpp->lun = SCpnt->device->lun;
1832 cpp->SCpnt = SCpnt;
1833 memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1834
1835 /* Use data transfer direction SCpnt->sc_data_direction */
1836 scsi_to_dev_dir(i, ha);
1837
1838 /* Map DMA buffers and SG list */
1839 map_dma(i, ha);
1840
1841 if (linked_comm && SCpnt->device->queue_depth > 2
1842 && TLDEV(SCpnt->device->type)) {
1843 ha->cp_stat[i] = READY;
1844 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0);
1845 return 0;
1846 }
1847
1848 /* Send control packet to the board */
1849 if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
1850 unmap_dma(i, ha);
1851 SCpnt->host_scribble = NULL;
1852 printk("%s: qcomm, target %d.%d:%d, pid %ld, adapter busy.\n",
1853 ha->board_name, SCpnt->device->channel, SCpnt->device->id,
1854 SCpnt->device->lun, SCpnt->pid);
1855 return 1;
1856 }
1857
1858 ha->cp_stat[i] = IN_USE;
1859 return 0;
1860 }
1861
1862 static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1863 {
1864 struct Scsi_Host *shost = SCarg->device->host;
1865 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1866 unsigned int i;
1867
1868 if (SCarg->host_scribble == NULL) {
1869 printk("%s: abort, target %d.%d:%d, pid %ld inactive.\n",
1870 ha->board_name, SCarg->device->channel, SCarg->device->id,
1871 SCarg->device->lun, SCarg->pid);
1872 return SUCCESS;
1873 }
1874
1875 i = *(unsigned int *)SCarg->host_scribble;
1876 printk("%s: abort, mbox %d, target %d.%d:%d, pid %ld.\n",
1877 ha->board_name, i, SCarg->device->channel, SCarg->device->id,
1878 SCarg->device->lun, SCarg->pid);
1879
1880 if (i >= shost->can_queue)
1881 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
1882
1883 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1884 printk("%s: abort, timeout error.\n", ha->board_name);
1885 return FAILED;
1886 }
1887
1888 if (ha->cp_stat[i] == FREE) {
1889 printk("%s: abort, mbox %d is free.\n", ha->board_name, i);
1890 return SUCCESS;
1891 }
1892
1893 if (ha->cp_stat[i] == IN_USE) {
1894 printk("%s: abort, mbox %d is in use.\n", ha->board_name, i);
1895
1896 if (SCarg != ha->cp[i].SCpnt)
1897 panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1898 ha->board_name, i, SCarg, ha->cp[i].SCpnt);
1899
1900 if (inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)
1901 printk("%s: abort, mbox %d, interrupt pending.\n",
1902 ha->board_name, i);
1903
1904 if (SCarg->eh_state == SCSI_STATE_TIMEOUT) {
1905 unmap_dma(i, ha);
1906 SCarg->host_scribble = NULL;
1907 ha->cp_stat[i] = FREE;
1908 printk
1909 ("%s, abort, mbox %d, eh_state timeout, pid %ld.\n",
1910 ha->board_name, i, SCarg->pid);
1911 return SUCCESS;
1912 }
1913
1914 return FAILED;
1915 }
1916
1917 if (ha->cp_stat[i] == IN_RESET) {
1918 printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i);
1919 return FAILED;
1920 }
1921
1922 if (ha->cp_stat[i] == LOCKED) {
1923 printk("%s: abort, mbox %d is locked.\n", ha->board_name, i);
1924 return SUCCESS;
1925 }
1926
1927 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1928 unmap_dma(i, ha);
1929 SCarg->result = DID_ABORT << 16;
1930 SCarg->host_scribble = NULL;
1931 ha->cp_stat[i] = FREE;
1932 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
1933 ha->board_name, i, SCarg->pid);
1934 SCarg->scsi_done(SCarg);
1935 return SUCCESS;
1936 }
1937
1938 panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i);
1939 }
1940
1941 static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1942 {
1943 unsigned int i, time, k, c, limit = 0;
1944 int arg_done = 0;
1945 struct scsi_cmnd *SCpnt;
1946 struct Scsi_Host *shost = SCarg->device->host;
1947 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1948
1949 printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n",
1950 ha->board_name, SCarg->device->channel, SCarg->device->id,
1951 SCarg->device->lun, SCarg->pid);
1952
1953 if (SCarg->host_scribble == NULL)
1954 printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid);
1955
1956 if (ha->in_reset) {
1957 printk("%s: reset, exit, already in reset.\n", ha->board_name);
1958 return FAILED;
1959 }
1960
1961 if (wait_on_busy(shost->io_port, MAXLOOP)) {
1962 printk("%s: reset, exit, timeout error.\n", ha->board_name);
1963 return FAILED;
1964 }
1965
1966 ha->retries = 0;
1967
1968 for (c = 0; c <= shost->max_channel; c++)
1969 for (k = 0; k < shost->max_id; k++) {
1970 ha->target_redo[k][c] = 1;
1971 ha->target_to[k][c] = 0;
1972 }
1973
1974 for (i = 0; i < shost->can_queue; i++) {
1975
1976 if (ha->cp_stat[i] == FREE)
1977 continue;
1978
1979 if (ha->cp_stat[i] == LOCKED) {
1980 ha->cp_stat[i] = FREE;
1981 printk("%s: reset, locked mbox %d forced free.\n",
1982 ha->board_name, i);
1983 continue;
1984 }
1985
1986 if (!(SCpnt = ha->cp[i].SCpnt))
1987 panic("%s: reset, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
1988
1989 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1990 ha->cp_stat[i] = ABORTING;
1991 printk("%s: reset, mbox %d aborting, pid %ld.\n",
1992 ha->board_name, i, SCpnt->pid);
1993 }
1994
1995 else {
1996 ha->cp_stat[i] = IN_RESET;
1997 printk("%s: reset, mbox %d in reset, pid %ld.\n",
1998 ha->board_name, i, SCpnt->pid);
1999 }
2000
2001 if (SCpnt->host_scribble == NULL)
2002 panic("%s: reset, mbox %d, garbled SCpnt.\n", ha->board_name, i);
2003
2004 if (*(unsigned int *)SCpnt->host_scribble != i)
2005 panic("%s: reset, mbox %d, index mismatch.\n", ha->board_name, i);
2006
2007 if (SCpnt->scsi_done == NULL)
2008 panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n",
2009 ha->board_name, i);
2010
2011 if (SCpnt == SCarg)
2012 arg_done = 1;
2013 }
2014
2015 if (do_dma(shost->io_port, 0, RESET_PIO)) {
2016 printk("%s: reset, cannot reset, timeout error.\n", ha->board_name);
2017 return FAILED;
2018 }
2019
2020 printk("%s: reset, board reset done, enabling interrupts.\n", ha->board_name);
2021
2022 #if defined(DEBUG_RESET)
2023 do_trace = 1;
2024 #endif
2025
2026 ha->in_reset = 1;
2027
2028 spin_unlock_irq(shost->host_lock);
2029 time = jiffies;
2030 while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
2031 udelay(100L);
2032 spin_lock_irq(shost->host_lock);
2033
2034 printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
2035
2036 for (i = 0; i < shost->can_queue; i++) {
2037
2038 if (ha->cp_stat[i] == IN_RESET) {
2039 SCpnt = ha->cp[i].SCpnt;
2040 unmap_dma(i, ha);
2041 SCpnt->result = DID_RESET << 16;
2042 SCpnt->host_scribble = NULL;
2043
2044 /* This mailbox is still waiting for its interrupt */
2045 ha->cp_stat[i] = LOCKED;
2046
2047 printk
2048 ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
2049 ha->board_name, i, SCpnt->pid);
2050 }
2051
2052 else if (ha->cp_stat[i] == ABORTING) {
2053 SCpnt = ha->cp[i].SCpnt;
2054 unmap_dma(i, ha);
2055 SCpnt->result = DID_RESET << 16;
2056 SCpnt->host_scribble = NULL;
2057
2058 /* This mailbox was never queued to the adapter */
2059 ha->cp_stat[i] = FREE;
2060
2061 printk
2062 ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
2063 ha->board_name, i, SCpnt->pid);
2064 }
2065
2066 else
2067 /* Any other mailbox has already been set free by interrupt */
2068 continue;
2069
2070 SCpnt->scsi_done(SCpnt);
2071 }
2072
2073 ha->in_reset = 0;
2074 do_trace = 0;
2075
2076 if (arg_done)
2077 printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->pid);
2078 else
2079 printk("%s: reset, exit.\n", ha->board_name);
2080
2081 return SUCCESS;
2082 }
2083
2084 int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2085 sector_t capacity, int *dkinfo)
2086 {
2087 unsigned int size = capacity;
2088
2089 if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
2090 dkinfo[0] = 255;
2091 dkinfo[1] = 63;
2092 dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
2093 }
2094 #if defined (DEBUG_GEOMETRY)
2095 printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
2096 dkinfo[0], dkinfo[1], dkinfo[2]);
2097 #endif
2098
2099 return 0;
2100 }
2101
2102 static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
2103 unsigned int rev)
2104 {
2105 unsigned int i, j, k, y;
2106 unsigned long x;
2107
2108 for (i = 0; i < n - 1; i++) {
2109 k = i;
2110
2111 for (j = k + 1; j < n; j++)
2112 if (rev) {
2113 if (sk[j] > sk[k])
2114 k = j;
2115 } else {
2116 if (sk[j] < sk[k])
2117 k = j;
2118 }
2119
2120 if (k != i) {
2121 x = sk[k];
2122 sk[k] = sk[i];
2123 sk[i] = x;
2124 y = da[k];
2125 da[k] = da[i];
2126 da[i] = y;
2127 }
2128 }
2129
2130 return;
2131 }
2132
2133 static int reorder(struct hostdata *ha, unsigned long cursec,
2134 unsigned int ihdlr, unsigned int il[], unsigned int n_ready)
2135 {
2136 struct scsi_cmnd *SCpnt;
2137 struct mscp *cpp;
2138 unsigned int k, n;
2139 unsigned int rev = 0, s = 1, r = 1;
2140 unsigned int input_only = 1, overlap = 0;
2141 unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
2142 unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
2143 unsigned long ioseek = 0;
2144
2145 static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
2146 static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
2147 static unsigned int readysorted = 0, revcount = 0;
2148 static unsigned long seeksorted = 0, seeknosort = 0;
2149
2150 if (link_statistics && !(++flushcount % link_statistics))
2151 printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
2152 " av %ldK as %ldK.\n", flushcount, batchcount,
2153 inputcount, ovlcount, readycount, readysorted, sortcount,
2154 revcount, seeknosort / (readycount + 1),
2155 seeksorted / (readycount + 1));
2156
2157 if (n_ready <= 1)
2158 return 0;
2159
2160 for (n = 0; n < n_ready; n++) {
2161 k = il[n];
2162 cpp = &ha->cp[k];
2163 SCpnt = cpp->SCpnt;
2164
2165 if (!cpp->din)
2166 input_only = 0;
2167
2168 if (SCpnt->request->sector < minsec)
2169 minsec = SCpnt->request->sector;
2170 if (SCpnt->request->sector > maxsec)
2171 maxsec = SCpnt->request->sector;
2172
2173 sl[n] = SCpnt->request->sector;
2174 ioseek += SCpnt->request->nr_sectors;
2175
2176 if (!n)
2177 continue;
2178
2179 if (sl[n] < sl[n - 1])
2180 s = 0;
2181 if (sl[n] > sl[n - 1])
2182 r = 0;
2183
2184 if (link_statistics) {
2185 if (sl[n] > sl[n - 1])
2186 seek += sl[n] - sl[n - 1];
2187 else
2188 seek += sl[n - 1] - sl[n];
2189 }
2190
2191 }
2192
2193 if (link_statistics) {
2194 if (cursec > sl[0])
2195 seek += cursec - sl[0];
2196 else
2197 seek += sl[0] - cursec;
2198 }
2199
2200 if (cursec > ((maxsec + minsec) / 2))
2201 rev = 1;
2202
2203 if (ioseek > ((maxsec - minsec) / 2))
2204 rev = 0;
2205
2206 if (!((rev && r) || (!rev && s)))
2207 sort(sl, il, n_ready, rev);
2208
2209 if (!input_only)
2210 for (n = 0; n < n_ready; n++) {
2211 k = il[n];
2212 cpp = &ha->cp[k];
2213 SCpnt = cpp->SCpnt;
2214 ll[n] = SCpnt->request->nr_sectors;
2215 pl[n] = SCpnt->pid;
2216
2217 if (!n)
2218 continue;
2219
2220 if ((sl[n] == sl[n - 1])
2221 || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
2222 || (rev && ((sl[n] + ll[n]) > sl[n - 1])))
2223 overlap = 1;
2224 }
2225
2226 if (overlap)
2227 sort(pl, il, n_ready, 0);
2228
2229 if (link_statistics) {
2230 if (cursec > sl[0])
2231 iseek = cursec - sl[0];
2232 else
2233 iseek = sl[0] - cursec;
2234 batchcount++;
2235 readycount += n_ready;
2236 seeknosort += seek / 1024;
2237 if (input_only)
2238 inputcount++;
2239 if (overlap) {
2240 ovlcount++;
2241 seeksorted += iseek / 1024;
2242 } else
2243 seeksorted += (iseek + maxsec - minsec) / 1024;
2244 if (rev && !r) {
2245 revcount++;
2246 readysorted += n_ready;
2247 }
2248 if (!rev && !s) {
2249 sortcount++;
2250 readysorted += n_ready;
2251 }
2252 }
2253 #if defined(DEBUG_LINKED_COMMANDS)
2254 if (link_statistics && (overlap || !(flushcount % link_statistics)))
2255 for (n = 0; n < n_ready; n++) {
2256 k = il[n];
2257 cpp = &ha->cp[k];
2258 SCpnt = cpp->SCpnt;
2259 printk
2260 ("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"
2261 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2262 (ihdlr ? "ihdlr" : "qcomm"),
2263 SCpnt->device->channel, SCpnt->device->id,
2264 SCpnt->device->lun, SCpnt->pid, k, flushcount,
2265 n_ready, SCpnt->request->sector,
2266 SCpnt->request->nr_sectors, cursec, YESNO(s),
2267 YESNO(r), YESNO(rev), YESNO(input_only),
2268 YESNO(overlap), cpp->din);
2269 }
2270 #endif
2271 return overlap;
2272 }
2273
2274 static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2275 struct hostdata *ha, unsigned int ihdlr)
2276 {
2277 struct scsi_cmnd *SCpnt;
2278 struct mscp *cpp;
2279 unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
2280
2281 for (k = 0; k < dev->host->can_queue; k++) {
2282
2283 if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE)
2284 continue;
2285
2286 cpp = &ha->cp[k];
2287 SCpnt = cpp->SCpnt;
2288
2289 if (SCpnt->device != dev)
2290 continue;
2291
2292 if (ha->cp_stat[k] == IN_USE)
2293 return;
2294
2295 il[n_ready++] = k;
2296 }
2297
2298 if (reorder(ha, cursec, ihdlr, il, n_ready))
2299 n_ready = 1;
2300
2301 for (n = 0; n < n_ready; n++) {
2302 k = il[n];
2303 cpp = &ha->cp[k];
2304 SCpnt = cpp->SCpnt;
2305
2306 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2307 printk
2308 ("%s: %s, target %d.%d:%d, pid %ld, mbox %d, adapter"
2309 " busy, will abort.\n", ha->board_name,
2310 (ihdlr ? "ihdlr" : "qcomm"),
2311 SCpnt->device->channel, SCpnt->device->id,
2312 SCpnt->device->lun, SCpnt->pid, k);
2313 ha->cp_stat[k] = ABORTING;
2314 continue;
2315 }
2316
2317 ha->cp_stat[k] = IN_USE;
2318 }
2319 }
2320
2321 static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost)
2322 {
2323 struct scsi_cmnd *SCpnt;
2324 unsigned int i, k, c, status, tstatus, reg;
2325 struct mssp *spp;
2326 struct mscp *cpp;
2327 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2328
2329 if (shost->irq != irq)
2330 panic("%s: ihdlr, irq %d, shost->irq %d.\n", ha->board_name, irq,
2331 shost->irq);
2332
2333 /* Check if this board need to be serviced */
2334 if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
2335 goto none;
2336
2337 ha->iocount++;
2338
2339 if (do_trace)
2340 printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq,
2341 ha->iocount);
2342
2343 /* Check if this board is still busy */
2344 if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) {
2345 reg = inb(shost->io_port + REG_STATUS);
2346 printk
2347 ("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n",
2348 ha->board_name, irq, reg, ha->iocount);
2349 goto none;
2350 }
2351
2352 spp = &ha->sp;
2353
2354 /* Make a local copy just before clearing the interrupt indication */
2355 memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp));
2356
2357 /* Clear the completion flag and cp pointer on the dynamic copy of sp */
2358 memset(ha->sp_cpu_addr, 0, sizeof(struct mssp));
2359
2360 /* Read the status register to clear the interrupt indication */
2361 reg = inb(shost->io_port + REG_STATUS);
2362
2363 #if defined (DEBUG_INTERRUPT)
2364 {
2365 unsigned char *bytesp;
2366 int cnt;
2367 bytesp = (unsigned char *)spp;
2368 if (ha->iocount < 200) {
2369 printk("sp[] =");
2370 for (cnt = 0; cnt < 15; cnt++)
2371 printk(" 0x%x", bytesp[cnt]);
2372 printk("\n");
2373 }
2374 }
2375 #endif
2376
2377 /* Reject any sp with supspect data */
2378 if (spp->eoc == 0 && ha->iocount > 1)
2379 printk
2380 ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n",
2381 ha->board_name, irq, reg, ha->iocount);
2382 if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue)
2383 printk
2384 ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n",
2385 ha->board_name, spp->cpp_index, irq, reg, ha->iocount);
2386 if (spp->eoc == 0 || spp->cpp_index < 0
2387 || spp->cpp_index >= shost->can_queue)
2388 goto handled;
2389
2390 /* Find the mailbox to be serviced on this board */
2391 i = spp->cpp_index;
2392
2393 cpp = &(ha->cp[i]);
2394
2395 #if defined(DEBUG_GENERATE_ABORTS)
2396 if ((ha->iocount > 500) && ((ha->iocount % 500) < 3))
2397 goto handled;
2398 #endif
2399
2400 if (ha->cp_stat[i] == IGNORE) {
2401 ha->cp_stat[i] = FREE;
2402 goto handled;
2403 } else if (ha->cp_stat[i] == LOCKED) {
2404 ha->cp_stat[i] = FREE;
2405 printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i,
2406 ha->iocount);
2407 goto handled;
2408 } else if (ha->cp_stat[i] == FREE) {
2409 printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i,
2410 ha->iocount);
2411 goto handled;
2412 } else if (ha->cp_stat[i] == IN_RESET)
2413 printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i);
2414 else if (ha->cp_stat[i] != IN_USE)
2415 panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
2416 ha->board_name, i, ha->cp_stat[i]);
2417
2418 ha->cp_stat[i] = FREE;
2419 SCpnt = cpp->SCpnt;
2420
2421 if (SCpnt == NULL)
2422 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2423
2424 if (SCpnt->host_scribble == NULL)
2425 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,
2426 i, SCpnt->pid, SCpnt);
2427
2428 if (*(unsigned int *)SCpnt->host_scribble != i)
2429 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
2430 ha->board_name, i, SCpnt->pid,
2431 *(unsigned int *)SCpnt->host_scribble);
2432
2433 sync_dma(i, ha);
2434
2435 if (linked_comm && SCpnt->device->queue_depth > 2
2436 && TLDEV(SCpnt->device->type))
2437 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
2438
2439 tstatus = status_byte(spp->target_status);
2440
2441 #if defined(DEBUG_GENERATE_ERRORS)
2442 if ((ha->iocount > 500) && ((ha->iocount % 200) < 2))
2443 spp->adapter_status = 0x01;
2444 #endif
2445
2446 switch (spp->adapter_status) {
2447 case ASOK: /* status OK */
2448
2449 /* Forces a reset if a disk drive keeps returning BUSY */
2450 if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
2451 status = DID_ERROR << 16;
2452
2453 /* If there was a bus reset, redo operation on each target */
2454 else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
2455 && ha->target_redo[SCpnt->device->id][SCpnt->
2456 device->
2457 channel])
2458 status = DID_BUS_BUSY << 16;
2459
2460 /* Works around a flaw in scsi.c */
2461 else if (tstatus == CHECK_CONDITION
2462 && SCpnt->device->type == TYPE_DISK
2463 && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
2464 status = DID_BUS_BUSY << 16;
2465
2466 else
2467 status = DID_OK << 16;
2468
2469 if (tstatus == GOOD)
2470 ha->target_redo[SCpnt->device->id][SCpnt->device->
2471 channel] = 0;
2472
2473 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2474 (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2475 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2476 printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
2477 "target_status 0x%x, sense key 0x%x.\n",
2478 ha->board_name,
2479 SCpnt->device->channel, SCpnt->device->id,
2480 SCpnt->device->lun, SCpnt->pid,
2481 spp->target_status, SCpnt->sense_buffer[2]);
2482
2483 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
2484
2485 if (ha->last_retried_pid == SCpnt->pid)
2486 ha->retries = 0;
2487
2488 break;
2489 case ASST: /* Selection Time Out */
2490 case 0x02: /* Command Time Out */
2491
2492 if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
2493 status = DID_ERROR << 16;
2494 else {
2495 status = DID_TIME_OUT << 16;
2496 ha->target_to[SCpnt->device->id][SCpnt->device->
2497 channel]++;
2498 }
2499
2500 break;
2501
2502 /* Perform a limited number of internal retries */
2503 case 0x03: /* SCSI Bus Reset Received */
2504 case 0x04: /* Initial Controller Power-up */
2505
2506 for (c = 0; c <= shost->max_channel; c++)
2507 for (k = 0; k < shost->max_id; k++)
2508 ha->target_redo[k][c] = 1;
2509
2510 if (SCpnt->device->type != TYPE_TAPE
2511 && ha->retries < MAX_INTERNAL_RETRIES) {
2512
2513 #if defined(DID_SOFT_ERROR)
2514 status = DID_SOFT_ERROR << 16;
2515 #else
2516 status = DID_BUS_BUSY << 16;
2517 #endif
2518
2519 ha->retries++;
2520 ha->last_retried_pid = SCpnt->pid;
2521 } else
2522 status = DID_ERROR << 16;
2523
2524 break;
2525 case 0x05: /* Unexpected Bus Phase */
2526 case 0x06: /* Unexpected Bus Free */
2527 case 0x07: /* Bus Parity Error */
2528 case 0x08: /* SCSI Hung */
2529 case 0x09: /* Unexpected Message Reject */
2530 case 0x0a: /* SCSI Bus Reset Stuck */
2531 case 0x0b: /* Auto Request-Sense Failed */
2532 case 0x0c: /* Controller Ram Parity Error */
2533 default:
2534 status = DID_ERROR << 16;
2535 break;
2536 }
2537
2538 SCpnt->result = status | spp->target_status;
2539
2540 #if defined(DEBUG_INTERRUPT)
2541 if (SCpnt->result || do_trace)
2542 #else
2543 if ((spp->adapter_status != ASOK && ha->iocount > 1000) ||
2544 (spp->adapter_status != ASOK &&
2545 spp->adapter_status != ASST && ha->iocount <= 1000) ||
2546 do_trace || msg_byte(spp->target_status))
2547 #endif
2548 printk("%s: ihdlr, mbox %2d, err 0x%x:%x,"
2549 " target %d.%d:%d, pid %ld, reg 0x%x, count %d.\n",
2550 ha->board_name, i, spp->adapter_status, spp->target_status,
2551 SCpnt->device->channel, SCpnt->device->id,
2552 SCpnt->device->lun, SCpnt->pid, reg, ha->iocount);
2553
2554 unmap_dma(i, ha);
2555
2556 /* Set the command state to inactive */
2557 SCpnt->host_scribble = NULL;
2558
2559 SCpnt->scsi_done(SCpnt);
2560
2561 if (do_trace)
2562 printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name,
2563 irq, ha->iocount);
2564
2565 handled:
2566 return IRQ_HANDLED;
2567 none:
2568 return IRQ_NONE;
2569 }
2570
2571 static irqreturn_t do_interrupt_handler(int irq, void *shap,
2572 struct pt_regs *regs)
2573 {
2574 struct Scsi_Host *shost;
2575 unsigned int j;
2576 unsigned long spin_flags;
2577 irqreturn_t ret;
2578
2579 /* Check if the interrupt must be processed by this handler */
2580 if ((j = (unsigned int)((char *)shap - sha)) >= num_boards)
2581 return IRQ_NONE;
2582 shost = sh[j];
2583
2584 spin_lock_irqsave(shost->host_lock, spin_flags);
2585 ret = ihdlr(irq, shost);
2586 spin_unlock_irqrestore(shost->host_lock, spin_flags);
2587 return ret;
2588 }
2589
2590 static int eata2x_release(struct Scsi_Host *shost)
2591 {
2592 struct hostdata *ha = (struct hostdata *)shost->hostdata;
2593 unsigned int i;
2594
2595 for (i = 0; i < shost->can_queue; i++)
2596 if ((&ha->cp[i])->sglist)
2597 kfree((&ha->cp[i])->sglist);
2598
2599 for (i = 0; i < shost->can_queue; i++)
2600 pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr,
2601 sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
2602
2603 if (ha->sp_cpu_addr)
2604 pci_free_consistent(ha->pdev, sizeof(struct mssp),
2605 ha->sp_cpu_addr, ha->sp_dma_addr);
2606
2607 free_irq(shost->irq, &sha[ha->board_number]);
2608
2609 if (shost->dma_channel != NO_DMA)
2610 free_dma(shost->dma_channel);
2611
2612 release_region(shost->io_port, shost->n_io_port);
2613 scsi_unregister(shost);
2614 return 0;
2615 }
2616
2617 #include "scsi_module.c"
2618
2619 #ifndef MODULE
2620 __setup("eata=", option_setup);
2621 #endif /* end MODULE */
linux v2.6.22.y-op