1/* 2 * eata.c - Low-level driver for EATA/DMA SCSI host adapters. 3 * 4 * 03 Jun 2003 Rev. 8.10 for linux-2.5.70 5 * + Update for new IRQ API. 6 * + Use "goto" when appropriate. 7 * + Drop eata.h. 8 * + Update for new module_param API. 9 * + Module parameters can now be specified only in the 10 * same format as the kernel boot options. 11 * 12 * boot option old module param 13 * ----------- ------------------ 14 * addr,... io_port=addr,... 15 * lc:[y|n] linked_comm=[1|0] 16 * mq:xx max_queue_depth=xx 17 * tm:[0|1|2] tag_mode=[0|1|2] 18 * et:[y|n] ext_tran=[1|0] 19 * rs:[y|n] rev_scan=[1|0] 20 * ip:[y|n] isa_probe=[1|0] 21 * ep:[y|n] eisa_probe=[1|0] 22 * pp:[y|n] pci_probe=[1|0] 23 * 24 * A valid example using the new parameter format is: 25 * modprobe eata "eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n" 26 * 27 * which is equivalent to the old format: 28 * modprobe eata io_port=0x7410,0x230 linked_comm=1 tag_mode=0 \ 29 * max_queue_depth=4 eisa_probe=0 30 * 31 * 12 Feb 2003 Rev. 8.04 for linux 2.5.60 32 * + Release irq before calling scsi_register. 33 * 34 * 12 Nov 2002 Rev. 8.02 for linux 2.5.47 35 * + Release driver_lock before calling scsi_register. 36 * 37 * 11 Nov 2002 Rev. 8.01 for linux 2.5.47 38 * + Fixed bios_param and scsicam_bios_param calling parameters. 39 * 40 * 28 Oct 2002 Rev. 8.00 for linux 2.5.44-ac4 41 * + Use new tcq and adjust_queue_depth api. 42 * + New command line option (tm:[0-2]) to choose the type of tags: 43 * 0 -> disable tagging ; 1 -> simple tags ; 2 -> ordered tags. 44 * Default is tm:0 (tagged commands disabled). 45 * For compatibility the "tc:" option is an alias of the "tm:" 46 * option; tc:n is equivalent to tm:0 and tc:y is equivalent to 47 * tm:1. 48 * + The tagged_comm module parameter has been removed, use tag_mode 49 * instead, equivalent to the "tm:" boot option. 50 * 51 * 10 Oct 2002 Rev. 7.70 for linux 2.5.42 52 * + Foreport from revision 6.70. 53 * 54 * 25 Jun 2002 Rev. 6.70 for linux 2.4.19 55 * + This release is the first one tested on a Big Endian platform: 56 * fixed endian-ness problem due to bitfields; 57 * fixed endian-ness problem in read_pio. 58 * + Added new options for selectively probing ISA, EISA and PCI bus: 59 * 60 * Boot option Parameter name Default according to 61 * 62 * ip:[y|n] isa_probe=[1|0] CONFIG_ISA defined 63 * ep:[y|n] eisa_probe=[1|0] CONFIG_EISA defined 64 * pp:[y|n] pci_probe=[1|0] CONFIG_PCI defined 65 * 66 * The default action is to perform probing if the corrisponding 67 * bus is configured and to skip probing otherwise. 68 * 69 * + If pci_probe is in effect and a list of I/O ports is specified 70 * as parameter or boot option, pci_enable_device() is performed 71 * on all pci devices matching PCI_CLASS_STORAGE_SCSI. 72 * 73 * 21 Feb 2002 Rev. 6.52 for linux 2.4.18 74 * + Backport from rev. 7.22 (use io_request_lock). 75 * 76 * 20 Feb 2002 Rev. 7.22 for linux 2.5.5 77 * + Remove any reference to virt_to_bus(). 78 * + Fix pio hang while detecting multiple HBAs. 79 * + Fixed a board detection bug: in a system with 80 * multiple ISA/EISA boards, all but the first one 81 * were erroneously detected as PCI. 82 * 83 * 01 Jan 2002 Rev. 7.20 for linux 2.5.1 84 * + Use the dynamic DMA mapping API. 85 * 86 * 19 Dec 2001 Rev. 7.02 for linux 2.5.1 87 * + Use SCpnt->sc_data_direction if set. 88 * + Use sglist.page instead of sglist.address. 89 * 90 * 11 Dec 2001 Rev. 7.00 for linux 2.5.1 91 * + Use host->host_lock instead of io_request_lock. 92 * 93 * 1 May 2001 Rev. 6.05 for linux 2.4.4 94 * + Clean up all pci related routines. 95 * + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d) 96 * 97 * 30 Jan 2001 Rev. 6.04 for linux 2.4.1 98 * + Call pci_resource_start after pci_enable_device. 99 * 100 * 25 Jan 2001 Rev. 6.03 for linux 2.4.0 101 * + "check_region" call replaced by "request_region". 102 * 103 * 22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11 104 * + Return code checked when calling pci_enable_device. 105 * + Removed old scsi error handling support. 106 * + The obsolete boot option flag eh:n is silently ignored. 107 * + Removed error messages while a disk drive is powered up at 108 * boot time. 109 * + Improved boot messages: all tagged capable device are 110 * indicated as "tagged" or "soft-tagged" : 111 * - "soft-tagged" means that the driver is trying to do its 112 * own tagging (i.e. the tc:y option is in effect); 113 * - "tagged" means that the device supports tagged commands, 114 * but the driver lets the HBA be responsible for tagging 115 * support. 116 * 117 * 16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18 118 * + Updated to the new __setup interface for boot command line options. 119 * + When loaded as a module, accepts the new parameter boot_options 120 * which value is a string with the same format of the kernel boot 121 * command line options. A valid example is: 122 * modprobe eata 'boot_options="0x7410,0x230,lc:y,tc:n,mq:4"' 123 * 124 * 9 Sep 1999 Rev. 5.10 for linux 2.2.12 and 2.3.17 125 * + 64bit cleanup for Linux/Alpha platform support 126 * (contribution from H.J. Lu). 127 * 128 * 22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11 129 * + Removed pre-2.2 source code compatibility. 130 * + Added call to pci_set_master. 131 * 132 * 26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111 133 * + Added command line option (rs:[y|n]) to reverse the scan order 134 * of PCI boards. The default is rs:y, which reverses the BIOS order 135 * while registering PCI boards. The default value rs:y generates 136 * the same order of all previous revisions of this driver. 137 * Pls. note that "BIOS order" might have been reversed itself 138 * after the 2.1.9x PCI modifications in the linux kernel. 139 * The rs value is ignored when the explicit list of addresses 140 * is used by the "eata=port0,port1,..." command line option. 141 * + Added command line option (et:[y|n]) to force use of extended 142 * translation (255 heads, 63 sectors) as disk geometry. 143 * The default is et:n, which uses the disk geometry returned 144 * by scsicam_bios_param. The default value et:n is compatible with 145 * all previous revisions of this driver. 146 * 147 * 28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104 148 * Increased busy timeout from 10 msec. to 200 msec. while 149 * processing interrupts. 150 * 151 * 16 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102 152 * Improved abort handling during the eh recovery process. 153 * 154 * 13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101 155 * The driver is now fully SMP safe, including the 156 * abort and reset routines. 157 * Added command line options (eh:[y|n]) to choose between 158 * new_eh_code and the old scsi code. 159 * If linux version >= 2.1.101 the default is eh:y, while the eh 160 * option is ignored for previous releases and the old scsi code 161 * is used. 162 * 163 * 18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97 164 * Reworked interrupt handler. 165 * 166 * 11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95 167 * Major reliability improvement: when a batch with overlapping 168 * requests is detected, requests are queued one at a time 169 * eliminating any possible board or drive reordering. 170 * 171 * 10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95 172 * Improved SMP support (if linux version >= 2.1.95). 173 * 174 * 9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94 175 * Added support for new PCI code and IO-APIC remapping of irqs. 176 * Performance improvement: when sequential i/o is detected, 177 * always use direct sort instead of reverse sort. 178 * 179 * 4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92 180 * io_port is now unsigned long. 181 * 182 * 17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88 183 * Use new scsi error handling code (if linux version >= 2.1.88). 184 * Use new interrupt code. 185 * 186 * 12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55 187 * Use of udelay inside the wait loops to avoid timeout 188 * problems with fast cpus. 189 * Removed check about useless calls to the interrupt service 190 * routine (reported on SMP systems only). 191 * At initialization time "sorted/unsorted" is displayed instead 192 * of "linked/unlinked" to reinforce the fact that "linking" is 193 * nothing but "elevator sorting" in the actual implementation. 194 * 195 * 17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38 196 * Use of serial_number_at_timeout in abort and reset processing. 197 * Use of the __initfunc and __initdata macro in setup code. 198 * Minor cleanups in the list_statistics code. 199 * Increased controller busy timeout in order to better support 200 * slow SCSI devices. 201 * 202 * 24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26 203 * When loading as a module, parameter passing is now supported 204 * both in 2.0 and in 2.1 style. 205 * Fixed data transfer direction for some SCSI opcodes. 206 * Immediate acknowledge to request sense commands. 207 * Linked commands to each disk device are now reordered by elevator 208 * sorting. Rare cases in which reordering of write requests could 209 * cause wrong results are managed. 210 * Fixed spurious timeouts caused by long simple queue tag sequences. 211 * New command line option (tm:[0-3]) to choose the type of tags: 212 * 0 -> mixed (default); 1 -> simple; 2 -> head; 3 -> ordered. 213 * 214 * 18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28 215 * Added command line options to enable/disable linked commands 216 * (lc:[y|n]), tagged commands (tc:[y|n]) and to set the max queue 217 * depth (mq:xx). Default is "eata=lc:n,tc:n,mq:16". 218 * Improved command linking. 219 * Documented how to setup RAID-0 with DPT SmartRAID boards. 220 * 221 * 8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27 222 * Added linked command support. 223 * Improved detection of PCI boards using ISA base addresses. 224 * 225 * 3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27 226 * Added support for tagged commands and queue depth adjustment. 227 * 228 * 22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26 229 * When CONFIG_PCI is defined, BIOS32 is used to include in the 230 * list of i/o ports to be probed all the PCI SCSI controllers. 231 * The list of i/o ports to be probed can be overwritten by the 232 * "eata=port0,port1,...." boot command line option. 233 * Scatter/gather lists are now allocated by a number of kmalloc 234 * calls, in order to avoid the previous size limit of 64Kb. 235 * 236 * 16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25 237 * Added support for EATA 2.0C, PCI, multichannel and wide SCSI. 238 * 239 * 27 Sep 1996 rev. 2.12 for linux 2.1.0 240 * Portability cleanups (virtual/bus addressing, little/big endian 241 * support). 242 * 243 * 09 Jul 1996 rev. 2.11 for linux 2.0.4 244 * Number of internal retries is now limited. 245 * 246 * 16 Apr 1996 rev. 2.10 for linux 1.3.90 247 * New argument "reset_flags" to the reset routine. 248 * 249 * 6 Jul 1995 rev. 2.01 for linux 1.3.7 250 * Update required by the new /proc/scsi support. 251 * 252 * 11 Mar 1995 rev. 2.00 for linux 1.2.0 253 * Fixed a bug which prevented media change detection for removable 254 * disk drives. 255 * 256 * 23 Feb 1995 rev. 1.18 for linux 1.1.94 257 * Added a check for scsi_register returning NULL. 258 * 259 * 11 Feb 1995 rev. 1.17 for linux 1.1.91 260 * Now DEBUG_RESET is disabled by default. 261 * Register a board even if it does not assert DMA protocol support 262 * (DPT SK2011B does not report correctly the dmasup bit). 263 * 264 * 9 Feb 1995 rev. 1.16 for linux 1.1.90 265 * Use host->wish_block instead of host->block. 266 * New list of Data Out SCSI commands. 267 * 268 * 8 Feb 1995 rev. 1.15 for linux 1.1.89 269 * Cleared target_time_out counter while performing a reset. 270 * All external symbols renamed to avoid possible name conflicts. 271 * 272 * 28 Jan 1995 rev. 1.14 for linux 1.1.86 273 * Added module support. 274 * Log and do a retry when a disk drive returns a target status 275 * different from zero on a recovered error. 276 * 277 * 24 Jan 1995 rev. 1.13 for linux 1.1.85 278 * Use optimized board configuration, with a measured performance 279 * increase in the range 10%-20% on i/o throughput. 280 * 281 * 16 Jan 1995 rev. 1.12 for linux 1.1.81 282 * Fix mscp structure comments (no functional change). 283 * Display a message if check_region detects a port address 284 * already in use. 285 * 286 * 17 Dec 1994 rev. 1.11 for linux 1.1.74 287 * Use the scsicam_bios_param routine. This allows an easy 288 * migration path from disk partition tables created using 289 * different SCSI drivers and non optimal disk geometry. 290 * 291 * 15 Dec 1994 rev. 1.10 for linux 1.1.74 292 * Added support for ISA EATA boards (DPT PM2011, DPT PM2021). 293 * The host->block flag is set for all the detected ISA boards. 294 * The detect routine no longer enforces LEVEL triggering 295 * for EISA boards, it just prints a warning message. 296 * 297 * 30 Nov 1994 rev. 1.09 for linux 1.1.68 298 * Redo i/o on target status CHECK_CONDITION for TYPE_DISK only. 299 * Added optional support for using a single board at a time. 300 * 301 * 18 Nov 1994 rev. 1.08 for linux 1.1.64 302 * Forces sg_tablesize = 64 and can_queue = 64 if these 303 * values are not correctly detected (DPT PM2012). 304 * 305 * 14 Nov 1994 rev. 1.07 for linux 1.1.63 Final BETA release. 306 * 04 Aug 1994 rev. 1.00 for linux 1.1.39 First BETA release. 307 * 308 * 309 * This driver is based on the CAM (Common Access Method Committee) 310 * EATA (Enhanced AT Bus Attachment) rev. 2.0A, using DMA protocol. 311 * 312 * Copyright (C) 1994-2003 Dario Ballabio (ballabio_dario@emc.com) 313 * 314 * Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it 315 * 316 * Redistribution and use in source and binary forms, with or without 317 * modification, are permitted provided that redistributions of source 318 * code retain the above copyright notice and this comment without 319 * modification. 320 * 321 */ 322 323/* 324 * 325 * Here is a brief description of the DPT SCSI host adapters. 326 * All these boards provide an EATA/DMA compatible programming interface 327 * and are fully supported by this driver in any configuration, including 328 * multiple SCSI channels: 329 * 330 * PM2011B/9X - Entry Level ISA 331 * PM2021A/9X - High Performance ISA 332 * PM2012A Old EISA 333 * PM2012B Old EISA 334 * PM2022A/9X - Entry Level EISA 335 * PM2122A/9X - High Performance EISA 336 * PM2322A/9X - Extra High Performance EISA 337 * PM3021 - SmartRAID Adapter for ISA 338 * PM3222 - SmartRAID Adapter for EISA (PM3222W is 16-bit wide SCSI) 339 * PM3224 - SmartRAID Adapter for PCI (PM3224W is 16-bit wide SCSI) 340 * PM33340UW - SmartRAID Adapter for PCI ultra wide multichannel 341 * 342 * The above list is just an indication: as a matter of fact all DPT 343 * boards using the EATA/DMA protocol are supported by this driver, 344 * since they use exactely the same programming interface. 345 * 346 * The DPT PM2001 provides only the EATA/PIO interface and hence is not 347 * supported by this driver. 348 * 349 * This code has been tested with up to 3 Distributed Processing Technology 350 * PM2122A/9X (DPT SCSI BIOS v002.D1, firmware v05E.0) EISA controllers, 351 * in any combination of private and shared IRQ. 352 * PCI support has been tested using up to 2 DPT PM3224W (DPT SCSI BIOS 353 * v003.D0, firmware v07G.0). 354 * 355 * DPT SmartRAID boards support "Hardware Array" - a group of disk drives 356 * which are all members of the same RAID-0, RAID-1 or RAID-5 array implemented 357 * in host adapter hardware. Hardware Arrays are fully compatible with this 358 * driver, since they look to it as a single disk drive. 359 * 360 * WARNING: to create a RAID-0 "Hardware Array" you must select "Other Unix" 361 * as the current OS in the DPTMGR "Initial System Installation" menu. 362 * Otherwise RAID-0 is generated as an "Array Group" (i.e. software RAID-0), 363 * which is not supported by the actual SCSI subsystem. 364 * To get the "Array Group" functionality, the Linux MD driver must be used 365 * instead of the DPT "Array Group" feature. 366 * 367 * Multiple ISA, EISA and PCI boards can be configured in the same system. 368 * It is suggested to put all the EISA boards on the same IRQ level, all 369 * the PCI boards on another IRQ level, while ISA boards cannot share 370 * interrupts. 371 * 372 * If you configure multiple boards on the same IRQ, the interrupt must 373 * be _level_ triggered (not _edge_ triggered). 374 * 375 * This driver detects EATA boards by probes at fixed port addresses, 376 * so no BIOS32 or PCI BIOS support is required. 377 * The suggested way to detect a generic EATA PCI board is to force on it 378 * any unused EISA address, even if there are other controllers on the EISA 379 * bus, or even if you system has no EISA bus at all. 380 * Do not force any ISA address on EATA PCI boards. 381 * 382 * If PCI bios support is configured into the kernel, BIOS32 is used to 383 * include in the list of i/o ports to be probed all the PCI SCSI controllers. 384 * 385 * Due to a DPT BIOS "feature", it might not be possible to force an EISA 386 * address on more than a single DPT PCI board, so in this case you have to 387 * let the PCI BIOS assign the addresses. 388 * 389 * The sequence of detection probes is: 390 * 391 * - ISA 0x1F0; 392 * - PCI SCSI controllers (only if BIOS32 is available); 393 * - EISA/PCI 0x1C88 through 0xFC88 (corresponding to EISA slots 1 to 15); 394 * - ISA 0x170, 0x230, 0x330. 395 * 396 * The above list of detection probes can be totally replaced by the 397 * boot command line option: "eata=port0,port1,port2,...", where the 398 * port0, port1... arguments are ISA/EISA/PCI addresses to be probed. 399 * For example using "eata=0x7410,0x7450,0x230", the driver probes 400 * only the two PCI addresses 0x7410 and 0x7450 and the ISA address 0x230, 401 * in this order; "eata=0" totally disables this driver. 402 * 403 * After the optional list of detection probes, other possible command line 404 * options are: 405 * 406 * et:y force use of extended translation (255 heads, 63 sectors); 407 * et:n use disk geometry detected by scsicam_bios_param; 408 * rs:y reverse scan order while detecting PCI boards; 409 * rs:n use BIOS order while detecting PCI boards; 410 * lc:y enables linked commands; 411 * lc:n disables linked commands; 412 * tm:0 disables tagged commands (same as tc:n); 413 * tm:1 use simple queue tags (same as tc:y); 414 * tm:2 use ordered queue tags (same as tc:2); 415 * mq:xx set the max queue depth to the value xx (2 <= xx <= 32). 416 * 417 * The default value is: "eata=lc:n,mq:16,tm:0,et:n,rs:n". 418 * An example using the list of detection probes could be: 419 * "eata=0x7410,0x230,lc:y,tm:2,mq:4,et:n". 420 * 421 * When loading as a module, parameters can be specified as well. 422 * The above example would be (use 1 in place of y and 0 in place of n): 423 * 424 * modprobe eata io_port=0x7410,0x230 linked_comm=1 \ 425 * max_queue_depth=4 ext_tran=0 tag_mode=2 \ 426 * rev_scan=1 427 * 428 * ---------------------------------------------------------------------------- 429 * In this implementation, linked commands are designed to work with any DISK 430 * or CD-ROM, since this linking has only the intent of clustering (time-wise) 431 * and reordering by elevator sorting commands directed to each device, 432 * without any relation with the actual SCSI protocol between the controller 433 * and the device. 434 * If Q is the queue depth reported at boot time for each device (also named 435 * cmds/lun) and Q > 2, whenever there is already an active command to the 436 * device all other commands to the same device (up to Q-1) are kept waiting 437 * in the elevator sorting queue. When the active command completes, the 438 * commands in this queue are sorted by sector address. The sort is chosen 439 * between increasing or decreasing by minimizing the seek distance between 440 * the sector of the commands just completed and the sector of the first 441 * command in the list to be sorted. 442 * Trivial math assures that the unsorted average seek distance when doing 443 * random seeks over S sectors is S/3. 444 * When (Q-1) requests are uniformly distributed over S sectors, the average 445 * distance between two adjacent requests is S/((Q-1) + 1), so the sorted 446 * average seek distance for (Q-1) random requests over S sectors is S/Q. 447 * The elevator sorting hence divides the seek distance by a factor Q/3. 448 * The above pure geometric remarks are valid in all cases and the 449 * driver effectively reduces the seek distance by the predicted factor 450 * when there are Q concurrent read i/o operations on the device, but this 451 * does not necessarily results in a noticeable performance improvement: 452 * your mileage may vary.... 453 * 454 * Note: command reordering inside a batch of queued commands could cause 455 * wrong results only if there is at least one write request and the 456 * intersection (sector-wise) of all requests is not empty. 457 * When the driver detects a batch including overlapping requests 458 * (a really rare event) strict serial (pid) order is enforced. 459 * ---------------------------------------------------------------------------- 460 * The extended translation option (et:y) is useful when using large physical 461 * disks/arrays. It could also be useful when switching between Adaptec boards 462 * and DPT boards without reformatting the disk. 463 * When a boot disk is partitioned with extended translation, in order to 464 * be able to boot it with a DPT board is could be necessary to add to 465 * lilo.conf additional commands as in the following example: 466 * 467 * fix-table 468 * disk=/dev/sda bios=0x80 sectors=63 heads=128 cylindres=546 469 * 470 * where the above geometry should be replaced with the one reported at 471 * power up by the DPT controller. 472 * ---------------------------------------------------------------------------- 473 * 474 * The boards are named EATA0, EATA1,... according to the detection order. 475 * 476 * In order to support multiple ISA boards in a reliable way, 477 * the driver sets host->wish_block = 1 for all ISA boards. 478 */ 479 480#include <linux/string.h> 481#include <linux/kernel.h> 482#include <linux/ioport.h> 483#include <linux/delay.h> 484#include <linux/proc_fs.h> 485#include <linux/blkdev.h> 486#include <linux/interrupt.h> 487#include <linux/stat.h> 488#include <linux/pci.h> 489#include <linux/init.h> 490#include <linux/ctype.h> 491#include <linux/spinlock.h> 492#include <linux/dma-mapping.h> 493#include <asm/byteorder.h> 494#include <asm/dma.h> 495#include <asm/io.h> 496#include <asm/irq.h> 497 498#include <scsi/scsi.h> 499#include <scsi/scsi_cmnd.h> 500#include <scsi/scsi_device.h> 501#include <scsi/scsi_host.h> 502#include <scsi/scsi_tcq.h> 503#include <scsi/scsicam.h> 504 505static int eata2x_detect(struct scsi_host_template *); 506static int eata2x_release(struct Scsi_Host *); 507static int eata2x_queuecommand(struct scsi_cmnd *, 508 void (*done) (struct scsi_cmnd *)); 509static int eata2x_eh_abort(struct scsi_cmnd *); 510static int eata2x_eh_host_reset(struct scsi_cmnd *); 511static int eata2x_bios_param(struct scsi_device *, struct block_device *, 512 sector_t, int *); 513static int eata2x_slave_configure(struct scsi_device *); 514 515static struct scsi_host_template driver_template = { 516 .name = "EATA/DMA 2.0x rev. 8.10.00 ", 517 .detect = eata2x_detect, 518 .release = eata2x_release, 519 .queuecommand = eata2x_queuecommand, 520 .eh_abort_handler = eata2x_eh_abort, 521 .eh_host_reset_handler = eata2x_eh_host_reset, 522 .bios_param = eata2x_bios_param, 523 .slave_configure = eata2x_slave_configure, 524 .this_id = 7, 525 .unchecked_isa_dma = 1, 526 .use_clustering = ENABLE_CLUSTERING 527}; 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 */ 619struct 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 */ 707struct 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 */ 727struct 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 742struct sg_list { 743 unsigned int address; /* Segment Address */ 744 unsigned int num_bytes; /* Segment Length */ 745}; 746 747/* MailBox SCSI Command Packet */ 748struct 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 816struct 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 837static struct Scsi_Host *sh[MAX_BOARDS]; 838static const char *driver_name = "EATA"; 839static char sha[MAX_BOARDS]; 840static DEFINE_SPINLOCK(driver_lock); 841 842/* Initialize num_boards so that ihdlr can work while detect is in progress */ 843static unsigned int num_boards = MAX_BOARDS; 844 845static 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 878static irqreturn_t do_interrupt_handler(int, void *); 879static void flush_dev(struct scsi_device *, unsigned long, struct hostdata *, 880 unsigned int); 881static int do_trace = 0; 882static int setup_done = 0; 883static int link_statistics; 884static int ext_tran = 0; 885static int rev_scan = 1; 886 887#if defined(CONFIG_SCSI_EATA_TAGGED_QUEUE) 888static int tag_mode = TAG_SIMPLE; 889#else 890static int tag_mode = TAG_DISABLED; 891#endif 892 893#if defined(CONFIG_SCSI_EATA_LINKED_COMMANDS) 894static int linked_comm = 1; 895#else 896static int linked_comm = 0; 897#endif 898 899#if defined(CONFIG_SCSI_EATA_MAX_TAGS) 900static int max_queue_depth = CONFIG_SCSI_EATA_MAX_TAGS; 901#else 902static int max_queue_depth = MAX_CMD_PER_LUN; 903#endif 904 905#if defined(CONFIG_ISA) 906static int isa_probe = 1; 907#else 908static int isa_probe = 0; 909#endif 910 911#if defined(CONFIG_EISA) 912static int eisa_probe = 1; 913#else 914static int eisa_probe = 0; 915#endif 916 917#if defined(CONFIG_PCI) 918static int pci_probe = 1; 919#else 920static int pci_probe = 0; 921#endif 922 923#define MAX_INT_PARAM 10 924#define MAX_BOOT_OPTIONS_SIZE 256 925static char boot_options[MAX_BOOT_OPTIONS_SIZE]; 926 927#if defined(MODULE) 928#include <linux/module.h> 929#include <linux/moduleparam.h> 930 931module_param_string(eata, boot_options, MAX_BOOT_OPTIONS_SIZE, 0); 932MODULE_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\""); 934MODULE_AUTHOR("Dario Ballabio"); 935MODULE_LICENSE("GPL"); 936MODULE_DESCRIPTION("EATA/DMA SCSI Driver"); 937 938#endif 939 940static int eata2x_slave_configure(struct scsi_device *dev) 941{ 942 int tqd, utqd; 943 char *tag_suffix, *link_suffix; 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 974 sdev_printk(KERN_INFO, dev, 975 "cmds/lun %d%s%s.\n", 976 dev->queue_depth, link_suffix, tag_suffix); 977 978 return 0; 979} 980 981static 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 991static 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 1012static 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 1030static 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 1056static 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 1076static 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, 1224 IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0), 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); 1358 gfp_t gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC; 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); 1429 if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) 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 1452static 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 1506static int option_setup(char *str) 1507{ 1508 int ints[MAX_INT_PARAM]; 1509 char *cur = str; 1510 int i = 1; 1511 1512 while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) { 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 1524static 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 1561static 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 1610static void map_dma(unsigned int i, struct hostdata *ha) 1611{ 1612 unsigned int k, count, pci_dir; 1613 struct scatterlist *sgpnt; 1614 struct mscp *cpp; 1615 struct scsi_cmnd *SCpnt; 1616 1617 cpp = &ha->cp[i]; 1618 SCpnt = cpp->SCpnt; 1619 pci_dir = SCpnt->sc_data_direction; 1620 1621 if (SCpnt->sense_buffer) 1622 cpp->sense_addr = 1623 H2DEV(pci_map_single(ha->pdev, SCpnt->sense_buffer, 1624 sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE)); 1625 1626 cpp->sense_len = sizeof SCpnt->sense_buffer; 1627 1628 if (!SCpnt->use_sg) { 1629 1630 /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */ 1631 if (!SCpnt->request_bufflen) 1632 pci_dir = PCI_DMA_BIDIRECTIONAL; 1633 1634 if (SCpnt->request_buffer) 1635 cpp->data_address = H2DEV(pci_map_single(ha->pdev, 1636 SCpnt-> 1637 request_buffer, 1638 SCpnt-> 1639 request_bufflen, 1640 pci_dir)); 1641 1642 cpp->data_len = H2DEV(SCpnt->request_bufflen); 1643 return; 1644 } 1645 1646 sgpnt = (struct scatterlist *)SCpnt->request_buffer; 1647 count = pci_map_sg(ha->pdev, sgpnt, SCpnt->use_sg, pci_dir); 1648 1649 for (k = 0; k < count; k++) { 1650 cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k])); 1651 cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k])); 1652 } 1653 1654 cpp->sg = 1; 1655 cpp->data_address = H2DEV(pci_map_single(ha->pdev, cpp->sglist, 1656 SCpnt->use_sg * 1657 sizeof(struct sg_list), 1658 pci_dir)); 1659 cpp->data_len = H2DEV((SCpnt->use_sg * sizeof(struct sg_list))); 1660} 1661 1662static void unmap_dma(unsigned int i, struct hostdata *ha) 1663{ 1664 unsigned int pci_dir; 1665 struct mscp *cpp; 1666 struct scsi_cmnd *SCpnt; 1667 1668 cpp = &ha->cp[i]; 1669 SCpnt = cpp->SCpnt; 1670 pci_dir = SCpnt->sc_data_direction; 1671 1672 if (DEV2H(cpp->sense_addr)) 1673 pci_unmap_single(ha->pdev, DEV2H(cpp->sense_addr), 1674 DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE); 1675 1676 if (SCpnt->use_sg) 1677 pci_unmap_sg(ha->pdev, SCpnt->request_buffer, SCpnt->use_sg, 1678 pci_dir); 1679 1680 if (!DEV2H(cpp->data_len)) 1681 pci_dir = PCI_DMA_BIDIRECTIONAL; 1682 1683 if (DEV2H(cpp->data_address)) 1684 pci_unmap_single(ha->pdev, DEV2H(cpp->data_address), 1685 DEV2H(cpp->data_len), pci_dir); 1686} 1687 1688static void sync_dma(unsigned int i, struct hostdata *ha) 1689{ 1690 unsigned int pci_dir; 1691 struct mscp *cpp; 1692 struct scsi_cmnd *SCpnt; 1693 1694 cpp = &ha->cp[i]; 1695 SCpnt = cpp->SCpnt; 1696 pci_dir = SCpnt->sc_data_direction; 1697 1698 if (DEV2H(cpp->sense_addr)) 1699 pci_dma_sync_single_for_cpu(ha->pdev, DEV2H(cpp->sense_addr), 1700 DEV2H(cpp->sense_len), 1701 PCI_DMA_FROMDEVICE); 1702 1703 if (SCpnt->use_sg) 1704 pci_dma_sync_sg_for_cpu(ha->pdev, SCpnt->request_buffer, 1705 SCpnt->use_sg, pci_dir); 1706 1707 if (!DEV2H(cpp->data_len)) 1708 pci_dir = PCI_DMA_BIDIRECTIONAL; 1709 1710 if (DEV2H(cpp->data_address)) 1711 pci_dma_sync_single_for_cpu(ha->pdev, 1712 DEV2H(cpp->data_address), 1713 DEV2H(cpp->data_len), pci_dir); 1714} 1715 1716static void scsi_to_dev_dir(unsigned int i, struct hostdata *ha) 1717{ 1718 unsigned int k; 1719 1720 static const unsigned char data_out_cmds[] = { 1721 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e, 1722 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40, 1723 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d 1724 }; 1725 1726 static const unsigned char data_none_cmds[] = { 1727 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e, 1728 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47, 1729 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00 1730 }; 1731 1732 struct mscp *cpp; 1733 struct scsi_cmnd *SCpnt; 1734 1735 cpp = &ha->cp[i]; 1736 SCpnt = cpp->SCpnt; 1737 1738 if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 1739 cpp->din = 1; 1740 cpp->dout = 0; 1741 return; 1742 } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) { 1743 cpp->din = 0; 1744 cpp->dout = 1; 1745 return; 1746 } else if (SCpnt->sc_data_direction == DMA_NONE) { 1747 cpp->din = 0; 1748 cpp->dout = 0; 1749 return; 1750 } 1751 1752 if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL) 1753 panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", 1754 ha->board_name); 1755 1756 for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++) 1757 if (SCpnt->cmnd[0] == data_out_cmds[k]) { 1758 cpp->dout = 1; 1759 break; 1760 } 1761 1762 if ((cpp->din = !cpp->dout)) 1763 for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++) 1764 if (SCpnt->cmnd[0] == data_none_cmds[k]) { 1765 cpp->din = 0; 1766 break; 1767 } 1768 1769} 1770 1771static int eata2x_queuecommand(struct scsi_cmnd *SCpnt, 1772 void (*done) (struct scsi_cmnd *)) 1773{ 1774 struct Scsi_Host *shost = SCpnt->device->host; 1775 struct hostdata *ha = (struct hostdata *)shost->hostdata; 1776 unsigned int i, k; 1777 struct mscp *cpp; 1778 1779 if (SCpnt->host_scribble) 1780 panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", 1781 ha->board_name, SCpnt->pid, SCpnt); 1782 1783 /* i is the mailbox number, look for the first free mailbox 1784 starting from last_cp_used */ 1785 i = ha->last_cp_used + 1; 1786 1787 for (k = 0; k < shost->can_queue; k++, i++) { 1788 if (i >= shost->can_queue) 1789 i = 0; 1790 if (ha->cp_stat[i] == FREE) { 1791 ha->last_cp_used = i; 1792 break; 1793 } 1794 } 1795 1796 if (k == shost->can_queue) { 1797 printk("%s: qcomm, no free mailbox.\n", ha->board_name); 1798 return 1; 1799 } 1800 1801 /* Set pointer to control packet structure */ 1802 cpp = &ha->cp[i]; 1803 1804 memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE); 1805 1806 /* Set pointer to status packet structure, Big Endian format */ 1807 cpp->sp_dma_addr = H2DEV(ha->sp_dma_addr); 1808 1809 SCpnt->scsi_done = done; 1810 cpp->cpp_index = i; 1811 SCpnt->host_scribble = (unsigned char *)&cpp->cpp_index; 1812 1813 if (do_trace) 1814 scmd_printk(KERN_INFO, SCpnt, 1815 "qcomm, mbox %d, pid %ld.\n", i, SCpnt->pid); 1816 1817 cpp->reqsen = 1; 1818 cpp->dispri = 1; 1819 cpp->one = 1; 1820 cpp->channel = SCpnt->device->channel; 1821 cpp->target = SCpnt->device->id; 1822 cpp->lun = SCpnt->device->lun; 1823 cpp->SCpnt = SCpnt; 1824 memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len); 1825 1826 /* Use data transfer direction SCpnt->sc_data_direction */ 1827 scsi_to_dev_dir(i, ha); 1828 1829 /* Map DMA buffers and SG list */ 1830 map_dma(i, ha); 1831 1832 if (linked_comm && SCpnt->device->queue_depth > 2 1833 && TLDEV(SCpnt->device->type)) { 1834 ha->cp_stat[i] = READY; 1835 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0); 1836 return 0; 1837 } 1838 1839 /* Send control packet to the board */ 1840 if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) { 1841 unmap_dma(i, ha); 1842 SCpnt->host_scribble = NULL; 1843 scmd_printk(KERN_INFO, SCpnt, 1844 "qcomm, pid %ld, adapter busy.\n", SCpnt->pid); 1845 return 1; 1846 } 1847 1848 ha->cp_stat[i] = IN_USE; 1849 return 0; 1850} 1851 1852static int eata2x_eh_abort(struct scsi_cmnd *SCarg) 1853{ 1854 struct Scsi_Host *shost = SCarg->device->host; 1855 struct hostdata *ha = (struct hostdata *)shost->hostdata; 1856 unsigned int i; 1857 1858 if (SCarg->host_scribble == NULL) { 1859 scmd_printk(KERN_INFO, SCarg, 1860 "abort, pid %ld inactive.\n", SCarg->pid); 1861 return SUCCESS; 1862 } 1863 1864 i = *(unsigned int *)SCarg->host_scribble; 1865 scmd_printk(KERN_WARNING, SCarg, 1866 "abort, mbox %d, pid %ld.\n", i, SCarg->pid); 1867 1868 if (i >= shost->can_queue) 1869 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name); 1870 1871 if (wait_on_busy(shost->io_port, MAXLOOP)) { 1872 printk("%s: abort, timeout error.\n", ha->board_name); 1873 return FAILED; 1874 } 1875 1876 if (ha->cp_stat[i] == FREE) { 1877 printk("%s: abort, mbox %d is free.\n", ha->board_name, i); 1878 return SUCCESS; 1879 } 1880 1881 if (ha->cp_stat[i] == IN_USE) { 1882 printk("%s: abort, mbox %d is in use.\n", ha->board_name, i); 1883 1884 if (SCarg != ha->cp[i].SCpnt) 1885 panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n", 1886 ha->board_name, i, SCarg, ha->cp[i].SCpnt); 1887 1888 if (inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED) 1889 printk("%s: abort, mbox %d, interrupt pending.\n", 1890 ha->board_name, i); 1891 1892 return FAILED; 1893 } 1894 1895 if (ha->cp_stat[i] == IN_RESET) { 1896 printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i); 1897 return FAILED; 1898 } 1899 1900 if (ha->cp_stat[i] == LOCKED) { 1901 printk("%s: abort, mbox %d is locked.\n", ha->board_name, i); 1902 return SUCCESS; 1903 } 1904 1905 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) { 1906 unmap_dma(i, ha); 1907 SCarg->result = DID_ABORT << 16; 1908 SCarg->host_scribble = NULL; 1909 ha->cp_stat[i] = FREE; 1910 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", 1911 ha->board_name, i, SCarg->pid); 1912 SCarg->scsi_done(SCarg); 1913 return SUCCESS; 1914 } 1915 1916 panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i); 1917} 1918 1919static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg) 1920{ 1921 unsigned int i, time, k, c, limit = 0; 1922 int arg_done = 0; 1923 struct scsi_cmnd *SCpnt; 1924 struct Scsi_Host *shost = SCarg->device->host; 1925 struct hostdata *ha = (struct hostdata *)shost->hostdata; 1926 1927 scmd_printk(KERN_INFO, SCarg, 1928 "reset, enter, pid %ld.\n", SCarg->pid); 1929 1930 spin_lock_irq(shost->host_lock); 1931 1932 if (SCarg->host_scribble == NULL) 1933 printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid); 1934 1935 if (ha->in_reset) { 1936 printk("%s: reset, exit, already in reset.\n", ha->board_name); 1937 spin_unlock_irq(shost->host_lock); 1938 return FAILED; 1939 } 1940 1941 if (wait_on_busy(shost->io_port, MAXLOOP)) { 1942 printk("%s: reset, exit, timeout error.\n", ha->board_name); 1943 spin_unlock_irq(shost->host_lock); 1944 return FAILED; 1945 } 1946 1947 ha->retries = 0; 1948 1949 for (c = 0; c <= shost->max_channel; c++) 1950 for (k = 0; k < shost->max_id; k++) { 1951 ha->target_redo[k][c] = 1; 1952 ha->target_to[k][c] = 0; 1953 } 1954 1955 for (i = 0; i < shost->can_queue; i++) { 1956 1957 if (ha->cp_stat[i] == FREE) 1958 continue; 1959 1960 if (ha->cp_stat[i] == LOCKED) { 1961 ha->cp_stat[i] = FREE; 1962 printk("%s: reset, locked mbox %d forced free.\n", 1963 ha->board_name, i); 1964 continue; 1965 } 1966 1967 if (!(SCpnt = ha->cp[i].SCpnt)) 1968 panic("%s: reset, mbox %d, SCpnt == NULL.\n", ha->board_name, i); 1969 1970 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) { 1971 ha->cp_stat[i] = ABORTING; 1972 printk("%s: reset, mbox %d aborting, pid %ld.\n", 1973 ha->board_name, i, SCpnt->pid); 1974 } 1975 1976 else { 1977 ha->cp_stat[i] = IN_RESET; 1978 printk("%s: reset, mbox %d in reset, pid %ld.\n", 1979 ha->board_name, i, SCpnt->pid); 1980 } 1981 1982 if (SCpnt->host_scribble == NULL) 1983 panic("%s: reset, mbox %d, garbled SCpnt.\n", ha->board_name, i); 1984 1985 if (*(unsigned int *)SCpnt->host_scribble != i) 1986 panic("%s: reset, mbox %d, index mismatch.\n", ha->board_name, i); 1987 1988 if (SCpnt->scsi_done == NULL) 1989 panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", 1990 ha->board_name, i); 1991 1992 if (SCpnt == SCarg) 1993 arg_done = 1; 1994 } 1995 1996 if (do_dma(shost->io_port, 0, RESET_PIO)) { 1997 printk("%s: reset, cannot reset, timeout error.\n", ha->board_name); 1998 spin_unlock_irq(shost->host_lock); 1999 return FAILED; 2000 } 2001 2002 printk("%s: reset, board reset done, enabling interrupts.\n", ha->board_name); 2003 2004#if defined(DEBUG_RESET) 2005 do_trace = 1; 2006#endif 2007 2008 ha->in_reset = 1; 2009 2010 spin_unlock_irq(shost->host_lock); 2011 2012 time = jiffies; 2013 while ((jiffies - time) < (10 * HZ) && limit++ < 200000) 2014 udelay(100L); 2015 2016 spin_lock_irq(shost->host_lock); 2017 2018 printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit); 2019 2020 for (i = 0; i < shost->can_queue; i++) { 2021 2022 if (ha->cp_stat[i] == IN_RESET) { 2023 SCpnt = ha->cp[i].SCpnt; 2024 unmap_dma(i, ha); 2025 SCpnt->result = DID_RESET << 16; 2026 SCpnt->host_scribble = NULL; 2027 2028 /* This mailbox is still waiting for its interrupt */ 2029 ha->cp_stat[i] = LOCKED; 2030 2031 printk 2032 ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", 2033 ha->board_name, i, SCpnt->pid); 2034 } 2035 2036 else if (ha->cp_stat[i] == ABORTING) { 2037 SCpnt = ha->cp[i].SCpnt; 2038 unmap_dma(i, ha); 2039 SCpnt->result = DID_RESET << 16; 2040 SCpnt->host_scribble = NULL; 2041 2042 /* This mailbox was never queued to the adapter */ 2043 ha->cp_stat[i] = FREE; 2044 2045 printk 2046 ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", 2047 ha->board_name, i, SCpnt->pid); 2048 } 2049 2050 else 2051 /* Any other mailbox has already been set free by interrupt */ 2052 continue; 2053 2054 SCpnt->scsi_done(SCpnt); 2055 } 2056 2057 ha->in_reset = 0; 2058 do_trace = 0; 2059 2060 if (arg_done) 2061 printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->pid); 2062 else 2063 printk("%s: reset, exit.\n", ha->board_name); 2064 2065 spin_unlock_irq(shost->host_lock); 2066 return SUCCESS; 2067} 2068 2069int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev, 2070 sector_t capacity, int *dkinfo) 2071{ 2072 unsigned int size = capacity; 2073 2074 if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) { 2075 dkinfo[0] = 255; 2076 dkinfo[1] = 63; 2077 dkinfo[2] = size / (dkinfo[0] * dkinfo[1]); 2078 } 2079#if defined(DEBUG_GEOMETRY) 2080 printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name, 2081 dkinfo[0], dkinfo[1], dkinfo[2]); 2082#endif 2083 2084 return 0; 2085} 2086 2087static void sort(unsigned long sk[], unsigned int da[], unsigned int n, 2088 unsigned int rev) 2089{ 2090 unsigned int i, j, k, y; 2091 unsigned long x; 2092 2093 for (i = 0; i < n - 1; i++) { 2094 k = i; 2095 2096 for (j = k + 1; j < n; j++) 2097 if (rev) { 2098 if (sk[j] > sk[k]) 2099 k = j; 2100 } else { 2101 if (sk[j] < sk[k]) 2102 k = j; 2103 } 2104 2105 if (k != i) { 2106 x = sk[k]; 2107 sk[k] = sk[i]; 2108 sk[i] = x; 2109 y = da[k]; 2110 da[k] = da[i]; 2111 da[i] = y; 2112 } 2113 } 2114 2115 return; 2116} 2117 2118static int reorder(struct hostdata *ha, unsigned long cursec, 2119 unsigned int ihdlr, unsigned int il[], unsigned int n_ready) 2120{ 2121 struct scsi_cmnd *SCpnt; 2122 struct mscp *cpp; 2123 unsigned int k, n; 2124 unsigned int rev = 0, s = 1, r = 1; 2125 unsigned int input_only = 1, overlap = 0; 2126 unsigned long sl[n_ready], pl[n_ready], ll[n_ready]; 2127 unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0; 2128 unsigned long ioseek = 0; 2129 2130 static unsigned int flushcount = 0, batchcount = 0, sortcount = 0; 2131 static unsigned int readycount = 0, ovlcount = 0, inputcount = 0; 2132 static unsigned int readysorted = 0, revcount = 0; 2133 static unsigned long seeksorted = 0, seeknosort = 0; 2134 2135 if (link_statistics && !(++flushcount % link_statistics)) 2136 printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d" 2137 " av %ldK as %ldK.\n", flushcount, batchcount, 2138 inputcount, ovlcount, readycount, readysorted, sortcount, 2139 revcount, seeknosort / (readycount + 1), 2140 seeksorted / (readycount + 1)); 2141 2142 if (n_ready <= 1) 2143 return 0; 2144 2145 for (n = 0; n < n_ready; n++) { 2146 k = il[n]; 2147 cpp = &ha->cp[k]; 2148 SCpnt = cpp->SCpnt; 2149 2150 if (!cpp->din) 2151 input_only = 0; 2152 2153 if (SCpnt->request->sector < minsec) 2154 minsec = SCpnt->request->sector; 2155 if (SCpnt->request->sector > maxsec) 2156 maxsec = SCpnt->request->sector; 2157 2158 sl[n] = SCpnt->request->sector; 2159 ioseek += SCpnt->request->nr_sectors; 2160 2161 if (!n) 2162 continue; 2163 2164 if (sl[n] < sl[n - 1]) 2165 s = 0; 2166 if (sl[n] > sl[n - 1]) 2167 r = 0; 2168 2169 if (link_statistics) { 2170 if (sl[n] > sl[n - 1]) 2171 seek += sl[n] - sl[n - 1]; 2172 else 2173 seek += sl[n - 1] - sl[n]; 2174 } 2175 2176 } 2177 2178 if (link_statistics) { 2179 if (cursec > sl[0]) 2180 seek += cursec - sl[0]; 2181 else 2182 seek += sl[0] - cursec; 2183 } 2184 2185 if (cursec > ((maxsec + minsec) / 2)) 2186 rev = 1; 2187 2188 if (ioseek > ((maxsec - minsec) / 2)) 2189 rev = 0; 2190 2191 if (!((rev && r) || (!rev && s))) 2192 sort(sl, il, n_ready, rev); 2193 2194 if (!input_only) 2195 for (n = 0; n < n_ready; n++) { 2196 k = il[n]; 2197 cpp = &ha->cp[k]; 2198 SCpnt = cpp->SCpnt; 2199 ll[n] = SCpnt->request->nr_sectors; 2200 pl[n] = SCpnt->pid; 2201 2202 if (!n) 2203 continue; 2204 2205 if ((sl[n] == sl[n - 1]) 2206 || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n])) 2207 || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) 2208 overlap = 1; 2209 } 2210 2211 if (overlap) 2212 sort(pl, il, n_ready, 0); 2213 2214 if (link_statistics) { 2215 if (cursec > sl[0]) 2216 iseek = cursec - sl[0]; 2217 else 2218 iseek = sl[0] - cursec; 2219 batchcount++; 2220 readycount += n_ready; 2221 seeknosort += seek / 1024; 2222 if (input_only) 2223 inputcount++; 2224 if (overlap) { 2225 ovlcount++; 2226 seeksorted += iseek / 1024; 2227 } else 2228 seeksorted += (iseek + maxsec - minsec) / 1024; 2229 if (rev && !r) { 2230 revcount++; 2231 readysorted += n_ready; 2232 } 2233 if (!rev && !s) { 2234 sortcount++; 2235 readysorted += n_ready; 2236 } 2237 } 2238#if defined(DEBUG_LINKED_COMMANDS) 2239 if (link_statistics && (overlap || !(flushcount % link_statistics))) 2240 for (n = 0; n < n_ready; n++) { 2241 k = il[n]; 2242 cpp = &ha->cp[k]; 2243 SCpnt = cpp->SCpnt; 2244 scmd_printk(KERN_INFO, SCpnt, 2245 "%s pid %ld mb %d fc %d nr %d sec %ld ns %ld" 2246 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", 2247 (ihdlr ? "ihdlr" : "qcomm"), 2248 SCpnt->pid, k, flushcount, 2249 n_ready, SCpnt->request->sector, 2250 SCpnt->request->nr_sectors, cursec, YESNO(s), 2251 YESNO(r), YESNO(rev), YESNO(input_only), 2252 YESNO(overlap), cpp->din); 2253 } 2254#endif 2255 return overlap; 2256} 2257 2258static void flush_dev(struct scsi_device *dev, unsigned long cursec, 2259 struct hostdata *ha, unsigned int ihdlr) 2260{ 2261 struct scsi_cmnd *SCpnt; 2262 struct mscp *cpp; 2263 unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES]; 2264 2265 for (k = 0; k < dev->host->can_queue; k++) { 2266 2267 if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE) 2268 continue; 2269 2270 cpp = &ha->cp[k]; 2271 SCpnt = cpp->SCpnt; 2272 2273 if (SCpnt->device != dev) 2274 continue; 2275 2276 if (ha->cp_stat[k] == IN_USE) 2277 return; 2278 2279 il[n_ready++] = k; 2280 } 2281 2282 if (reorder(ha, cursec, ihdlr, il, n_ready)) 2283 n_ready = 1; 2284 2285 for (n = 0; n < n_ready; n++) { 2286 k = il[n]; 2287 cpp = &ha->cp[k]; 2288 SCpnt = cpp->SCpnt; 2289 2290 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) { 2291 scmd_printk(KERN_INFO, SCpnt, 2292 "%s, pid %ld, mbox %d, adapter" 2293 " busy, will abort.\n", 2294 (ihdlr ? "ihdlr" : "qcomm"), 2295 SCpnt->pid, k); 2296 ha->cp_stat[k] = ABORTING; 2297 continue; 2298 } 2299 2300 ha->cp_stat[k] = IN_USE; 2301 } 2302} 2303 2304static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost) 2305{ 2306 struct scsi_cmnd *SCpnt; 2307 unsigned int i, k, c, status, tstatus, reg; 2308 struct mssp *spp; 2309 struct mscp *cpp; 2310 struct hostdata *ha = (struct hostdata *)shost->hostdata; 2311 2312 if (shost->irq != irq) 2313 panic("%s: ihdlr, irq %d, shost->irq %d.\n", ha->board_name, irq, 2314 shost->irq); 2315 2316 /* Check if this board need to be serviced */ 2317 if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)) 2318 goto none; 2319 2320 ha->iocount++; 2321 2322 if (do_trace) 2323 printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq, 2324 ha->iocount); 2325 2326 /* Check if this board is still busy */ 2327 if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) { 2328 reg = inb(shost->io_port + REG_STATUS); 2329 printk 2330 ("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n", 2331 ha->board_name, irq, reg, ha->iocount); 2332 goto none; 2333 } 2334 2335 spp = &ha->sp; 2336 2337 /* Make a local copy just before clearing the interrupt indication */ 2338 memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp)); 2339 2340 /* Clear the completion flag and cp pointer on the dynamic copy of sp */ 2341 memset(ha->sp_cpu_addr, 0, sizeof(struct mssp)); 2342 2343 /* Read the status register to clear the interrupt indication */ 2344 reg = inb(shost->io_port + REG_STATUS); 2345 2346#if defined(DEBUG_INTERRUPT) 2347 { 2348 unsigned char *bytesp; 2349 int cnt; 2350 bytesp = (unsigned char *)spp; 2351 if (ha->iocount < 200) { 2352 printk("sp[] ="); 2353 for (cnt = 0; cnt < 15; cnt++) 2354 printk(" 0x%x", bytesp[cnt]); 2355 printk("\n"); 2356 } 2357 } 2358#endif 2359 2360 /* Reject any sp with supspect data */ 2361 if (spp->eoc == 0 && ha->iocount > 1) 2362 printk 2363 ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n", 2364 ha->board_name, irq, reg, ha->iocount); 2365 if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue) 2366 printk 2367 ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n", 2368 ha->board_name, spp->cpp_index, irq, reg, ha->iocount); 2369 if (spp->eoc == 0 || spp->cpp_index < 0 2370 || spp->cpp_index >= shost->can_queue) 2371 goto handled; 2372 2373 /* Find the mailbox to be serviced on this board */ 2374 i = spp->cpp_index; 2375 2376 cpp = &(ha->cp[i]); 2377 2378#if defined(DEBUG_GENERATE_ABORTS) 2379 if ((ha->iocount > 500) && ((ha->iocount % 500) < 3)) 2380 goto handled; 2381#endif 2382 2383 if (ha->cp_stat[i] == IGNORE) { 2384 ha->cp_stat[i] = FREE; 2385 goto handled; 2386 } else if (ha->cp_stat[i] == LOCKED) { 2387 ha->cp_stat[i] = FREE; 2388 printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i, 2389 ha->iocount); 2390 goto handled; 2391 } else if (ha->cp_stat[i] == FREE) { 2392 printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i, 2393 ha->iocount); 2394 goto handled; 2395 } else if (ha->cp_stat[i] == IN_RESET) 2396 printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i); 2397 else if (ha->cp_stat[i] != IN_USE) 2398 panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n", 2399 ha->board_name, i, ha->cp_stat[i]); 2400 2401 ha->cp_stat[i] = FREE; 2402 SCpnt = cpp->SCpnt; 2403 2404 if (SCpnt == NULL) 2405 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i); 2406 2407 if (SCpnt->host_scribble == NULL) 2408 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name, 2409 i, SCpnt->pid, SCpnt); 2410 2411 if (*(unsigned int *)SCpnt->host_scribble != i) 2412 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", 2413 ha->board_name, i, SCpnt->pid, 2414 *(unsigned int *)SCpnt->host_scribble); 2415 2416 sync_dma(i, ha); 2417 2418 if (linked_comm && SCpnt->device->queue_depth > 2 2419 && TLDEV(SCpnt->device->type)) 2420 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1); 2421 2422 tstatus = status_byte(spp->target_status); 2423 2424#if defined(DEBUG_GENERATE_ERRORS) 2425 if ((ha->iocount > 500) && ((ha->iocount % 200) < 2)) 2426 spp->adapter_status = 0x01; 2427#endif 2428 2429 switch (spp->adapter_status) { 2430 case ASOK: /* status OK */ 2431 2432 /* Forces a reset if a disk drive keeps returning BUSY */ 2433 if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 2434 status = DID_ERROR << 16; 2435 2436 /* If there was a bus reset, redo operation on each target */ 2437 else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK 2438 && ha->target_redo[SCpnt->device->id][SCpnt-> 2439 device-> 2440 channel]) 2441 status = DID_BUS_BUSY << 16; 2442 2443 /* Works around a flaw in scsi.c */ 2444 else if (tstatus == CHECK_CONDITION 2445 && SCpnt->device->type == TYPE_DISK 2446 && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR) 2447 status = DID_BUS_BUSY << 16; 2448 2449 else 2450 status = DID_OK << 16; 2451 2452 if (tstatus == GOOD) 2453 ha->target_redo[SCpnt->device->id][SCpnt->device-> 2454 channel] = 0; 2455 2456 if (spp->target_status && SCpnt->device->type == TYPE_DISK && 2457 (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 && 2458 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) 2459 printk("%s: ihdlr, target %d.%d:%d, pid %ld, " 2460 "target_status 0x%x, sense key 0x%x.\n", 2461 ha->board_name, 2462 SCpnt->device->channel, SCpnt->device->id, 2463 SCpnt->device->lun, SCpnt->pid, 2464 spp->target_status, SCpnt->sense_buffer[2]); 2465 2466 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0; 2467 2468 if (ha->last_retried_pid == SCpnt->pid) 2469 ha->retries = 0; 2470 2471 break; 2472 case ASST: /* Selection Time Out */ 2473 case 0x02: /* Command Time Out */ 2474 2475 if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1) 2476 status = DID_ERROR << 16; 2477 else { 2478 status = DID_TIME_OUT << 16; 2479 ha->target_to[SCpnt->device->id][SCpnt->device-> 2480 channel]++; 2481 } 2482 2483 break; 2484 2485 /* Perform a limited number of internal retries */ 2486 case 0x03: /* SCSI Bus Reset Received */ 2487 case 0x04: /* Initial Controller Power-up */ 2488 2489 for (c = 0; c <= shost->max_channel; c++) 2490 for (k = 0; k < shost->max_id; k++) 2491 ha->target_redo[k][c] = 1; 2492 2493 if (SCpnt->device->type != TYPE_TAPE 2494 && ha->retries < MAX_INTERNAL_RETRIES) { 2495 2496#if defined(DID_SOFT_ERROR) 2497 status = DID_SOFT_ERROR << 16; 2498#else 2499 status = DID_BUS_BUSY << 16; 2500#endif 2501 2502 ha->retries++; 2503 ha->last_retried_pid = SCpnt->pid; 2504 } else 2505 status = DID_ERROR << 16; 2506 2507 break; 2508 case 0x05: /* Unexpected Bus Phase */ 2509 case 0x06: /* Unexpected Bus Free */ 2510 case 0x07: /* Bus Parity Error */ 2511 case 0x08: /* SCSI Hung */ 2512 case 0x09: /* Unexpected Message Reject */ 2513 case 0x0a: /* SCSI Bus Reset Stuck */ 2514 case 0x0b: /* Auto Request-Sense Failed */ 2515 case 0x0c: /* Controller Ram Parity Error */ 2516 default: 2517 status = DID_ERROR << 16; 2518 break; 2519 } 2520 2521 SCpnt->result = status | spp->target_status; 2522 2523#if defined(DEBUG_INTERRUPT) 2524 if (SCpnt->result || do_trace) 2525#else 2526 if ((spp->adapter_status != ASOK && ha->iocount > 1000) || 2527 (spp->adapter_status != ASOK && 2528 spp->adapter_status != ASST && ha->iocount <= 1000) || 2529 do_trace || msg_byte(spp->target_status)) 2530#endif 2531 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x," 2532 " pid %ld, reg 0x%x, count %d.\n", 2533 i, spp->adapter_status, spp->target_status, 2534 SCpnt->pid, reg, ha->iocount); 2535 2536 unmap_dma(i, ha); 2537 2538 /* Set the command state to inactive */ 2539 SCpnt->host_scribble = NULL; 2540 2541 SCpnt->scsi_done(SCpnt); 2542 2543 if (do_trace) 2544 printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name, 2545 irq, ha->iocount); 2546 2547 handled: 2548 return IRQ_HANDLED; 2549 none: 2550 return IRQ_NONE; 2551} 2552 2553static irqreturn_t do_interrupt_handler(int irq, void *shap) 2554{ 2555 struct Scsi_Host *shost; 2556 unsigned int j; 2557 unsigned long spin_flags; 2558 irqreturn_t ret; 2559 2560 /* Check if the interrupt must be processed by this handler */ 2561 if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) 2562 return IRQ_NONE; 2563 shost = sh[j]; 2564 2565 spin_lock_irqsave(shost->host_lock, spin_flags); 2566 ret = ihdlr(irq, shost); 2567 spin_unlock_irqrestore(shost->host_lock, spin_flags); 2568 return ret; 2569} 2570 2571static int eata2x_release(struct Scsi_Host *shost) 2572{ 2573 struct hostdata *ha = (struct hostdata *)shost->hostdata; 2574 unsigned int i; 2575 2576 for (i = 0; i < shost->can_queue; i++) 2577 kfree((&ha->cp[i])->sglist); 2578 2579 for (i = 0; i < shost->can_queue; i++) 2580 pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr, 2581 sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL); 2582 2583 if (ha->sp_cpu_addr) 2584 pci_free_consistent(ha->pdev, sizeof(struct mssp), 2585 ha->sp_cpu_addr, ha->sp_dma_addr); 2586 2587 free_irq(shost->irq, &sha[ha->board_number]); 2588 2589 if (shost->dma_channel != NO_DMA) 2590 free_dma(shost->dma_channel); 2591 2592 release_region(shost->io_port, shost->n_io_port); 2593 scsi_unregister(shost); 2594 return 0; 2595} 2596 2597#include "scsi_module.c" 2598 2599#ifndef MODULE 2600__setup("eata=", option_setup); 2601#endif /* end MODULE */ 2602