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