drivers/scsi/eata.c

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