linux/drivers/scsi/eata.c
<<
>>
Prefs
   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 corresponding
  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_Host *, 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                        (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_zalloc_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                cf->len = (ushort) H2DEV16((ushort) 510);
1253                cf->ocena = 1;
1254
1255                if (do_dma(port_base, cf_dma_addr, SET_CONFIG_DMA)) {
1256                        printk
1257                            ("%s: busy timeout sending configuration, detaching.\n",
1258                             name);
1259                        pci_free_consistent(pdev, sizeof(struct eata_config),
1260                                            cf, cf_dma_addr);
1261                        goto freedma;
1262                }
1263
1264        }
1265#endif
1266
1267        spin_unlock_irq(&driver_lock);
1268        sh[j] = shost = scsi_register(tpnt, sizeof(struct hostdata));
1269        spin_lock_irq(&driver_lock);
1270
1271        if (shost == NULL) {
1272                printk("%s: unable to register host, detaching.\n", name);
1273                goto freedma;
1274        }
1275
1276        shost->io_port = port_base;
1277        shost->unique_id = port_base;
1278        shost->n_io_port = REGION_SIZE;
1279        shost->dma_channel = dma_channel;
1280        shost->irq = irq;
1281        shost->sg_tablesize = (ushort) info.scatt_size;
1282        shost->this_id = (ushort) info.host_addr[3];
1283        shost->can_queue = (ushort) info.queue_size;
1284        shost->cmd_per_lun = MAX_CMD_PER_LUN;
1285
1286        ha = (struct hostdata *)shost->hostdata;
1287        
1288        memset(ha, 0, sizeof(struct hostdata));
1289        ha->subversion = subversion;
1290        ha->protocol_rev = protocol_rev;
1291        ha->is_pci = is_pci;
1292        ha->pdev = pdev;
1293        ha->board_number = j;
1294
1295        if (ha->subversion == ESA)
1296                shost->unchecked_isa_dma = 0;
1297        else {
1298                unsigned long flags;
1299                shost->unchecked_isa_dma = 1;
1300
1301                flags = claim_dma_lock();
1302                disable_dma(dma_channel);
1303                clear_dma_ff(dma_channel);
1304                set_dma_mode(dma_channel, DMA_MODE_CASCADE);
1305                enable_dma(dma_channel);
1306                release_dma_lock(flags);
1307
1308        }
1309
1310        strcpy(ha->board_name, name);
1311
1312        /* DPT PM2012 does not allow to detect sg_tablesize correctly */
1313        if (shost->sg_tablesize > MAX_SGLIST || shost->sg_tablesize < 2) {
1314                printk("%s: detect, wrong n. of SG lists %d, fixed.\n",
1315                       ha->board_name, shost->sg_tablesize);
1316                shost->sg_tablesize = MAX_SGLIST;
1317        }
1318
1319        /* DPT PM2012 does not allow to detect can_queue correctly */
1320        if (shost->can_queue > MAX_MAILBOXES || shost->can_queue < 2) {
1321                printk("%s: detect, wrong n. of mbox %d, fixed.\n",
1322                       ha->board_name, shost->can_queue);
1323                shost->can_queue = MAX_MAILBOXES;
1324        }
1325
1326        if (protocol_rev != 'A') {
1327                if (info.max_chan > 0 && info.max_chan < MAX_CHANNEL)
1328                        shost->max_channel = info.max_chan;
1329
1330                if (info.max_id > 7 && info.max_id < MAX_TARGET)
1331                        shost->max_id = info.max_id + 1;
1332
1333                if (info.large_sg && shost->sg_tablesize == MAX_SGLIST)
1334                        shost->sg_tablesize = MAX_LARGE_SGLIST;
1335        }
1336
1337        if (protocol_rev == 'C') {
1338                if (info.max_lun > 7 && info.max_lun < MAX_LUN)
1339                        shost->max_lun = info.max_lun + 1;
1340        }
1341
1342        if (dma_channel == NO_DMA)
1343                sprintf(dma_name, "%s", "BMST");
1344        else
1345                sprintf(dma_name, "DMA %u", dma_channel);
1346
1347        spin_unlock_irq(&driver_lock);
1348
1349        for (i = 0; i < shost->can_queue; i++)
1350                ha->cp[i].cp_dma_addr = pci_map_single(ha->pdev,
1351                                                          &ha->cp[i],
1352                                                          sizeof(struct mscp),
1353                                                          PCI_DMA_BIDIRECTIONAL);
1354
1355        for (i = 0; i < shost->can_queue; i++) {
1356                size_t sz = shost->sg_tablesize *sizeof(struct sg_list);
1357                gfp_t gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
1358                ha->cp[i].sglist = kmalloc(sz, gfp_mask);
1359                if (!ha->cp[i].sglist) {
1360                        printk
1361                            ("%s: kmalloc SGlist failed, mbox %d, detaching.\n",
1362                             ha->board_name, i);
1363                        goto release;
1364                }
1365        }
1366
1367        if (!(ha->sp_cpu_addr = pci_alloc_consistent(ha->pdev,
1368                                                        sizeof(struct mssp),
1369                                                        &ha->sp_dma_addr))) {
1370                printk("%s: pci_alloc_consistent failed, detaching.\n", ha->board_name);
1371                goto release;
1372        }
1373
1374        if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
1375                max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
1376
1377        if (max_queue_depth < MAX_CMD_PER_LUN)
1378                max_queue_depth = MAX_CMD_PER_LUN;
1379
1380        if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
1381                tag_mode = TAG_ORDERED;
1382
1383        if (j == 0) {
1384                printk
1385                    ("EATA/DMA 2.0x: Copyright (C) 1994-2003 Dario Ballabio.\n");
1386                printk
1387                    ("%s config options -> tm:%d, lc:%c, mq:%d, rs:%c, et:%c, "
1388                     "ip:%c, ep:%c, pp:%c.\n", driver_name, tag_mode,
1389                     YESNO(linked_comm), max_queue_depth, YESNO(rev_scan),
1390                     YESNO(ext_tran), YESNO(isa_probe), YESNO(eisa_probe),
1391                     YESNO(pci_probe));
1392        }
1393
1394        printk("%s: 2.0%c, %s 0x%03lx, IRQ %u, %s, SG %d, MB %d.\n",
1395               ha->board_name, ha->protocol_rev, bus_type,
1396               (unsigned long)shost->io_port, shost->irq, dma_name,
1397               shost->sg_tablesize, shost->can_queue);
1398
1399        if (shost->max_id > 8 || shost->max_lun > 8)
1400                printk
1401                    ("%s: wide SCSI support enabled, max_id %u, max_lun %llu.\n",
1402                     ha->board_name, shost->max_id, shost->max_lun);
1403
1404        for (i = 0; i <= shost->max_channel; i++)
1405                printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1406                       ha->board_name, i, info.host_addr[3 - i]);
1407
1408#if defined(DEBUG_DETECT)
1409        printk("%s: Vers. 0x%x, ocs %u, tar %u, trnxfr %u, more %u, SYNC 0x%x, "
1410               "sec. %u, infol %d, cpl %d spl %d.\n", name, info.version,
1411               info.ocsena, info.tarsup, info.trnxfr, info.morsup, info.sync,
1412               info.second, info.data_len, info.cp_len, info.sp_len);
1413
1414        if (protocol_rev == 'B' || protocol_rev == 'C')
1415                printk("%s: isaena %u, forcaddr %u, max_id %u, max_chan %u, "
1416                       "large_sg %u, res1 %u.\n", name, info.isaena,
1417                       info.forcaddr, info.max_id, info.max_chan, info.large_sg,
1418                       info.res1);
1419
1420        if (protocol_rev == 'C')
1421                printk("%s: max_lun %u, m1 %u, idquest %u, pci %u, eisa %u, "
1422                       "raidnum %u.\n", name, info.max_lun, info.m1,
1423                       info.idquest, info.pci, info.eisa, info.raidnum);
1424#endif
1425
1426        if (ha->pdev) {
1427                pci_set_master(ha->pdev);
1428                if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32)))
1429                        printk("%s: warning, pci_set_dma_mask failed.\n",
1430                               ha->board_name);
1431        }
1432
1433        return 1;
1434
1435      freedma:
1436        if (subversion == ISA)
1437                free_dma(dma_channel);
1438      freeirq:
1439        free_irq(irq, &sha[j]);
1440      freelock:
1441        spin_unlock_irq(&driver_lock);
1442        release_region(port_base, REGION_SIZE);
1443      fail:
1444        return 0;
1445
1446      release:
1447        eata2x_release(shost);
1448        return 0;
1449}
1450
1451static void internal_setup(char *str, int *ints)
1452{
1453        int i, argc = ints[0];
1454        char *cur = str, *pc;
1455
1456        if (argc > 0) {
1457                if (argc > MAX_INT_PARAM)
1458                        argc = MAX_INT_PARAM;
1459
1460                for (i = 0; i < argc; i++)
1461                        io_port[i] = ints[i + 1];
1462
1463                io_port[i] = 0;
1464                setup_done = 1;
1465        }
1466
1467        while (cur && (pc = strchr(cur, ':'))) {
1468                int val = 0, c = *++pc;
1469
1470                if (c == 'n' || c == 'N')
1471                        val = 0;
1472                else if (c == 'y' || c == 'Y')
1473                        val = 1;
1474                else
1475                        val = (int)simple_strtoul(pc, NULL, 0);
1476
1477                if (!strncmp(cur, "lc:", 3))
1478                        linked_comm = val;
1479                else if (!strncmp(cur, "tm:", 3))
1480                        tag_mode = val;
1481                else if (!strncmp(cur, "tc:", 3))
1482                        tag_mode = val;
1483                else if (!strncmp(cur, "mq:", 3))
1484                        max_queue_depth = val;
1485                else if (!strncmp(cur, "ls:", 3))
1486                        link_statistics = val;
1487                else if (!strncmp(cur, "et:", 3))
1488                        ext_tran = val;
1489                else if (!strncmp(cur, "rs:", 3))
1490                        rev_scan = val;
1491                else if (!strncmp(cur, "ip:", 3))
1492                        isa_probe = val;
1493                else if (!strncmp(cur, "ep:", 3))
1494                        eisa_probe = val;
1495                else if (!strncmp(cur, "pp:", 3))
1496                        pci_probe = val;
1497
1498                if ((cur = strchr(cur, ',')))
1499                        ++cur;
1500        }
1501
1502        return;
1503}
1504
1505static int option_setup(char *str)
1506{
1507        int ints[MAX_INT_PARAM];
1508        char *cur = str;
1509        int i = 1;
1510
1511        while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
1512                ints[i++] = simple_strtoul(cur, NULL, 0);
1513
1514                if ((cur = strchr(cur, ',')) != NULL)
1515                        cur++;
1516        }
1517
1518        ints[0] = i - 1;
1519        internal_setup(cur, ints);
1520        return 1;
1521}
1522
1523static void add_pci_ports(void)
1524{
1525#if defined(CONFIG_PCI)
1526        unsigned int addr, k;
1527        struct pci_dev *dev = NULL;
1528
1529        for (k = 0; k < MAX_PCI; k++) {
1530
1531                if (!(dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev)))
1532                        break;
1533
1534                if (pci_enable_device(dev)) {
1535#if defined(DEBUG_PCI_DETECT)
1536                        printk
1537                            ("%s: detect, bus %d, devfn 0x%x, pci_enable_device failed.\n",
1538                             driver_name, dev->bus->number, dev->devfn);
1539#endif
1540
1541                        continue;
1542                }
1543
1544                addr = pci_resource_start(dev, 0);
1545
1546#if defined(DEBUG_PCI_DETECT)
1547                printk("%s: detect, seq. %d, bus %d, devfn 0x%x, addr 0x%x.\n",
1548                       driver_name, k, dev->bus->number, dev->devfn, addr);
1549#endif
1550
1551                /* Order addresses according to rev_scan value */
1552                io_port[MAX_INT_PARAM + (rev_scan ? (MAX_PCI - k) : (1 + k))] =
1553                    addr + PCI_BASE_ADDRESS_0;
1554        }
1555
1556        pci_dev_put(dev);
1557#endif                          /* end CONFIG_PCI */
1558}
1559
1560static int eata2x_detect(struct scsi_host_template *tpnt)
1561{
1562        unsigned int j = 0, k;
1563
1564        tpnt->proc_name = "eata2x";
1565
1566        if (strlen(boot_options))
1567                option_setup(boot_options);
1568
1569#if defined(MODULE)
1570        /* io_port could have been modified when loading as a module */
1571        if (io_port[0] != SKIP) {
1572                setup_done = 1;
1573                io_port[MAX_INT_PARAM] = 0;
1574        }
1575#endif
1576
1577        for (k = MAX_INT_PARAM; io_port[k]; k++)
1578                if (io_port[k] == SKIP)
1579                        continue;
1580                else if (io_port[k] <= MAX_ISA_ADDR) {
1581                        if (!isa_probe)
1582                                io_port[k] = SKIP;
1583                } else if (io_port[k] >= MIN_EISA_ADDR
1584                           && io_port[k] <= MAX_EISA_ADDR) {
1585                        if (!eisa_probe)
1586                                io_port[k] = SKIP;
1587                }
1588
1589        if (pci_probe) {
1590                if (!setup_done)
1591                        add_pci_ports();
1592                else
1593                        enable_pci_ports();
1594        }
1595
1596        for (k = 0; io_port[k]; k++) {
1597
1598                if (io_port[k] == SKIP)
1599                        continue;
1600
1601                if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt))
1602                        j++;
1603        }
1604
1605        num_boards = j;
1606        return j;
1607}
1608
1609static void map_dma(unsigned int i, struct hostdata *ha)
1610{
1611        unsigned int k, pci_dir;
1612        int count;
1613        struct scatterlist *sg;
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                           SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE));
1625
1626        cpp->sense_len = SCSI_SENSE_BUFFERSIZE;
1627
1628        if (!scsi_sg_count(SCpnt)) {
1629                cpp->data_len = 0;
1630                return;
1631        }
1632
1633        count = pci_map_sg(ha->pdev, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
1634                           pci_dir);
1635        BUG_ON(!count);
1636
1637        scsi_for_each_sg(SCpnt, sg, count, k) {
1638                cpp->sglist[k].address = H2DEV(sg_dma_address(sg));
1639                cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(sg));
1640        }
1641
1642        cpp->sg = 1;
1643        cpp->data_address = H2DEV(pci_map_single(ha->pdev, cpp->sglist,
1644                                                 scsi_sg_count(SCpnt) *
1645                                                 sizeof(struct sg_list),
1646                                                 pci_dir));
1647        cpp->data_len = H2DEV((scsi_sg_count(SCpnt) * sizeof(struct sg_list)));
1648}
1649
1650static void unmap_dma(unsigned int i, struct hostdata *ha)
1651{
1652        unsigned int pci_dir;
1653        struct mscp *cpp;
1654        struct scsi_cmnd *SCpnt;
1655
1656        cpp = &ha->cp[i];
1657        SCpnt = cpp->SCpnt;
1658        pci_dir = SCpnt->sc_data_direction;
1659
1660        if (DEV2H(cpp->sense_addr))
1661                pci_unmap_single(ha->pdev, DEV2H(cpp->sense_addr),
1662                                 DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1663
1664        if (scsi_sg_count(SCpnt))
1665                pci_unmap_sg(ha->pdev, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
1666                             pci_dir);
1667
1668        if (!DEV2H(cpp->data_len))
1669                pci_dir = PCI_DMA_BIDIRECTIONAL;
1670
1671        if (DEV2H(cpp->data_address))
1672                pci_unmap_single(ha->pdev, DEV2H(cpp->data_address),
1673                                 DEV2H(cpp->data_len), pci_dir);
1674}
1675
1676static void sync_dma(unsigned int i, struct hostdata *ha)
1677{
1678        unsigned int pci_dir;
1679        struct mscp *cpp;
1680        struct scsi_cmnd *SCpnt;
1681
1682        cpp = &ha->cp[i];
1683        SCpnt = cpp->SCpnt;
1684        pci_dir = SCpnt->sc_data_direction;
1685
1686        if (DEV2H(cpp->sense_addr))
1687                pci_dma_sync_single_for_cpu(ha->pdev, DEV2H(cpp->sense_addr),
1688                                            DEV2H(cpp->sense_len),
1689                                            PCI_DMA_FROMDEVICE);
1690
1691        if (scsi_sg_count(SCpnt))
1692                pci_dma_sync_sg_for_cpu(ha->pdev, scsi_sglist(SCpnt),
1693                                        scsi_sg_count(SCpnt), pci_dir);
1694
1695        if (!DEV2H(cpp->data_len))
1696                pci_dir = PCI_DMA_BIDIRECTIONAL;
1697
1698        if (DEV2H(cpp->data_address))
1699                pci_dma_sync_single_for_cpu(ha->pdev,
1700                                            DEV2H(cpp->data_address),
1701                                            DEV2H(cpp->data_len), pci_dir);
1702}
1703
1704static void scsi_to_dev_dir(unsigned int i, struct hostdata *ha)
1705{
1706        unsigned int k;
1707
1708        static const unsigned char data_out_cmds[] = {
1709                0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1710                0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1711                0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1712        };
1713
1714        static const unsigned char data_none_cmds[] = {
1715                0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1716                0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1717                0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1718        };
1719
1720        struct mscp *cpp;
1721        struct scsi_cmnd *SCpnt;
1722
1723        cpp = &ha->cp[i];
1724        SCpnt = cpp->SCpnt;
1725
1726        if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1727                cpp->din = 1;
1728                cpp->dout = 0;
1729                return;
1730        } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1731                cpp->din = 0;
1732                cpp->dout = 1;
1733                return;
1734        } else if (SCpnt->sc_data_direction == DMA_NONE) {
1735                cpp->din = 0;
1736                cpp->dout = 0;
1737                return;
1738        }
1739
1740        if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1741                panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n",
1742                                ha->board_name);
1743
1744        for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1745                if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1746                        cpp->dout = 1;
1747                        break;
1748                }
1749
1750        if ((cpp->din = !cpp->dout))
1751                for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1752                        if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1753                                cpp->din = 0;
1754                                break;
1755                        }
1756
1757}
1758
1759static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
1760                               void (*done) (struct scsi_cmnd *))
1761{
1762        struct Scsi_Host *shost = SCpnt->device->host;
1763        struct hostdata *ha = (struct hostdata *)shost->hostdata;
1764        unsigned int i, k;
1765        struct mscp *cpp;
1766
1767        if (SCpnt->host_scribble)
1768                panic("%s: qcomm, SCpnt %p already active.\n",
1769                      ha->board_name, SCpnt);
1770
1771        /* i is the mailbox number, look for the first free mailbox
1772           starting from last_cp_used */
1773        i = ha->last_cp_used + 1;
1774
1775        for (k = 0; k < shost->can_queue; k++, i++) {
1776                if (i >= shost->can_queue)
1777                        i = 0;
1778                if (ha->cp_stat[i] == FREE) {
1779                        ha->last_cp_used = i;
1780                        break;
1781                }
1782        }
1783
1784        if (k == shost->can_queue) {
1785                printk("%s: qcomm, no free mailbox.\n", ha->board_name);
1786                return 1;
1787        }
1788
1789        /* Set pointer to control packet structure */
1790        cpp = &ha->cp[i];
1791
1792        memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1793
1794        /* Set pointer to status packet structure, Big Endian format */
1795        cpp->sp_dma_addr = H2DEV(ha->sp_dma_addr);
1796
1797        SCpnt->scsi_done = done;
1798        cpp->cpp_index = i;
1799        SCpnt->host_scribble = (unsigned char *)&cpp->cpp_index;
1800
1801        if (do_trace)
1802                scmd_printk(KERN_INFO, SCpnt,
1803                        "qcomm, mbox %d.\n", i);
1804
1805        cpp->reqsen = 1;
1806        cpp->dispri = 1;
1807#if 0
1808        if (SCpnt->device->type == TYPE_TAPE)
1809                cpp->hbaci = 1;
1810#endif
1811        cpp->one = 1;
1812        cpp->channel = SCpnt->device->channel;
1813        cpp->target = SCpnt->device->id;
1814        cpp->lun = SCpnt->device->lun;
1815        cpp->SCpnt = SCpnt;
1816        memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1817
1818        /* Use data transfer direction SCpnt->sc_data_direction */
1819        scsi_to_dev_dir(i, ha);
1820
1821        /* Map DMA buffers and SG list */
1822        map_dma(i, ha);
1823
1824        if (linked_comm && SCpnt->device->queue_depth > 2
1825            && TLDEV(SCpnt->device->type)) {
1826                ha->cp_stat[i] = READY;
1827                flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 0);
1828                return 0;
1829        }
1830
1831        /* Send control packet to the board */
1832        if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
1833                unmap_dma(i, ha);
1834                SCpnt->host_scribble = NULL;
1835                scmd_printk(KERN_INFO, SCpnt, "qcomm, adapter busy.\n");
1836                return 1;
1837        }
1838
1839        ha->cp_stat[i] = IN_USE;
1840        return 0;
1841}
1842
1843static DEF_SCSI_QCMD(eata2x_queuecommand)
1844
1845static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1846{
1847        struct Scsi_Host *shost = SCarg->device->host;
1848        struct hostdata *ha = (struct hostdata *)shost->hostdata;
1849        unsigned int i;
1850
1851        if (SCarg->host_scribble == NULL) {
1852                scmd_printk(KERN_INFO, SCarg, "abort, cmd inactive.\n");
1853                return SUCCESS;
1854        }
1855
1856        i = *(unsigned int *)SCarg->host_scribble;
1857        scmd_printk(KERN_WARNING, SCarg, "abort, mbox %d.\n", i);
1858
1859        if (i >= shost->can_queue)
1860                panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
1861
1862        if (wait_on_busy(shost->io_port, MAXLOOP)) {
1863                printk("%s: abort, timeout error.\n", ha->board_name);
1864                return FAILED;
1865        }
1866
1867        if (ha->cp_stat[i] == FREE) {
1868                printk("%s: abort, mbox %d is free.\n", ha->board_name, i);
1869                return SUCCESS;
1870        }
1871
1872        if (ha->cp_stat[i] == IN_USE) {
1873                printk("%s: abort, mbox %d is in use.\n", ha->board_name, i);
1874
1875                if (SCarg != ha->cp[i].SCpnt)
1876                        panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1877                              ha->board_name, i, SCarg, ha->cp[i].SCpnt);
1878
1879                if (inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)
1880                        printk("%s: abort, mbox %d, interrupt pending.\n",
1881                               ha->board_name, i);
1882
1883                return FAILED;
1884        }
1885
1886        if (ha->cp_stat[i] == IN_RESET) {
1887                printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i);
1888                return FAILED;
1889        }
1890
1891        if (ha->cp_stat[i] == LOCKED) {
1892                printk("%s: abort, mbox %d is locked.\n", ha->board_name, i);
1893                return SUCCESS;
1894        }
1895
1896        if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1897                unmap_dma(i, ha);
1898                SCarg->result = DID_ABORT << 16;
1899                SCarg->host_scribble = NULL;
1900                ha->cp_stat[i] = FREE;
1901                printk("%s, abort, mbox %d ready, DID_ABORT, done.\n",
1902                       ha->board_name, i);
1903                SCarg->scsi_done(SCarg);
1904                return SUCCESS;
1905        }
1906
1907        panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i);
1908}
1909
1910static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1911{
1912        unsigned int i, time, k, c, limit = 0;
1913        int arg_done = 0;
1914        struct scsi_cmnd *SCpnt;
1915        struct Scsi_Host *shost = SCarg->device->host;
1916        struct hostdata *ha = (struct hostdata *)shost->hostdata;
1917
1918        scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
1919
1920        spin_lock_irq(shost->host_lock);
1921
1922        if (SCarg->host_scribble == NULL)
1923                printk("%s: reset, inactive.\n", ha->board_name);
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.\n",
1963                               ha->board_name, i);
1964                }
1965
1966                else {
1967                        ha->cp_stat[i] = IN_RESET;
1968                        printk("%s: reset, mbox %d in reset.\n",
1969                               ha->board_name, i);
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        /* FIXME: use a sleep instead */
2003        time = jiffies;
2004        while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
2005                udelay(100L);
2006
2007        spin_lock_irq(shost->host_lock);
2008
2009        printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
2010
2011        for (i = 0; i < shost->can_queue; i++) {
2012
2013                if (ha->cp_stat[i] == IN_RESET) {
2014                        SCpnt = ha->cp[i].SCpnt;
2015                        unmap_dma(i, ha);
2016                        SCpnt->result = DID_RESET << 16;
2017                        SCpnt->host_scribble = NULL;
2018
2019                        /* This mailbox is still waiting for its interrupt */
2020                        ha->cp_stat[i] = LOCKED;
2021
2022                        printk
2023                            ("%s, reset, mbox %d locked, DID_RESET, done.\n",
2024                             ha->board_name, i);
2025                }
2026
2027                else if (ha->cp_stat[i] == ABORTING) {
2028                        SCpnt = ha->cp[i].SCpnt;
2029                        unmap_dma(i, ha);
2030                        SCpnt->result = DID_RESET << 16;
2031                        SCpnt->host_scribble = NULL;
2032
2033                        /* This mailbox was never queued to the adapter */
2034                        ha->cp_stat[i] = FREE;
2035
2036                        printk
2037                            ("%s, reset, mbox %d aborting, DID_RESET, done.\n",
2038                             ha->board_name, i);
2039                }
2040
2041                else
2042                        /* Any other mailbox has already been set free by interrupt */
2043                        continue;
2044
2045                SCpnt->scsi_done(SCpnt);
2046        }
2047
2048        ha->in_reset = 0;
2049        do_trace = 0;
2050
2051        if (arg_done)
2052                printk("%s: reset, exit, done.\n", ha->board_name);
2053        else
2054                printk("%s: reset, exit.\n", ha->board_name);
2055
2056        spin_unlock_irq(shost->host_lock);
2057        return SUCCESS;
2058}
2059
2060int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2061                      sector_t capacity, int *dkinfo)
2062{
2063        unsigned int size = capacity;
2064
2065        if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
2066                dkinfo[0] = 255;
2067                dkinfo[1] = 63;
2068                dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
2069        }
2070#if defined (DEBUG_GEOMETRY)
2071        printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
2072               dkinfo[0], dkinfo[1], dkinfo[2]);
2073#endif
2074
2075        return 0;
2076}
2077
2078static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
2079                 unsigned int rev)
2080{
2081        unsigned int i, j, k, y;
2082        unsigned long x;
2083
2084        for (i = 0; i < n - 1; i++) {
2085                k = i;
2086
2087                for (j = k + 1; j < n; j++)
2088                        if (rev) {
2089                                if (sk[j] > sk[k])
2090                                        k = j;
2091                        } else {
2092                                if (sk[j] < sk[k])
2093                                        k = j;
2094                        }
2095
2096                if (k != i) {
2097                        x = sk[k];
2098                        sk[k] = sk[i];
2099                        sk[i] = x;
2100                        y = da[k];
2101                        da[k] = da[i];
2102                        da[i] = y;
2103                }
2104        }
2105
2106        return;
2107}
2108
2109static int reorder(struct hostdata *ha, unsigned long cursec,
2110                   unsigned int ihdlr, unsigned int il[], unsigned int n_ready)
2111{
2112        struct scsi_cmnd *SCpnt;
2113        struct mscp *cpp;
2114        unsigned int k, n;
2115        unsigned int rev = 0, s = 1, r = 1;
2116        unsigned int input_only = 1, overlap = 0;
2117        unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
2118        unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
2119        unsigned long ioseek = 0;
2120
2121        static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
2122        static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
2123        static unsigned int readysorted = 0, revcount = 0;
2124        static unsigned long seeksorted = 0, seeknosort = 0;
2125
2126        if (link_statistics && !(++flushcount % link_statistics))
2127                printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
2128                       " av %ldK as %ldK.\n", flushcount, batchcount,
2129                       inputcount, ovlcount, readycount, readysorted, sortcount,
2130                       revcount, seeknosort / (readycount + 1),
2131                       seeksorted / (readycount + 1));
2132
2133        if (n_ready <= 1)
2134                return 0;
2135
2136        for (n = 0; n < n_ready; n++) {
2137                k = il[n];
2138                cpp = &ha->cp[k];
2139                SCpnt = cpp->SCpnt;
2140
2141                if (!cpp->din)
2142                        input_only = 0;
2143
2144                if (blk_rq_pos(SCpnt->request) < minsec)
2145                        minsec = blk_rq_pos(SCpnt->request);
2146                if (blk_rq_pos(SCpnt->request) > maxsec)
2147                        maxsec = blk_rq_pos(SCpnt->request);
2148
2149                sl[n] = blk_rq_pos(SCpnt->request);
2150                ioseek += blk_rq_sectors(SCpnt->request);
2151
2152                if (!n)
2153                        continue;
2154
2155                if (sl[n] < sl[n - 1])
2156                        s = 0;
2157                if (sl[n] > sl[n - 1])
2158                        r = 0;
2159
2160                if (link_statistics) {
2161                        if (sl[n] > sl[n - 1])
2162                                seek += sl[n] - sl[n - 1];
2163                        else
2164                                seek += sl[n - 1] - sl[n];
2165                }
2166
2167        }
2168
2169        if (link_statistics) {
2170                if (cursec > sl[0])
2171                        seek += cursec - sl[0];
2172                else
2173                        seek += sl[0] - cursec;
2174        }
2175
2176        if (cursec > ((maxsec + minsec) / 2))
2177                rev = 1;
2178
2179        if (ioseek > ((maxsec - minsec) / 2))
2180                rev = 0;
2181
2182        if (!((rev && r) || (!rev && s)))
2183                sort(sl, il, n_ready, rev);
2184
2185        if (!input_only)
2186                for (n = 0; n < n_ready; n++) {
2187                        k = il[n];
2188                        cpp = &ha->cp[k];
2189                        SCpnt = cpp->SCpnt;
2190                        ll[n] = blk_rq_sectors(SCpnt->request);
2191                        pl[n] = SCpnt->serial_number;
2192
2193                        if (!n)
2194                                continue;
2195
2196                        if ((sl[n] == sl[n - 1])
2197                            || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
2198                            || (rev && ((sl[n] + ll[n]) > sl[n - 1])))
2199                                overlap = 1;
2200                }
2201
2202        if (overlap)
2203                sort(pl, il, n_ready, 0);
2204
2205        if (link_statistics) {
2206                if (cursec > sl[0])
2207                        iseek = cursec - sl[0];
2208                else
2209                        iseek = sl[0] - cursec;
2210                batchcount++;
2211                readycount += n_ready;
2212                seeknosort += seek / 1024;
2213                if (input_only)
2214                        inputcount++;
2215                if (overlap) {
2216                        ovlcount++;
2217                        seeksorted += iseek / 1024;
2218                } else
2219                        seeksorted += (iseek + maxsec - minsec) / 1024;
2220                if (rev && !r) {
2221                        revcount++;
2222                        readysorted += n_ready;
2223                }
2224                if (!rev && !s) {
2225                        sortcount++;
2226                        readysorted += n_ready;
2227                }
2228        }
2229#if defined(DEBUG_LINKED_COMMANDS)
2230        if (link_statistics && (overlap || !(flushcount % link_statistics)))
2231                for (n = 0; n < n_ready; n++) {
2232                        k = il[n];
2233                        cpp = &ha->cp[k];
2234                        SCpnt = cpp->SCpnt;
2235                        scmd_printk(KERN_INFO, SCpnt,
2236                            "%s mb %d fc %d nr %d sec %ld ns %u"
2237                             " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2238                             (ihdlr ? "ihdlr" : "qcomm"),
2239                             k, flushcount,
2240                             n_ready, blk_rq_pos(SCpnt->request),
2241                             blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
2242                             YESNO(r), YESNO(rev), YESNO(input_only),
2243                             YESNO(overlap), cpp->din);
2244                }
2245#endif
2246        return overlap;
2247}
2248
2249static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2250                      struct hostdata *ha, unsigned int ihdlr)
2251{
2252        struct scsi_cmnd *SCpnt;
2253        struct mscp *cpp;
2254        unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
2255
2256        for (k = 0; k < dev->host->can_queue; k++) {
2257
2258                if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE)
2259                        continue;
2260
2261                cpp = &ha->cp[k];
2262                SCpnt = cpp->SCpnt;
2263
2264                if (SCpnt->device != dev)
2265                        continue;
2266
2267                if (ha->cp_stat[k] == IN_USE)
2268                        return;
2269
2270                il[n_ready++] = k;
2271        }
2272
2273        if (reorder(ha, cursec, ihdlr, il, n_ready))
2274                n_ready = 1;
2275
2276        for (n = 0; n < n_ready; n++) {
2277                k = il[n];
2278                cpp = &ha->cp[k];
2279                SCpnt = cpp->SCpnt;
2280
2281                if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2282                        scmd_printk(KERN_INFO, SCpnt,
2283                            "%s, mbox %d, adapter"
2284                             " busy, will abort.\n",
2285                             (ihdlr ? "ihdlr" : "qcomm"),
2286                             k);
2287                        ha->cp_stat[k] = ABORTING;
2288                        continue;
2289                }
2290
2291                ha->cp_stat[k] = IN_USE;
2292        }
2293}
2294
2295static irqreturn_t ihdlr(struct Scsi_Host *shost)
2296{
2297        struct scsi_cmnd *SCpnt;
2298        unsigned int i, k, c, status, tstatus, reg;
2299        struct mssp *spp;
2300        struct mscp *cpp;
2301        struct hostdata *ha = (struct hostdata *)shost->hostdata;
2302        int irq = shost->irq;
2303
2304        /* Check if this board need to be serviced */
2305        if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
2306                goto none;
2307
2308        ha->iocount++;
2309
2310        if (do_trace)
2311                printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq,
2312                       ha->iocount);
2313
2314        /* Check if this board is still busy */
2315        if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) {
2316                reg = inb(shost->io_port + REG_STATUS);
2317                printk
2318                    ("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.\n",
2319                     ha->board_name, irq, reg, ha->iocount);
2320                goto none;
2321        }
2322
2323        spp = &ha->sp;
2324
2325        /* Make a local copy just before clearing the interrupt indication */
2326        memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp));
2327
2328        /* Clear the completion flag and cp pointer on the dynamic copy of sp */
2329        memset(ha->sp_cpu_addr, 0, sizeof(struct mssp));
2330
2331        /* Read the status register to clear the interrupt indication */
2332        reg = inb(shost->io_port + REG_STATUS);
2333
2334#if defined (DEBUG_INTERRUPT)
2335        {
2336                unsigned char *bytesp;
2337                int cnt;
2338                bytesp = (unsigned char *)spp;
2339                if (ha->iocount < 200) {
2340                        printk("sp[] =");
2341                        for (cnt = 0; cnt < 15; cnt++)
2342                                printk(" 0x%x", bytesp[cnt]);
2343                        printk("\n");
2344                }
2345        }
2346#endif
2347
2348        /* Reject any sp with supspect data */
2349        if (spp->eoc == 0 && ha->iocount > 1)
2350                printk
2351                    ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n",
2352                     ha->board_name, irq, reg, ha->iocount);
2353        if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue)
2354                printk
2355                    ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n",
2356                     ha->board_name, spp->cpp_index, irq, reg, ha->iocount);
2357        if (spp->eoc == 0 || spp->cpp_index < 0
2358            || spp->cpp_index >= shost->can_queue)
2359                goto handled;
2360
2361        /* Find the mailbox to be serviced on this board */
2362        i = spp->cpp_index;
2363
2364        cpp = &(ha->cp[i]);
2365
2366#if defined(DEBUG_GENERATE_ABORTS)
2367        if ((ha->iocount > 500) && ((ha->iocount % 500) < 3))
2368                goto handled;
2369#endif
2370
2371        if (ha->cp_stat[i] == IGNORE) {
2372                ha->cp_stat[i] = FREE;
2373                goto handled;
2374        } else if (ha->cp_stat[i] == LOCKED) {
2375                ha->cp_stat[i] = FREE;
2376                printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i,
2377                       ha->iocount);
2378                goto handled;
2379        } else if (ha->cp_stat[i] == FREE) {
2380                printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i,
2381                       ha->iocount);
2382                goto handled;
2383        } else if (ha->cp_stat[i] == IN_RESET)
2384                printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i);
2385        else if (ha->cp_stat[i] != IN_USE)
2386                panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
2387                      ha->board_name, i, ha->cp_stat[i]);
2388
2389        ha->cp_stat[i] = FREE;
2390        SCpnt = cpp->SCpnt;
2391
2392        if (SCpnt == NULL)
2393                panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2394
2395        if (SCpnt->host_scribble == NULL)
2396                panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", ha->board_name,
2397                      i, SCpnt);
2398
2399        if (*(unsigned int *)SCpnt->host_scribble != i)
2400                panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
2401                      ha->board_name, i,
2402                      *(unsigned int *)SCpnt->host_scribble);
2403
2404        sync_dma(i, ha);
2405
2406        if (linked_comm && SCpnt->device->queue_depth > 2
2407            && TLDEV(SCpnt->device->type))
2408                flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 1);
2409
2410        tstatus = status_byte(spp->target_status);
2411
2412#if defined(DEBUG_GENERATE_ERRORS)
2413        if ((ha->iocount > 500) && ((ha->iocount % 200) < 2))
2414                spp->adapter_status = 0x01;
2415#endif
2416
2417        switch (spp->adapter_status) {
2418        case ASOK:              /* status OK */
2419
2420                /* Forces a reset if a disk drive keeps returning BUSY */
2421                if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
2422                        status = DID_ERROR << 16;
2423
2424                /* If there was a bus reset, redo operation on each target */
2425                else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
2426                         && ha->target_redo[SCpnt->device->id][SCpnt->
2427                                                                  device->
2428                                                                  channel])
2429                        status = DID_BUS_BUSY << 16;
2430
2431                /* Works around a flaw in scsi.c */
2432                else if (tstatus == CHECK_CONDITION
2433                         && SCpnt->device->type == TYPE_DISK
2434                         && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
2435                        status = DID_BUS_BUSY << 16;
2436
2437                else
2438                        status = DID_OK << 16;
2439
2440                if (tstatus == GOOD)
2441                        ha->target_redo[SCpnt->device->id][SCpnt->device->
2442                                                              channel] = 0;
2443
2444                if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2445                    (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2446                       (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2447                        printk("%s: ihdlr, target %d.%d:%d, "
2448                               "target_status 0x%x, sense key 0x%x.\n",
2449                               ha->board_name,
2450                               SCpnt->device->channel, SCpnt->device->id,
2451                               (u8)SCpnt->device->lun,
2452                               spp->target_status, SCpnt->sense_buffer[2]);
2453
2454                ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
2455
2456                if (ha->last_retried_pid == SCpnt->serial_number)
2457                        ha->retries = 0;
2458
2459                break;
2460        case ASST:              /* Selection Time Out */
2461        case 0x02:              /* Command Time Out   */
2462
2463                if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
2464                        status = DID_ERROR << 16;
2465                else {
2466                        status = DID_TIME_OUT << 16;
2467                        ha->target_to[SCpnt->device->id][SCpnt->device->
2468                                                            channel]++;
2469                }
2470
2471                break;
2472
2473                /* Perform a limited number of internal retries */
2474        case 0x03:              /* SCSI Bus Reset Received */
2475        case 0x04:              /* Initial Controller Power-up */
2476
2477                for (c = 0; c <= shost->max_channel; c++)
2478                        for (k = 0; k < shost->max_id; k++)
2479                                ha->target_redo[k][c] = 1;
2480
2481                if (SCpnt->device->type != TYPE_TAPE
2482                    && ha->retries < MAX_INTERNAL_RETRIES) {
2483
2484#if defined(DID_SOFT_ERROR)
2485                        status = DID_SOFT_ERROR << 16;
2486#else
2487                        status = DID_BUS_BUSY << 16;
2488#endif
2489
2490                        ha->retries++;
2491                        ha->last_retried_pid = SCpnt->serial_number;
2492                } else
2493                        status = DID_ERROR << 16;
2494
2495                break;
2496        case 0x05:              /* Unexpected Bus Phase */
2497        case 0x06:              /* Unexpected Bus Free */
2498        case 0x07:              /* Bus Parity Error */
2499        case 0x08:              /* SCSI Hung */
2500        case 0x09:              /* Unexpected Message Reject */
2501        case 0x0a:              /* SCSI Bus Reset Stuck */
2502        case 0x0b:              /* Auto Request-Sense Failed */
2503        case 0x0c:              /* Controller Ram Parity Error */
2504        default:
2505                status = DID_ERROR << 16;
2506                break;
2507        }
2508
2509        SCpnt->result = status | spp->target_status;
2510
2511#if defined(DEBUG_INTERRUPT)
2512        if (SCpnt->result || do_trace)
2513#else
2514        if ((spp->adapter_status != ASOK && ha->iocount > 1000) ||
2515            (spp->adapter_status != ASOK &&
2516             spp->adapter_status != ASST && ha->iocount <= 1000) ||
2517            do_trace || msg_byte(spp->target_status))
2518#endif
2519                scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"
2520                       " reg 0x%x, count %d.\n",
2521                       i, spp->adapter_status, spp->target_status,
2522                       reg, ha->iocount);
2523
2524        unmap_dma(i, ha);
2525
2526        /* Set the command state to inactive */
2527        SCpnt->host_scribble = NULL;
2528
2529        SCpnt->scsi_done(SCpnt);
2530
2531        if (do_trace)
2532                printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name,
2533                                irq, ha->iocount);
2534
2535      handled:
2536        return IRQ_HANDLED;
2537      none:
2538        return IRQ_NONE;
2539}
2540
2541static irqreturn_t do_interrupt_handler(int dummy, void *shap)
2542{
2543        struct Scsi_Host *shost;
2544        unsigned int j;
2545        unsigned long spin_flags;
2546        irqreturn_t ret;
2547
2548        /* Check if the interrupt must be processed by this handler */
2549        if ((j = (unsigned int)((char *)shap - sha)) >= num_boards)
2550                return IRQ_NONE;
2551        shost = sh[j];
2552
2553        spin_lock_irqsave(shost->host_lock, spin_flags);
2554        ret = ihdlr(shost);
2555        spin_unlock_irqrestore(shost->host_lock, spin_flags);
2556        return ret;
2557}
2558
2559static int eata2x_release(struct Scsi_Host *shost)
2560{
2561        struct hostdata *ha = (struct hostdata *)shost->hostdata;
2562        unsigned int i;
2563
2564        for (i = 0; i < shost->can_queue; i++)
2565                kfree((&ha->cp[i])->sglist);
2566
2567        for (i = 0; i < shost->can_queue; i++)
2568                pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr,
2569                                 sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
2570
2571        if (ha->sp_cpu_addr)
2572                pci_free_consistent(ha->pdev, sizeof(struct mssp),
2573                                    ha->sp_cpu_addr, ha->sp_dma_addr);
2574
2575        free_irq(shost->irq, &sha[ha->board_number]);
2576
2577        if (shost->dma_channel != NO_DMA)
2578                free_dma(shost->dma_channel);
2579
2580        release_region(shost->io_port, shost->n_io_port);
2581        scsi_unregister(shost);
2582        return 0;
2583}
2584
2585#include "scsi_module.c"
2586
2587#ifndef MODULE
2588__setup("eata=", option_setup);
2589#endif                          /* end MODULE */
2590