1/*
   2 *      u14-34f.c - Low-level driver for UltraStor 14F/34F 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 u14-34f.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 *             of:[y|n]       have_old_firmware=[1|0]
  20 *
  21 *          A valid example using the new parameter format is:
  22 *          modprobe u14-34f "u14-34f=0x340,0x330,lc:y,tm:0,mq:4"
  23 *
  24 *          which is equivalent to the old format:
  25 *          modprobe u14-34f io_port=0x340,0x330 linked_comm=1 tag_mode=0 \
  26 *                        max_queue_depth=4
  27 *
  28 *          With actual module code, u14-34f and u14_34f are equivalent
  29 *          as module parameter names.
  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 *
  49 *      10 Oct 2002 Rev. 7.70 for linux 2.5.42
  50 *        + Foreport from revision 6.70.
  51 *
  52 *      25 Jun 2002 Rev. 6.70 for linux 2.4.19
  53 *        + Fixed endian-ness problem due to bitfields.
  54 *
  55 *      21 Feb 2002 Rev. 6.52 for linux 2.4.18
  56 *        + Backport from rev. 7.22 (use io_request_lock).
  57 *
  58 *      20 Feb 2002 Rev. 7.22 for linux 2.5.5
  59 *        + Remove any reference to virt_to_bus().
  60 *        + Fix pio hang while detecting multiple HBAs.
  61 *
  62 *      01 Jan 2002 Rev. 7.20 for linux 2.5.1
  63 *        + Use the dynamic DMA mapping API.
  64 *
  65 *      19 Dec 2001 Rev. 7.02 for linux 2.5.1
  66 *        + Use SCpnt->sc_data_direction if set.
  67 *        + Use sglist.page instead of sglist.address.
  68 *
  69 *      11 Dec 2001 Rev. 7.00 for linux 2.5.1
  70 *        + Use host->host_lock instead of io_request_lock.
  71 *
  72 *       1 May 2001 Rev. 6.05 for linux 2.4.4
  73 *        + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d)
  74 *
  75 *      25 Jan 2001 Rev. 6.03 for linux 2.4.0
  76 *        + "check_region" call replaced by "request_region".
  77 *
  78 *      22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11
  79 *        + Removed old scsi error handling support.
  80 *        + The obsolete boot option flag eh:n is silently ignored.
  81 *        + Removed error messages while a disk drive is powered up at
  82 *          boot time.
  83 *        + Improved boot messages: all tagged capable device are
  84 *          indicated as "tagged".
  85 *
  86 *      16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18
  87 *        + Updated to the new __setup interface for boot command line options.
  88 *        + When loaded as a module, accepts the new parameter boot_options
  89 *          which value is a string with the same format of the kernel boot
  90 *          command line options. A valid example is:
  91 *          modprobe u14-34f 'boot_options="0x230,0x340,lc:y,mq:4"'
  92 *
  93 *      22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11
  94 *        + Removed pre-2.2 source code compatibility.
  95 *
  96 *      26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111
  97 *          Added command line option (et:[y|n]) to use the existing
  98 *          translation (returned by scsicam_bios_param) as disk geometry.
  99 *          The default is et:n, which uses the disk geometry jumpered
 100 *          on the board.
 101 *          The default value et:n is compatible with all previous revisions
 102 *          of this driver.
 103 *
 104 *      28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104
 105 *          Increased busy timeout from 10 msec. to 200 msec. while
 106 *          processing interrupts.
 107 *
 108 *      18 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102
 109 *          Improved abort handling during the eh recovery process.
 110 *
 111 *      13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101
 112 *          The driver is now fully SMP safe, including the
 113 *          abort and reset routines.
 114 *          Added command line options (eh:[y|n]) to choose between
 115 *          new_eh_code and the old scsi code.
 116 *          If linux version >= 2.1.101 the default is eh:y, while the eh
 117 *          option is ignored for previous releases and the old scsi code
 118 *          is used.
 119 *
 120 *      18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97
 121 *          Reworked interrupt handler.
 122 *
 123 *      11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95
 124 *          Major reliability improvement: when a batch with overlapping
 125 *          requests is detected, requests are queued one at a time
 126 *          eliminating any possible board or drive reordering.
 127 *
 128 *      10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95
 129 *          Improved SMP support (if linux version >= 2.1.95).
 130 *
 131 *       9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94
 132 *          Performance improvement: when sequential i/o is detected,
 133 *          always use direct sort instead of reverse sort.
 134 *
 135 *       4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92
 136 *          io_port is now unsigned long.
 137 *
 138 *      17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88
 139 *          Use new scsi error handling code (if linux version >= 2.1.88).
 140 *          Use new interrupt code.
 141 *
 142 *      12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55
 143 *          Use of udelay inside the wait loops to avoid timeout
 144 *          problems with fast cpus.
 145 *          Removed check about useless calls to the interrupt service
 146 *          routine (reported on SMP systems only).
 147 *          At initialization time "sorted/unsorted" is displayed instead
 148 *          of "linked/unlinked" to reinforce the fact that "linking" is
 149 *          nothing but "elevator sorting" in the actual implementation.
 150 *
 151 *      17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38
 152 *          Use of serial_number_at_timeout in abort and reset processing.
 153 *          Use of the __initfunc and __initdata macro in setup code.
 154 *          Minor cleanups in the list_statistics code.
 155 *
 156 *      24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26
 157 *          When loading as a module, parameter passing is now supported
 158 *          both in 2.0 and in 2.1 style.
 159 *          Fixed data transfer direction for some SCSI opcodes.
 160 *          Immediate acknowledge to request sense commands.
 161 *          Linked commands to each disk device are now reordered by elevator
 162 *          sorting. Rare cases in which reordering of write requests could
 163 *          cause wrong results are managed.
 164 *
 165 *      18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28
 166 *          Added command line options to enable/disable linked commands
 167 *          (lc:[y|n]), old firmware support (of:[y|n]) and to set the max
 168 *          queue depth (mq:xx). Default is "u14-34f=lc:n,of:n,mq:8".
 169 *          Improved command linking.
 170 *
 171 *       8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27
 172 *          Added linked command support.
 173 *
 174 *       3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27
 175 *          Added queue depth adjustment.
 176 *
 177 *      22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26
 178 *          The list of i/o ports to be probed can be overwritten by the
 179 *          "u14-34f=port0,port1,...." boot command line option.
 180 *          Scatter/gather lists are now allocated by a number of kmalloc
 181 *          calls, in order to avoid the previous size limit of 64Kb.
 182 *
 183 *      16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25
 184 *          Added multichannel support.
 185 *
 186 *      27 Sep 1996 rev. 2.12 for linux 2.1.0
 187 *          Portability cleanups (virtual/bus addressing, little/big endian
 188 *          support).
 189 *
 190 *      09 Jul 1996 rev. 2.11 for linux 2.0.4
 191 *          "Data over/under-run" no longer implies a redo on all targets.
 192 *          Number of internal retries is now limited.
 193 *
 194 *      16 Apr 1996 rev. 2.10 for linux 1.3.90
 195 *          New argument "reset_flags" to the reset routine.
 196 *
 197 *      21 Jul 1995 rev. 2.02 for linux 1.3.11
 198 *          Fixed Data Transfer Direction for some SCSI commands.
 199 *
 200 *      13 Jun 1995 rev. 2.01 for linux 1.2.10
 201 *          HAVE_OLD_UX4F_FIRMWARE should be defined for U34F boards when
 202 *          the firmware prom is not the latest one (28008-006).
 203 *
 204 *      11 Mar 1995 rev. 2.00 for linux 1.2.0
 205 *          Fixed a bug which prevented media change detection for removable
 206 *          disk drives.
 207 *
 208 *      23 Feb 1995 rev. 1.18 for linux 1.1.94
 209 *          Added a check for scsi_register returning NULL.
 210 *
 211 *      11 Feb 1995 rev. 1.17 for linux 1.1.91
 212 *          U14F qualified to run with 32 sglists.
 213 *          Now DEBUG_RESET is disabled by default.
 214 *
 215 *       9 Feb 1995 rev. 1.16 for linux 1.1.90
 216 *          Use host->wish_block instead of host->block.
 217 *
 218 *       8 Feb 1995 rev. 1.15 for linux 1.1.89
 219 *          Cleared target_time_out counter while performing a reset.
 220 *
 221 *      28 Jan 1995 rev. 1.14 for linux 1.1.86
 222 *          Added module support.
 223 *          Log and do a retry when a disk drive returns a target status
 224 *          different from zero on a recovered error.
 225 *          Auto detects if U14F boards have an old firmware revision.
 226 *          Max number of scatter/gather lists set to 16 for all boards
 227 *          (most installation run fine using 33 sglists, while other
 228 *          has problems when using more than 16).
 229 *
 230 *      16 Jan 1995 rev. 1.13 for linux 1.1.81
 231 *          Display a message if check_region detects a port address
 232 *          already in use.
 233 *
 234 *      15 Dec 1994 rev. 1.12 for linux 1.1.74
 235 *          The host->block flag is set for all the detected ISA boards.
 236 *
 237 *      30 Nov 1994 rev. 1.11 for linux 1.1.68
 238 *          Redo i/o on target status CHECK_CONDITION for TYPE_DISK only.
 239 *          Added optional support for using a single board at a time.
 240 *
 241 *      14 Nov 1994 rev. 1.10 for linux 1.1.63
 242 *
 243 *      28 Oct 1994 rev. 1.09 for linux 1.1.58  Final BETA release.
 244 *      16 Jul 1994 rev. 1.00 for linux 1.1.29  Initial ALPHA release.
 245 *
 246 *          This driver is a total replacement of the original UltraStor
 247 *          scsi driver, but it supports ONLY the 14F and 34F boards.
 248 *          It can be configured in the same kernel in which the original
 249 *          ultrastor driver is configured to allow the original U24F
 250 *          support.
 251 *
 252 *          Multiple U14F and/or U34F host adapters are supported.
 253 *
 254 *  Copyright (C) 1994-2003 Dario Ballabio (ballabio_dario@emc.com)
 255 *
 256 *  Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it
 257 *
 258 *  Redistribution and use in source and binary forms, with or without
 259 *  modification, are permitted provided that redistributions of source
 260 *  code retain the above copyright notice and this comment without
 261 *  modification.
 262 *
 263 *      WARNING: if your 14/34F board has an old firmware revision (see below)
 264 *               you must change "#undef" into "#define" in the following
 265 *               statement.
 266 */
 267#undef HAVE_OLD_UX4F_FIRMWARE
 268/*
 269 *  The UltraStor 14F, 24F, and 34F are a family of intelligent, high
 270 *  performance SCSI-2 host adapters.
 271 *  Here is the scoop on the various models:
 272 *
 273 *  14F - ISA first-party DMA HA with floppy support and WD1003 emulation.
 274 *  24F - EISA Bus Master HA with floppy support and WD1003 emulation.
 275 *  34F - VESA Local-Bus Bus Master HA (no WD1003 emulation).
 276 *
 277 *  This code has been tested with up to two U14F boards, using both
 278 *  firmware 28004-005/38004-004 (BIOS rev. 2.00) and the latest firmware
 279 *  28004-006/38004-005 (BIOS rev. 2.01).
 280 *
 281 *  The latest firmware is required in order to get reliable operations when
 282 *  clustering is enabled. ENABLE_CLUSTERING provides a performance increase
 283 *  up to 50% on sequential access.
 284 *
 285 *  Since the struct scsi_host_template structure is shared among all 14F and 34F,
 286 *  the last setting of use_clustering is in effect for all of these boards.
 287 *
 288 *  Here a sample configuration using two U14F boards:
 289 *
 290 U14F0: ISA 0x330, BIOS 0xc8000, IRQ 11, DMA 5, SG 32, MB 16, of:n, lc:y, mq:8.
 291 U14F1: ISA 0x340, BIOS 0x00000, IRQ 10, DMA 6, SG 32, MB 16, of:n, lc:y, mq:8.
 292 *
 293 *  The boot controller must have its BIOS enabled, while other boards can
 294 *  have their BIOS disabled, or enabled to an higher address.
 295 *  Boards are named Ux4F0, Ux4F1..., according to the port address order in
 296 *  the io_port[] array.
 297 *
 298 *  The following facts are based on real testing results (not on
 299 *  documentation) on the above U14F board.
 300 *
 301 *  - The U14F board should be jumpered for bus on time less or equal to 7
 302 *    microseconds, while the default is 11 microseconds. This is order to
 303 *    get acceptable performance while using floppy drive and hard disk
 304 *    together. The jumpering for 7 microseconds is: JP13 pin 15-16,
 305 *    JP14 pin 7-8 and pin 9-10.
 306 *    The reduction has a little impact on scsi performance.
 307 *
 308 *  - If scsi bus length exceeds 3m., the scsi bus speed needs to be reduced
 309 *    from 10Mhz to 5Mhz (do this by inserting a jumper on JP13 pin 7-8).
 310 *
 311 *  - If U14F on board firmware is older than 28004-006/38004-005,
 312 *    the U14F board is unable to provide reliable operations if the scsi
 313 *    request length exceeds 16Kbyte. When this length is exceeded the
 314 *    behavior is:
 315 *    - adapter_status equal 0x96 or 0xa3 or 0x93 or 0x94;
 316 *    - adapter_status equal 0 and target_status equal 2 on for all targets
 317 *      in the next operation following the reset.
 318 *    This sequence takes a long time (>3 seconds), so in the meantime
 319 *    the SD_TIMEOUT in sd.c could expire giving rise to scsi aborts
 320 *    (SD_TIMEOUT has been increased from 3 to 6 seconds in 1.1.31).
 321 *    Because of this I had to DISABLE_CLUSTERING and to work around the
 322 *    bus reset in the interrupt service routine, returning DID_BUS_BUSY
 323 *    so that the operations are retried without complains from the scsi.c
 324 *    code.
 325 *    Any reset of the scsi bus is going to kill tape operations, since
 326 *    no retry is allowed for tapes. Bus resets are more likely when the
 327 *    scsi bus is under heavy load.
 328 *    Requests using scatter/gather have a maximum length of 16 x 1024 bytes
 329 *    when DISABLE_CLUSTERING is in effect, but unscattered requests could be
 330 *    larger than 16Kbyte.
 331 *
 332 *    The new firmware has fixed all the above problems.
 333 *
 334 *  For U34F boards the latest bios prom is 38008-002 (BIOS rev. 2.01),
 335 *  the latest firmware prom is 28008-006. Older firmware 28008-005 has
 336 *  problems when using more than 16 scatter/gather lists.
 337 *
 338 *  The list of i/o ports to be probed can be totally replaced by the
 339 *  boot command line option: "u14-34f=port0,port1,port2,...", where the
 340 *  port0, port1... arguments are ISA/VESA addresses to be probed.
 341 *  For example using "u14-34f=0x230,0x340", the driver probes only the two
 342 *  addresses 0x230 and 0x340 in this order; "u14-34f=0" totally disables
 343 *  this driver.
 344 *
 345 *  After the optional list of detection probes, other possible command line
 346 *  options are:
 347 *
 348 *  et:y  use disk geometry returned by scsicam_bios_param;
 349 *  et:n  use disk geometry jumpered on the board;
 350 *  lc:y  enables linked commands;
 351 *  lc:n  disables linked commands;
 352 *  tm:0  disables tagged commands (same as tc:n);
 353 *  tm:1  use simple queue tags (same as tc:y);
 354 *  tm:2  use ordered queue tags (same as tc:2);
 355 *  of:y  enables old firmware support;
 356 *  of:n  disables old firmware support;
 357 *  mq:xx set the max queue depth to the value xx (2 <= xx <= 8).
 358 *
 359 *  The default value is: "u14-34f=lc:n,of:n,mq:8,tm:0,et:n".
 360 *  An example using the list of detection probes could be:
 361 *  "u14-34f=0x230,0x340,lc:y,tm:2,of:n,mq:4,et:n".
 362 *
 363 *  When loading as a module, parameters can be specified as well.
 364 *  The above example would be (use 1 in place of y and 0 in place of n):
 365 *
 366 *  modprobe u14-34f io_port=0x230,0x340 linked_comm=1 have_old_firmware=0 \
 367 *                max_queue_depth=4 ext_tran=0 tag_mode=2
 368 *
 369 *  ----------------------------------------------------------------------------
 370 *  In this implementation, linked commands are designed to work with any DISK
 371 *  or CD-ROM, since this linking has only the intent of clustering (time-wise)
 372 *  and reordering by elevator sorting commands directed to each device,
 373 *  without any relation with the actual SCSI protocol between the controller
 374 *  and the device.
 375 *  If Q is the queue depth reported at boot time for each device (also named
 376 *  cmds/lun) and Q > 2, whenever there is already an active command to the
 377 *  device all other commands to the same device  (up to Q-1) are kept waiting
 378 *  in the elevator sorting queue. When the active command completes, the
 379 *  commands in this queue are sorted by sector address. The sort is chosen
 380 *  between increasing or decreasing by minimizing the seek distance between
 381 *  the sector of the commands just completed and the sector of the first
 382 *  command in the list to be sorted.
 383 *  Trivial math assures that the unsorted average seek distance when doing
 384 *  random seeks over S sectors is S/3.
 385 *  When (Q-1) requests are uniformly distributed over S sectors, the average
 386 *  distance between two adjacent requests is S/((Q-1) + 1), so the sorted
 387 *  average seek distance for (Q-1) random requests over S sectors is S/Q.
 388 *  The elevator sorting hence divides the seek distance by a factor Q/3.
 389 *  The above pure geometric remarks are valid in all cases and the
 390 *  driver effectively reduces the seek distance by the predicted factor
 391 *  when there are Q concurrent read i/o operations on the device, but this
 392 *  does not necessarily results in a noticeable performance improvement:
 393 *  your mileage may vary....
 394 *
 395 *  Note: command reordering inside a batch of queued commands could cause
 396 *        wrong results only if there is at least one write request and the
 397 *        intersection (sector-wise) of all requests is not empty.
 398 *        When the driver detects a batch including overlapping requests
 399 *        (a really rare event) strict serial (pid) order is enforced.
 400 *  ----------------------------------------------------------------------------
 401 *
 402 *  The boards are named Ux4F0, Ux4F1,... according to the detection order.
 403 *
 404 *  In order to support multiple ISA boards in a reliable way,
 405 *  the driver sets host->wish_block = TRUE for all ISA boards.
 406 */
 407
 408#include <linux/string.h>
 409#include <linux/kernel.h>
 410#include <linux/ioport.h>
 411#include <linux/delay.h>
 412#include <asm/io.h>
 413#include <asm/system.h>
 414#include <asm/byteorder.h>
 415#include <linux/proc_fs.h>
 416#include <linux/blkdev.h>
 417#include <linux/interrupt.h>
 418#include <linux/stat.h>
 419#include <linux/pci.h>
 420#include <linux/init.h>
 421#include <linux/ctype.h>
 422#include <linux/spinlock.h>
 423#include <linux/slab.h>
 424#include <asm/dma.h>
 425#include <asm/irq.h>
 426
 427#include <scsi/scsi.h>
 428#include <scsi/scsi_cmnd.h>
 429#include <scsi/scsi_device.h>
 430#include <scsi/scsi_host.h>
 431#include <scsi/scsi_tcq.h>
 432#include <scsi/scsicam.h>
 433
 434static int u14_34f_detect(struct scsi_host_template *);
 435static int u14_34f_release(struct Scsi_Host *);
 436static int u14_34f_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
 437static int u14_34f_eh_abort(struct scsi_cmnd *);
 438static int u14_34f_eh_host_reset(struct scsi_cmnd *);
 439static int u14_34f_bios_param(struct scsi_device *, struct block_device *,
 440                              sector_t, int *);
 441static int u14_34f_slave_configure(struct scsi_device *);
 442
 443static struct scsi_host_template driver_template = {
 444                .name                    = "UltraStor 14F/34F rev. 8.10.00 ",
 445                .detect                  = u14_34f_detect,
 446                .release                 = u14_34f_release,
 447                .queuecommand            = u14_34f_queuecommand,
 448                .eh_abort_handler        = u14_34f_eh_abort,
 449                .eh_host_reset_handler   = u14_34f_eh_host_reset,
 450                .bios_param              = u14_34f_bios_param,
 451                .slave_configure         = u14_34f_slave_configure,
 452                .this_id                 = 7,
 453                .unchecked_isa_dma       = 1,
 454                .use_clustering          = ENABLE_CLUSTERING,
 455                };
 456
 457#if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
 458#error "Adjust your <asm/byteorder.h> defines"
 459#endif
 460
 461/* Values for the PRODUCT_ID ports for the 14/34F */
 462#define PRODUCT_ID1  0x56
 463#define PRODUCT_ID2  0x40        /* NOTE: Only upper nibble is used */
 464
 465/* Subversion values */
 466#define ISA  0
 467#define ESA 1
 468
 469#define OP_HOST_ADAPTER   0x1
 470#define OP_SCSI           0x2
 471#define OP_RESET          0x4
 472#define DTD_SCSI          0x0
 473#define DTD_IN            0x1
 474#define DTD_OUT           0x2
 475#define DTD_NONE          0x3
 476#define HA_CMD_INQUIRY    0x1
 477#define HA_CMD_SELF_DIAG  0x2
 478#define HA_CMD_READ_BUFF  0x3
 479#define HA_CMD_WRITE_BUFF 0x4
 480
 481#undef  DEBUG_LINKED_COMMANDS
 482#undef  DEBUG_DETECT
 483#undef  DEBUG_INTERRUPT
 484#undef  DEBUG_RESET
 485#undef  DEBUG_GENERATE_ERRORS
 486#undef  DEBUG_GENERATE_ABORTS
 487#undef  DEBUG_GEOMETRY
 488
 489#define MAX_ISA 3
 490#define MAX_VESA 1
 491#define MAX_EISA 0
 492#define MAX_PCI 0
 493#define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
 494#define MAX_CHANNEL 1
 495#define MAX_LUN 8
 496#define MAX_TARGET 8
 497#define MAX_MAILBOXES 16
 498#define MAX_SGLIST 32
 499#define MAX_SAFE_SGLIST 16
 500#define MAX_INTERNAL_RETRIES 64
 501#define MAX_CMD_PER_LUN 2
 502#define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
 503
 504#define SKIP ULONG_MAX
 505#define FALSE 0
 506#define TRUE 1
 507#define FREE 0
 508#define IN_USE   1
 509#define LOCKED   2
 510#define IN_RESET 3
 511#define IGNORE   4
 512#define READY    5
 513#define ABORTING 6
 514#define NO_DMA  0xff
 515#define MAXLOOP  10000
 516#define TAG_DISABLED 0
 517#define TAG_SIMPLE   1
 518#define TAG_ORDERED  2
 519
 520#define REG_LCL_MASK      0
 521#define REG_LCL_INTR      1
 522#define REG_SYS_MASK      2
 523#define REG_SYS_INTR      3
 524#define REG_PRODUCT_ID1   4
 525#define REG_PRODUCT_ID2   5
 526#define REG_CONFIG1       6
 527#define REG_CONFIG2       7
 528#define REG_OGM           8
 529#define REG_ICM           12
 530#define REGION_SIZE       13UL
 531#define BSY_ASSERTED      0x01
 532#define IRQ_ASSERTED      0x01
 533#define CMD_RESET         0xc0
 534#define CMD_OGM_INTR      0x01
 535#define CMD_CLR_INTR      0x01
 536#define CMD_ENA_INTR      0x81
 537#define ASOK              0x00
 538#define ASST              0x91
 539
 540#define YESNO(a) ((a) ? 'y' : 'n')
 541#define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
 542
 543#define PACKED          __attribute__((packed))
 544
 545struct sg_list {
 546   unsigned int address;                /* Segment Address */
 547   unsigned int num_bytes;              /* Segment Length */
 548   };
 549
 550/* MailBox SCSI Command Packet */
 551struct mscp {
 552
 553#if defined(__BIG_ENDIAN_BITFIELD)
 554   unsigned char sg:1, ca:1, dcn:1, xdir:2, opcode:3;
 555   unsigned char lun: 3, channel:2, target:3;
 556#else
 557   unsigned char opcode: 3,             /* type of command */
 558                 xdir: 2,               /* data transfer direction */
 559                 dcn: 1,                /* disable disconnect */
 560                 ca: 1,                 /* use cache (if available) */
 561                 sg: 1;                 /* scatter/gather operation */
 562   unsigned char target: 3,             /* SCSI target id */
 563                 channel: 2,            /* SCSI channel number */
 564                 lun: 3;                /* SCSI logical unit number */
 565#endif
 566
 567   unsigned int data_address PACKED;    /* transfer data pointer */
 568   unsigned int data_len PACKED;        /* length in bytes */
 569   unsigned int link_address PACKED;    /* for linking command chains */
 570   unsigned char clink_id;              /* identifies command in chain */
 571   unsigned char use_sg;                /* (if sg is set) 8 bytes per list */
 572   unsigned char sense_len;
 573   unsigned char cdb_len;               /* 6, 10, or 12 */
 574   unsigned char cdb[12];               /* SCSI Command Descriptor Block */
 575   unsigned char adapter_status;        /* non-zero indicates HA error */
 576   unsigned char target_status;         /* non-zero indicates target error */
 577   unsigned int sense_addr PACKED;
 578
 579   /* Additional fields begin here. */
 580   struct scsi_cmnd *SCpnt;
 581   unsigned int cpp_index;              /* cp index */
 582
 583   /* All the cp structure is zero filled by queuecommand except the
 584      following CP_TAIL_SIZE bytes, initialized by detect */
 585   dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
 586   struct sg_list *sglist; /* pointer to the allocated SG list */
 587   };
 588
 589#define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
 590
 591struct hostdata {
 592   struct mscp cp[MAX_MAILBOXES];       /* Mailboxes for this board */
 593   unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
 594   unsigned int last_cp_used;           /* Index of last mailbox used */
 595   unsigned int iocount;                /* Total i/o done for this board */
 596   int board_number;                    /* Number of this board */
 597   char board_name[16];                 /* Name of this board */
 598   int in_reset;                        /* True if board is doing a reset */
 599   int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
 600   int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If TRUE redo i/o on target */
 601   unsigned int retries;                /* Number of internal retries */
 602   unsigned long last_retried_pid;      /* Pid of last retried command */
 603   unsigned char subversion;            /* Bus type, either ISA or ESA */
 604   struct pci_dev *pdev;                /* Always NULL */
 605   unsigned char heads;
 606   unsigned char sectors;
 607   char board_id[256];                  /* data from INQUIRY on this board */
 608   };
 609
 610static struct Scsi_Host *sh[MAX_BOARDS + 1];
 611static const char *driver_name = "Ux4F";
 612static char sha[MAX_BOARDS];
 613static DEFINE_SPINLOCK(driver_lock);
 614
 615/* Initialize num_boards so that ihdlr can work while detect is in progress */
 616static unsigned int num_boards = MAX_BOARDS;
 617
 618static unsigned long io_port[] = {
 619
 620   /* Space for MAX_INT_PARAM ports usable while loading as a module */
 621   SKIP,    SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,
 622   SKIP,    SKIP,
 623
 624   /* Possible ISA/VESA ports */
 625   0x330, 0x340, 0x230, 0x240, 0x210, 0x130, 0x140,
 626
 627   /* End of list */
 628   0x0
 629   };
 630
 631#define HD(board) ((struct hostdata *) &sh[board]->hostdata)
 632#define BN(board) (HD(board)->board_name)
 633
 634/* Device is Little Endian */
 635#define H2DEV(x) cpu_to_le32(x)
 636#define DEV2H(x) le32_to_cpu(x)
 637
 638static irqreturn_t do_interrupt_handler(int, void *);
 639static void flush_dev(struct scsi_device *, unsigned long, unsigned int, unsigned int);
 640static int do_trace = FALSE;
 641static int setup_done = FALSE;
 642static int link_statistics;
 643static int ext_tran = FALSE;
 644
 645#if defined(HAVE_OLD_UX4F_FIRMWARE)
 646static int have_old_firmware = TRUE;
 647#else
 648static int have_old_firmware = FALSE;
 649#endif
 650
 651#if defined(CONFIG_SCSI_U14_34F_TAGGED_QUEUE)
 652static int tag_mode = TAG_SIMPLE;
 653#else
 654static int tag_mode = TAG_DISABLED;
 655#endif
 656
 657#if defined(CONFIG_SCSI_U14_34F_LINKED_COMMANDS)
 658static int linked_comm = TRUE;
 659#else
 660static int linked_comm = FALSE;
 661#endif
 662
 663#if defined(CONFIG_SCSI_U14_34F_MAX_TAGS)
 664static int max_queue_depth = CONFIG_SCSI_U14_34F_MAX_TAGS;
 665#else
 666static int max_queue_depth = MAX_CMD_PER_LUN;
 667#endif
 668
 669#define MAX_INT_PARAM 10
 670#define MAX_BOOT_OPTIONS_SIZE 256
 671static char boot_options[MAX_BOOT_OPTIONS_SIZE];
 672
 673#if defined(MODULE)
 674#include <linux/module.h>
 675#include <linux/moduleparam.h>
 676
 677module_param_string(u14_34f, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
 678MODULE_PARM_DESC(u14_34f, " equivalent to the \"u14-34f=...\" kernel boot " \
 679"option." \
 680"      Example: modprobe u14-34f \"u14_34f=0x340,0x330,lc:y,tm:0,mq:4\"");
 681MODULE_AUTHOR("Dario Ballabio");
 682MODULE_LICENSE("GPL");
 683MODULE_DESCRIPTION("UltraStor 14F/34F SCSI Driver");
 684
 685#endif
 686
 687static int u14_34f_slave_configure(struct scsi_device *dev) {
 688   int j, tqd, utqd;
 689   char *tag_suffix, *link_suffix;
 690   struct Scsi_Host *host = dev->host;
 691
 692   j = ((struct hostdata *) host->hostdata)->board_number;
 693
 694   utqd = MAX_CMD_PER_LUN;
 695   tqd = max_queue_depth;
 696
 697   if (TLDEV(dev->type) && dev->tagged_supported)
 698
 699      if (tag_mode == TAG_SIMPLE) {
 700         scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
 701         tag_suffix = ", simple tags";
 702         }
 703      else if (tag_mode == TAG_ORDERED) {
 704         scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
 705         tag_suffix = ", ordered tags";
 706         }
 707      else {
 708         scsi_adjust_queue_depth(dev, 0, tqd);
 709         tag_suffix = ", no tags";
 710         }
 711
 712   else if (TLDEV(dev->type) && linked_comm) {
 713      scsi_adjust_queue_depth(dev, 0, tqd);
 714      tag_suffix = ", untagged";
 715      }
 716
 717   else {
 718      scsi_adjust_queue_depth(dev, 0, utqd);
 719      tag_suffix = "";
 720      }
 721
 722   if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
 723      link_suffix = ", sorted";
 724   else if (TLDEV(dev->type))
 725      link_suffix = ", unsorted";
 726   else
 727      link_suffix = "";
 728
 729   sdev_printk(KERN_INFO, dev, "cmds/lun %d%s%s.\n",
 730          dev->queue_depth, link_suffix, tag_suffix);
 731
 732   return FALSE;
 733}
 734
 735static int wait_on_busy(unsigned long iobase, unsigned int loop) {
 736
 737   while (inb(iobase + REG_LCL_INTR) & BSY_ASSERTED) {
 738      udelay(1L);
 739      if (--loop == 0) return TRUE;
 740      }
 741
 742   return FALSE;
 743}
 744
 745static int board_inquiry(unsigned int j) {
 746   struct mscp *cpp;
 747   dma_addr_t id_dma_addr;
 748   unsigned int limit = 0;
 749   unsigned long time;
 750
 751   id_dma_addr = pci_map_single(HD(j)->pdev, HD(j)->board_id,
 752                    sizeof(HD(j)->board_id), PCI_DMA_BIDIRECTIONAL);
 753   cpp = &HD(j)->cp[0];
 754   cpp->cp_dma_addr = pci_map_single(HD(j)->pdev, cpp, sizeof(struct mscp),
 755                                     PCI_DMA_BIDIRECTIONAL);
 756   memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
 757   cpp->opcode = OP_HOST_ADAPTER;
 758   cpp->xdir = DTD_IN;
 759   cpp->data_address = H2DEV(id_dma_addr);
 760   cpp->data_len = H2DEV(sizeof(HD(j)->board_id));
 761   cpp->cdb_len = 6;
 762   cpp->cdb[0] = HA_CMD_INQUIRY;
 763
 764   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
 765      printk("%s: board_inquiry, adapter busy.\n", BN(j));
 766      return TRUE;
 767      }
 768
 769   HD(j)->cp_stat[0] = IGNORE;
 770
 771   /* Clear the interrupt indication */
 772   outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
 773
 774   /* Store pointer in OGM address bytes */
 775   outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
 776
 777   /* Issue OGM interrupt */
 778   outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
 779
 780   spin_unlock_irq(&driver_lock);
 781   time = jiffies;
 782   while ((jiffies - time) < HZ && limit++ < 20000) udelay(100L);
 783   spin_lock_irq(&driver_lock);
 784
 785   if (cpp->adapter_status || HD(j)->cp_stat[0] != FREE) {
 786      HD(j)->cp_stat[0] = FREE;
 787      printk("%s: board_inquiry, err 0x%x.\n", BN(j), cpp->adapter_status);
 788      return TRUE;
 789      }
 790
 791   pci_unmap_single(HD(j)->pdev, cpp->cp_dma_addr, sizeof(struct mscp),
 792                    PCI_DMA_BIDIRECTIONAL);
 793   pci_unmap_single(HD(j)->pdev, id_dma_addr, sizeof(HD(j)->board_id),
 794                    PCI_DMA_BIDIRECTIONAL);
 795   return FALSE;
 796}
 797
 798static int port_detect \
 799      (unsigned long port_base, unsigned int j, struct scsi_host_template *tpnt) {
 800   unsigned char irq, dma_channel, subversion, i;
 801   unsigned char in_byte;
 802   char *bus_type, dma_name[16];
 803
 804   /* Allowed BIOS base addresses (NULL indicates reserved) */
 805   unsigned long bios_segment_table[8] = {
 806      0,
 807      0xc4000, 0xc8000, 0xcc000, 0xd0000,
 808      0xd4000, 0xd8000, 0xdc000
 809      };
 810
 811   /* Allowed IRQs */
 812   unsigned char interrupt_table[4] = { 15, 14, 11, 10 };
 813
 814   /* Allowed DMA channels for ISA (0 indicates reserved) */
 815   unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
 816
 817   /* Head/sector mappings */
 818   struct {
 819      unsigned char heads;
 820      unsigned char sectors;
 821      } mapping_table[4] = {
 822           { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 }
 823           };
 824
 825   struct config_1 {
 826
 827#if defined(__BIG_ENDIAN_BITFIELD)
 828      unsigned char dma_channel: 2, interrupt:2,
 829                    removable_disks_as_fixed:1, bios_segment: 3;
 830#else
 831      unsigned char bios_segment: 3, removable_disks_as_fixed: 1,
 832                    interrupt: 2, dma_channel: 2;
 833#endif
 834
 835      } config_1;
 836
 837   struct config_2 {
 838
 839#if defined(__BIG_ENDIAN_BITFIELD)
 840      unsigned char tfr_port: 2, bios_drive_number: 1,
 841                    mapping_mode: 2, ha_scsi_id: 3;
 842#else
 843      unsigned char ha_scsi_id: 3, mapping_mode: 2,
 844                    bios_drive_number: 1, tfr_port: 2;
 845#endif
 846
 847      } config_2;
 848
 849   char name[16];
 850
 851   sprintf(name, "%s%d", driver_name, j);
 852
 853   if (!request_region(port_base, REGION_SIZE, driver_name)) {
 854#if defined(DEBUG_DETECT)
 855      printk("%s: address 0x%03lx in use, skipping probe.\n", name, port_base);
 856#endif
 857      goto fail;
 858      }
 859
 860   spin_lock_irq(&driver_lock);
 861
 862   if (inb(port_base + REG_PRODUCT_ID1) != PRODUCT_ID1) goto freelock;
 863
 864   in_byte = inb(port_base + REG_PRODUCT_ID2);
 865
 866   if ((in_byte & 0xf0) != PRODUCT_ID2) goto freelock;
 867
 868   *(char *)&config_1 = inb(port_base + REG_CONFIG1);
 869   *(char *)&config_2 = inb(port_base + REG_CONFIG2);
 870
 871   irq = interrupt_table[config_1.interrupt];
 872   dma_channel = dma_channel_table[config_1.dma_channel];
 873   subversion = (in_byte & 0x0f);
 874
 875   /* Board detected, allocate its IRQ */
 876   if (request_irq(irq, do_interrupt_handler,
 877             IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0),
 878             driver_name, (void *) &sha[j])) {
 879      printk("%s: unable to allocate IRQ %u, detaching.\n", name, irq);
 880      goto freelock;
 881      }
 882
 883   if (subversion == ISA && request_dma(dma_channel, driver_name)) {
 884      printk("%s: unable to allocate DMA channel %u, detaching.\n",
 885             name, dma_channel);
 886      goto freeirq;
 887      }
 888
 889   if (have_old_firmware) tpnt->use_clustering = DISABLE_CLUSTERING;
 890
 891   spin_unlock_irq(&driver_lock);
 892   sh[j] = scsi_register(tpnt, sizeof(struct hostdata));
 893   spin_lock_irq(&driver_lock);
 894
 895   if (sh[j] == NULL) {
 896      printk("%s: unable to register host, detaching.\n", name);
 897      goto freedma;
 898      }
 899
 900   sh[j]->io_port = port_base;
 901   sh[j]->unique_id = port_base;
 902   sh[j]->n_io_port = REGION_SIZE;
 903   sh[j]->base = bios_segment_table[config_1.bios_segment];
 904   sh[j]->irq = irq;
 905   sh[j]->sg_tablesize = MAX_SGLIST;
 906   sh[j]->this_id = config_2.ha_scsi_id;
 907   sh[j]->can_queue = MAX_MAILBOXES;
 908   sh[j]->cmd_per_lun = MAX_CMD_PER_LUN;
 909
 910#if defined(DEBUG_DETECT)
 911   {
 912   unsigned char sys_mask, lcl_mask;
 913
 914   sys_mask = inb(sh[j]->io_port + REG_SYS_MASK);
 915   lcl_mask = inb(sh[j]->io_port + REG_LCL_MASK);
 916   printk("SYS_MASK 0x%x, LCL_MASK 0x%x.\n", sys_mask, lcl_mask);
 917   }
 918#endif
 919
 920   /* Probably a bogus host scsi id, set it to the dummy value */
 921   if (sh[j]->this_id == 0) sh[j]->this_id = -1;
 922
 923   /* If BIOS is disabled, force enable interrupts */
 924   if (sh[j]->base == 0) outb(CMD_ENA_INTR, sh[j]->io_port + REG_SYS_MASK);
 925
 926   memset(HD(j), 0, sizeof(struct hostdata));
 927   HD(j)->heads = mapping_table[config_2.mapping_mode].heads;
 928   HD(j)->sectors = mapping_table[config_2.mapping_mode].sectors;
 929   HD(j)->subversion = subversion;
 930   HD(j)->pdev = NULL;
 931   HD(j)->board_number = j;
 932
 933   if (have_old_firmware) sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
 934
 935   if (HD(j)->subversion == ESA) {
 936      sh[j]->unchecked_isa_dma = FALSE;
 937      sh[j]->dma_channel = NO_DMA;
 938      sprintf(BN(j), "U34F%d", j);
 939      bus_type = "VESA";
 940      }
 941   else {
 942      unsigned long flags;
 943      sh[j]->unchecked_isa_dma = TRUE;
 944
 945      flags=claim_dma_lock();
 946      disable_dma(dma_channel);
 947      clear_dma_ff(dma_channel);
 948      set_dma_mode(dma_channel, DMA_MODE_CASCADE);
 949      enable_dma(dma_channel);
 950      release_dma_lock(flags);
 951
 952      sh[j]->dma_channel = dma_channel;
 953      sprintf(BN(j), "U14F%d", j);
 954      bus_type = "ISA";
 955      }
 956
 957   sh[j]->max_channel = MAX_CHANNEL - 1;
 958   sh[j]->max_id = MAX_TARGET;
 959   sh[j]->max_lun = MAX_LUN;
 960
 961   if (HD(j)->subversion == ISA && !board_inquiry(j)) {
 962      HD(j)->board_id[40] = 0;
 963
 964      if (strcmp(&HD(j)->board_id[32], "06000600")) {
 965         printk("%s: %s.\n", BN(j), &HD(j)->board_id[8]);
 966         printk("%s: firmware %s is outdated, FW PROM should be 28004-006.\n",
 967                BN(j), &HD(j)->board_id[32]);
 968         sh[j]->hostt->use_clustering = DISABLE_CLUSTERING;
 969         sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
 970         }
 971      }
 972
 973   if (dma_channel == NO_DMA) sprintf(dma_name, "%s", "BMST");
 974   else                       sprintf(dma_name, "DMA %u", dma_channel);
 975
 976   spin_unlock_irq(&driver_lock);
 977
 978   for (i = 0; i < sh[j]->can_queue; i++)
 979      HD(j)->cp[i].cp_dma_addr = pci_map_single(HD(j)->pdev,
 980            &HD(j)->cp[i], sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
 981
 982   for (i = 0; i < sh[j]->can_queue; i++)
 983      if (! ((&HD(j)->cp[i])->sglist = kmalloc(
 984            sh[j]->sg_tablesize * sizeof(struct sg_list),
 985            (sh[j]->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC))) {
 986         printk("%s: kmalloc SGlist failed, mbox %d, detaching.\n", BN(j), i);
 987         goto release;
 988         }
 989
 990   if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
 991       max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
 992
 993   if (max_queue_depth < MAX_CMD_PER_LUN) max_queue_depth = MAX_CMD_PER_LUN;
 994
 995   if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
 996      tag_mode = TAG_ORDERED;
 997
 998   if (j == 0) {
 999      printk("UltraStor 14F/34F: Copyright (C) 1994-2003 Dario Ballabio.\n");
1000      printk("%s config options -> of:%c, tm:%d, lc:%c, mq:%d, et:%c.\n",
1001             driver_name, YESNO(have_old_firmware), tag_mode,
1002             YESNO(linked_comm), max_queue_depth, YESNO(ext_tran));
1003      }
1004
1005   printk("%s: %s 0x%03lx, BIOS 0x%05x, IRQ %u, %s, SG %d, MB %d.\n",
1006          BN(j), bus_type, (unsigned long)sh[j]->io_port, (int)sh[j]->base,
1007          sh[j]->irq, dma_name, sh[j]->sg_tablesize, sh[j]->can_queue);
1008
1009   if (sh[j]->max_id > 8 || sh[j]->max_lun > 8)
1010      printk("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1011             BN(j), sh[j]->max_id, sh[j]->max_lun);
1012
1013   for (i = 0; i <= sh[j]->max_channel; i++)
1014      printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1015             BN(j), i, sh[j]->this_id);
1016
1017   return TRUE;
1018
1019freedma:
1020   if (subversion == ISA) free_dma(dma_channel);
1021freeirq:
1022   free_irq(irq, &sha[j]);
1023freelock:
1024   spin_unlock_irq(&driver_lock);
1025   release_region(port_base, REGION_SIZE);
1026fail:
1027   return FALSE;
1028
1029release:
1030   u14_34f_release(sh[j]);
1031   return FALSE;
1032}
1033
1034static void internal_setup(char *str, int *ints) {
1035   int i, argc = ints[0];
1036   char *cur = str, *pc;
1037
1038   if (argc > 0) {
1039
1040      if (argc > MAX_INT_PARAM) argc = MAX_INT_PARAM;
1041
1042      for (i = 0; i < argc; i++) io_port[i] = ints[i + 1];
1043
1044      io_port[i] = 0;
1045      setup_done = TRUE;
1046      }
1047
1048   while (cur && (pc = strchr(cur, ':'))) {
1049      int val = 0, c = *++pc;
1050
1051      if (c == 'n' || c == 'N') val = FALSE;
1052      else if (c == 'y' || c == 'Y') val = TRUE;
1053      else val = (int) simple_strtoul(pc, NULL, 0);
1054
1055      if (!strncmp(cur, "lc:", 3)) linked_comm = val;
1056      else if (!strncmp(cur, "of:", 3)) have_old_firmware = val;
1057      else if (!strncmp(cur, "tm:", 3)) tag_mode = val;
1058      else if (!strncmp(cur, "tc:", 3)) tag_mode = val;
1059      else if (!strncmp(cur, "mq:", 3))  max_queue_depth = val;
1060      else if (!strncmp(cur, "ls:", 3))  link_statistics = val;
1061      else if (!strncmp(cur, "et:", 3))  ext_tran = val;
1062
1063      if ((cur = strchr(cur, ','))) ++cur;
1064      }
1065
1066   return;
1067}
1068
1069static int option_setup(char *str) {
1070   int ints[MAX_INT_PARAM];
1071   char *cur = str;
1072   int i = 1;
1073
1074   while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
1075      ints[i++] = simple_strtoul(cur, NULL, 0);
1076
1077      if ((cur = strchr(cur, ',')) != NULL) cur++;
1078   }
1079
1080   ints[0] = i - 1;
1081   internal_setup(cur, ints);
1082   return 1;
1083}
1084
1085static int u14_34f_detect(struct scsi_host_template *tpnt) {
1086   unsigned int j = 0, k;
1087
1088   tpnt->proc_name = "u14-34f";
1089
1090   if(strlen(boot_options)) option_setup(boot_options);
1091
1092#if defined(MODULE)
1093   /* io_port could have been modified when loading as a module */
1094   if(io_port[0] != SKIP) {
1095      setup_done = TRUE;
1096      io_port[MAX_INT_PARAM] = 0;
1097      }
1098#endif
1099
1100   for (k = 0; k < MAX_BOARDS + 1; k++) sh[k] = NULL;
1101
1102   for (k = 0; io_port[k]; k++) {
1103
1104      if (io_port[k] == SKIP) continue;
1105
1106      if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt)) j++;
1107      }
1108
1109   num_boards = j;
1110   return j;
1111}
1112
1113static void map_dma(unsigned int i, unsigned int j) {
1114   unsigned int data_len = 0;
1115   unsigned int k, pci_dir;
1116   int count;
1117   struct scatterlist *sg;
1118   struct mscp *cpp;
1119   struct scsi_cmnd *SCpnt;
1120
1121   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1122   pci_dir = SCpnt->sc_data_direction;
1123
1124   if (SCpnt->sense_buffer)
1125      cpp->sense_addr = H2DEV(pci_map_single(HD(j)->pdev, SCpnt->sense_buffer,
1126                           SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE));
1127
1128   cpp->sense_len = SCSI_SENSE_BUFFERSIZE;
1129
1130   if (scsi_bufflen(SCpnt)) {
1131	   count = scsi_dma_map(SCpnt);
1132	   BUG_ON(count < 0);
1133
1134	   scsi_for_each_sg(SCpnt, sg, count, k) {
1135		   cpp->sglist[k].address = H2DEV(sg_dma_address(sg));
1136		   cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(sg));
1137		   data_len += sg->length;
1138	   }
1139
1140	   cpp->sg = TRUE;
1141	   cpp->use_sg = scsi_sg_count(SCpnt);
1142	   cpp->data_address =
1143		   H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist,
1144					cpp->use_sg * sizeof(struct sg_list),
1145					pci_dir));
1146	   cpp->data_len = H2DEV(data_len);
1147
1148   } else {
1149	   pci_dir = PCI_DMA_BIDIRECTIONAL;
1150	   cpp->data_len = H2DEV(scsi_bufflen(SCpnt));
1151   }
1152}
1153
1154static void unmap_dma(unsigned int i, unsigned int j) {
1155   unsigned int pci_dir;
1156   struct mscp *cpp;
1157   struct scsi_cmnd *SCpnt;
1158
1159   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1160   pci_dir = SCpnt->sc_data_direction;
1161
1162   if (DEV2H(cpp->sense_addr))
1163      pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
1164                       DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1165
1166   scsi_dma_unmap(SCpnt);
1167
1168   if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1169
1170   if (DEV2H(cpp->data_address))
1171      pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address),
1172                       DEV2H(cpp->data_len), pci_dir);
1173}
1174
1175static void sync_dma(unsigned int i, unsigned int j) {
1176   unsigned int pci_dir;
1177   struct mscp *cpp;
1178   struct scsi_cmnd *SCpnt;
1179
1180   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1181   pci_dir = SCpnt->sc_data_direction;
1182
1183   if (DEV2H(cpp->sense_addr))
1184      pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr),
1185                          DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1186
1187   if (scsi_sg_count(SCpnt))
1188	   pci_dma_sync_sg_for_cpu(HD(j)->pdev, scsi_sglist(SCpnt),
1189				   scsi_sg_count(SCpnt), pci_dir);
1190
1191   if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1192
1193   if (DEV2H(cpp->data_address))
1194      pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address),
1195                       DEV2H(cpp->data_len), pci_dir);
1196}
1197
1198static void scsi_to_dev_dir(unsigned int i, unsigned int j) {
1199   unsigned int k;
1200
1201   static const unsigned char data_out_cmds[] = {
1202      0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1203      0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1204      0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1205      };
1206
1207   static const unsigned char data_none_cmds[] = {
1208      0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1209      0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1210      0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1211      };
1212
1213   struct mscp *cpp;
1214   struct scsi_cmnd *SCpnt;
1215
1216   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1217
1218   if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1219      cpp->xdir = DTD_IN;
1220      return;
1221      }
1222   else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1223      cpp->xdir = DTD_OUT;
1224      return;
1225      }
1226   else if (SCpnt->sc_data_direction == DMA_NONE) {
1227      cpp->xdir = DTD_NONE;
1228      return;
1229      }
1230
1231   if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1232      panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", BN(j));
1233
1234   cpp->xdir = DTD_IN;
1235
1236   for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1237      if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1238         cpp->xdir = DTD_OUT;
1239         break;
1240         }
1241
1242   if (cpp->xdir == DTD_IN)
1243      for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1244         if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1245            cpp->xdir = DTD_NONE;
1246            break;
1247            }
1248
1249}
1250
1251static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) {
1252   unsigned int i, j, k;
1253   struct mscp *cpp;
1254
1255   /* j is the board number */
1256   j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
1257
1258   if (SCpnt->host_scribble)
1259      panic("%s: qcomm, SCpnt %p already active.\n",
1260            BN(j), SCpnt);
1261
1262   /* i is the mailbox number, look for the first free mailbox
1263      starting from last_cp_used */
1264   i = HD(j)->last_cp_used + 1;
1265
1266   for (k = 0; k < sh[j]->can_queue; k++, i++) {
1267
1268      if (i >= sh[j]->can_queue) i = 0;
1269
1270      if (HD(j)->cp_stat[i] == FREE) {
1271         HD(j)->last_cp_used = i;
1272         break;
1273         }
1274      }
1275
1276   if (k == sh[j]->can_queue) {
1277      printk("%s: qcomm, no free mailbox.\n", BN(j));
1278      return 1;
1279      }
1280
1281   /* Set pointer to control packet structure */
1282   cpp = &HD(j)->cp[i];
1283
1284   memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1285   SCpnt->scsi_done = done;
1286   cpp->cpp_index = i;
1287   SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
1288
1289   if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d.\n",
1290                        BN(j), i, SCpnt->device->channel, SCpnt->device->id,
1291                        SCpnt->device->lun);
1292
1293   cpp->opcode = OP_SCSI;
1294   cpp->channel = SCpnt->device->channel;
1295   cpp->target = SCpnt->device->id;
1296   cpp->lun = SCpnt->device->lun;
1297   cpp->SCpnt = SCpnt;
1298   cpp->cdb_len = SCpnt->cmd_len;
1299   memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1300
1301   /* Use data transfer direction SCpnt->sc_data_direction */
1302   scsi_to_dev_dir(i, j);
1303
1304   /* Map DMA buffers and SG list */
1305   map_dma(i, j);
1306
1307   if (linked_comm && SCpnt->device->queue_depth > 2
1308                                     && TLDEV(SCpnt->device->type)) {
1309      HD(j)->cp_stat[i] = READY;
1310      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, FALSE);
1311      return 0;
1312      }
1313
1314   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1315      unmap_dma(i, j);
1316      SCpnt->host_scribble = NULL;
1317      scmd_printk(KERN_INFO, SCpnt,
1318      		"qcomm, adapter busy.\n");
1319      return 1;
1320      }
1321
1322   /* Store pointer in OGM address bytes */
1323   outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1324
1325   /* Issue OGM interrupt */
1326   outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1327
1328   HD(j)->cp_stat[i] = IN_USE;
1329   return 0;
1330}
1331
1332static DEF_SCSI_QCMD(u14_34f_queuecommand)
1333
1334static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
1335   unsigned int i, j;
1336
1337   j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1338
1339   if (SCarg->host_scribble == NULL) {
1340      scmd_printk(KERN_INFO, SCarg, "abort, command inactive.\n");
1341      return SUCCESS;
1342      }
1343
1344   i = *(unsigned int *)SCarg->host_scribble;
1345   scmd_printk(KERN_INFO, SCarg, "abort, mbox %d.\n", i);
1346
1347   if (i >= sh[j]->can_queue)
1348      panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
1349
1350   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1351      printk("%s: abort, timeout error.\n", BN(j));
1352      return FAILED;
1353      }
1354
1355   if (HD(j)->cp_stat[i] == FREE) {
1356      printk("%s: abort, mbox %d is free.\n", BN(j), i);
1357      return SUCCESS;
1358      }
1359
1360   if (HD(j)->cp_stat[i] == IN_USE) {
1361      printk("%s: abort, mbox %d is in use.\n", BN(j), i);
1362
1363      if (SCarg != HD(j)->cp[i].SCpnt)
1364         panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1365               BN(j), i, SCarg, HD(j)->cp[i].SCpnt);
1366
1367      if (inb(sh[j]->io_port + REG_SYS_INTR) & IRQ_ASSERTED)
1368         printk("%s: abort, mbox %d, interrupt pending.\n", BN(j), i);
1369
1370      return FAILED;
1371      }
1372
1373   if (HD(j)->cp_stat[i] == IN_RESET) {
1374      printk("%s: abort, mbox %d is in reset.\n", BN(j), i);
1375      return FAILED;
1376      }
1377
1378   if (HD(j)->cp_stat[i] == LOCKED) {
1379      printk("%s: abort, mbox %d is locked.\n", BN(j), i);
1380      return SUCCESS;
1381      }
1382
1383   if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1384      unmap_dma(i, j);
1385      SCarg->result = DID_ABORT << 16;
1386      SCarg->host_scribble = NULL;
1387      HD(j)->cp_stat[i] = FREE;
1388      printk("%s, abort, mbox %d ready, DID_ABORT, done.\n", BN(j), i);
1389      SCarg->scsi_done(SCarg);
1390      return SUCCESS;
1391      }
1392
1393   panic("%s: abort, mbox %d, invalid cp_stat.\n", BN(j), i);
1394}
1395
1396static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1397   unsigned int i, j, k, c, limit = 0;
1398   unsigned long time;
1399   int arg_done = FALSE;
1400   struct scsi_cmnd *SCpnt;
1401
1402   j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1403   scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
1404
1405   spin_lock_irq(sh[j]->host_lock);
1406
1407   if (SCarg->host_scribble == NULL)
1408      printk("%s: reset, inactive.\n", BN(j));
1409
1410   if (HD(j)->in_reset) {
1411      printk("%s: reset, exit, already in reset.\n", BN(j));
1412      spin_unlock_irq(sh[j]->host_lock);
1413      return FAILED;
1414      }
1415
1416   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1417      printk("%s: reset, exit, timeout error.\n", BN(j));
1418      spin_unlock_irq(sh[j]->host_lock);
1419      return FAILED;
1420      }
1421
1422   HD(j)->retries = 0;
1423
1424   for (c = 0; c <= sh[j]->max_channel; c++)
1425      for (k = 0; k < sh[j]->max_id; k++) {
1426         HD(j)->target_redo[k][c] = TRUE;
1427         HD(j)->target_to[k][c] = 0;
1428         }
1429
1430   for (i = 0; i < sh[j]->can_queue; i++) {
1431
1432      if (HD(j)->cp_stat[i] == FREE) continue;
1433
1434      if (HD(j)->cp_stat[i] == LOCKED) {
1435         HD(j)->cp_stat[i] = FREE;
1436         printk("%s: reset, locked mbox %d forced free.\n", BN(j), i);
1437         continue;
1438         }
1439
1440      if (!(SCpnt = HD(j)->cp[i].SCpnt))
1441         panic("%s: reset, mbox %d, SCpnt == NULL.\n", BN(j), i);
1442
1443      if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1444         HD(j)->cp_stat[i] = ABORTING;
1445         printk("%s: reset, mbox %d aborting.\n", BN(j), i);
1446         }
1447
1448      else {
1449         HD(j)->cp_stat[i] = IN_RESET;
1450         printk("%s: reset, mbox %d in reset.\n", BN(j), i);
1451         }
1452
1453      if (SCpnt->host_scribble == NULL)
1454         panic("%s: reset, mbox %d, garbled SCpnt.\n", BN(j), i);
1455
1456      if (*(unsigned int *)SCpnt->host_scribble != i)
1457         panic("%s: reset, mbox %d, index mismatch.\n", BN(j), i);
1458
1459      if (SCpnt->scsi_done == NULL)
1460         panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", BN(j), i);
1461
1462      if (SCpnt == SCarg) arg_done = TRUE;
1463      }
1464
1465   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1466      printk("%s: reset, cannot reset, timeout error.\n", BN(j));
1467      spin_unlock_irq(sh[j]->host_lock);
1468      return FAILED;
1469      }
1470
1471   outb(CMD_RESET, sh[j]->io_port + REG_LCL_INTR);
1472   printk("%s: reset, board reset done, enabling interrupts.\n", BN(j));
1473
1474#if defined(DEBUG_RESET)
1475   do_trace = TRUE;
1476#endif
1477
1478   HD(j)->in_reset = TRUE;
1479
1480   spin_unlock_irq(sh[j]->host_lock);
1481   time = jiffies;
1482   while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L);
1483   spin_lock_irq(sh[j]->host_lock);
1484
1485   printk("%s: reset, interrupts disabled, loops %d.\n", BN(j), limit);
1486
1487   for (i = 0; i < sh[j]->can_queue; i++) {
1488
1489      if (HD(j)->cp_stat[i] == IN_RESET) {
1490         SCpnt = HD(j)->cp[i].SCpnt;
1491         unmap_dma(i, j);
1492         SCpnt->result = DID_RESET << 16;
1493         SCpnt->host_scribble = NULL;
1494
1495         /* This mailbox is still waiting for its interrupt */
1496         HD(j)->cp_stat[i] = LOCKED;
1497
1498         printk("%s, reset, mbox %d locked, DID_RESET, done.\n", BN(j), i);
1499         }
1500
1501      else if (HD(j)->cp_stat[i] == ABORTING) {
1502         SCpnt = HD(j)->cp[i].SCpnt;
1503         unmap_dma(i, j);
1504         SCpnt->result = DID_RESET << 16;
1505         SCpnt->host_scribble = NULL;
1506
1507         /* This mailbox was never queued to the adapter */
1508         HD(j)->cp_stat[i] = FREE;
1509
1510         printk("%s, reset, mbox %d aborting, DID_RESET, done.\n", BN(j), i);
1511         }
1512
1513      else
1514
1515         /* Any other mailbox has already been set free by interrupt */
1516         continue;
1517
1518      SCpnt->scsi_done(SCpnt);
1519      }
1520
1521   HD(j)->in_reset = FALSE;
1522   do_trace = FALSE;
1523
1524   if (arg_done) printk("%s: reset, exit, done.\n", BN(j));
1525   else          printk("%s: reset, exit.\n", BN(j));
1526
1527   spin_unlock_irq(sh[j]->host_lock);
1528   return SUCCESS;
1529}
1530
1531static int u14_34f_bios_param(struct scsi_device *disk,
1532                 struct block_device *bdev, sector_t capacity, int *dkinfo) {
1533   unsigned int j = 0;
1534   unsigned int size = capacity;
1535
1536   dkinfo[0] = HD(j)->heads;
1537   dkinfo[1] = HD(j)->sectors;
1538   dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
1539
1540   if (ext_tran && (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
1541      dkinfo[0] = 255;
1542      dkinfo[1] = 63;
1543      dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
1544      }
1545
1546#if defined (DEBUG_GEOMETRY)
1547   printk ("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
1548           dkinfo[0], dkinfo[1], dkinfo[2]);
1549#endif
1550
1551   return FALSE;
1552}
1553
1554static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
1555                 unsigned int rev) {
1556   unsigned int i, j, k, y;
1557   unsigned long x;
1558
1559   for (i = 0; i < n - 1; i++) {
1560      k = i;
1561
1562      for (j = k + 1; j < n; j++)
1563         if (rev) {
1564            if (sk[j] > sk[k]) k = j;
1565            }
1566         else {
1567            if (sk[j] < sk[k]) k = j;
1568            }
1569
1570      if (k != i) {
1571         x = sk[k]; sk[k] = sk[i]; sk[i] = x;
1572         y = da[k]; da[k] = da[i]; da[i] = y;
1573         }
1574      }
1575
1576   return;
1577   }
1578
1579static int reorder(unsigned int j, unsigned long cursec,
1580                 unsigned int ihdlr, unsigned int il[], unsigned int n_ready) {
1581   struct scsi_cmnd *SCpnt;
1582   struct mscp *cpp;
1583   unsigned int k, n;
1584   unsigned int rev = FALSE, s = TRUE, r = TRUE;
1585   unsigned int input_only = TRUE, overlap = FALSE;
1586   unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
1587   unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
1588   unsigned long ioseek = 0;
1589
1590   static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
1591   static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
1592   static unsigned int readysorted = 0, revcount = 0;
1593   static unsigned long seeksorted = 0, seeknosort = 0;
1594
1595   if (link_statistics && !(++flushcount % link_statistics))
1596      printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"\
1597             " av %ldK as %ldK.\n", flushcount, batchcount, inputcount,
1598             ovlcount, readycount, readysorted, sortcount, revcount,
1599             seeknosort / (readycount + 1),
1600             seeksorted / (readycount + 1));
1601
1602   if (n_ready <= 1) return FALSE;
1603
1604   for (n = 0; n < n_ready; n++) {
1605      k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1606
1607      if (!(cpp->xdir == DTD_IN)) input_only = FALSE;
1608
1609      if (blk_rq_pos(SCpnt->request) < minsec)
1610	 minsec = blk_rq_pos(SCpnt->request);
1611      if (blk_rq_pos(SCpnt->request) > maxsec)
1612	 maxsec = blk_rq_pos(SCpnt->request);
1613
1614      sl[n] = blk_rq_pos(SCpnt->request);
1615      ioseek += blk_rq_sectors(SCpnt->request);
1616
1617      if (!n) continue;
1618
1619      if (sl[n] < sl[n - 1]) s = FALSE;
1620      if (sl[n] > sl[n - 1]) r = FALSE;
1621
1622      if (link_statistics) {
1623         if (sl[n] > sl[n - 1])
1624            seek += sl[n] - sl[n - 1];
1625         else
1626            seek += sl[n - 1] - sl[n];
1627         }
1628
1629      }
1630
1631   if (link_statistics) {
1632      if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec;
1633      }
1634
1635   if (cursec > ((maxsec + minsec) / 2)) rev = TRUE;
1636
1637   if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE;
1638
1639   if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev);
1640
1641   if (!input_only) for (n = 0; n < n_ready; n++) {
1642      k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1643      ll[n] = blk_rq_sectors(SCpnt->request); pl[n] = SCpnt->serial_number;
1644
1645      if (!n) continue;
1646
1647      if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
1648          || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE;
1649      }
1650
1651   if (overlap) sort(pl, il, n_ready, FALSE);
1652
1653   if (link_statistics) {
1654      if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec;
1655      batchcount++; readycount += n_ready; seeknosort += seek / 1024;
1656      if (input_only) inputcount++;
1657      if (overlap) { ovlcount++; seeksorted += iseek / 1024; }
1658      else seeksorted += (iseek + maxsec - minsec) / 1024;
1659      if (rev && !r)     {  revcount++; readysorted += n_ready; }
1660      if (!rev && !s)    { sortcount++; readysorted += n_ready; }
1661      }
1662
1663#if defined(DEBUG_LINKED_COMMANDS)
1664   if (link_statistics && (overlap || !(flushcount % link_statistics)))
1665      for (n = 0; n < n_ready; n++) {
1666         k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1667         printk("%s %d.%d:%d mb %d fc %d nr %d sec %ld ns %u"\
1668                " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
1669                (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
1670                SCpnt->lun, k, flushcount, n_ready,
1671                blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
1672		cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
1673                YESNO(overlap), cpp->xdir);
1674         }
1675#endif
1676   return overlap;
1677}
1678
1679static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned int j,
1680                      unsigned int ihdlr) {
1681   struct scsi_cmnd *SCpnt;
1682   struct mscp *cpp;
1683   unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
1684
1685   for (k = 0; k < sh[j]->can_queue; k++) {
1686
1687      if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue;
1688
1689      cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1690
1691      if (SCpnt->device != dev) continue;
1692
1693      if (HD(j)->cp_stat[k] == IN_USE) return;
1694
1695      il[n_ready++] = k;
1696      }
1697
1698   if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1;
1699
1700   for (n = 0; n < n_ready; n++) {
1701      k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1702
1703      if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1704         scmd_printk(KERN_INFO, SCpnt,
1705	 	"%s, mbox %d, adapter"
1706                " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"),
1707                k);
1708         HD(j)->cp_stat[k] = ABORTING;
1709         continue;
1710         }
1711
1712      outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1713      outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1714      HD(j)->cp_stat[k] = IN_USE;
1715      }
1716
1717}
1718
1719static irqreturn_t ihdlr(unsigned int j)
1720{
1721   struct scsi_cmnd *SCpnt;
1722   unsigned int i, k, c, status, tstatus, reg, ret;
1723   struct mscp *spp, *cpp;
1724   int irq = sh[j]->irq;
1725
1726   /* Check if this board need to be serviced */
1727   if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none;
1728
1729   HD(j)->iocount++;
1730
1731   if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.\n", BN(j), irq,
1732                        HD(j)->iocount);
1733
1734   /* Check if this board is still busy */
1735   if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) {
1736      outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1737      printk("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.\n",
1738             BN(j), irq, reg, HD(j)->iocount);
1739      goto none;
1740      }
1741
1742   ret = inl(sh[j]->io_port + REG_ICM);
1743
1744   /* Clear interrupt pending flag */
1745   outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1746
1747   /* Find the mailbox to be serviced on this board */
1748   for (i = 0; i < sh[j]->can_queue; i++)
1749      if (H2DEV(HD(j)->cp[i].cp_dma_addr) == ret) break;
1750
1751   if (i >= sh[j]->can_queue)
1752      panic("%s: ihdlr, invalid mscp bus address %p, cp0 %p.\n", BN(j),
1753            (void *)ret, (void *)H2DEV(HD(j)->cp[0].cp_dma_addr));
1754
1755   cpp = &(HD(j)->cp[i]);
1756   spp = cpp;
1757
1758#if defined(DEBUG_GENERATE_ABORTS)
1759   if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) goto handled;
1760#endif
1761
1762   if (HD(j)->cp_stat[i] == IGNORE) {
1763      HD(j)->cp_stat[i] = FREE;
1764      goto handled;
1765      }
1766   else if (HD(j)->cp_stat[i] == LOCKED) {
1767      HD(j)->cp_stat[i] = FREE;
1768      printk("%s: ihdlr, mbox %d unlocked, count %d.\n", BN(j), i,
1769             HD(j)->iocount);
1770      goto handled;
1771      }
1772   else if (HD(j)->cp_stat[i] == FREE) {
1773      printk("%s: ihdlr, mbox %d is free, count %d.\n", BN(j), i,
1774             HD(j)->iocount);
1775      goto handled;
1776      }
1777   else if (HD(j)->cp_stat[i] == IN_RESET)
1778      printk("%s: ihdlr, mbox %d is in reset.\n", BN(j), i);
1779   else if (HD(j)->cp_stat[i] != IN_USE)
1780      panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
1781            BN(j), i, HD(j)->cp_stat[i]);
1782
1783   HD(j)->cp_stat[i] = FREE;
1784   SCpnt = cpp->SCpnt;
1785
1786   if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
1787
1788   if (SCpnt->host_scribble == NULL)
1789      panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", BN(j), i,
1790            SCpnt);
1791
1792   if (*(unsigned int *)SCpnt->host_scribble != i)
1793      panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
1794            BN(j), i, *(unsigned int *)SCpnt->host_scribble);
1795
1796   sync_dma(i, j);
1797
1798   if (linked_comm && SCpnt->device->queue_depth > 2
1799                                     && TLDEV(SCpnt->device->type))
1800      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, TRUE);
1801
1802   tstatus = status_byte(spp->target_status);
1803
1804#if defined(DEBUG_GENERATE_ERRORS)
1805   if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2))
1806                                           spp->adapter_status = 0x01;
1807#endif
1808
1809   switch (spp->adapter_status) {
1810      case ASOK:     /* status OK */
1811
1812         /* Forces a reset if a disk drive keeps returning BUSY */
1813         if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
1814            status = DID_ERROR << 16;
1815
1816         /* If there was a bus reset, redo operation on each target */
1817         else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
1818                  && HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)])
1819            status = DID_BUS_BUSY << 16;
1820
1821         /* Works around a flaw in scsi.c */
1822         else if (tstatus == CHECK_CONDITION
1823                  && SCpnt->device->type == TYPE_DISK
1824                  && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
1825            status = DID_BUS_BUSY << 16;
1826
1827         else
1828            status = DID_OK << 16;
1829
1830         if (tstatus == GOOD)
1831            HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)] = FALSE;
1832
1833         if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
1834             (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
1835               (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
1836            scmd_printk(KERN_INFO, SCpnt,
1837	    	"ihdlr, target_status 0x%x, sense key 0x%x.\n",
1838                   spp->target_status,
1839                   SCpnt->sense_buffer[2]);
1840
1841         HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0;
1842
1843         if (HD(j)->last_retried_pid == SCpnt->serial_number) HD(j)->retries = 0;
1844
1845         break;
1846      case ASST:     /* Selection Time Out */
1847
1848         if (HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] > 1)
1849            status = DID_ERROR << 16;
1850         else {
1851            status = DID_TIME_OUT << 16;
1852            HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)]++;
1853            }
1854
1855         break;
1856
1857      /* Perform a limited number of internal retries */
1858      case 0x93:     /* Unexpected bus free */
1859      case 0x94:     /* Target bus phase sequence failure */
1860      case 0x96:     /* Illegal SCSI command */
1861      case 0xa3:     /* SCSI bus reset error */
1862
1863         for (c = 0; c <= sh[j]->max_channel; c++)
1864            for (k = 0; k < sh[j]->max_id; k++)
1865               HD(j)->target_redo[k][c] = TRUE;
1866
1867
1868      case 0x92:     /* Data over/under-run */
1869
1870         if (SCpnt->device->type != TYPE_TAPE
1871             && HD(j)->retries < MAX_INTERNAL_RETRIES) {
1872
1873#if defined(DID_SOFT_ERROR)
1874            status = DID_SOFT_ERROR << 16;
1875#else
1876            status = DID_BUS_BUSY << 16;
1877#endif
1878
1879            HD(j)->retries++;
1880            HD(j)->last_retried_pid = SCpnt->serial_number;
1881            }
1882         else
1883            status = DID_ERROR << 16;
1884
1885         break;
1886      case 0x01:     /* Invalid command */
1887      case 0x02:     /* Invalid parameters */
1888      case 0x03:     /* Invalid data list */
1889      case 0x84:     /* SCSI bus abort error */
1890      case 0x9b:     /* Auto request sense error */
1891      case 0x9f:     /* Unexpected command complete message error */
1892      case 0xff:     /* Invalid parameter in the S/G list */
1893      default:
1894         status = DID_ERROR << 16;
1895         break;
1896      }
1897
1898   SCpnt->result = status | spp->target_status;
1899
1900#if defined(DEBUG_INTERRUPT)
1901   if (SCpnt->result || do_trace)
1902#else
1903   if ((spp->adapter_status != ASOK && HD(j)->iocount >  1000) ||
1904       (spp->adapter_status != ASOK &&
1905        spp->adapter_status != ASST && HD(j)->iocount <= 1000) ||
1906        do_trace || msg_byte(spp->target_status))
1907#endif
1908      scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\
1909             " reg 0x%x, count %d.\n",
1910             i, spp->adapter_status, spp->target_status,
1911             reg, HD(j)->iocount);
1912
1913   unmap_dma(i, j);
1914
1915   /* Set the command state to inactive */
1916   SCpnt->host_scribble = NULL;
1917
1918   SCpnt->scsi_done(SCpnt);
1919
1920   if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.\n", BN(j), irq,
1921                        HD(j)->iocount);
1922
1923handled:
1924   return IRQ_HANDLED;
1925none:
1926   return IRQ_NONE;
1927}
1928
1929static irqreturn_t do_interrupt_handler(int irq, void *shap) {
1930   unsigned int j;
1931   unsigned long spin_flags;
1932   irqreturn_t ret;
1933
1934   /* Check if the interrupt must be processed by this handler */
1935   if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE;
1936
1937   spin_lock_irqsave(sh[j]->host_lock, spin_flags);
1938   ret = ihdlr(j);
1939   spin_unlock_irqrestore(sh[j]->host_lock, spin_flags);
1940   return ret;
1941}
1942
1943static int u14_34f_release(struct Scsi_Host *shpnt) {
1944   unsigned int i, j;
1945
1946   for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++);
1947
1948   if (sh[j] == NULL)
1949      panic("%s: release, invalid Scsi_Host pointer.\n", driver_name);
1950
1951   for (i = 0; i < sh[j]->can_queue; i++)
1952      kfree((&HD(j)->cp[i])->sglist);
1953
1954   for (i = 0; i < sh[j]->can_queue; i++)
1955      pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr,
1956                     sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
1957
1958   free_irq(sh[j]->irq, &sha[j]);
1959
1960   if (sh[j]->dma_channel != NO_DMA)
1961      free_dma(sh[j]->dma_channel);
1962
1963   release_region(sh[j]->io_port, sh[j]->n_io_port);
1964   scsi_unregister(sh[j]);
1965   return FALSE;
1966}
1967
1968#include "scsi_module.c"
1969
1970#ifndef MODULE
1971__setup("u14-34f=", option_setup);
1972#endif /* end MODULE */