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 corrisponding
  67  *          bus is configured and to skip probing otherwise.
  68  *
  69  *        + If pci_probe is in effect and a list of I/O  ports is specified
  70  *          as parameter or boot option, pci_enable_device() is performed
  71  *          on all pci devices matching PCI_CLASS_STORAGE_SCSI.
  72  *
  73  *      21 Feb 2002 Rev. 6.52 for linux 2.4.18
  74  *        + Backport from rev. 7.22 (use io_request_lock).
  75  *
  76  *      20 Feb 2002 Rev. 7.22 for linux 2.5.5
  77  *        + Remove any reference to virt_to_bus().
  78  *        + Fix pio hang while detecting multiple HBAs.
  79  *        + Fixed a board detection bug: in a system with
  80  *          multiple ISA/EISA boards, all but the first one
  81  *          were erroneously detected as PCI.
  82  *
  83  *      01 Jan 2002 Rev. 7.20 for linux 2.5.1
  84  *        + Use the dynamic DMA mapping API.
  85  *
  86  *      19 Dec 2001 Rev. 7.02 for linux 2.5.1
  87  *        + Use SCpnt->sc_data_direction if set.
  88  *        + Use sglist.page instead of sglist.address.
  89  *
  90  *      11 Dec 2001 Rev. 7.00 for linux 2.5.1
  91  *        + Use host->host_lock instead of io_request_lock.
  92  *
  93  *       1 May 2001 Rev. 6.05 for linux 2.4.4
  94  *        + Clean up all pci related routines.
  95  *        + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d)
  96  *
  97  *      30 Jan 2001 Rev. 6.04 for linux 2.4.1
  98  *        + Call pci_resource_start after pci_enable_device.
  99  *
 100  *      25 Jan 2001 Rev. 6.03 for linux 2.4.0
 101  *        + "check_region" call replaced by "request_region".
 102  *
 103  *      22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11
 104  *        + Return code checked when calling pci_enable_device.
 105  *        + Removed old scsi error handling support.
 106  *        + The obsolete boot option flag eh:n is silently ignored.
 107  *        + Removed error messages while a disk drive is powered up at
 108  *          boot time.
 109  *        + Improved boot messages: all tagged capable device are
 110  *          indicated as "tagged" or "soft-tagged" :
 111  *          - "soft-tagged"  means that the driver is trying to do its
 112  *            own tagging (i.e. the tc:y option is in effect);
 113  *          - "tagged" means that the device supports tagged commands,
 114  *            but the driver lets the HBA be responsible for tagging
 115  *            support.
 116  *
 117  *      16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18
 118  *        + Updated to the new __setup interface for boot command line options.
 119  *        + When loaded as a module, accepts the new parameter boot_options
 120  *          which value is a string with the same format of the kernel boot
 121  *          command line options. A valid example is:
 122  *          modprobe eata 'boot_options="0x7410,0x230,lc:y,tc:n,mq:4"'
 123  *
 124  *       9 Sep 1999 Rev. 5.10 for linux 2.2.12 and 2.3.17
 125  *        + 64bit cleanup for Linux/Alpha platform support
 126  *          (contribution from H.J. Lu).
 127  *
 128  *      22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11
 129  *        + Removed pre-2.2 source code compatibility.
 130  *        + Added call to pci_set_master.
 131  *
 132  *      26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111
 133  *        + Added command line option (rs:[y|n]) to reverse the scan order
 134  *          of PCI boards. The default is rs:y, which reverses the BIOS order
 135  *          while registering PCI boards. The default value rs:y generates
 136  *          the same order of all previous revisions of this driver.
 137  *          Pls. note that "BIOS order" might have been reversed itself
 138  *          after the 2.1.9x PCI modifications in the linux kernel.
 139  *          The rs value is ignored when the explicit list of addresses
 140  *          is used by the "eata=port0,port1,..." command line option.
 141  *        + Added command line option (et:[y|n]) to force use of extended
 142  *          translation (255 heads, 63 sectors) as disk geometry.
 143  *          The default is et:n, which uses the disk geometry returned
 144  *          by scsicam_bios_param. The default value et:n is compatible with
 145  *          all previous revisions of this driver.
 146  *
 147  *      28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104
 148  *          Increased busy timeout from 10 msec. to 200 msec. while
 149  *          processing interrupts.
 150  *
 151  *      16 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102
 152  *          Improved abort handling during the eh recovery process.
 153  *
 154  *      13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101
 155  *          The driver is now fully SMP safe, including the
 156  *          abort and reset routines.
 157  *          Added command line options (eh:[y|n]) to choose between
 158  *          new_eh_code and the old scsi code.
 159  *          If linux version >= 2.1.101 the default is eh:y, while the eh
 160  *          option is ignored for previous releases and the old scsi code
 161  *          is used.
 162  *
 163  *      18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97
 164  *          Reworked interrupt handler.
 165  *
 166  *      11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95
 167  *          Major reliability improvement: when a batch with overlapping
 168  *          requests is detected, requests are queued one at a time
 169  *          eliminating any possible board or drive reordering.
 170  *
 171  *      10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95
 172  *          Improved SMP support (if linux version >= 2.1.95).
 173  *
 174  *       9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94
 175  *          Added support for new PCI code and IO-APIC remapping of irqs.
 176  *          Performance improvement: when sequential i/o is detected,
 177  *          always use direct sort instead of reverse sort.
 178  *
 179  *       4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92
 180  *          io_port is now unsigned long.
 181  *
 182  *      17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88
 183  *          Use new scsi error handling code (if linux version >= 2.1.88).
 184  *          Use new interrupt code.
 185  *
 186  *      12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55
 187  *          Use of udelay inside the wait loops to avoid timeout
 188  *          problems with fast cpus.
 189  *          Removed check about useless calls to the interrupt service
 190  *          routine (reported on SMP systems only).
 191  *          At initialization time "sorted/unsorted" is displayed instead
 192  *          of "linked/unlinked" to reinforce the fact that "linking" is
 193  *          nothing but "elevator sorting" in the actual implementation.
 194  *
 195  *      17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38
 196  *          Use of serial_number_at_timeout in abort and reset processing.
 197  *          Use of the __initfunc and __initdata macro in setup code.
 198  *          Minor cleanups in the list_statistics code.
 199  *          Increased controller busy timeout in order to better support
 200  *          slow SCSI devices.
 201  *
 202  *      24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26
 203  *          When loading as a module, parameter passing is now supported
 204  *          both in 2.0 and in 2.1 style.
 205  *          Fixed data transfer direction for some SCSI opcodes.
 206  *          Immediate acknowledge to request sense commands.
 207  *          Linked commands to each disk device are now reordered by elevator
 208  *          sorting. Rare cases in which reordering of write requests could
 209  *          cause wrong results are managed.
 210  *          Fixed spurious timeouts caused by long simple queue tag sequences.
 211  *          New command line option (tm:[0-3]) to choose the type of tags:
 212  *          0 -> mixed (default); 1 -> simple; 2 -> head; 3 -> ordered.
 213  *
 214  *      18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28
 215  *          Added command line options to enable/disable linked commands
 216  *          (lc:[y|n]), tagged commands (tc:[y|n]) and to set the max queue
 217  *          depth (mq:xx). Default is "eata=lc:n,tc:n,mq:16".
 218  *          Improved command linking.
 219  *          Documented how to setup RAID-0 with DPT SmartRAID boards.
 220  *
 221  *       8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27
 222  *          Added linked command support.
 223  *          Improved detection of PCI boards using ISA base addresses.
 224  *
 225  *       3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27
 226  *          Added support for tagged commands and queue depth adjustment.
 227  *
 228  *      22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26
 229  *          When CONFIG_PCI is defined, BIOS32 is used to include in the
 230  *          list of i/o ports to be probed all the PCI SCSI controllers.
 231  *          The list of i/o ports to be probed can be overwritten by the
 232  *          "eata=port0,port1,...." boot command line option.
 233  *          Scatter/gather lists are now allocated by a number of kmalloc
 234  *          calls, in order to avoid the previous size limit of 64Kb.
 235  *
 236  *      16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25
 237  *          Added support for EATA 2.0C, PCI, multichannel and wide SCSI.
 238  *
 239  *      27 Sep 1996 rev. 2.12 for linux 2.1.0
 240  *          Portability cleanups (virtual/bus addressing, little/big endian
 241  *          support).
 242  *
 243  *      09 Jul 1996 rev. 2.11 for linux 2.0.4
 244  *          Number of internal retries is now limited.
 245  *
 246  *      16 Apr 1996 rev. 2.10 for linux 1.3.90
 247  *          New argument "reset_flags" to the reset routine.
 248  *
 249  *       6 Jul 1995 rev. 2.01 for linux 1.3.7
 250  *          Update required by the new /proc/scsi support.
 251  *
 252  *      11 Mar 1995 rev. 2.00 for linux 1.2.0
 253  *          Fixed a bug which prevented media change detection for removable
 254  *          disk drives.
 255  *
 256  *      23 Feb 1995 rev. 1.18 for linux 1.1.94
 257  *          Added a check for scsi_register returning NULL.
 258  *
 259  *      11 Feb 1995 rev. 1.17 for linux 1.1.91
 260  *          Now DEBUG_RESET is disabled by default.
 261  *          Register a board even if it does not assert DMA protocol support
 262  *          (DPT SK2011B does not report correctly the dmasup bit).
 263  *
 264  *       9 Feb 1995 rev. 1.16 for linux 1.1.90
 265  *          Use host->wish_block instead of host->block.
 266  *          New list of Data Out SCSI commands.
 267  *
 268  *       8 Feb 1995 rev. 1.15 for linux 1.1.89
 269  *          Cleared target_time_out counter while performing a reset.
 270  *          All external symbols renamed to avoid possible name conflicts.
 271  *
 272  *      28 Jan 1995 rev. 1.14 for linux 1.1.86
 273  *          Added module support.
 274  *          Log and do a retry when a disk drive returns a target status
 275  *          different from zero on a recovered error.
 276  *
 277  *      24 Jan 1995 rev. 1.13 for linux 1.1.85
 278  *          Use optimized board configuration, with a measured performance
 279  *          increase in the range 10%-20% on i/o throughput.
 280  *
 281  *      16 Jan 1995 rev. 1.12 for linux 1.1.81
 282  *          Fix mscp structure comments (no functional change).
 283  *          Display a message if check_region detects a port address
 284  *          already in use.
 285  *
 286  *      17 Dec 1994 rev. 1.11 for linux 1.1.74
 287  *          Use the scsicam_bios_param routine. This allows an easy
 288  *          migration path from disk partition tables created using
 289  *          different SCSI drivers and non optimal disk geometry.
 290  *
 291  *      15 Dec 1994 rev. 1.10 for linux 1.1.74
 292  *          Added support for ISA EATA boards (DPT PM2011, DPT PM2021).
 293  *          The host->block flag is set for all the detected ISA boards.
 294  *          The detect routine no longer enforces LEVEL triggering
 295  *          for EISA boards, it just prints a warning message.
 296  *
 297  *      30 Nov 1994 rev. 1.09 for linux 1.1.68
 298  *          Redo i/o on target status CHECK_CONDITION for TYPE_DISK only.
 299  *          Added optional support for using a single board at a time.
 300  *
 301  *      18 Nov 1994 rev. 1.08 for linux 1.1.64
 302  *          Forces sg_tablesize = 64 and can_queue = 64 if these
 303  *          values are not correctly detected (DPT PM2012).
 304  *
 305  *      14 Nov 1994 rev. 1.07 for linux 1.1.63  Final BETA release.
 306  *      04 Aug 1994 rev. 1.00 for linux 1.1.39  First BETA release.
 307  *
 308  *
 309  *          This driver is based on the CAM (Common Access Method Committee)
 310  *          EATA (Enhanced AT Bus Attachment) rev. 2.0A, using DMA protocol.
 311  *
 312  *  Copyright (C) 1994-2003 Dario Ballabio (ballabio_dario@emc.com)
 313  *
 314  *  Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it
 315  *
 316  *  Redistribution and use in source and binary forms, with or without
 317  *  modification, are permitted provided that redistributions of source
 318  *  code retain the above copyright notice and this comment without
 319  *  modification.
 320  *
 321  */
 322
 323 /*
 324  *
 325  *  Here is a brief description of the DPT SCSI host adapters.
 326  *  All these boards provide an EATA/DMA compatible programming interface
 327  *  and are fully supported by this driver in any configuration, including
 328  *  multiple SCSI channels:
 329  *
 330  *  PM2011B/9X -  Entry Level ISA
 331  *  PM2021A/9X -  High Performance ISA
 332  *  PM2012A       Old EISA
 333  *  PM2012B       Old EISA
 334  *  PM2022A/9X -  Entry Level EISA
 335  *  PM2122A/9X -  High Performance EISA
 336  *  PM2322A/9X -  Extra High Performance EISA
 337  *  PM3021     -  SmartRAID Adapter for ISA
 338  *  PM3222     -  SmartRAID Adapter for EISA (PM3222W is 16-bit wide SCSI)
 339  *  PM3224     -  SmartRAID Adapter for PCI  (PM3224W is 16-bit wide SCSI)
 340  *  PM33340UW  -  SmartRAID Adapter for PCI  ultra wide multichannel
 341  *
 342  *  The above list is just an indication: as a matter of fact all DPT
 343  *  boards using the EATA/DMA protocol are supported by this driver,
 344  *  since they use exactely the same programming interface.
 345  *
 346  *  The DPT PM2001 provides only the EATA/PIO interface and hence is not
 347  *  supported by this driver.
 348  *
 349  *  This code has been tested with up to 3 Distributed Processing Technology
 350  *  PM2122A/9X (DPT SCSI BIOS v002.D1, firmware v05E.0) EISA controllers,
 351  *  in any combination of private and shared IRQ.
 352  *  PCI support has been tested using up to 2 DPT PM3224W (DPT SCSI BIOS
 353  *  v003.D0, firmware v07G.0).
 354  *
 355  *  DPT SmartRAID boards support "Hardware Array" - a group of disk drives
 356  *  which are all members of the same RAID-0, RAID-1 or RAID-5 array implemented
 357  *  in host adapter hardware. Hardware Arrays are fully compatible with this
 358  *  driver, since they look to it as a single disk drive.
 359  *
 360  *  WARNING: to create a RAID-0 "Hardware Array" you must select "Other Unix"
 361  *  as the current OS in the DPTMGR "Initial System Installation" menu.
 362  *  Otherwise RAID-0 is generated as an "Array Group" (i.e. software RAID-0),
 363  *  which is not supported by the actual SCSI subsystem.
 364  *  To get the "Array Group" functionality, the Linux MD driver must be used
 365  *  instead of the DPT "Array Group" feature.
 366  *
 367  *  Multiple ISA, EISA and PCI boards can be configured in the same system.
 368  *  It is suggested to put all the EISA boards on the same IRQ level, all
 369  *  the PCI  boards on another IRQ level, while ISA boards cannot share
 370  *  interrupts.
 371  *
 372  *  If you configure multiple boards on the same IRQ, the interrupt must
 373  *  be _level_ triggered (not _edge_ triggered).
 374  *
 375  *  This driver detects EATA boards by probes at fixed port addresses,
 376  *  so no BIOS32 or PCI BIOS support is required.
 377  *  The suggested way to detect a generic EATA PCI board is to force on it
 378  *  any unused EISA address, even if there are other controllers on the EISA
 379  *  bus, or even if you system has no EISA bus at all.
 380  *  Do not force any ISA address on EATA PCI boards.
 381  *
 382  *  If PCI bios support is configured into the kernel, BIOS32 is used to
 383  *  include in the list of i/o ports to be probed all the PCI SCSI controllers.
 384  *
 385  *  Due to a DPT BIOS "feature", it might not be possible to force an EISA
 386  *  address on more than a single DPT PCI board, so in this case you have to
 387  *  let the PCI BIOS assign the addresses.
 388  *
 389  *  The sequence of detection probes is:
 390  *
 391  *  - ISA 0x1F0;
 392  *  - PCI SCSI controllers (only if BIOS32 is available);
 393  *  - EISA/PCI 0x1C88 through 0xFC88 (corresponding to EISA slots 1 to 15);
 394  *  - ISA  0x170, 0x230, 0x330.
 395  *
 396  *  The above list of detection probes can be totally replaced by the
 397  *  boot command line option: "eata=port0,port1,port2,...", where the
 398  *  port0, port1... arguments are ISA/EISA/PCI addresses to be probed.
 399  *  For example using "eata=0x7410,0x7450,0x230", the driver probes
 400  *  only the two PCI addresses 0x7410 and 0x7450 and the ISA address 0x230,
 401  *  in this order; "eata=0" totally disables this driver.
 402  *
 403  *  After the optional list of detection probes, other possible command line
 404  *  options are:
 405  *
 406  *  et:y  force use of extended translation (255 heads, 63 sectors);
 407  *  et:n  use disk geometry detected by scsicam_bios_param;
 408  *  rs:y  reverse scan order while detecting PCI boards;
 409  *  rs:n  use BIOS order while detecting PCI boards;
 410  *  lc:y  enables linked commands;
 411  *  lc:n  disables linked commands;
 412  *  tm:0  disables tagged commands (same as tc:n);
 413  *  tm:1  use simple queue tags (same as tc:y);
 414  *  tm:2  use ordered queue tags (same as tc:2);
 415  *  mq:xx set the max queue depth to the value xx (2 <= xx <= 32).
 416  *
 417  *  The default value is: "eata=lc:n,mq:16,tm:0,et:n,rs:n".
 418  *  An example using the list of detection probes could be:
 419  *  "eata=0x7410,0x230,lc:y,tm:2,mq:4,et:n".
 420  *
 421  *  When loading as a module, parameters can be specified as well.
 422  *  The above example would be (use 1 in place of y and 0 in place of n):
 423  *
 424  *  modprobe eata io_port=0x7410,0x230 linked_comm=1 \
 425  *                max_queue_depth=4 ext_tran=0 tag_mode=2 \
 426  *                rev_scan=1
 427  *
 428  *  ----------------------------------------------------------------------------
 429  *  In this implementation, linked commands are designed to work with any DISK
 430  *  or CD-ROM, since this linking has only the intent of clustering (time-wise)
 431  *  and reordering by elevator sorting commands directed to each device,
 432  *  without any relation with the actual SCSI protocol between the controller
 433  *  and the device.
 434  *  If Q is the queue depth reported at boot time for each device (also named
 435  *  cmds/lun) and Q > 2, whenever there is already an active command to the
 436  *  device all other commands to the same device  (up to Q-1) are kept waiting
 437  *  in the elevator sorting queue. When the active command completes, the
 438  *  commands in this queue are sorted by sector address. The sort is chosen
 439  *  between increasing or decreasing by minimizing the seek distance between
 440  *  the sector of the commands just completed and the sector of the first
 441  *  command in the list to be sorted.
 442  *  Trivial math assures that the unsorted average seek distance when doing
 443  *  random seeks over S sectors is S/3.
 444  *  When (Q-1) requests are uniformly distributed over S sectors, the average
 445  *  distance between two adjacent requests is S/((Q-1) + 1), so the sorted
 446  *  average seek distance for (Q-1) random requests over S sectors is S/Q.
 447  *  The elevator sorting hence divides the seek distance by a factor Q/3.
 448  *  The above pure geometric remarks are valid in all cases and the
 449  *  driver effectively reduces the seek distance by the predicted factor
 450  *  when there are Q concurrent read i/o operations on the device, but this
 451  *  does not necessarily results in a noticeable performance improvement:
 452  *  your mileage may vary....
 453  *
 454  *  Note: command reordering inside a batch of queued commands could cause
 455  *        wrong results only if there is at least one write request and the
 456  *        intersection (sector-wise) of all requests is not empty.
 457  *        When the driver detects a batch including overlapping requests
 458  *        (a really rare event) strict serial (pid) order is enforced.
 459  *  ----------------------------------------------------------------------------
 460  *  The extended translation option (et:y) is useful when using large physical
 461  *  disks/arrays. It could also be useful when switching between Adaptec boards
 462  *  and DPT boards without reformatting the disk.
 463  *  When a boot disk is partitioned with extended translation, in order to
 464  *  be able to boot it with a DPT board is could be necessary to add to
 465  *  lilo.conf additional commands as in the following example:
 466  *
 467  *  fix-table
 468  *  disk=/dev/sda bios=0x80 sectors=63 heads=128 cylindres=546
 469  *
 470  *  where the above geometry should be replaced with the one reported at
 471  *  power up by the DPT controller.
 472  *  ----------------------------------------------------------------------------
 473  *
 474  *  The boards are named EATA0, EATA1,... according to the detection order.
 475  *
 476  *  In order to support multiple ISA boards in a reliable way,
 477  *  the driver sets host->wish_block = 1 for all ISA boards.
 478  */
 479
 480 #include <linux/config.h>
 481 #include <linux/string.h>
 482 #include <linux/kernel.h>
 483 #include <linux/ioport.h>
 484 #include <linux/delay.h>
 485 #include <linux/proc_fs.h>
 486 #include <linux/blkdev.h>
 487 #include <linux/interrupt.h>
 488 #include <linux/stat.h>
 489 #include <linux/pci.h>
 490 #include <linux/init.h>
 491 #include <linux/ctype.h>
 492 #include <linux/spinlock.h>
 493 #include <asm/byteorder.h>
 494 #include <asm/dma.h>
 495 #include <asm/io.h>
 496 #include <asm/irq.h>
 497
 498 #include <scsi/scsi.h>
 499 #include <scsi/scsi_cmnd.h>
 500 #include <scsi/scsi_device.h>
 501 #include <scsi/scsi_host.h>
 502 #include <scsi/scsi_tcq.h>
 503 #include <scsi/scsicam.h>
 504
 505 static int eata2x_detect(struct scsi_host_template *);
 506 static int eata2x_release(struct Scsi_Host *);
 507 static int eata2x_queuecommand(struct scsi_cmnd *,
 508                                void (*done) (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 static DEFINE_SPINLOCK(driver_lock);
 841
 842 /* Initialize num_boards so that ihdlr can work while detect is in progress */
 843 static unsigned int num_boards = MAX_BOARDS;
 844
 845 static unsigned long io_port[] = {
 846
 847         /* Space for MAX_INT_PARAM ports usable while loading as a module */
 848         SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
 849         SKIP, SKIP,
 850
 851         /* First ISA */
 852         0x1f0,
 853
 854         /* Space for MAX_PCI ports possibly reported by PCI_BIOS */
 855         SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
 856         SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,
 857
 858         /* MAX_EISA ports */
 859         0x1c88, 0x2c88, 0x3c88, 0x4c88, 0x5c88, 0x6c88, 0x7c88, 0x8c88,
 860         0x9c88, 0xac88, 0xbc88, 0xcc88, 0xdc88, 0xec88, 0xfc88,
 861
 862         /* Other (MAX_ISA - 1) ports */
 863         0x170, 0x230, 0x330,
 864
 865         /* End of list */
 866         0x0
 867 };
 868
 869 /* Device is Big Endian */
 870 #define H2DEV(x)   cpu_to_be32(x)
 871 #define DEV2H(x)   be32_to_cpu(x)
 872 #define H2DEV16(x) cpu_to_be16(x)
 873 #define DEV2H16(x) be16_to_cpu(x)
 874
 875 /* But transfer orientation from the 16 bit data register is Little Endian */
 876 #define REG2H(x)   le16_to_cpu(x)
 877
 878 static irqreturn_t do_interrupt_handler(int, void *, struct pt_regs *);
 879 static void flush_dev(struct scsi_device *, unsigned long, struct hostdata *,
 880                       unsigned int);
 881 static int do_trace = 0;
 882 static int setup_done = 0;
 883 static int link_statistics;
 884 static int ext_tran = 0;
 885 static int rev_scan = 1;
 886
 887 #if defined(CONFIG_SCSI_EATA_TAGGED_QUEUE)
 888 static int tag_mode = TAG_SIMPLE;
 889 #else
 890 static int tag_mode = TAG_DISABLED;
 891 #endif
 892
 893 #if defined(CONFIG_SCSI_EATA_LINKED_COMMANDS)
 894 static int linked_comm = 1;
 895 #else
 896 static int linked_comm = 0;
 897 #endif
 898
 899 #if defined(CONFIG_SCSI_EATA_MAX_TAGS)
 900 static int max_queue_depth = CONFIG_SCSI_EATA_MAX_TAGS;
 901 #else
 902 static int max_queue_depth = MAX_CMD_PER_LUN;
 903 #endif
 904
 905 #if defined(CONFIG_ISA)
 906 static int isa_probe = 1;
 907 #else
 908 static int isa_probe = 0;
 909 #endif
 910
 911 #if defined(CONFIG_EISA)
 912 static int eisa_probe = 1;
 913 #else
 914 static int eisa_probe = 0;
 915 #endif
 916
 917 #if defined(CONFIG_PCI)
 918 static int pci_probe = 1;
 919 #else
 920 static int pci_probe = 0;
 921 #endif
 922
 923 #define MAX_INT_PARAM 10
 924 #define MAX_BOOT_OPTIONS_SIZE 256
 925 static char boot_options[MAX_BOOT_OPTIONS_SIZE];
 926
 927 #if defined(MODULE)
 928 #include <linux/module.h>
 929 #include <linux/moduleparam.h>
 930
 931 module_param_string(eata, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
 932 MODULE_PARM_DESC(eata, " equivalent to the \"eata=...\" kernel boot option."
 933                  "            Example: modprobe eata \"eata=0x7410,0x230,lc:y,tm:0,mq:4,ep:n\"");
 934 MODULE_AUTHOR("Dario Ballabio");
 935 MODULE_LICENSE("GPL");
 936 MODULE_DESCRIPTION("EATA/DMA SCSI Driver");
 937
 938 #endif
 939
 940 static int eata2x_slave_configure(struct scsi_device *dev)
 941 {
 942         int tqd, utqd;
 943         char *tag_suffix, *link_suffix;
 944         struct Scsi_Host *shost = dev->host;
 945         struct hostdata *ha = (struct hostdata *)shost->hostdata;
 946
 947         utqd = MAX_CMD_PER_LUN;
 948         tqd = max_queue_depth;
 949
 950         if (TLDEV(dev->type) && dev->tagged_supported) {
 951                 if (tag_mode == TAG_SIMPLE) {
 952                         scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
 953                         tag_suffix = ", simple tags";
 954                 } else if (tag_mode == TAG_ORDERED) {
 955                         scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
 956                         tag_suffix = ", ordered tags";
 957                 } else {
 958                         scsi_adjust_queue_depth(dev, 0, tqd);
 959                         tag_suffix = ", no tags";
 960                 }
 961         } else if (TLDEV(dev->type) && linked_comm) {
 962                 scsi_adjust_queue_depth(dev, 0, tqd);
 963                 tag_suffix = ", untagged";
 964         } else {
 965                 scsi_adjust_queue_depth(dev, 0, utqd);
 966                 tag_suffix = "";
 967         }
 968
 969         if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
 970                 link_suffix = ", sorted";
 971         else if (TLDEV(dev->type))
 972                 link_suffix = ", unsorted";
 973         else
 974                 link_suffix = "";
 975
 976         printk("%s: scsi%d, channel %d, id %d, lun %d, cmds/lun %d%s%s.\n",
 977                ha->board_name, shost->host_no, dev->channel, dev->id, dev->lun,
 978                dev->queue_depth, link_suffix, tag_suffix);
 979
 980         return 0;
 981 }
 982
 983 static int wait_on_busy(unsigned long iobase, unsigned int loop)
 984 {
 985         while (inb(iobase + REG_AUX_STATUS) & ABSY_ASSERTED) {
 986                 udelay(1L);
 987                 if (--loop == 0)
 988                         return 1;
 989         }
 990         return 0;
 991 }
 992
 993 static int do_dma(unsigned long iobase, unsigned long addr, unchar cmd)
 994 {
 995         unsigned char *byaddr;
 996         unsigned long devaddr;
 997
 998         if (wait_on_busy(iobase, (addr ? MAXLOOP * 100 : MAXLOOP)))
 999                 return 1;
1000
1001         if (addr) {
1002                 devaddr = H2DEV(addr);
1003                 byaddr = (unsigned char *)&devaddr;
1004                 outb(byaddr[3], iobase + REG_LOW);
1005                 outb(byaddr[2], iobase + REG_LM);
1006                 outb(byaddr[1], iobase + REG_MID);
1007                 outb(byaddr[0], iobase + REG_MSB);
1008         }
1009
1010         outb(cmd, iobase + REG_CMD);
1011         return 0;
1012 }
1013
1014 static int read_pio(unsigned long iobase, ushort * start, ushort * end)
1015 {
1016         unsigned int loop = MAXLOOP;
1017         ushort *p;
1018
1019         for (p = start; p <= end; p++) {
1020                 while (!(inb(iobase + REG_STATUS) & DRQ_ASSERTED)) {
1021                         udelay(1L);
1022                         if (--loop == 0)
1023                                 return 1;
1024                 }
1025                 loop = MAXLOOP;
1026                 *p = REG2H(inw(iobase));
1027         }
1028
1029         return 0;
1030 }
1031
1032 static struct pci_dev *get_pci_dev(unsigned long port_base)
1033 {
1034 #if defined(CONFIG_PCI)
1035         unsigned int addr;
1036         struct pci_dev *dev = NULL;
1037
1038         while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1039                 addr = pci_resource_start(dev, 0);
1040
1041 #if defined(DEBUG_PCI_DETECT)
1042                 printk("%s: get_pci_dev, bus %d, devfn 0x%x, addr 0x%x.\n",
1043                        driver_name, dev->bus->number, dev->devfn, addr);
1044 #endif
1045
1046                 /* we are in so much trouble for a pci hotplug system with this driver
1047                  * anyway, so doing this at least lets people unload the driver and not
1048                  * cause memory problems, but in general this is a bad thing to do (this
1049                  * driver needs to be converted to the proper PCI api someday... */
1050                 pci_dev_put(dev);
1051                 if (addr + PCI_BASE_ADDRESS_0 == port_base)
1052                         return dev;
1053         }
1054 #endif                          /* end CONFIG_PCI */
1055         return NULL;
1056 }
1057
1058 static void enable_pci_ports(void)
1059 {
1060 #if defined(CONFIG_PCI)
1061         struct pci_dev *dev = NULL;
1062
1063         while ((dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev))) {
1064 #if defined(DEBUG_PCI_DETECT)
1065                 printk("%s: enable_pci_ports, bus %d, devfn 0x%x.\n",
1066                        driver_name, dev->bus->number, dev->devfn);
1067 #endif
1068
1069                 if (pci_enable_device(dev))
1070                         printk
1071                             ("%s: warning, pci_enable_device failed, bus %d devfn 0x%x.\n",
1072                              driver_name, dev->bus->number, dev->devfn);
1073         }
1074
1075 #endif                          /* end CONFIG_PCI */
1076 }
1077
1078 static int port_detect(unsigned long port_base, unsigned int j,
1079                 struct scsi_host_template *tpnt)
1080 {
1081         unsigned char irq, dma_channel, subversion, i, is_pci = 0;
1082         unsigned char protocol_rev;
1083         struct eata_info info;
1084         char *bus_type, dma_name[16];
1085         struct pci_dev *pdev;
1086         /* Allowed DMA channels for ISA (0 indicates reserved) */
1087         unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
1088         struct Scsi_Host *shost;
1089         struct hostdata *ha;
1090         char name[16];
1091
1092         sprintf(name, "%s%d", driver_name, j);
1093
1094         if (!request_region(port_base, REGION_SIZE, driver_name)) {
1095 #if defined(DEBUG_DETECT)
1096                 printk("%s: address 0x%03lx in use, skipping probe.\n", name,
1097                        port_base);
1098 #endif
1099                 goto fail;
1100         }
1101
1102         spin_lock_irq(&driver_lock);
1103
1104         if (do_dma(port_base, 0, READ_CONFIG_PIO)) {
1105 #if defined(DEBUG_DETECT)
1106                 printk("%s: detect, do_dma failed at 0x%03lx.\n", name,
1107                        port_base);
1108 #endif
1109                 goto freelock;
1110         }
1111
1112         /* Read the info structure */
1113         if (read_pio(port_base, (ushort *) & info, (ushort *) & info.ipad[0])) {
1114 #if defined(DEBUG_DETECT)
1115                 printk("%s: detect, read_pio failed at 0x%03lx.\n", name,
1116                        port_base);
1117 #endif
1118                 goto freelock;
1119         }
1120
1121         info.data_len = DEV2H(info.data_len);
1122         info.sign = DEV2H(info.sign);
1123         info.cp_pad_len = DEV2H16(info.cp_pad_len);
1124         info.cp_len = DEV2H(info.cp_len);
1125         info.sp_len = DEV2H(info.sp_len);
1126         info.scatt_size = DEV2H16(info.scatt_size);
1127         info.queue_size = DEV2H16(info.queue_size);
1128
1129         /* Check the controller "EATA" signature */
1130         if (info.sign != EATA_SIG_BE) {
1131 #if defined(DEBUG_DETECT)
1132                 printk("%s: signature 0x%04x discarded.\n", name, info.sign);
1133 #endif
1134                 goto freelock;
1135         }
1136
1137         if (info.data_len < EATA_2_0A_SIZE) {
1138                 printk
1139                     ("%s: config structure size (%d bytes) too short, detaching.\n",
1140                      name, info.data_len);
1141                 goto freelock;
1142         } else if (info.data_len == EATA_2_0A_SIZE)
1143                 protocol_rev = 'A';
1144         else if (info.data_len == EATA_2_0B_SIZE)
1145                 protocol_rev = 'B';
1146         else
1147                 protocol_rev = 'C';
1148
1149         if (protocol_rev != 'A' && info.forcaddr) {
1150                 printk("%s: warning, port address has been forced.\n", name);
1151                 bus_type = "PCI";
1152                 is_pci = 1;
1153                 subversion = ESA;
1154         } else if (port_base > MAX_EISA_ADDR
1155                    || (protocol_rev == 'C' && info.pci)) {
1156                 bus_type = "PCI";
1157                 is_pci = 1;
1158                 subversion = ESA;
1159         } else if (port_base >= MIN_EISA_ADDR
1160                    || (protocol_rev == 'C' && info.eisa)) {
1161                 bus_type = "EISA";
1162                 subversion = ESA;
1163         } else if (protocol_rev == 'C' && !info.eisa && !info.pci) {
1164                 bus_type = "ISA";
1165                 subversion = ISA;
1166         } else if (port_base > MAX_ISA_ADDR) {
1167                 bus_type = "PCI";
1168                 is_pci = 1;
1169                 subversion = ESA;
1170         } else {
1171                 bus_type = "ISA";
1172                 subversion = ISA;
1173         }
1174
1175         if (!info.haaval || info.ata) {
1176                 printk
1177                     ("%s: address 0x%03lx, unusable %s board (%d%d), detaching.\n",
1178                      name, port_base, bus_type, info.haaval, info.ata);
1179                 goto freelock;
1180         }
1181
1182         if (info.drqvld) {
1183                 if (subversion == ESA)
1184                         printk("%s: warning, weird %s board using DMA.\n", name,
1185                                bus_type);
1186
1187                 subversion = ISA;
1188                 dma_channel = dma_channel_table[3 - info.drqx];
1189         } else {
1190                 if (subversion == ISA)
1191                         printk("%s: warning, weird %s board not using DMA.\n",
1192                                name, bus_type);
1193
1194                 subversion = ESA;
1195                 dma_channel = NO_DMA;
1196         }
1197
1198         if (!info.dmasup)
1199                 printk("%s: warning, DMA protocol support not asserted.\n",
1200                        name);
1201
1202         irq = info.irq;
1203
1204         if (subversion == ESA && !info.irq_tr)
1205                 printk
1206                     ("%s: warning, LEVEL triggering is suggested for IRQ %u.\n",
1207                      name, irq);
1208
1209         if (is_pci) {
1210                 pdev = get_pci_dev(port_base);
1211                 if (!pdev)
1212                         printk
1213                             ("%s: warning, failed to get pci_dev structure.\n",
1214                              name);
1215         } else
1216                 pdev = NULL;
1217
1218         if (pdev && (irq != pdev->irq)) {
1219                 printk("%s: IRQ %u mapped to IO-APIC IRQ %u.\n", name, irq,
1220                        pdev->irq);
1221                 irq = pdev->irq;
1222         }
1223
1224         /* Board detected, allocate its IRQ */
1225         if (request_irq(irq, do_interrupt_handler,
1226                         SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0),
1227                         driver_name, (void *)&sha[j])) {
1228                 printk("%s: unable to allocate IRQ %u, detaching.\n", name,
1229                        irq);
1230                 goto freelock;
1231         }
1232
1233         if (subversion == ISA && request_dma(dma_channel, driver_name)) {
1234                 printk("%s: unable to allocate DMA channel %u, detaching.\n",
1235                        name, dma_channel);
1236                 goto freeirq;
1237         }
1238 #if defined(FORCE_CONFIG)
1239         {
1240                 struct eata_config *cf;
1241                 dma_addr_t cf_dma_addr;
1242
1243                 cf = pci_alloc_consistent(pdev, sizeof(struct eata_config),
1244                                           &cf_dma_addr);
1245
1246                 if (!cf) {
1247                         printk
1248                             ("%s: config, pci_alloc_consistent failed, detaching.\n",
1249                              name);
1250                         goto freedma;
1251                 }
1252
1253                 /* Set board configuration */
1254                 memset((char *)cf, 0, sizeof(struct eata_config));
1255                 cf->len = (ushort) H2DEV16((ushort) 510);
1256                 cf->ocena = 1;
1257
1258                 if (do_dma(port_base, cf_dma_addr, SET_CONFIG_DMA)) {
1259                         printk
1260                             ("%s: busy timeout sending configuration, detaching.\n",
1261                              name);
1262                         pci_free_consistent(pdev, sizeof(struct eata_config),
1263                                             cf, cf_dma_addr);
1264                         goto freedma;
1265                 }
1266
1267         }
1268 #endif
1269
1270         spin_unlock_irq(&driver_lock);
1271         sh[j] = shost = scsi_register(tpnt, sizeof(struct hostdata));
1272         spin_lock_irq(&driver_lock);
1273
1274         if (shost == NULL) {
1275                 printk("%s: unable to register host, detaching.\n", name);
1276                 goto freedma;
1277         }
1278
1279         shost->io_port = port_base;
1280         shost->unique_id = port_base;
1281         shost->n_io_port = REGION_SIZE;
1282         shost->dma_channel = dma_channel;
1283         shost->irq = irq;
1284         shost->sg_tablesize = (ushort) info.scatt_size;
1285         shost->this_id = (ushort) info.host_addr[3];
1286         shost->can_queue = (ushort) info.queue_size;
1287         shost->cmd_per_lun = MAX_CMD_PER_LUN;
1288
1289         ha = (struct hostdata *)shost->hostdata;
1290
1291         memset(ha, 0, sizeof(struct hostdata));
1292         ha->subversion = subversion;
1293         ha->protocol_rev = protocol_rev;
1294         ha->is_pci = is_pci;
1295         ha->pdev = pdev;
1296         ha->board_number = j;
1297
1298         if (ha->subversion == ESA)
1299                 shost->unchecked_isa_dma = 0;
1300         else {
1301                 unsigned long flags;
1302                 shost->unchecked_isa_dma = 1;
1303
1304                 flags = claim_dma_lock();
1305                 disable_dma(dma_channel);
1306                 clear_dma_ff(dma_channel);
1307                 set_dma_mode(dma_channel, DMA_MODE_CASCADE);
1308                 enable_dma(dma_channel);
1309                 release_dma_lock(flags);
1310
1311         }
1312
1313         strcpy(ha->board_name, name);
1314
1315         /* DPT PM2012 does not allow to detect sg_tablesize correctly */
1316         if (shost->sg_tablesize > MAX_SGLIST || shost->sg_tablesize < 2) {
1317                 printk("%s: detect, wrong n. of SG lists %d, fixed.\n",
1318                        ha->board_name, shost->sg_tablesize);
1319                 shost->sg_tablesize = MAX_SGLIST;
1320         }
1321
1322         /* DPT PM2012 does not allow to detect can_queue correctly */
1323         if (shost->can_queue > MAX_MAILBOXES || shost->can_queue < 2) {
1324                 printk("%s: detect, wrong n. of mbox %d, fixed.\n",
1325                        ha->board_name, shost->can_queue);
1326                 shost->can_queue = MAX_MAILBOXES;
1327         }
1328
1329         if (protocol_rev != 'A') {
1330                 if (info.max_chan > 0 && info.max_chan < MAX_CHANNEL)
1331                         shost->max_channel = info.max_chan;
1332
1333                 if (info.max_id > 7 && info.max_id < MAX_TARGET)
1334                         shost->max_id = info.max_id + 1;
1335
1336                 if (info.large_sg && shost->sg_tablesize == MAX_SGLIST)
1337                         shost->sg_tablesize = MAX_LARGE_SGLIST;
1338         }
1339
1340         if (protocol_rev == 'C') {
1341                 if (info.max_lun > 7 && info.max_lun < MAX_LUN)
1342                         shost->max_lun = info.max_lun + 1;
1343         }
1344
1345         if (dma_channel == NO_DMA)
1346                 sprintf(dma_name, "%s", "BMST");
1347         else
1348                 sprintf(dma_name, "DMA %u", dma_channel);
1349
1350         spin_unlock_irq(&driver_lock);
1351
1352         for (i = 0; i < shost->can_queue; i++)
1353                 ha->cp[i].cp_dma_addr = pci_map_single(ha->pdev,
1354                                                           &ha->cp[i],
1355                                                           sizeof(struct mscp),
1356                                                           PCI_DMA_BIDIRECTIONAL);
1357
1358         for (i = 0; i < shost->can_queue; i++) {
1359                 size_t sz = shost->sg_tablesize *sizeof(struct sg_list);
1360                 unsigned int gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
1361                 ha->cp[i].sglist = kmalloc(sz, gfp_mask);
1362                 if (!ha->cp[i].sglist) {
1363                         printk
1364                             ("%s: kmalloc SGlist failed, mbox %d, detaching.\n",
1365                              ha->board_name, i);
1366                         goto release;
1367                 }
1368         }
1369
1370         if (!(ha->sp_cpu_addr = pci_alloc_consistent(ha->pdev,
1371                                                         sizeof(struct mssp),
1372                                                         &ha->sp_dma_addr))) {
1373                 printk("%s: pci_alloc_consistent failed, detaching.\n", ha->board_name);
1374                 goto release;
1375         }
1376
1377         if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
1378                 max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
1379
1380         if (max_queue_depth < MAX_CMD_PER_LUN)
1381                 max_queue_depth = MAX_CMD_PER_LUN;
1382
1383         if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
1384                 tag_mode = TAG_ORDERED;
1385
1386         if (j == 0) {
1387                 printk
1388                     ("EATA/DMA 2.0x: Copyright (C) 1994-2003 Dario Ballabio.\n");
1389                 printk
1390                     ("%s config options -> tm:%d, lc:%c, mq:%d, rs:%c, et:%c, "
1391                      "ip:%c, ep:%c, pp:%c.\n", driver_name, tag_mode,
1392                      YESNO(linked_comm), max_queue_depth, YESNO(rev_scan),
1393                      YESNO(ext_tran), YESNO(isa_probe), YESNO(eisa_probe),
1394                      YESNO(pci_probe));
1395         }
1396
1397         printk("%s: 2.0%c, %s 0x%03lx, IRQ %u, %s, SG %d, MB %d.\n",
1398                ha->board_name, ha->protocol_rev, bus_type,
1399                (unsigned long)shost->io_port, shost->irq, dma_name,
1400                shost->sg_tablesize, shost->can_queue);
1401
1402         if (shost->max_id > 8 || shost->max_lun > 8)
1403                 printk
1404                     ("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1405                      ha->board_name, shost->max_id, shost->max_lun);
1406
1407         for (i = 0; i <= shost->max_channel; i++)
1408                 printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1409                        ha->board_name, i, info.host_addr[3 - i]);
1410
1411 #if defined(DEBUG_DETECT)
1412         printk("%s: Vers. 0x%x, ocs %u, tar %u, trnxfr %u, more %u, SYNC 0x%x, "
1413                "sec. %u, infol %d, cpl %d spl %d.\n", name, info.version,
1414                info.ocsena, info.tarsup, info.trnxfr, info.morsup, info.sync,
1415                info.second, info.data_len, info.cp_len, info.sp_len);
1416
1417         if (protocol_rev == 'B' || protocol_rev == 'C')
1418                 printk("%s: isaena %u, forcaddr %u, max_id %u, max_chan %u, "
1419                        "large_sg %u, res1 %u.\n", name, info.isaena,
1420                        info.forcaddr, info.max_id, info.max_chan, info.large_sg,
1421                        info.res1);
1422
1423         if (protocol_rev == 'C')
1424                 printk("%s: max_lun %u, m1 %u, idquest %u, pci %u, eisa %u, "
1425                        "raidnum %u.\n", name, info.max_lun, info.m1,
1426                        info.idquest, info.pci, info.eisa, info.raidnum);
1427 #endif
1428
1429         if (ha->pdev) {
1430                 pci_set_master(ha->pdev);
1431                 if (pci_set_dma_mask(ha->pdev, 0xffffffff))
1432                         printk("%s: warning, pci_set_dma_mask failed.\n",
1433                                ha->board_name);
1434         }
1435
1436         return 1;
1437
1438       freedma:
1439         if (subversion == ISA)
1440                 free_dma(dma_channel);
1441       freeirq:
1442         free_irq(irq, &sha[j]);
1443       freelock:
1444         spin_unlock_irq(&driver_lock);
1445         release_region(port_base, REGION_SIZE);
1446       fail:
1447         return 0;
1448
1449       release:
1450         eata2x_release(shost);
1451         return 0;
1452 }
1453
1454 static void internal_setup(char *str, int *ints)
1455 {
1456         int i, argc = ints[0];
1457         char *cur = str, *pc;
1458
1459         if (argc > 0) {
1460                 if (argc > MAX_INT_PARAM)
1461                         argc = MAX_INT_PARAM;
1462
1463                 for (i = 0; i < argc; i++)
1464                         io_port[i] = ints[i + 1];
1465
1466                 io_port[i] = 0;
1467                 setup_done = 1;
1468         }
1469
1470         while (cur && (pc = strchr(cur, ':'))) {
1471                 int val = 0, c = *++pc;
1472
1473                 if (c == 'n' || c == 'N')
1474                         val = 0;
1475                 else if (c == 'y' || c == 'Y')
1476                         val = 1;
1477                 else
1478                         val = (int)simple_strtoul(pc, NULL, 0);
1479
1480                 if (!strncmp(cur, "lc:", 3))
1481                         linked_comm = val;
1482                 else if (!strncmp(cur, "tm:", 3))
1483                         tag_mode = val;
1484                 else if (!strncmp(cur, "tc:", 3))
1485                         tag_mode = val;
1486                 else if (!strncmp(cur, "mq:", 3))
1487                         max_queue_depth = val;
1488                 else if (!strncmp(cur, "ls:", 3))
1489                         link_statistics = val;
1490                 else if (!strncmp(cur, "et:", 3))
1491                         ext_tran = val;
1492                 else if (!strncmp(cur, "rs:", 3))
1493                         rev_scan = val;
1494                 else if (!strncmp(cur, "ip:", 3))
1495                         isa_probe = val;
1496                 else if (!strncmp(cur, "ep:", 3))
1497                         eisa_probe = val;
1498                 else if (!strncmp(cur, "pp:", 3))
1499                         pci_probe = val;
1500
1501                 if ((cur = strchr(cur, ',')))
1502                         ++cur;
1503         }
1504
1505         return;
1506 }
1507
1508 static int option_setup(char *str)
1509 {
1510         int ints[MAX_INT_PARAM];
1511         char *cur = str;
1512         int i = 1;
1513
1514         while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
1515                 ints[i++] = simple_strtoul(cur, NULL, 0);
1516
1517                 if ((cur = strchr(cur, ',')) != NULL)
1518                         cur++;
1519         }
1520
1521         ints[0] = i - 1;
1522         internal_setup(cur, ints);
1523         return 1;
1524 }
1525
1526 static void add_pci_ports(void)
1527 {
1528 #if defined(CONFIG_PCI)
1529         unsigned int addr, k;
1530         struct pci_dev *dev = NULL;
1531
1532         for (k = 0; k < MAX_PCI; k++) {
1533
1534                 if (!(dev = pci_get_class(PCI_CLASS_STORAGE_SCSI << 8, dev)))
1535                         break;
1536
1537                 if (pci_enable_device(dev)) {
1538 #if defined(DEBUG_PCI_DETECT)
1539                         printk
1540                             ("%s: detect, bus %d, devfn 0x%x, pci_enable_device failed.\n",
1541                              driver_name, dev->bus->number, dev->devfn);
1542 #endif
1543
1544                         continue;
1545                 }
1546
1547                 addr = pci_resource_start(dev, 0);
1548
1549 #if defined(DEBUG_PCI_DETECT)
1550                 printk("%s: detect, seq. %d, bus %d, devfn 0x%x, addr 0x%x.\n",
1551                        driver_name, k, dev->bus->number, dev->devfn, addr);
1552 #endif
1553
1554                 /* Order addresses according to rev_scan value */
1555                 io_port[MAX_INT_PARAM + (rev_scan ? (MAX_PCI - k) : (1 + k))] =
1556                     addr + PCI_BASE_ADDRESS_0;
1557         }
1558
1559         pci_dev_put(dev);
1560 #endif                          /* end CONFIG_PCI */
1561 }
1562
1563 static int eata2x_detect(struct scsi_host_template *tpnt)
1564 {
1565         unsigned int j = 0, k;
1566
1567         tpnt->proc_name = "eata2x";
1568
1569         if (strlen(boot_options))
1570                 option_setup(boot_options);
1571
1572 #if defined(MODULE)
1573         /* io_port could have been modified when loading as a module */
1574         if (io_port[0] != SKIP) {
1575                 setup_done = 1;
1576                 io_port[MAX_INT_PARAM] = 0;
1577         }
1578 #endif
1579
1580         for (k = MAX_INT_PARAM; io_port[k]; k++)
1581                 if (io_port[k] == SKIP)
1582                         continue;
1583                 else if (io_port[k] <= MAX_ISA_ADDR) {
1584                         if (!isa_probe)
1585                                 io_port[k] = SKIP;
1586                 } else if (io_port[k] >= MIN_EISA_ADDR
1587                            && io_port[k] <= MAX_EISA_ADDR) {
1588                         if (!eisa_probe)
1589                                 io_port[k] = SKIP;
1590                 }
1591
1592         if (pci_probe) {
1593                 if (!setup_done)
1594                         add_pci_ports();
1595                 else
1596                         enable_pci_ports();
1597         }
1598
1599         for (k = 0; io_port[k]; k++) {
1600
1601                 if (io_port[k] == SKIP)
1602                         continue;
1603
1604                 if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt))
1605                         j++;
1606         }
1607
1608         num_boards = j;
1609         return j;
1610 }
1611
1612 static void map_dma(unsigned int i, struct hostdata *ha)
1613 {
1614         unsigned int k, count, pci_dir;
1615         struct scatterlist *sgpnt;
1616         struct mscp *cpp;
1617         struct scsi_cmnd *SCpnt;
1618
1619         cpp = &ha->cp[i];
1620         SCpnt = cpp->SCpnt;
1621         pci_dir = SCpnt->sc_data_direction;
1622
1623         if (SCpnt->sense_buffer)
1624                 cpp->sense_addr =
1625                     H2DEV(pci_map_single(ha->pdev, SCpnt->sense_buffer,
1626                            sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE));
1627
1628         cpp->sense_len = sizeof SCpnt->sense_buffer;
1629
1630         if (!SCpnt->use_sg) {
1631
1632                 /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */
1633                 if (!SCpnt->request_bufflen)
1634                         pci_dir = PCI_DMA_BIDIRECTIONAL;
1635
1636                 if (SCpnt->request_buffer)
1637                         cpp->data_address = H2DEV(pci_map_single(ha->pdev,
1638                                                                  SCpnt->
1639                                                                  request_buffer,
1640                                                                  SCpnt->
1641                                                                  request_bufflen,
1642                                                                  pci_dir));
1643
1644                 cpp->data_len = H2DEV(SCpnt->request_bufflen);
1645                 return;
1646         }
1647
1648         sgpnt = (struct scatterlist *)SCpnt->request_buffer;
1649         count = pci_map_sg(ha->pdev, sgpnt, SCpnt->use_sg, pci_dir);
1650
1651         for (k = 0; k < count; k++) {
1652                 cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k]));
1653                 cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k]));
1654         }
1655
1656         cpp->sg = 1;
1657         cpp->data_address = H2DEV(pci_map_single(ha->pdev, cpp->sglist,
1658                                                  SCpnt->use_sg *
1659                                                  sizeof(struct sg_list),
1660                                                  pci_dir));
1661         cpp->data_len = H2DEV((SCpnt->use_sg * sizeof(struct sg_list)));
1662 }
1663
1664 static void unmap_dma(unsigned int i, struct hostdata *ha)
1665 {
1666         unsigned int pci_dir;
1667         struct mscp *cpp;
1668         struct scsi_cmnd *SCpnt;
1669
1670         cpp = &ha->cp[i];
1671         SCpnt = cpp->SCpnt;
1672         pci_dir = SCpnt->sc_data_direction;
1673
1674         if (DEV2H(cpp->sense_addr))
1675                 pci_unmap_single(ha->pdev, DEV2H(cpp->sense_addr),
1676                                  DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1677
1678         if (SCpnt->use_sg)
1679                 pci_unmap_sg(ha->pdev, SCpnt->request_buffer, SCpnt->use_sg,
1680                              pci_dir);
1681
1682         if (!DEV2H(cpp->data_len))
1683                 pci_dir = PCI_DMA_BIDIRECTIONAL;
1684
1685         if (DEV2H(cpp->data_address))
1686                 pci_unmap_single(ha->pdev, DEV2H(cpp->data_address),
1687                                  DEV2H(cpp->data_len), pci_dir);
1688 }
1689
1690 static void sync_dma(unsigned int i, struct hostdata *ha)
1691 {
1692         unsigned int pci_dir;
1693         struct mscp *cpp;
1694         struct scsi_cmnd *SCpnt;
1695
1696         cpp = &ha->cp[i];
1697         SCpnt = cpp->SCpnt;
1698         pci_dir = SCpnt->sc_data_direction;
1699
1700         if (DEV2H(cpp->sense_addr))
1701                 pci_dma_sync_single_for_cpu(ha->pdev, DEV2H(cpp->sense_addr),
1702                                             DEV2H(cpp->sense_len),
1703                                             PCI_DMA_FROMDEVICE);
1704
1705         if (SCpnt->use_sg)
1706                 pci_dma_sync_sg_for_cpu(ha->pdev, SCpnt->request_buffer,
1707                                         SCpnt->use_sg, pci_dir);
1708
1709         if (!DEV2H(cpp->data_len))
1710                 pci_dir = PCI_DMA_BIDIRECTIONAL;
1711
1712         if (DEV2H(cpp->data_address))
1713                 pci_dma_sync_single_for_cpu(ha->pdev,
1714                                             DEV2H(cpp->data_address),
1715                                             DEV2H(cpp->data_len), pci_dir);
1716 }
1717
1718 static void scsi_to_dev_dir(unsigned int i, struct hostdata *ha)
1719 {
1720         unsigned int k;
1721
1722         static const unsigned char data_out_cmds[] = {
1723                 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1724                 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1725                 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1726         };
1727
1728         static const unsigned char data_none_cmds[] = {
1729                 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1730                 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1731                 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1732         };
1733
1734         struct mscp *cpp;
1735         struct scsi_cmnd *SCpnt;
1736
1737         cpp = &ha->cp[i];
1738         SCpnt = cpp->SCpnt;
1739
1740         if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1741                 cpp->din = 1;
1742                 cpp->dout = 0;
1743                 return;
1744         } else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1745                 cpp->din = 0;
1746                 cpp->dout = 1;
1747                 return;
1748         } else if (SCpnt->sc_data_direction == DMA_NONE) {
1749                 cpp->din = 0;
1750                 cpp->dout = 0;
1751                 return;
1752         }
1753
1754         if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1755                 panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n",
1756                                 ha->board_name);
1757
1758         for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1759                 if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1760                         cpp->dout = 1;
1761                         break;
1762                 }
1763
1764         if ((cpp->din = !cpp->dout))
1765                 for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1766                         if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1767                                 cpp->din = 0;
1768                                 break;
1769                         }
1770
1771 }
1772
1773 static int eata2x_queuecommand(struct scsi_cmnd *SCpnt,
1774                                void (*done) (struct scsi_cmnd *))
1775 {
1776         struct Scsi_Host *shost = SCpnt->device->host;
1777         struct hostdata *ha = (struct hostdata *)shost->hostdata;
1778         unsigned int i, k;
1779         struct mscp *cpp;
1780
1781         if (SCpnt->host_scribble)
1782                 panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
1783                       ha->board_name, SCpnt->pid, SCpnt);
1784
1785         /* i is the mailbox number, look for the first free mailbox
1786            starting from last_cp_used */
1787         i = ha->last_cp_used + 1;
1788
1789         for (k = 0; k < shost->can_queue; k++, i++) {
1790                 if (i >= shost->can_queue)
1791                         i = 0;
1792                 if (ha->cp_stat[i] == FREE) {
1793                         ha->last_cp_used = i;
1794                         break;
1795                 }
1796         }
1797
1798         if (k == shost->can_queue) {
1799                 printk("%s: qcomm, no free mailbox.\n", ha->board_name);
1800                 return 1;
1801         }
1802
1803         /* Set pointer to control packet structure */
1804         cpp = &ha->cp[i];
1805
1806         memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1807
1808         /* Set pointer to status packet structure, Big Endian format */
1809         cpp->sp_dma_addr = H2DEV(ha->sp_dma_addr);
1810
1811         SCpnt->scsi_done = done;
1812         cpp->cpp_index = i;
1813         SCpnt->host_scribble = (unsigned char *)&cpp->cpp_index;
1814
1815         if (do_trace)
1816                 printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n",
1817                        ha->board_name, i, SCpnt->device->channel, SCpnt->device->id,
1818                        SCpnt->device->lun, SCpnt->pid);
1819
1820         cpp->reqsen = 1;
1821         cpp->dispri = 1;
1822 #if 0
1823         if (SCpnt->device->type == TYPE_TAPE)
1824                 cpp->hbaci = 1;
1825 #endif
1826         cpp->one = 1;
1827         cpp->channel = SCpnt->device->channel;
1828         cpp->target = SCpnt->device->id;
1829         cpp->lun = SCpnt->device->lun;
1830         cpp->SCpnt = SCpnt;
1831         memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1832
1833         /* Use data transfer direction SCpnt->sc_data_direction */
1834         scsi_to_dev_dir(i, ha);
1835
1836         /* Map DMA buffers and SG list */
1837         map_dma(i, ha);
1838
1839         if (linked_comm && SCpnt->device->queue_depth > 2
1840             && TLDEV(SCpnt->device->type)) {
1841                 ha->cp_stat[i] = READY;
1842                 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0);
1843                 return 0;
1844         }
1845
1846         /* Send control packet to the board */
1847         if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
1848                 unmap_dma(i, ha);
1849                 SCpnt->host_scribble = NULL;
1850                 printk("%s: qcomm, target %d.%d:%d, pid %ld, adapter busy.\n",
1851                        ha->board_name, SCpnt->device->channel, SCpnt->device->id,
1852                        SCpnt->device->lun, SCpnt->pid);
1853                 return 1;
1854         }
1855
1856         ha->cp_stat[i] = IN_USE;
1857         return 0;
1858 }
1859
1860 static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1861 {
1862         struct Scsi_Host *shost = SCarg->device->host;
1863         struct hostdata *ha = (struct hostdata *)shost->hostdata;
1864         unsigned int i;
1865
1866         if (SCarg->host_scribble == NULL) {
1867                 printk("%s: abort, target %d.%d:%d, pid %ld inactive.\n",
1868                        ha->board_name, SCarg->device->channel, SCarg->device->id,
1869                        SCarg->device->lun, SCarg->pid);
1870                 return SUCCESS;
1871         }
1872
1873         i = *(unsigned int *)SCarg->host_scribble;
1874         printk("%s: abort, mbox %d, target %d.%d:%d, pid %ld.\n",
1875                ha->board_name, i, SCarg->device->channel, SCarg->device->id,
1876                SCarg->device->lun, SCarg->pid);
1877
1878         if (i >= shost->can_queue)
1879                 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
1880
1881         if (wait_on_busy(shost->io_port, MAXLOOP)) {
1882                 printk("%s: abort, timeout error.\n", ha->board_name);
1883                 return FAILED;
1884         }
1885
1886         if (ha->cp_stat[i] == FREE) {
1887                 printk("%s: abort, mbox %d is free.\n", ha->board_name, i);
1888                 return SUCCESS;
1889         }
1890
1891         if (ha->cp_stat[i] == IN_USE) {
1892                 printk("%s: abort, mbox %d is in use.\n", ha->board_name, i);
1893
1894                 if (SCarg != ha->cp[i].SCpnt)
1895                         panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1896                               ha->board_name, i, SCarg, ha->cp[i].SCpnt);
1897
1898                 if (inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED)
1899                         printk("%s: abort, mbox %d, interrupt pending.\n",
1900                                ha->board_name, i);
1901
1902                 return FAILED;
1903         }
1904
1905         if (ha->cp_stat[i] == IN_RESET) {
1906                 printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i);
1907                 return FAILED;
1908         }
1909
1910         if (ha->cp_stat[i] == LOCKED) {
1911                 printk("%s: abort, mbox %d is locked.\n", ha->board_name, i);
1912                 return SUCCESS;
1913         }
1914
1915         if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1916                 unmap_dma(i, ha);
1917                 SCarg->result = DID_ABORT << 16;
1918                 SCarg->host_scribble = NULL;
1919                 ha->cp_stat[i] = FREE;
1920                 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
1921                        ha->board_name, i, SCarg->pid);
1922                 SCarg->scsi_done(SCarg);
1923                 return SUCCESS;
1924         }
1925
1926         panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i);
1927 }
1928
1929 static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1930 {
1931         unsigned int i, time, k, c, limit = 0;
1932         int arg_done = 0;
1933         struct scsi_cmnd *SCpnt;
1934         struct Scsi_Host *shost = SCarg->device->host;
1935         struct hostdata *ha = (struct hostdata *)shost->hostdata;
1936
1937         printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n",
1938                ha->board_name, SCarg->device->channel, SCarg->device->id,
1939                SCarg->device->lun, SCarg->pid);
1940
1941         spin_lock_irq(shost->host_lock);
1942
1943         if (SCarg->host_scribble == NULL)
1944                 printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid);
1945
1946         if (ha->in_reset) {
1947                 printk("%s: reset, exit, already in reset.\n", ha->board_name);
1948                 spin_unlock_irq(shost->host_lock);
1949                 return FAILED;
1950         }
1951
1952         if (wait_on_busy(shost->io_port, MAXLOOP)) {
1953                 printk("%s: reset, exit, timeout error.\n", ha->board_name);
1954                 spin_unlock_irq(shost->host_lock);
1955                 return FAILED;
1956         }
1957
1958         ha->retries = 0;
1959
1960         for (c = 0; c <= shost->max_channel; c++)
1961                 for (k = 0; k < shost->max_id; k++) {
1962                         ha->target_redo[k][c] = 1;
1963                         ha->target_to[k][c] = 0;
1964                 }
1965
1966         for (i = 0; i < shost->can_queue; i++) {
1967
1968                 if (ha->cp_stat[i] == FREE)
1969                         continue;
1970
1971                 if (ha->cp_stat[i] == LOCKED) {
1972                         ha->cp_stat[i] = FREE;
1973                         printk("%s: reset, locked mbox %d forced free.\n",
1974                                ha->board_name, i);
1975                         continue;
1976                 }
1977
1978                 if (!(SCpnt = ha->cp[i].SCpnt))
1979                         panic("%s: reset, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
1980
1981                 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1982                         ha->cp_stat[i] = ABORTING;
1983                         printk("%s: reset, mbox %d aborting, pid %ld.\n",
1984                                ha->board_name, i, SCpnt->pid);
1985                 }
1986
1987                 else {
1988                         ha->cp_stat[i] = IN_RESET;
1989                         printk("%s: reset, mbox %d in reset, pid %ld.\n",
1990                                ha->board_name, i, SCpnt->pid);
1991                 }
1992
1993                 if (SCpnt->host_scribble == NULL)
1994                         panic("%s: reset, mbox %d, garbled SCpnt.\n", ha->board_name, i);
1995
1996                 if (*(unsigned int *)SCpnt->host_scribble != i)
1997                         panic("%s: reset, mbox %d, index mismatch.\n", ha->board_name, i);
1998
1999                 if (SCpnt->scsi_done == NULL)
2000                         panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n",
2001                               ha->board_name, i);
2002
2003                 if (SCpnt == SCarg)
2004                         arg_done = 1;
2005         }
2006
2007         if (do_dma(shost->io_port, 0, RESET_PIO)) {
2008                 printk("%s: reset, cannot reset, timeout error.\n", ha->board_name);
2009                 spin_unlock_irq(shost->host_lock);
2010                 return FAILED;
2011         }
2012
2013         printk("%s: reset, board reset done, enabling interrupts.\n", ha->board_name);
2014
2015 #if defined(DEBUG_RESET)
2016         do_trace = 1;
2017 #endif
2018
2019         ha->in_reset = 1;
2020
2021         spin_unlock_irq(shost->host_lock);
2022
2023         /* FIXME: use a sleep instead */
2024         time = jiffies;
2025         while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
2026                 udelay(100L);
2027
2028         spin_lock_irq(shost->host_lock);
2029
2030         printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
2031
2032         for (i = 0; i < shost->can_queue; i++) {
2033
2034                 if (ha->cp_stat[i] == IN_RESET) {
2035                         SCpnt = ha->cp[i].SCpnt;
2036                         unmap_dma(i, ha);
2037                         SCpnt->result = DID_RESET << 16;
2038                         SCpnt->host_scribble = NULL;
2039
2040                         /* This mailbox is still waiting for its interrupt */
2041                         ha->cp_stat[i] = LOCKED;
2042
2043                         printk
2044                             ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
2045                              ha->board_name, i, SCpnt->pid);
2046                 }
2047
2048                 else if (ha->cp_stat[i] == ABORTING) {
2049                         SCpnt = ha->cp[i].SCpnt;
2050                         unmap_dma(i, ha);
2051                         SCpnt->result = DID_RESET << 16;
2052                         SCpnt->host_scribble = NULL;
2053
2054                         /* This mailbox was never queued to the adapter */
2055                         ha->cp_stat[i] = FREE;
2056
2057                         printk
2058                             ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
2059                              ha->board_name, i, SCpnt->pid);
2060                 }
2061
2062                 else
2063                         /* Any other mailbox has already been set free by interrupt */
2064                         continue;
2065
2066                 SCpnt->scsi_done(SCpnt);
2067         }
2068
2069         ha->in_reset = 0;
2070         do_trace = 0;
2071
2072         if (arg_done)
2073                 printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->pid);
2074         else
2075                 printk("%s: reset, exit.\n", ha->board_name);
2076
2077         spin_unlock_irq(shost->host_lock);
2078         return SUCCESS;
2079 }
2080
2081 int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2082                       sector_t capacity, int *dkinfo)
2083 {
2084         unsigned int size = capacity;
2085
2086         if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
2087                 dkinfo[0] = 255;
2088                 dkinfo[1] = 63;
2089                 dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
2090         }
2091 #if defined (DEBUG_GEOMETRY)
2092         printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
2093                dkinfo[0], dkinfo[1], dkinfo[2]);
2094 #endif
2095
2096         return 0;
2097 }
2098
2099 static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
2100                  unsigned int rev)
2101 {
2102         unsigned int i, j, k, y;
2103         unsigned long x;
2104
2105         for (i = 0; i < n - 1; i++) {
2106                 k = i;
2107
2108                 for (j = k + 1; j < n; j++)
2109                         if (rev) {
2110                                 if (sk[j] > sk[k])
2111                                         k = j;
2112                         } else {
2113                                 if (sk[j] < sk[k])
2114                                         k = j;
2115                         }
2116
2117                 if (k != i) {
2118                         x = sk[k];
2119                         sk[k] = sk[i];
2120                         sk[i] = x;
2121                         y = da[k];
2122                         da[k] = da[i];
2123                         da[i] = y;
2124                 }
2125         }
2126
2127         return;
2128 }
2129
2130 static int reorder(struct hostdata *ha, unsigned long cursec,
2131                    unsigned int ihdlr, unsigned int il[], unsigned int n_ready)
2132 {
2133         struct scsi_cmnd *SCpnt;
2134         struct mscp *cpp;
2135         unsigned int k, n;
2136         unsigned int rev = 0, s = 1, r = 1;
2137         unsigned int input_only = 1, overlap = 0;
2138         unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
2139         unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
2140         unsigned long ioseek = 0;
2141
2142         static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
2143         static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
2144         static unsigned int readysorted = 0, revcount = 0;
2145         static unsigned long seeksorted = 0, seeknosort = 0;
2146
2147         if (link_statistics && !(++flushcount % link_statistics))
2148                 printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
2149                        " av %ldK as %ldK.\n", flushcount, batchcount,
2150                        inputcount, ovlcount, readycount, readysorted, sortcount,
2151                        revcount, seeknosort / (readycount + 1),
2152                        seeksorted / (readycount + 1));
2153
2154         if (n_ready <= 1)
2155                 return 0;
2156
2157         for (n = 0; n < n_ready; n++) {
2158                 k = il[n];
2159                 cpp = &ha->cp[k];
2160                 SCpnt = cpp->SCpnt;
2161
2162                 if (!cpp->din)
2163                         input_only = 0;
2164
2165                 if (SCpnt->request->sector < minsec)
2166                         minsec = SCpnt->request->sector;
2167                 if (SCpnt->request->sector > maxsec)
2168                         maxsec = SCpnt->request->sector;
2169
2170                 sl[n] = SCpnt->request->sector;
2171                 ioseek += SCpnt->request->nr_sectors;
2172
2173                 if (!n)
2174                         continue;
2175
2176                 if (sl[n] < sl[n - 1])
2177                         s = 0;
2178                 if (sl[n] > sl[n - 1])
2179                         r = 0;
2180
2181                 if (link_statistics) {
2182                         if (sl[n] > sl[n - 1])
2183                                 seek += sl[n] - sl[n - 1];
2184                         else
2185                                 seek += sl[n - 1] - sl[n];
2186                 }
2187
2188         }
2189
2190         if (link_statistics) {
2191                 if (cursec > sl[0])
2192                         seek += cursec - sl[0];
2193                 else
2194                         seek += sl[0] - cursec;
2195         }
2196
2197         if (cursec > ((maxsec + minsec) / 2))
2198                 rev = 1;
2199
2200         if (ioseek > ((maxsec - minsec) / 2))
2201                 rev = 0;
2202
2203         if (!((rev && r) || (!rev && s)))
2204                 sort(sl, il, n_ready, rev);
2205
2206         if (!input_only)
2207                 for (n = 0; n < n_ready; n++) {
2208                         k = il[n];
2209                         cpp = &ha->cp[k];
2210                         SCpnt = cpp->SCpnt;
2211                         ll[n] = SCpnt->request->nr_sectors;
2212                         pl[n] = SCpnt->pid;
2213
2214                         if (!n)
2215                                 continue;
2216
2217                         if ((sl[n] == sl[n - 1])
2218                             || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
2219                             || (rev && ((sl[n] + ll[n]) > sl[n - 1])))
2220                                 overlap = 1;
2221                 }
2222
2223         if (overlap)
2224                 sort(pl, il, n_ready, 0);
2225
2226         if (link_statistics) {
2227                 if (cursec > sl[0])
2228                         iseek = cursec - sl[0];
2229                 else
2230                         iseek = sl[0] - cursec;
2231                 batchcount++;
2232                 readycount += n_ready;
2233                 seeknosort += seek / 1024;
2234                 if (input_only)
2235                         inputcount++;
2236                 if (overlap) {
2237                         ovlcount++;
2238                         seeksorted += iseek / 1024;
2239                 } else
2240                         seeksorted += (iseek + maxsec - minsec) / 1024;
2241                 if (rev && !r) {
2242                         revcount++;
2243                         readysorted += n_ready;
2244                 }
2245                 if (!rev && !s) {
2246                         sortcount++;
2247                         readysorted += n_ready;
2248                 }
2249         }
2250 #if defined(DEBUG_LINKED_COMMANDS)
2251         if (link_statistics && (overlap || !(flushcount % link_statistics)))
2252                 for (n = 0; n < n_ready; n++) {
2253                         k = il[n];
2254                         cpp = &ha->cp[k];
2255                         SCpnt = cpp->SCpnt;
2256                         printk
2257                             ("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"
2258                              " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2259                              (ihdlr ? "ihdlr" : "qcomm"),
2260                              SCpnt->device->channel, SCpnt->device->id,
2261                              SCpnt->device->lun, SCpnt->pid, k, flushcount,
2262                              n_ready, SCpnt->request->sector,
2263                              SCpnt->request->nr_sectors, cursec, YESNO(s),
2264                              YESNO(r), YESNO(rev), YESNO(input_only),
2265                              YESNO(overlap), cpp->din);
2266                 }
2267 #endif
2268         return overlap;
2269 }
2270
2271 static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2272                       struct hostdata *ha, unsigned int ihdlr)
2273 {
2274         struct scsi_cmnd *SCpnt;
2275         struct mscp *cpp;
2276         unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
2277
2278         for (k = 0; k < dev->host->can_queue; k++) {
2279
2280                 if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE)
2281                         continue;
2282
2283                 cpp = &ha->cp[k];
2284                 SCpnt = cpp->SCpnt;
2285
2286                 if (SCpnt->device != dev)
2287                         continue;
2288
2289                 if (ha->cp_stat[k] == IN_USE)
2290                         return;
2291
2292                 il[n_ready++] = k;
2293         }
2294
2295         if (reorder(ha, cursec, ihdlr, il, n_ready))
2296                 n_ready = 1;
2297
2298         for (n = 0; n < n_ready; n++) {
2299                 k = il[n];
2300                 cpp = &ha->cp[k];
2301                 SCpnt = cpp->SCpnt;
2302
2303                 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2304                         printk
2305                             ("%s: %s, target %d.%d:%d, pid %ld, mbox %d, adapter"
2306                              " busy, will abort.\n", ha->board_name,
2307                              (ihdlr ? "ihdlr" : "qcomm"),
2308                              SCpnt->device->channel, SCpnt->device->id,
2309                              SCpnt->device->lun, SCpnt->pid, k);
2310                         ha->cp_stat[k] = ABORTING;
2311                         continue;
2312                 }
2313
2314                 ha->cp_stat[k] = IN_USE;
2315         }
2316 }
2317
2318 static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost)
2319 {
2320         struct scsi_cmnd *SCpnt;
2321         unsigned int i, k, c, status, tstatus, reg;
2322         struct mssp *spp;
2323         struct mscp *cpp;
2324         struct hostdata *ha = (struct hostdata *)shost->hostdata;
2325
2326         if (shost->irq != irq)
2327                 panic("%s: ihdlr, irq %d, shost->irq %d.\n", ha->board_name, irq,
2328                       shost->irq);
2329
2330         /* Check if this board need to be serviced */
2331         if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
2332                 goto none;
2333
2334         ha->iocount++;
2335
2336         if (do_trace)
2337                 printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq,
2338                        ha->iocount);
2339
2340         /* Check if this board is still busy */
2341         if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) {
2342                 reg = inb(shost->io_port + REG_STATUS);
2343                 printk
2344                     ("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.\n",
2345                      ha->board_name, irq, reg, ha->iocount);
2346                 goto none;
2347         }
2348
2349         spp = &ha->sp;
2350
2351         /* Make a local copy just before clearing the interrupt indication */
2352         memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp));
2353
2354         /* Clear the completion flag and cp pointer on the dynamic copy of sp */
2355         memset(ha->sp_cpu_addr, 0, sizeof(struct mssp));
2356
2357         /* Read the status register to clear the interrupt indication */
2358         reg = inb(shost->io_port + REG_STATUS);
2359
2360 #if defined (DEBUG_INTERRUPT)
2361         {
2362                 unsigned char *bytesp;
2363                 int cnt;
2364                 bytesp = (unsigned char *)spp;
2365                 if (ha->iocount < 200) {
2366                         printk("sp[] =");
2367                         for (cnt = 0; cnt < 15; cnt++)
2368                                 printk(" 0x%x", bytesp[cnt]);
2369                         printk("\n");
2370                 }
2371         }
2372 #endif
2373
2374         /* Reject any sp with supspect data */
2375         if (spp->eoc == 0 && ha->iocount > 1)
2376                 printk
2377                     ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n",
2378                      ha->board_name, irq, reg, ha->iocount);
2379         if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue)
2380                 printk
2381                     ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n",
2382                      ha->board_name, spp->cpp_index, irq, reg, ha->iocount);
2383         if (spp->eoc == 0 || spp->cpp_index < 0
2384             || spp->cpp_index >= shost->can_queue)
2385                 goto handled;
2386
2387         /* Find the mailbox to be serviced on this board */
2388         i = spp->cpp_index;
2389
2390         cpp = &(ha->cp[i]);
2391
2392 #if defined(DEBUG_GENERATE_ABORTS)
2393         if ((ha->iocount > 500) && ((ha->iocount % 500) < 3))
2394                 goto handled;
2395 #endif
2396
2397         if (ha->cp_stat[i] == IGNORE) {
2398                 ha->cp_stat[i] = FREE;
2399                 goto handled;
2400         } else if (ha->cp_stat[i] == LOCKED) {
2401                 ha->cp_stat[i] = FREE;
2402                 printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i,
2403                        ha->iocount);
2404                 goto handled;
2405         } else if (ha->cp_stat[i] == FREE) {
2406                 printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i,
2407                        ha->iocount);
2408                 goto handled;
2409         } else if (ha->cp_stat[i] == IN_RESET)
2410                 printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i);
2411         else if (ha->cp_stat[i] != IN_USE)
2412                 panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
2413                       ha->board_name, i, ha->cp_stat[i]);
2414
2415         ha->cp_stat[i] = FREE;
2416         SCpnt = cpp->SCpnt;
2417
2418         if (SCpnt == NULL)
2419                 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2420
2421         if (SCpnt->host_scribble == NULL)
2422                 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,
2423                       i, SCpnt->pid, SCpnt);
2424
2425         if (*(unsigned int *)SCpnt->host_scribble != i)
2426                 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
2427                       ha->board_name, i, SCpnt->pid,
2428                       *(unsigned int *)SCpnt->host_scribble);
2429
2430         sync_dma(i, ha);
2431
2432         if (linked_comm && SCpnt->device->queue_depth > 2
2433             && TLDEV(SCpnt->device->type))
2434                 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
2435
2436         tstatus = status_byte(spp->target_status);
2437
2438 #if defined(DEBUG_GENERATE_ERRORS)
2439         if ((ha->iocount > 500) && ((ha->iocount % 200) < 2))
2440                 spp->adapter_status = 0x01;
2441 #endif
2442
2443         switch (spp->adapter_status) {
2444         case ASOK:              /* status OK */
2445
2446                 /* Forces a reset if a disk drive keeps returning BUSY */
2447                 if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
2448                         status = DID_ERROR << 16;
2449
2450                 /* If there was a bus reset, redo operation on each target */
2451                 else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
2452                          && ha->target_redo[SCpnt->device->id][SCpnt->
2453                                                                   device->
2454                                                                   channel])
2455                         status = DID_BUS_BUSY << 16;
2456
2457                 /* Works around a flaw in scsi.c */
2458                 else if (tstatus == CHECK_CONDITION
2459                          && SCpnt->device->type == TYPE_DISK
2460                          && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
2461                         status = DID_BUS_BUSY << 16;
2462
2463                 else
2464                         status = DID_OK << 16;
2465
2466                 if (tstatus == GOOD)
2467                         ha->target_redo[SCpnt->device->id][SCpnt->device->
2468                                                               channel] = 0;
2469
2470                 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2471                     (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2472                        (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2473                         printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
2474                                "target_status 0x%x, sense key 0x%x.\n",
2475                                ha->board_name,
2476                                SCpnt->device->channel, SCpnt->device->id,
2477                                SCpnt->device->lun, SCpnt->pid,
2478                                spp->target_status, SCpnt->sense_buffer[2]);
2479
2480                 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
2481
2482                 if (ha->last_retried_pid == SCpnt->pid)
2483                         ha->retries = 0;
2484
2485                 break;
2486         case ASST:              /* Selection Time Out */
2487         case 0x02:              /* Command Time Out   */
2488
2489                 if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
2490                         status = DID_ERROR << 16;
2491                 else {
2492                         status = DID_TIME_OUT << 16;
2493                         ha->target_to[SCpnt->device->id][SCpnt->device->
2494                                                             channel]++;
2495                 }
2496
2497                 break;
2498
2499                 /* Perform a limited number of internal retries */
2500         case 0x03:              /* SCSI Bus Reset Received */
2501         case 0x04:              /* Initial Controller Power-up */
2502
2503                 for (c = 0; c <= shost->max_channel; c++)
2504                         for (k = 0; k < shost->max_id; k++)
2505                                 ha->target_redo[k][c] = 1;
2506
2507                 if (SCpnt->device->type != TYPE_TAPE
2508                     && ha->retries < MAX_INTERNAL_RETRIES) {
2509
2510 #if defined(DID_SOFT_ERROR)
2511                         status = DID_SOFT_ERROR << 16;
2512 #else
2513                         status = DID_BUS_BUSY << 16;
2514 #endif
2515
2516                         ha->retries++;
2517                         ha->last_retried_pid = SCpnt->pid;
2518                 } else
2519                         status = DID_ERROR << 16;
2520
2521                 break;
2522         case 0x05:              /* Unexpected Bus Phase */
2523         case 0x06:              /* Unexpected Bus Free */
2524         case 0x07:              /* Bus Parity Error */
2525         case 0x08:              /* SCSI Hung */
2526         case 0x09:              /* Unexpected Message Reject */
2527         case 0x0a:              /* SCSI Bus Reset Stuck */
2528         case 0x0b:              /* Auto Request-Sense Failed */
2529         case 0x0c:              /* Controller Ram Parity Error */
2530         default:
2531                 status = DID_ERROR << 16;
2532                 break;
2533         }
2534
2535         SCpnt->result = status | spp->target_status;
2536
2537 #if defined(DEBUG_INTERRUPT)
2538         if (SCpnt->result || do_trace)
2539 #else
2540         if ((spp->adapter_status != ASOK && ha->iocount > 1000) ||
2541             (spp->adapter_status != ASOK &&
2542              spp->adapter_status != ASST && ha->iocount <= 1000) ||
2543             do_trace || msg_byte(spp->target_status))
2544 #endif
2545                 printk("%s: ihdlr, mbox %2d, err 0x%x:%x,"
2546                        " target %d.%d:%d, pid %ld, reg 0x%x, count %d.\n",
2547                        ha->board_name, i, spp->adapter_status, spp->target_status,
2548                        SCpnt->device->channel, SCpnt->device->id,
2549                        SCpnt->device->lun, SCpnt->pid, reg, ha->iocount);
2550
2551         unmap_dma(i, ha);
2552
2553         /* Set the command state to inactive */
2554         SCpnt->host_scribble = NULL;
2555
2556         SCpnt->scsi_done(SCpnt);
2557
2558         if (do_trace)
2559                 printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name,
2560                                 irq, ha->iocount);
2561
2562       handled:
2563         return IRQ_HANDLED;
2564       none:
2565         return IRQ_NONE;
2566 }
2567
2568 static irqreturn_t do_interrupt_handler(int irq, void *shap,
2569                                         struct pt_regs *regs)
2570 {
2571         struct Scsi_Host *shost;
2572         unsigned int j;
2573         unsigned long spin_flags;
2574         irqreturn_t ret;
2575
2576         /* Check if the interrupt must be processed by this handler */
2577         if ((j = (unsigned int)((char *)shap - sha)) >= num_boards)
2578                 return IRQ_NONE;
2579         shost = sh[j];
2580
2581         spin_lock_irqsave(shost->host_lock, spin_flags);
2582         ret = ihdlr(irq, shost);
2583         spin_unlock_irqrestore(shost->host_lock, spin_flags);
2584         return ret;
2585 }
2586
2587 static int eata2x_release(struct Scsi_Host *shost)
2588 {
2589         struct hostdata *ha = (struct hostdata *)shost->hostdata;
2590         unsigned int i;
2591
2592         for (i = 0; i < shost->can_queue; i++)
2593                 if ((&ha->cp[i])->sglist)
2594                         kfree((&ha->cp[i])->sglist);
2595
2596         for (i = 0; i < shost->can_queue; i++)
2597                 pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr,
2598                                  sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
2599
2600         if (ha->sp_cpu_addr)
2601                 pci_free_consistent(ha->pdev, sizeof(struct mssp),
2602                                     ha->sp_cpu_addr, ha->sp_dma_addr);
2603
2604         free_irq(shost->irq, &sha[ha->board_number]);
2605
2606         if (shost->dma_channel != NO_DMA)
2607                 free_dma(shost->dma_channel);
2608
2609         release_region(shost->io_port, shost->n_io_port);
2610         scsi_unregister(shost);
2611         return 0;
2612 }
2613
2614 #include "scsi_module.c"
2615
2616 #ifndef MODULE
2617 __setup("eata=", option_setup);
2618 #endif                          /* end MODULE */