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