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