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                 if (SCarg->eh_state == SCSI_STATE_TIMEOUT) {
1903                         unmap_dma(i, ha);
1904                         SCarg->host_scribble = NULL;
1905                         ha->cp_stat[i] = FREE;
1906                         printk
1907                             ("%s, abort, mbox %d, eh_state timeout, pid %ld.\n",
1908                              ha->board_name, i, SCarg->pid);
1909                         return SUCCESS;
1910                 }
1911
1912                 return FAILED;
1913         }
1914
1915         if (ha->cp_stat[i] == IN_RESET) {
1916                 printk("%s: abort, mbox %d is in reset.\n", ha->board_name, i);
1917                 return FAILED;
1918         }
1919
1920         if (ha->cp_stat[i] == LOCKED) {
1921                 printk("%s: abort, mbox %d is locked.\n", ha->board_name, i);
1922                 return SUCCESS;
1923         }
1924
1925         if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1926                 unmap_dma(i, ha);
1927                 SCarg->result = DID_ABORT << 16;
1928                 SCarg->host_scribble = NULL;
1929                 ha->cp_stat[i] = FREE;
1930                 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
1931                        ha->board_name, i, SCarg->pid);
1932                 SCarg->scsi_done(SCarg);
1933                 return SUCCESS;
1934         }
1935
1936         panic("%s: abort, mbox %d, invalid cp_stat.\n", ha->board_name, i);
1937 }
1938
1939 static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1940 {
1941         unsigned int i, time, k, c, limit = 0;
1942         int arg_done = 0;
1943         struct scsi_cmnd *SCpnt;
1944         struct Scsi_Host *shost = SCarg->device->host;
1945         struct hostdata *ha = (struct hostdata *)shost->hostdata;
1946
1947         printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n",
1948                ha->board_name, SCarg->device->channel, SCarg->device->id,
1949                SCarg->device->lun, SCarg->pid);
1950
1951         spin_lock_irq(shost->host_lock);
1952
1953         if (SCarg->host_scribble == NULL)
1954                 printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid);
1955
1956         if (ha->in_reset) {
1957                 printk("%s: reset, exit, already in reset.\n", ha->board_name);
1958                 spin_unlock_irq(shost->host_lock);
1959                 return FAILED;
1960         }
1961
1962         if (wait_on_busy(shost->io_port, MAXLOOP)) {
1963                 printk("%s: reset, exit, timeout error.\n", ha->board_name);
1964                 spin_unlock_irq(shost->host_lock);
1965                 return FAILED;
1966         }
1967
1968         ha->retries = 0;
1969
1970         for (c = 0; c <= shost->max_channel; c++)
1971                 for (k = 0; k < shost->max_id; k++) {
1972                         ha->target_redo[k][c] = 1;
1973                         ha->target_to[k][c] = 0;
1974                 }
1975
1976         for (i = 0; i < shost->can_queue; i++) {
1977
1978                 if (ha->cp_stat[i] == FREE)
1979                         continue;
1980
1981                 if (ha->cp_stat[i] == LOCKED) {
1982                         ha->cp_stat[i] = FREE;
1983                         printk("%s: reset, locked mbox %d forced free.\n",
1984                                ha->board_name, i);
1985                         continue;
1986                 }
1987
1988                 if (!(SCpnt = ha->cp[i].SCpnt))
1989                         panic("%s: reset, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
1990
1991                 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1992                         ha->cp_stat[i] = ABORTING;
1993                         printk("%s: reset, mbox %d aborting, pid %ld.\n",
1994                                ha->board_name, i, SCpnt->pid);
1995                 }
1996
1997                 else {
1998                         ha->cp_stat[i] = IN_RESET;
1999                         printk("%s: reset, mbox %d in reset, pid %ld.\n",
2000                                ha->board_name, i, SCpnt->pid);
2001                 }
2002
2003                 if (SCpnt->host_scribble == NULL)
2004                         panic("%s: reset, mbox %d, garbled SCpnt.\n", ha->board_name, i);
2005
2006                 if (*(unsigned int *)SCpnt->host_scribble != i)
2007                         panic("%s: reset, mbox %d, index mismatch.\n", ha->board_name, i);
2008
2009                 if (SCpnt->scsi_done == NULL)
2010                         panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n",
2011                               ha->board_name, i);
2012
2013                 if (SCpnt == SCarg)
2014                         arg_done = 1;
2015         }
2016
2017         if (do_dma(shost->io_port, 0, RESET_PIO)) {
2018                 printk("%s: reset, cannot reset, timeout error.\n", ha->board_name);
2019                 spin_unlock_irq(shost->host_lock);
2020                 return FAILED;
2021         }
2022
2023         printk("%s: reset, board reset done, enabling interrupts.\n", ha->board_name);
2024
2025 #if defined(DEBUG_RESET)
2026         do_trace = 1;
2027 #endif
2028
2029         ha->in_reset = 1;
2030
2031         spin_unlock_irq(shost->host_lock);
2032
2033         /* FIXME: use a sleep instead */
2034         time = jiffies;
2035         while ((jiffies - time) < (10 * HZ) && limit++ < 200000)
2036                 udelay(100L);
2037
2038         spin_lock_irq(shost->host_lock);
2039
2040         printk("%s: reset, interrupts disabled, loops %d.\n", ha->board_name, limit);
2041
2042         for (i = 0; i < shost->can_queue; i++) {
2043
2044                 if (ha->cp_stat[i] == IN_RESET) {
2045                         SCpnt = ha->cp[i].SCpnt;
2046                         unmap_dma(i, ha);
2047                         SCpnt->result = DID_RESET << 16;
2048                         SCpnt->host_scribble = NULL;
2049
2050                         /* This mailbox is still waiting for its interrupt */
2051                         ha->cp_stat[i] = LOCKED;
2052
2053                         printk
2054                             ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
2055                              ha->board_name, i, SCpnt->pid);
2056                 }
2057
2058                 else if (ha->cp_stat[i] == ABORTING) {
2059                         SCpnt = ha->cp[i].SCpnt;
2060                         unmap_dma(i, ha);
2061                         SCpnt->result = DID_RESET << 16;
2062                         SCpnt->host_scribble = NULL;
2063
2064                         /* This mailbox was never queued to the adapter */
2065                         ha->cp_stat[i] = FREE;
2066
2067                         printk
2068                             ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
2069                              ha->board_name, i, SCpnt->pid);
2070                 }
2071
2072                 else
2073                         /* Any other mailbox has already been set free by interrupt */
2074                         continue;
2075
2076                 SCpnt->scsi_done(SCpnt);
2077         }
2078
2079         ha->in_reset = 0;
2080         do_trace = 0;
2081
2082         if (arg_done)
2083                 printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->pid);
2084         else
2085                 printk("%s: reset, exit.\n", ha->board_name);
2086
2087         spin_unlock_irq(shost->host_lock);
2088         return SUCCESS;
2089 }
2090
2091 int eata2x_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2092                       sector_t capacity, int *dkinfo)
2093 {
2094         unsigned int size = capacity;
2095
2096         if (ext_tran || (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
2097                 dkinfo[0] = 255;
2098                 dkinfo[1] = 63;
2099                 dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
2100         }
2101 #if defined (DEBUG_GEOMETRY)
2102         printk("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
2103                dkinfo[0], dkinfo[1], dkinfo[2]);
2104 #endif
2105
2106         return 0;
2107 }
2108
2109 static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
2110                  unsigned int rev)
2111 {
2112         unsigned int i, j, k, y;
2113         unsigned long x;
2114
2115         for (i = 0; i < n - 1; i++) {
2116                 k = i;
2117
2118                 for (j = k + 1; j < n; j++)
2119                         if (rev) {
2120                                 if (sk[j] > sk[k])
2121                                         k = j;
2122                         } else {
2123                                 if (sk[j] < sk[k])
2124                                         k = j;
2125                         }
2126
2127                 if (k != i) {
2128                         x = sk[k];
2129                         sk[k] = sk[i];
2130                         sk[i] = x;
2131                         y = da[k];
2132                         da[k] = da[i];
2133                         da[i] = y;
2134                 }
2135         }
2136
2137         return;
2138 }
2139
2140 static int reorder(struct hostdata *ha, unsigned long cursec,
2141                    unsigned int ihdlr, unsigned int il[], unsigned int n_ready)
2142 {
2143         struct scsi_cmnd *SCpnt;
2144         struct mscp *cpp;
2145         unsigned int k, n;
2146         unsigned int rev = 0, s = 1, r = 1;
2147         unsigned int input_only = 1, overlap = 0;
2148         unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
2149         unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
2150         unsigned long ioseek = 0;
2151
2152         static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
2153         static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
2154         static unsigned int readysorted = 0, revcount = 0;
2155         static unsigned long seeksorted = 0, seeknosort = 0;
2156
2157         if (link_statistics && !(++flushcount % link_statistics))
2158                 printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"
2159                        " av %ldK as %ldK.\n", flushcount, batchcount,
2160                        inputcount, ovlcount, readycount, readysorted, sortcount,
2161                        revcount, seeknosort / (readycount + 1),
2162                        seeksorted / (readycount + 1));
2163
2164         if (n_ready <= 1)
2165                 return 0;
2166
2167         for (n = 0; n < n_ready; n++) {
2168                 k = il[n];
2169                 cpp = &ha->cp[k];
2170                 SCpnt = cpp->SCpnt;
2171
2172                 if (!cpp->din)
2173                         input_only = 0;
2174
2175                 if (SCpnt->request->sector < minsec)
2176                         minsec = SCpnt->request->sector;
2177                 if (SCpnt->request->sector > maxsec)
2178                         maxsec = SCpnt->request->sector;
2179
2180                 sl[n] = SCpnt->request->sector;
2181                 ioseek += SCpnt->request->nr_sectors;
2182
2183                 if (!n)
2184                         continue;
2185
2186                 if (sl[n] < sl[n - 1])
2187                         s = 0;
2188                 if (sl[n] > sl[n - 1])
2189                         r = 0;
2190
2191                 if (link_statistics) {
2192                         if (sl[n] > sl[n - 1])
2193                                 seek += sl[n] - sl[n - 1];
2194                         else
2195                                 seek += sl[n - 1] - sl[n];
2196                 }
2197
2198         }
2199
2200         if (link_statistics) {
2201                 if (cursec > sl[0])
2202                         seek += cursec - sl[0];
2203                 else
2204                         seek += sl[0] - cursec;
2205         }
2206
2207         if (cursec > ((maxsec + minsec) / 2))
2208                 rev = 1;
2209
2210         if (ioseek > ((maxsec - minsec) / 2))
2211                 rev = 0;
2212
2213         if (!((rev && r) || (!rev && s)))
2214                 sort(sl, il, n_ready, rev);
2215
2216         if (!input_only)
2217                 for (n = 0; n < n_ready; n++) {
2218                         k = il[n];
2219                         cpp = &ha->cp[k];
2220                         SCpnt = cpp->SCpnt;
2221                         ll[n] = SCpnt->request->nr_sectors;
2222                         pl[n] = SCpnt->pid;
2223
2224                         if (!n)
2225                                 continue;
2226
2227                         if ((sl[n] == sl[n - 1])
2228                             || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
2229                             || (rev && ((sl[n] + ll[n]) > sl[n - 1])))
2230                                 overlap = 1;
2231                 }
2232
2233         if (overlap)
2234                 sort(pl, il, n_ready, 0);
2235
2236         if (link_statistics) {
2237                 if (cursec > sl[0])
2238                         iseek = cursec - sl[0];
2239                 else
2240                         iseek = sl[0] - cursec;
2241                 batchcount++;
2242                 readycount += n_ready;
2243                 seeknosort += seek / 1024;
2244                 if (input_only)
2245                         inputcount++;
2246                 if (overlap) {
2247                         ovlcount++;
2248                         seeksorted += iseek / 1024;
2249                 } else
2250                         seeksorted += (iseek + maxsec - minsec) / 1024;
2251                 if (rev && !r) {
2252                         revcount++;
2253                         readysorted += n_ready;
2254                 }
2255                 if (!rev && !s) {
2256                         sortcount++;
2257                         readysorted += n_ready;
2258                 }
2259         }
2260 #if defined(DEBUG_LINKED_COMMANDS)
2261         if (link_statistics && (overlap || !(flushcount % link_statistics)))
2262                 for (n = 0; n < n_ready; n++) {
2263                         k = il[n];
2264                         cpp = &ha->cp[k];
2265                         SCpnt = cpp->SCpnt;
2266                         printk
2267                             ("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"
2268                              " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2269                              (ihdlr ? "ihdlr" : "qcomm"),
2270                              SCpnt->device->channel, SCpnt->device->id,
2271                              SCpnt->device->lun, SCpnt->pid, k, flushcount,
2272                              n_ready, SCpnt->request->sector,
2273                              SCpnt->request->nr_sectors, cursec, YESNO(s),
2274                              YESNO(r), YESNO(rev), YESNO(input_only),
2275                              YESNO(overlap), cpp->din);
2276                 }
2277 #endif
2278         return overlap;
2279 }
2280
2281 static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2282                       struct hostdata *ha, unsigned int ihdlr)
2283 {
2284         struct scsi_cmnd *SCpnt;
2285         struct mscp *cpp;
2286         unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
2287
2288         for (k = 0; k < dev->host->can_queue; k++) {
2289
2290                 if (ha->cp_stat[k] != READY && ha->cp_stat[k] != IN_USE)
2291                         continue;
2292
2293                 cpp = &ha->cp[k];
2294                 SCpnt = cpp->SCpnt;
2295
2296                 if (SCpnt->device != dev)
2297                         continue;
2298
2299                 if (ha->cp_stat[k] == IN_USE)
2300                         return;
2301
2302                 il[n_ready++] = k;
2303         }
2304
2305         if (reorder(ha, cursec, ihdlr, il, n_ready))
2306                 n_ready = 1;
2307
2308         for (n = 0; n < n_ready; n++) {
2309                 k = il[n];
2310                 cpp = &ha->cp[k];
2311                 SCpnt = cpp->SCpnt;
2312
2313                 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2314                         printk
2315                             ("%s: %s, target %d.%d:%d, pid %ld, mbox %d, adapter"
2316                              " busy, will abort.\n", ha->board_name,
2317                              (ihdlr ? "ihdlr" : "qcomm"),
2318                              SCpnt->device->channel, SCpnt->device->id,
2319                              SCpnt->device->lun, SCpnt->pid, k);
2320                         ha->cp_stat[k] = ABORTING;
2321                         continue;
2322                 }
2323
2324                 ha->cp_stat[k] = IN_USE;
2325         }
2326 }
2327
2328 static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost)
2329 {
2330         struct scsi_cmnd *SCpnt;
2331         unsigned int i, k, c, status, tstatus, reg;
2332         struct mssp *spp;
2333         struct mscp *cpp;
2334         struct hostdata *ha = (struct hostdata *)shost->hostdata;
2335
2336         if (shost->irq != irq)
2337                 panic("%s: ihdlr, irq %d, shost->irq %d.\n", ha->board_name, irq,
2338                       shost->irq);
2339
2340         /* Check if this board need to be serviced */
2341         if (!(inb(shost->io_port + REG_AUX_STATUS) & IRQ_ASSERTED))
2342                 goto none;
2343
2344         ha->iocount++;
2345
2346         if (do_trace)
2347                 printk("%s: ihdlr, enter, irq %d, count %d.\n", ha->board_name, irq,
2348                        ha->iocount);
2349
2350         /* Check if this board is still busy */
2351         if (wait_on_busy(shost->io_port, 20 * MAXLOOP)) {
2352                 reg = inb(shost->io_port + REG_STATUS);
2353                 printk
2354                     ("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.\n",
2355                      ha->board_name, irq, reg, ha->iocount);
2356                 goto none;
2357         }
2358
2359         spp = &ha->sp;
2360
2361         /* Make a local copy just before clearing the interrupt indication */
2362         memcpy(spp, ha->sp_cpu_addr, sizeof(struct mssp));
2363
2364         /* Clear the completion flag and cp pointer on the dynamic copy of sp */
2365         memset(ha->sp_cpu_addr, 0, sizeof(struct mssp));
2366
2367         /* Read the status register to clear the interrupt indication */
2368         reg = inb(shost->io_port + REG_STATUS);
2369
2370 #if defined (DEBUG_INTERRUPT)
2371         {
2372                 unsigned char *bytesp;
2373                 int cnt;
2374                 bytesp = (unsigned char *)spp;
2375                 if (ha->iocount < 200) {
2376                         printk("sp[] =");
2377                         for (cnt = 0; cnt < 15; cnt++)
2378                                 printk(" 0x%x", bytesp[cnt]);
2379                         printk("\n");
2380                 }
2381         }
2382 #endif
2383
2384         /* Reject any sp with supspect data */
2385         if (spp->eoc == 0 && ha->iocount > 1)
2386                 printk
2387                     ("%s: ihdlr, spp->eoc == 0, irq %d, reg 0x%x, count %d.\n",
2388                      ha->board_name, irq, reg, ha->iocount);
2389         if (spp->cpp_index < 0 || spp->cpp_index >= shost->can_queue)
2390                 printk
2391                     ("%s: ihdlr, bad spp->cpp_index %d, irq %d, reg 0x%x, count %d.\n",
2392                      ha->board_name, spp->cpp_index, irq, reg, ha->iocount);
2393         if (spp->eoc == 0 || spp->cpp_index < 0
2394             || spp->cpp_index >= shost->can_queue)
2395                 goto handled;
2396
2397         /* Find the mailbox to be serviced on this board */
2398         i = spp->cpp_index;
2399
2400         cpp = &(ha->cp[i]);
2401
2402 #if defined(DEBUG_GENERATE_ABORTS)
2403         if ((ha->iocount > 500) && ((ha->iocount % 500) < 3))
2404                 goto handled;
2405 #endif
2406
2407         if (ha->cp_stat[i] == IGNORE) {
2408                 ha->cp_stat[i] = FREE;
2409                 goto handled;
2410         } else if (ha->cp_stat[i] == LOCKED) {
2411                 ha->cp_stat[i] = FREE;
2412                 printk("%s: ihdlr, mbox %d unlocked, count %d.\n", ha->board_name, i,
2413                        ha->iocount);
2414                 goto handled;
2415         } else if (ha->cp_stat[i] == FREE) {
2416                 printk("%s: ihdlr, mbox %d is free, count %d.\n", ha->board_name, i,
2417                        ha->iocount);
2418                 goto handled;
2419         } else if (ha->cp_stat[i] == IN_RESET)
2420                 printk("%s: ihdlr, mbox %d is in reset.\n", ha->board_name, i);
2421         else if (ha->cp_stat[i] != IN_USE)
2422                 panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
2423                       ha->board_name, i, ha->cp_stat[i]);
2424
2425         ha->cp_stat[i] = FREE;
2426         SCpnt = cpp->SCpnt;
2427
2428         if (SCpnt == NULL)
2429                 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2430
2431         if (SCpnt->host_scribble == NULL)
2432                 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,
2433                       i, SCpnt->pid, SCpnt);
2434
2435         if (*(unsigned int *)SCpnt->host_scribble != i)
2436                 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
2437                       ha->board_name, i, SCpnt->pid,
2438                       *(unsigned int *)SCpnt->host_scribble);
2439
2440         sync_dma(i, ha);
2441
2442         if (linked_comm && SCpnt->device->queue_depth > 2
2443             && TLDEV(SCpnt->device->type))
2444                 flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
2445
2446         tstatus = status_byte(spp->target_status);
2447
2448 #if defined(DEBUG_GENERATE_ERRORS)
2449         if ((ha->iocount > 500) && ((ha->iocount % 200) < 2))
2450                 spp->adapter_status = 0x01;
2451 #endif
2452
2453         switch (spp->adapter_status) {
2454         case ASOK:              /* status OK */
2455
2456                 /* Forces a reset if a disk drive keeps returning BUSY */
2457                 if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
2458                         status = DID_ERROR << 16;
2459
2460                 /* If there was a bus reset, redo operation on each target */
2461                 else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
2462                          && ha->target_redo[SCpnt->device->id][SCpnt->
2463                                                                   device->
2464                                                                   channel])
2465                         status = DID_BUS_BUSY << 16;
2466
2467                 /* Works around a flaw in scsi.c */
2468                 else if (tstatus == CHECK_CONDITION
2469                          && SCpnt->device->type == TYPE_DISK
2470                          && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
2471                         status = DID_BUS_BUSY << 16;
2472
2473                 else
2474                         status = DID_OK << 16;
2475
2476                 if (tstatus == GOOD)
2477                         ha->target_redo[SCpnt->device->id][SCpnt->device->
2478                                                               channel] = 0;
2479
2480                 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2481                     (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2482                        (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2483                         printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
2484                                "target_status 0x%x, sense key 0x%x.\n",
2485                                ha->board_name,
2486                                SCpnt->device->channel, SCpnt->device->id,
2487                                SCpnt->device->lun, SCpnt->pid,
2488                                spp->target_status, SCpnt->sense_buffer[2]);
2489
2490                 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
2491
2492                 if (ha->last_retried_pid == SCpnt->pid)
2493                         ha->retries = 0;
2494
2495                 break;
2496         case ASST:              /* Selection Time Out */
2497         case 0x02:              /* Command Time Out   */
2498
2499                 if (ha->target_to[SCpnt->device->id][SCpnt->device->channel] > 1)
2500                         status = DID_ERROR << 16;
2501                 else {
2502                         status = DID_TIME_OUT << 16;
2503                         ha->target_to[SCpnt->device->id][SCpnt->device->
2504                                                             channel]++;
2505                 }
2506
2507                 break;
2508
2509                 /* Perform a limited number of internal retries */
2510         case 0x03:              /* SCSI Bus Reset Received */
2511         case 0x04:              /* Initial Controller Power-up */
2512
2513                 for (c = 0; c <= shost->max_channel; c++)
2514                         for (k = 0; k < shost->max_id; k++)
2515                                 ha->target_redo[k][c] = 1;
2516
2517                 if (SCpnt->device->type != TYPE_TAPE
2518                     && ha->retries < MAX_INTERNAL_RETRIES) {
2519
2520 #if defined(DID_SOFT_ERROR)
2521                         status = DID_SOFT_ERROR << 16;
2522 #else
2523                         status = DID_BUS_BUSY << 16;
2524 #endif
2525
2526                         ha->retries++;
2527                         ha->last_retried_pid = SCpnt->pid;
2528                 } else
2529                         status = DID_ERROR << 16;
2530
2531                 break;
2532         case 0x05:              /* Unexpected Bus Phase */
2533         case 0x06:              /* Unexpected Bus Free */
2534         case 0x07:              /* Bus Parity Error */
2535         case 0x08:              /* SCSI Hung */
2536         case 0x09:              /* Unexpected Message Reject */
2537         case 0x0a:              /* SCSI Bus Reset Stuck */
2538         case 0x0b:              /* Auto Request-Sense Failed */
2539         case 0x0c:              /* Controller Ram Parity Error */
2540         default:
2541                 status = DID_ERROR << 16;
2542                 break;
2543         }
2544
2545         SCpnt->result = status | spp->target_status;
2546
2547 #if defined(DEBUG_INTERRUPT)
2548         if (SCpnt->result || do_trace)
2549 #else
2550         if ((spp->adapter_status != ASOK && ha->iocount > 1000) ||
2551             (spp->adapter_status != ASOK &&
2552              spp->adapter_status != ASST && ha->iocount <= 1000) ||
2553             do_trace || msg_byte(spp->target_status))
2554 #endif
2555                 printk("%s: ihdlr, mbox %2d, err 0x%x:%x,"
2556                        " target %d.%d:%d, pid %ld, reg 0x%x, count %d.\n",
2557                        ha->board_name, i, spp->adapter_status, spp->target_status,
2558                        SCpnt->device->channel, SCpnt->device->id,
2559                        SCpnt->device->lun, SCpnt->pid, reg, ha->iocount);
2560
2561         unmap_dma(i, ha);
2562
2563         /* Set the command state to inactive */
2564         SCpnt->host_scribble = NULL;
2565
2566         SCpnt->scsi_done(SCpnt);
2567
2568         if (do_trace)
2569                 printk("%s: ihdlr, exit, irq %d, count %d.\n", ha->board_name,
2570                                 irq, ha->iocount);
2571
2572       handled:
2573         return IRQ_HANDLED;
2574       none:
2575         return IRQ_NONE;
2576 }
2577
2578 static irqreturn_t do_interrupt_handler(int irq, void *shap,
2579                                         struct pt_regs *regs)
2580 {
2581         struct Scsi_Host *shost;
2582         unsigned int j;
2583         unsigned long spin_flags;
2584         irqreturn_t ret;
2585
2586         /* Check if the interrupt must be processed by this handler */
2587         if ((j = (unsigned int)((char *)shap - sha)) >= num_boards)
2588                 return IRQ_NONE;
2589         shost = sh[j];
2590
2591         spin_lock_irqsave(shost->host_lock, spin_flags);
2592         ret = ihdlr(irq, shost);
2593         spin_unlock_irqrestore(shost->host_lock, spin_flags);
2594         return ret;
2595 }
2596
2597 static int eata2x_release(struct Scsi_Host *shost)
2598 {
2599         struct hostdata *ha = (struct hostdata *)shost->hostdata;
2600         unsigned int i;
2601
2602         for (i = 0; i < shost->can_queue; i++)
2603                 if ((&ha->cp[i])->sglist)
2604                         kfree((&ha->cp[i])->sglist);
2605
2606         for (i = 0; i < shost->can_queue; i++)
2607                 pci_unmap_single(ha->pdev, ha->cp[i].cp_dma_addr,
2608                                  sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
2609
2610         if (ha->sp_cpu_addr)
2611                 pci_free_consistent(ha->pdev, sizeof(struct mssp),
2612                                     ha->sp_cpu_addr, ha->sp_dma_addr);
2613
2614         free_irq(shost->irq, &sha[ha->board_number]);
2615
2616         if (shost->dma_channel != NO_DMA)
2617                 free_dma(shost->dma_channel);
2618
2619         release_region(shost->io_port, shost->n_io_port);
2620         scsi_unregister(shost);
2621         return 0;
2622 }
2623
2624 #include "scsi_module.c"
2625
2626 #ifndef MODULE
2627 __setup("eata=", option_setup);
2628 #endif                          /* end MODULE */