linux/drivers/scsi/u14-34f.c
<<
>>
Prefs
   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/byteorder.h>
 414#include <linux/proc_fs.h>
 415#include <linux/blkdev.h>
 416#include <linux/interrupt.h>
 417#include <linux/stat.h>
 418#include <linux/pci.h>
 419#include <linux/init.h>
 420#include <linux/ctype.h>
 421#include <linux/spinlock.h>
 422#include <linux/slab.h>
 423#include <asm/dma.h>
 424#include <asm/irq.h>
 425
 426#include <scsi/scsi.h>
 427#include <scsi/scsi_cmnd.h>
 428#include <scsi/scsi_device.h>
 429#include <scsi/scsi_host.h>
 430#include <scsi/scsi_tcq.h>
 431#include <scsi/scsicam.h>
 432
 433static int u14_34f_detect(struct scsi_host_template *);
 434static int u14_34f_release(struct Scsi_Host *);
 435static int u14_34f_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
 436static int u14_34f_eh_abort(struct scsi_cmnd *);
 437static int u14_34f_eh_host_reset(struct scsi_cmnd *);
 438static int u14_34f_bios_param(struct scsi_device *, struct block_device *,
 439                              sector_t, int *);
 440static int u14_34f_slave_configure(struct scsi_device *);
 441
 442static struct scsi_host_template driver_template = {
 443                .name                    = "UltraStor 14F/34F rev. 8.10.00 ",
 444                .detect                  = u14_34f_detect,
 445                .release                 = u14_34f_release,
 446                .queuecommand            = u14_34f_queuecommand,
 447                .eh_abort_handler        = u14_34f_eh_abort,
 448                .eh_host_reset_handler   = u14_34f_eh_host_reset,
 449                .bios_param              = u14_34f_bios_param,
 450                .slave_configure         = u14_34f_slave_configure,
 451                .this_id                 = 7,
 452                .unchecked_isa_dma       = 1,
 453                .use_clustering          = ENABLE_CLUSTERING,
 454                };
 455
 456#if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD)
 457#error "Adjust your <asm/byteorder.h> defines"
 458#endif
 459
 460/* Values for the PRODUCT_ID ports for the 14/34F */
 461#define PRODUCT_ID1  0x56
 462#define PRODUCT_ID2  0x40        /* NOTE: Only upper nibble is used */
 463
 464/* Subversion values */
 465#define ISA  0
 466#define ESA 1
 467
 468#define OP_HOST_ADAPTER   0x1
 469#define OP_SCSI           0x2
 470#define OP_RESET          0x4
 471#define DTD_SCSI          0x0
 472#define DTD_IN            0x1
 473#define DTD_OUT           0x2
 474#define DTD_NONE          0x3
 475#define HA_CMD_INQUIRY    0x1
 476#define HA_CMD_SELF_DIAG  0x2
 477#define HA_CMD_READ_BUFF  0x3
 478#define HA_CMD_WRITE_BUFF 0x4
 479
 480#undef  DEBUG_LINKED_COMMANDS
 481#undef  DEBUG_DETECT
 482#undef  DEBUG_INTERRUPT
 483#undef  DEBUG_RESET
 484#undef  DEBUG_GENERATE_ERRORS
 485#undef  DEBUG_GENERATE_ABORTS
 486#undef  DEBUG_GEOMETRY
 487
 488#define MAX_ISA 3
 489#define MAX_VESA 1
 490#define MAX_EISA 0
 491#define MAX_PCI 0
 492#define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI)
 493#define MAX_CHANNEL 1
 494#define MAX_LUN 8
 495#define MAX_TARGET 8
 496#define MAX_MAILBOXES 16
 497#define MAX_SGLIST 32
 498#define MAX_SAFE_SGLIST 16
 499#define MAX_INTERNAL_RETRIES 64
 500#define MAX_CMD_PER_LUN 2
 501#define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN)
 502
 503#define SKIP ULONG_MAX
 504#define FALSE 0
 505#define TRUE 1
 506#define FREE 0
 507#define IN_USE   1
 508#define LOCKED   2
 509#define IN_RESET 3
 510#define IGNORE   4
 511#define READY    5
 512#define ABORTING 6
 513#define NO_DMA  0xff
 514#define MAXLOOP  10000
 515#define TAG_DISABLED 0
 516#define TAG_SIMPLE   1
 517#define TAG_ORDERED  2
 518
 519#define REG_LCL_MASK      0
 520#define REG_LCL_INTR      1
 521#define REG_SYS_MASK      2
 522#define REG_SYS_INTR      3
 523#define REG_PRODUCT_ID1   4
 524#define REG_PRODUCT_ID2   5
 525#define REG_CONFIG1       6
 526#define REG_CONFIG2       7
 527#define REG_OGM           8
 528#define REG_ICM           12
 529#define REGION_SIZE       13UL
 530#define BSY_ASSERTED      0x01
 531#define IRQ_ASSERTED      0x01
 532#define CMD_RESET         0xc0
 533#define CMD_OGM_INTR      0x01
 534#define CMD_CLR_INTR      0x01
 535#define CMD_ENA_INTR      0x81
 536#define ASOK              0x00
 537#define ASST              0x91
 538
 539#define YESNO(a) ((a) ? 'y' : 'n')
 540#define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM)
 541
 542#define PACKED          __attribute__((packed))
 543
 544struct sg_list {
 545   unsigned int address;                /* Segment Address */
 546   unsigned int num_bytes;              /* Segment Length */
 547   };
 548
 549/* MailBox SCSI Command Packet */
 550struct mscp {
 551
 552#if defined(__BIG_ENDIAN_BITFIELD)
 553   unsigned char sg:1, ca:1, dcn:1, xdir:2, opcode:3;
 554   unsigned char lun: 3, channel:2, target:3;
 555#else
 556   unsigned char opcode: 3,             /* type of command */
 557                 xdir: 2,               /* data transfer direction */
 558                 dcn: 1,                /* disable disconnect */
 559                 ca: 1,                 /* use cache (if available) */
 560                 sg: 1;                 /* scatter/gather operation */
 561   unsigned char target: 3,             /* SCSI target id */
 562                 channel: 2,            /* SCSI channel number */
 563                 lun: 3;                /* SCSI logical unit number */
 564#endif
 565
 566   unsigned int data_address PACKED;    /* transfer data pointer */
 567   unsigned int data_len PACKED;        /* length in bytes */
 568   unsigned int link_address PACKED;    /* for linking command chains */
 569   unsigned char clink_id;              /* identifies command in chain */
 570   unsigned char use_sg;                /* (if sg is set) 8 bytes per list */
 571   unsigned char sense_len;
 572   unsigned char cdb_len;               /* 6, 10, or 12 */
 573   unsigned char cdb[12];               /* SCSI Command Descriptor Block */
 574   unsigned char adapter_status;        /* non-zero indicates HA error */
 575   unsigned char target_status;         /* non-zero indicates target error */
 576   unsigned int sense_addr PACKED;
 577
 578   /* Additional fields begin here. */
 579   struct scsi_cmnd *SCpnt;
 580   unsigned int cpp_index;              /* cp index */
 581
 582   /* All the cp structure is zero filled by queuecommand except the
 583      following CP_TAIL_SIZE bytes, initialized by detect */
 584   dma_addr_t cp_dma_addr; /* dma handle for this cp structure */
 585   struct sg_list *sglist; /* pointer to the allocated SG list */
 586   };
 587
 588#define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t))
 589
 590struct hostdata {
 591   struct mscp cp[MAX_MAILBOXES];       /* Mailboxes for this board */
 592   unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */
 593   unsigned int last_cp_used;           /* Index of last mailbox used */
 594   unsigned int iocount;                /* Total i/o done for this board */
 595   int board_number;                    /* Number of this board */
 596   char board_name[16];                 /* Name of this board */
 597   int in_reset;                        /* True if board is doing a reset */
 598   int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */
 599   int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If TRUE redo i/o on target */
 600   unsigned int retries;                /* Number of internal retries */
 601   unsigned long last_retried_pid;      /* Pid of last retried command */
 602   unsigned char subversion;            /* Bus type, either ISA or ESA */
 603   struct pci_dev *pdev;                /* Always NULL */
 604   unsigned char heads;
 605   unsigned char sectors;
 606   char board_id[256];                  /* data from INQUIRY on this board */
 607   };
 608
 609static struct Scsi_Host *sh[MAX_BOARDS + 1];
 610static const char *driver_name = "Ux4F";
 611static char sha[MAX_BOARDS];
 612static DEFINE_SPINLOCK(driver_lock);
 613
 614/* Initialize num_boards so that ihdlr can work while detect is in progress */
 615static unsigned int num_boards = MAX_BOARDS;
 616
 617static unsigned long io_port[] = {
 618
 619   /* Space for MAX_INT_PARAM ports usable while loading as a module */
 620   SKIP,    SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,   SKIP,
 621   SKIP,    SKIP,
 622
 623   /* Possible ISA/VESA ports */
 624   0x330, 0x340, 0x230, 0x240, 0x210, 0x130, 0x140,
 625
 626   /* End of list */
 627   0x0
 628   };
 629
 630#define HD(board) ((struct hostdata *) &sh[board]->hostdata)
 631#define BN(board) (HD(board)->board_name)
 632
 633/* Device is Little Endian */
 634#define H2DEV(x) cpu_to_le32(x)
 635#define DEV2H(x) le32_to_cpu(x)
 636
 637static irqreturn_t do_interrupt_handler(int, void *);
 638static void flush_dev(struct scsi_device *, unsigned long, unsigned int, unsigned int);
 639static int do_trace = FALSE;
 640static int setup_done = FALSE;
 641static int link_statistics;
 642static int ext_tran = FALSE;
 643
 644#if defined(HAVE_OLD_UX4F_FIRMWARE)
 645static int have_old_firmware = TRUE;
 646#else
 647static int have_old_firmware = FALSE;
 648#endif
 649
 650#if defined(CONFIG_SCSI_U14_34F_TAGGED_QUEUE)
 651static int tag_mode = TAG_SIMPLE;
 652#else
 653static int tag_mode = TAG_DISABLED;
 654#endif
 655
 656#if defined(CONFIG_SCSI_U14_34F_LINKED_COMMANDS)
 657static int linked_comm = TRUE;
 658#else
 659static int linked_comm = FALSE;
 660#endif
 661
 662#if defined(CONFIG_SCSI_U14_34F_MAX_TAGS)
 663static int max_queue_depth = CONFIG_SCSI_U14_34F_MAX_TAGS;
 664#else
 665static int max_queue_depth = MAX_CMD_PER_LUN;
 666#endif
 667
 668#define MAX_INT_PARAM 10
 669#define MAX_BOOT_OPTIONS_SIZE 256
 670static char boot_options[MAX_BOOT_OPTIONS_SIZE];
 671
 672#if defined(MODULE)
 673#include <linux/module.h>
 674#include <linux/moduleparam.h>
 675
 676module_param_string(u14_34f, boot_options, MAX_BOOT_OPTIONS_SIZE, 0);
 677MODULE_PARM_DESC(u14_34f, " equivalent to the \"u14-34f=...\" kernel boot " \
 678"option." \
 679"      Example: modprobe u14-34f \"u14_34f=0x340,0x330,lc:y,tm:0,mq:4\"");
 680MODULE_AUTHOR("Dario Ballabio");
 681MODULE_LICENSE("GPL");
 682MODULE_DESCRIPTION("UltraStor 14F/34F SCSI Driver");
 683
 684#endif
 685
 686static int u14_34f_slave_configure(struct scsi_device *dev) {
 687   int j, tqd, utqd;
 688   char *tag_suffix, *link_suffix;
 689   struct Scsi_Host *host = dev->host;
 690
 691   j = ((struct hostdata *) host->hostdata)->board_number;
 692
 693   utqd = MAX_CMD_PER_LUN;
 694   tqd = max_queue_depth;
 695
 696   if (TLDEV(dev->type) && dev->tagged_supported)
 697
 698      if (tag_mode == TAG_SIMPLE) {
 699         scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
 700         tag_suffix = ", simple tags";
 701         }
 702      else if (tag_mode == TAG_ORDERED) {
 703         scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
 704         tag_suffix = ", ordered tags";
 705         }
 706      else {
 707         scsi_adjust_queue_depth(dev, 0, tqd);
 708         tag_suffix = ", no tags";
 709         }
 710
 711   else if (TLDEV(dev->type) && linked_comm) {
 712      scsi_adjust_queue_depth(dev, 0, tqd);
 713      tag_suffix = ", untagged";
 714      }
 715
 716   else {
 717      scsi_adjust_queue_depth(dev, 0, utqd);
 718      tag_suffix = "";
 719      }
 720
 721   if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2)
 722      link_suffix = ", sorted";
 723   else if (TLDEV(dev->type))
 724      link_suffix = ", unsorted";
 725   else
 726      link_suffix = "";
 727
 728   sdev_printk(KERN_INFO, dev, "cmds/lun %d%s%s.\n",
 729          dev->queue_depth, link_suffix, tag_suffix);
 730
 731   return FALSE;
 732}
 733
 734static int wait_on_busy(unsigned long iobase, unsigned int loop) {
 735
 736   while (inb(iobase + REG_LCL_INTR) & BSY_ASSERTED) {
 737      udelay(1L);
 738      if (--loop == 0) return TRUE;
 739      }
 740
 741   return FALSE;
 742}
 743
 744static int board_inquiry(unsigned int j) {
 745   struct mscp *cpp;
 746   dma_addr_t id_dma_addr;
 747   unsigned int limit = 0;
 748   unsigned long time;
 749
 750   id_dma_addr = pci_map_single(HD(j)->pdev, HD(j)->board_id,
 751                    sizeof(HD(j)->board_id), PCI_DMA_BIDIRECTIONAL);
 752   cpp = &HD(j)->cp[0];
 753   cpp->cp_dma_addr = pci_map_single(HD(j)->pdev, cpp, sizeof(struct mscp),
 754                                     PCI_DMA_BIDIRECTIONAL);
 755   memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
 756   cpp->opcode = OP_HOST_ADAPTER;
 757   cpp->xdir = DTD_IN;
 758   cpp->data_address = H2DEV(id_dma_addr);
 759   cpp->data_len = H2DEV(sizeof(HD(j)->board_id));
 760   cpp->cdb_len = 6;
 761   cpp->cdb[0] = HA_CMD_INQUIRY;
 762
 763   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
 764      printk("%s: board_inquiry, adapter busy.\n", BN(j));
 765      return TRUE;
 766      }
 767
 768   HD(j)->cp_stat[0] = IGNORE;
 769
 770   /* Clear the interrupt indication */
 771   outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
 772
 773   /* Store pointer in OGM address bytes */
 774   outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
 775
 776   /* Issue OGM interrupt */
 777   outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
 778
 779   spin_unlock_irq(&driver_lock);
 780   time = jiffies;
 781   while ((jiffies - time) < HZ && limit++ < 20000) udelay(100L);
 782   spin_lock_irq(&driver_lock);
 783
 784   if (cpp->adapter_status || HD(j)->cp_stat[0] != FREE) {
 785      HD(j)->cp_stat[0] = FREE;
 786      printk("%s: board_inquiry, err 0x%x.\n", BN(j), cpp->adapter_status);
 787      return TRUE;
 788      }
 789
 790   pci_unmap_single(HD(j)->pdev, cpp->cp_dma_addr, sizeof(struct mscp),
 791                    PCI_DMA_BIDIRECTIONAL);
 792   pci_unmap_single(HD(j)->pdev, id_dma_addr, sizeof(HD(j)->board_id),
 793                    PCI_DMA_BIDIRECTIONAL);
 794   return FALSE;
 795}
 796
 797static int port_detect \
 798      (unsigned long port_base, unsigned int j, struct scsi_host_template *tpnt) {
 799   unsigned char irq, dma_channel, subversion, i;
 800   unsigned char in_byte;
 801   char *bus_type, dma_name[16];
 802
 803   /* Allowed BIOS base addresses (NULL indicates reserved) */
 804   unsigned long bios_segment_table[8] = {
 805      0,
 806      0xc4000, 0xc8000, 0xcc000, 0xd0000,
 807      0xd4000, 0xd8000, 0xdc000
 808      };
 809
 810   /* Allowed IRQs */
 811   unsigned char interrupt_table[4] = { 15, 14, 11, 10 };
 812
 813   /* Allowed DMA channels for ISA (0 indicates reserved) */
 814   unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
 815
 816   /* Head/sector mappings */
 817   struct {
 818      unsigned char heads;
 819      unsigned char sectors;
 820      } mapping_table[4] = {
 821           { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 }
 822           };
 823
 824   struct config_1 {
 825
 826#if defined(__BIG_ENDIAN_BITFIELD)
 827      unsigned char dma_channel: 2, interrupt:2,
 828                    removable_disks_as_fixed:1, bios_segment: 3;
 829#else
 830      unsigned char bios_segment: 3, removable_disks_as_fixed: 1,
 831                    interrupt: 2, dma_channel: 2;
 832#endif
 833
 834      } config_1;
 835
 836   struct config_2 {
 837
 838#if defined(__BIG_ENDIAN_BITFIELD)
 839      unsigned char tfr_port: 2, bios_drive_number: 1,
 840                    mapping_mode: 2, ha_scsi_id: 3;
 841#else
 842      unsigned char ha_scsi_id: 3, mapping_mode: 2,
 843                    bios_drive_number: 1, tfr_port: 2;
 844#endif
 845
 846      } config_2;
 847
 848   char name[16];
 849
 850   sprintf(name, "%s%d", driver_name, j);
 851
 852   if (!request_region(port_base, REGION_SIZE, driver_name)) {
 853#if defined(DEBUG_DETECT)
 854      printk("%s: address 0x%03lx in use, skipping probe.\n", name, port_base);
 855#endif
 856      goto fail;
 857      }
 858
 859   spin_lock_irq(&driver_lock);
 860
 861   if (inb(port_base + REG_PRODUCT_ID1) != PRODUCT_ID1) goto freelock;
 862
 863   in_byte = inb(port_base + REG_PRODUCT_ID2);
 864
 865   if ((in_byte & 0xf0) != PRODUCT_ID2) goto freelock;
 866
 867   *(char *)&config_1 = inb(port_base + REG_CONFIG1);
 868   *(char *)&config_2 = inb(port_base + REG_CONFIG2);
 869
 870   irq = interrupt_table[config_1.interrupt];
 871   dma_channel = dma_channel_table[config_1.dma_channel];
 872   subversion = (in_byte & 0x0f);
 873
 874   /* Board detected, allocate its IRQ */
 875   if (request_irq(irq, do_interrupt_handler,
 876             IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0),
 877             driver_name, (void *) &sha[j])) {
 878      printk("%s: unable to allocate IRQ %u, detaching.\n", name, irq);
 879      goto freelock;
 880      }
 881
 882   if (subversion == ISA && request_dma(dma_channel, driver_name)) {
 883      printk("%s: unable to allocate DMA channel %u, detaching.\n",
 884             name, dma_channel);
 885      goto freeirq;
 886      }
 887
 888   if (have_old_firmware) tpnt->use_clustering = DISABLE_CLUSTERING;
 889
 890   spin_unlock_irq(&driver_lock);
 891   sh[j] = scsi_register(tpnt, sizeof(struct hostdata));
 892   spin_lock_irq(&driver_lock);
 893
 894   if (sh[j] == NULL) {
 895      printk("%s: unable to register host, detaching.\n", name);
 896      goto freedma;
 897      }
 898
 899   sh[j]->io_port = port_base;
 900   sh[j]->unique_id = port_base;
 901   sh[j]->n_io_port = REGION_SIZE;
 902   sh[j]->base = bios_segment_table[config_1.bios_segment];
 903   sh[j]->irq = irq;
 904   sh[j]->sg_tablesize = MAX_SGLIST;
 905   sh[j]->this_id = config_2.ha_scsi_id;
 906   sh[j]->can_queue = MAX_MAILBOXES;
 907   sh[j]->cmd_per_lun = MAX_CMD_PER_LUN;
 908
 909#if defined(DEBUG_DETECT)
 910   {
 911   unsigned char sys_mask, lcl_mask;
 912
 913   sys_mask = inb(sh[j]->io_port + REG_SYS_MASK);
 914   lcl_mask = inb(sh[j]->io_port + REG_LCL_MASK);
 915   printk("SYS_MASK 0x%x, LCL_MASK 0x%x.\n", sys_mask, lcl_mask);
 916   }
 917#endif
 918
 919   /* Probably a bogus host scsi id, set it to the dummy value */
 920   if (sh[j]->this_id == 0) sh[j]->this_id = -1;
 921
 922   /* If BIOS is disabled, force enable interrupts */
 923   if (sh[j]->base == 0) outb(CMD_ENA_INTR, sh[j]->io_port + REG_SYS_MASK);
 924
 925   memset(HD(j), 0, sizeof(struct hostdata));
 926   HD(j)->heads = mapping_table[config_2.mapping_mode].heads;
 927   HD(j)->sectors = mapping_table[config_2.mapping_mode].sectors;
 928   HD(j)->subversion = subversion;
 929   HD(j)->pdev = NULL;
 930   HD(j)->board_number = j;
 931
 932   if (have_old_firmware) sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
 933
 934   if (HD(j)->subversion == ESA) {
 935      sh[j]->unchecked_isa_dma = FALSE;
 936      sh[j]->dma_channel = NO_DMA;
 937      sprintf(BN(j), "U34F%d", j);
 938      bus_type = "VESA";
 939      }
 940   else {
 941      unsigned long flags;
 942      sh[j]->unchecked_isa_dma = TRUE;
 943
 944      flags=claim_dma_lock();
 945      disable_dma(dma_channel);
 946      clear_dma_ff(dma_channel);
 947      set_dma_mode(dma_channel, DMA_MODE_CASCADE);
 948      enable_dma(dma_channel);
 949      release_dma_lock(flags);
 950
 951      sh[j]->dma_channel = dma_channel;
 952      sprintf(BN(j), "U14F%d", j);
 953      bus_type = "ISA";
 954      }
 955
 956   sh[j]->max_channel = MAX_CHANNEL - 1;
 957   sh[j]->max_id = MAX_TARGET;
 958   sh[j]->max_lun = MAX_LUN;
 959
 960   if (HD(j)->subversion == ISA && !board_inquiry(j)) {
 961      HD(j)->board_id[40] = 0;
 962
 963      if (strcmp(&HD(j)->board_id[32], "06000600")) {
 964         printk("%s: %s.\n", BN(j), &HD(j)->board_id[8]);
 965         printk("%s: firmware %s is outdated, FW PROM should be 28004-006.\n",
 966                BN(j), &HD(j)->board_id[32]);
 967         sh[j]->hostt->use_clustering = DISABLE_CLUSTERING;
 968         sh[j]->sg_tablesize = MAX_SAFE_SGLIST;
 969         }
 970      }
 971
 972   if (dma_channel == NO_DMA) sprintf(dma_name, "%s", "BMST");
 973   else                       sprintf(dma_name, "DMA %u", dma_channel);
 974
 975   spin_unlock_irq(&driver_lock);
 976
 977   for (i = 0; i < sh[j]->can_queue; i++)
 978      HD(j)->cp[i].cp_dma_addr = pci_map_single(HD(j)->pdev,
 979            &HD(j)->cp[i], sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
 980
 981   for (i = 0; i < sh[j]->can_queue; i++)
 982      if (! ((&HD(j)->cp[i])->sglist = kmalloc(
 983            sh[j]->sg_tablesize * sizeof(struct sg_list),
 984            (sh[j]->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC))) {
 985         printk("%s: kmalloc SGlist failed, mbox %d, detaching.\n", BN(j), i);
 986         goto release;
 987         }
 988
 989   if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN)
 990       max_queue_depth = MAX_TAGGED_CMD_PER_LUN;
 991
 992   if (max_queue_depth < MAX_CMD_PER_LUN) max_queue_depth = MAX_CMD_PER_LUN;
 993
 994   if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE)
 995      tag_mode = TAG_ORDERED;
 996
 997   if (j == 0) {
 998      printk("UltraStor 14F/34F: Copyright (C) 1994-2003 Dario Ballabio.\n");
 999      printk("%s config options -> of:%c, tm:%d, lc:%c, mq:%d, et:%c.\n",
1000             driver_name, YESNO(have_old_firmware), tag_mode,
1001             YESNO(linked_comm), max_queue_depth, YESNO(ext_tran));
1002      }
1003
1004   printk("%s: %s 0x%03lx, BIOS 0x%05x, IRQ %u, %s, SG %d, MB %d.\n",
1005          BN(j), bus_type, (unsigned long)sh[j]->io_port, (int)sh[j]->base,
1006          sh[j]->irq, dma_name, sh[j]->sg_tablesize, sh[j]->can_queue);
1007
1008   if (sh[j]->max_id > 8 || sh[j]->max_lun > 8)
1009      printk("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n",
1010             BN(j), sh[j]->max_id, sh[j]->max_lun);
1011
1012   for (i = 0; i <= sh[j]->max_channel; i++)
1013      printk("%s: SCSI channel %u enabled, host target ID %d.\n",
1014             BN(j), i, sh[j]->this_id);
1015
1016   return TRUE;
1017
1018freedma:
1019   if (subversion == ISA) free_dma(dma_channel);
1020freeirq:
1021   free_irq(irq, &sha[j]);
1022freelock:
1023   spin_unlock_irq(&driver_lock);
1024   release_region(port_base, REGION_SIZE);
1025fail:
1026   return FALSE;
1027
1028release:
1029   u14_34f_release(sh[j]);
1030   return FALSE;
1031}
1032
1033static void internal_setup(char *str, int *ints) {
1034   int i, argc = ints[0];
1035   char *cur = str, *pc;
1036
1037   if (argc > 0) {
1038
1039      if (argc > MAX_INT_PARAM) argc = MAX_INT_PARAM;
1040
1041      for (i = 0; i < argc; i++) io_port[i] = ints[i + 1];
1042
1043      io_port[i] = 0;
1044      setup_done = TRUE;
1045      }
1046
1047   while (cur && (pc = strchr(cur, ':'))) {
1048      int val = 0, c = *++pc;
1049
1050      if (c == 'n' || c == 'N') val = FALSE;
1051      else if (c == 'y' || c == 'Y') val = TRUE;
1052      else val = (int) simple_strtoul(pc, NULL, 0);
1053
1054      if (!strncmp(cur, "lc:", 3)) linked_comm = val;
1055      else if (!strncmp(cur, "of:", 3)) have_old_firmware = val;
1056      else if (!strncmp(cur, "tm:", 3)) tag_mode = val;
1057      else if (!strncmp(cur, "tc:", 3)) tag_mode = val;
1058      else if (!strncmp(cur, "mq:", 3))  max_queue_depth = val;
1059      else if (!strncmp(cur, "ls:", 3))  link_statistics = val;
1060      else if (!strncmp(cur, "et:", 3))  ext_tran = val;
1061
1062      if ((cur = strchr(cur, ','))) ++cur;
1063      }
1064
1065   return;
1066}
1067
1068static int option_setup(char *str) {
1069   int ints[MAX_INT_PARAM];
1070   char *cur = str;
1071   int i = 1;
1072
1073   while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
1074      ints[i++] = simple_strtoul(cur, NULL, 0);
1075
1076      if ((cur = strchr(cur, ',')) != NULL) cur++;
1077   }
1078
1079   ints[0] = i - 1;
1080   internal_setup(cur, ints);
1081   return 1;
1082}
1083
1084static int u14_34f_detect(struct scsi_host_template *tpnt) {
1085   unsigned int j = 0, k;
1086
1087   tpnt->proc_name = "u14-34f";
1088
1089   if(strlen(boot_options)) option_setup(boot_options);
1090
1091#if defined(MODULE)
1092   /* io_port could have been modified when loading as a module */
1093   if(io_port[0] != SKIP) {
1094      setup_done = TRUE;
1095      io_port[MAX_INT_PARAM] = 0;
1096      }
1097#endif
1098
1099   for (k = 0; k < MAX_BOARDS + 1; k++) sh[k] = NULL;
1100
1101   for (k = 0; io_port[k]; k++) {
1102
1103      if (io_port[k] == SKIP) continue;
1104
1105      if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt)) j++;
1106      }
1107
1108   num_boards = j;
1109   return j;
1110}
1111
1112static void map_dma(unsigned int i, unsigned int j) {
1113   unsigned int data_len = 0;
1114   unsigned int k, pci_dir;
1115   int count;
1116   struct scatterlist *sg;
1117   struct mscp *cpp;
1118   struct scsi_cmnd *SCpnt;
1119
1120   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1121   pci_dir = SCpnt->sc_data_direction;
1122
1123   if (SCpnt->sense_buffer)
1124      cpp->sense_addr = H2DEV(pci_map_single(HD(j)->pdev, SCpnt->sense_buffer,
1125                           SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE));
1126
1127   cpp->sense_len = SCSI_SENSE_BUFFERSIZE;
1128
1129   if (scsi_bufflen(SCpnt)) {
1130           count = scsi_dma_map(SCpnt);
1131           BUG_ON(count < 0);
1132
1133           scsi_for_each_sg(SCpnt, sg, count, k) {
1134                   cpp->sglist[k].address = H2DEV(sg_dma_address(sg));
1135                   cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(sg));
1136                   data_len += sg->length;
1137           }
1138
1139           cpp->sg = TRUE;
1140           cpp->use_sg = scsi_sg_count(SCpnt);
1141           cpp->data_address =
1142                   H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist,
1143                                        cpp->use_sg * sizeof(struct sg_list),
1144                                        pci_dir));
1145           cpp->data_len = H2DEV(data_len);
1146
1147   } else {
1148           pci_dir = PCI_DMA_BIDIRECTIONAL;
1149           cpp->data_len = H2DEV(scsi_bufflen(SCpnt));
1150   }
1151}
1152
1153static void unmap_dma(unsigned int i, unsigned int j) {
1154   unsigned int pci_dir;
1155   struct mscp *cpp;
1156   struct scsi_cmnd *SCpnt;
1157
1158   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1159   pci_dir = SCpnt->sc_data_direction;
1160
1161   if (DEV2H(cpp->sense_addr))
1162      pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr),
1163                       DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1164
1165   scsi_dma_unmap(SCpnt);
1166
1167   if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1168
1169   if (DEV2H(cpp->data_address))
1170      pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address),
1171                       DEV2H(cpp->data_len), pci_dir);
1172}
1173
1174static void sync_dma(unsigned int i, unsigned int j) {
1175   unsigned int pci_dir;
1176   struct mscp *cpp;
1177   struct scsi_cmnd *SCpnt;
1178
1179   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1180   pci_dir = SCpnt->sc_data_direction;
1181
1182   if (DEV2H(cpp->sense_addr))
1183      pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr),
1184                          DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE);
1185
1186   if (scsi_sg_count(SCpnt))
1187           pci_dma_sync_sg_for_cpu(HD(j)->pdev, scsi_sglist(SCpnt),
1188                                   scsi_sg_count(SCpnt), pci_dir);
1189
1190   if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL;
1191
1192   if (DEV2H(cpp->data_address))
1193      pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address),
1194                       DEV2H(cpp->data_len), pci_dir);
1195}
1196
1197static void scsi_to_dev_dir(unsigned int i, unsigned int j) {
1198   unsigned int k;
1199
1200   static const unsigned char data_out_cmds[] = {
1201      0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e,
1202      0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40,
1203      0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d
1204      };
1205
1206   static const unsigned char data_none_cmds[] = {
1207      0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e,
1208      0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47,
1209      0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00
1210      };
1211
1212   struct mscp *cpp;
1213   struct scsi_cmnd *SCpnt;
1214
1215   cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt;
1216
1217   if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) {
1218      cpp->xdir = DTD_IN;
1219      return;
1220      }
1221   else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) {
1222      cpp->xdir = DTD_OUT;
1223      return;
1224      }
1225   else if (SCpnt->sc_data_direction == DMA_NONE) {
1226      cpp->xdir = DTD_NONE;
1227      return;
1228      }
1229
1230   if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL)
1231      panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", BN(j));
1232
1233   cpp->xdir = DTD_IN;
1234
1235   for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++)
1236      if (SCpnt->cmnd[0] == data_out_cmds[k]) {
1237         cpp->xdir = DTD_OUT;
1238         break;
1239         }
1240
1241   if (cpp->xdir == DTD_IN)
1242      for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++)
1243         if (SCpnt->cmnd[0] == data_none_cmds[k]) {
1244            cpp->xdir = DTD_NONE;
1245            break;
1246            }
1247
1248}
1249
1250static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) {
1251   unsigned int i, j, k;
1252   struct mscp *cpp;
1253
1254   /* j is the board number */
1255   j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
1256
1257   if (SCpnt->host_scribble)
1258      panic("%s: qcomm, SCpnt %p already active.\n",
1259            BN(j), SCpnt);
1260
1261   /* i is the mailbox number, look for the first free mailbox
1262      starting from last_cp_used */
1263   i = HD(j)->last_cp_used + 1;
1264
1265   for (k = 0; k < sh[j]->can_queue; k++, i++) {
1266
1267      if (i >= sh[j]->can_queue) i = 0;
1268
1269      if (HD(j)->cp_stat[i] == FREE) {
1270         HD(j)->last_cp_used = i;
1271         break;
1272         }
1273      }
1274
1275   if (k == sh[j]->can_queue) {
1276      printk("%s: qcomm, no free mailbox.\n", BN(j));
1277      return 1;
1278      }
1279
1280   /* Set pointer to control packet structure */
1281   cpp = &HD(j)->cp[i];
1282
1283   memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE);
1284   SCpnt->scsi_done = done;
1285   cpp->cpp_index = i;
1286   SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
1287
1288   if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d.\n",
1289                        BN(j), i, SCpnt->device->channel, SCpnt->device->id,
1290                        SCpnt->device->lun);
1291
1292   cpp->opcode = OP_SCSI;
1293   cpp->channel = SCpnt->device->channel;
1294   cpp->target = SCpnt->device->id;
1295   cpp->lun = SCpnt->device->lun;
1296   cpp->SCpnt = SCpnt;
1297   cpp->cdb_len = SCpnt->cmd_len;
1298   memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1299
1300   /* Use data transfer direction SCpnt->sc_data_direction */
1301   scsi_to_dev_dir(i, j);
1302
1303   /* Map DMA buffers and SG list */
1304   map_dma(i, j);
1305
1306   if (linked_comm && SCpnt->device->queue_depth > 2
1307                                     && TLDEV(SCpnt->device->type)) {
1308      HD(j)->cp_stat[i] = READY;
1309      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, FALSE);
1310      return 0;
1311      }
1312
1313   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1314      unmap_dma(i, j);
1315      SCpnt->host_scribble = NULL;
1316      scmd_printk(KERN_INFO, SCpnt,
1317                "qcomm, adapter busy.\n");
1318      return 1;
1319      }
1320
1321   /* Store pointer in OGM address bytes */
1322   outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1323
1324   /* Issue OGM interrupt */
1325   outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1326
1327   HD(j)->cp_stat[i] = IN_USE;
1328   return 0;
1329}
1330
1331static DEF_SCSI_QCMD(u14_34f_queuecommand)
1332
1333static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
1334   unsigned int i, j;
1335
1336   j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1337
1338   if (SCarg->host_scribble == NULL) {
1339      scmd_printk(KERN_INFO, SCarg, "abort, command inactive.\n");
1340      return SUCCESS;
1341      }
1342
1343   i = *(unsigned int *)SCarg->host_scribble;
1344   scmd_printk(KERN_INFO, SCarg, "abort, mbox %d.\n", i);
1345
1346   if (i >= sh[j]->can_queue)
1347      panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
1348
1349   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1350      printk("%s: abort, timeout error.\n", BN(j));
1351      return FAILED;
1352      }
1353
1354   if (HD(j)->cp_stat[i] == FREE) {
1355      printk("%s: abort, mbox %d is free.\n", BN(j), i);
1356      return SUCCESS;
1357      }
1358
1359   if (HD(j)->cp_stat[i] == IN_USE) {
1360      printk("%s: abort, mbox %d is in use.\n", BN(j), i);
1361
1362      if (SCarg != HD(j)->cp[i].SCpnt)
1363         panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n",
1364               BN(j), i, SCarg, HD(j)->cp[i].SCpnt);
1365
1366      if (inb(sh[j]->io_port + REG_SYS_INTR) & IRQ_ASSERTED)
1367         printk("%s: abort, mbox %d, interrupt pending.\n", BN(j), i);
1368
1369      return FAILED;
1370      }
1371
1372   if (HD(j)->cp_stat[i] == IN_RESET) {
1373      printk("%s: abort, mbox %d is in reset.\n", BN(j), i);
1374      return FAILED;
1375      }
1376
1377   if (HD(j)->cp_stat[i] == LOCKED) {
1378      printk("%s: abort, mbox %d is locked.\n", BN(j), i);
1379      return SUCCESS;
1380      }
1381
1382   if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1383      unmap_dma(i, j);
1384      SCarg->result = DID_ABORT << 16;
1385      SCarg->host_scribble = NULL;
1386      HD(j)->cp_stat[i] = FREE;
1387      printk("%s, abort, mbox %d ready, DID_ABORT, done.\n", BN(j), i);
1388      SCarg->scsi_done(SCarg);
1389      return SUCCESS;
1390      }
1391
1392   panic("%s: abort, mbox %d, invalid cp_stat.\n", BN(j), i);
1393}
1394
1395static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1396   unsigned int i, j, k, c, limit = 0;
1397   unsigned long time;
1398   int arg_done = FALSE;
1399   struct scsi_cmnd *SCpnt;
1400
1401   j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1402   scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
1403
1404   spin_lock_irq(sh[j]->host_lock);
1405
1406   if (SCarg->host_scribble == NULL)
1407      printk("%s: reset, inactive.\n", BN(j));
1408
1409   if (HD(j)->in_reset) {
1410      printk("%s: reset, exit, already in reset.\n", BN(j));
1411      spin_unlock_irq(sh[j]->host_lock);
1412      return FAILED;
1413      }
1414
1415   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1416      printk("%s: reset, exit, timeout error.\n", BN(j));
1417      spin_unlock_irq(sh[j]->host_lock);
1418      return FAILED;
1419      }
1420
1421   HD(j)->retries = 0;
1422
1423   for (c = 0; c <= sh[j]->max_channel; c++)
1424      for (k = 0; k < sh[j]->max_id; k++) {
1425         HD(j)->target_redo[k][c] = TRUE;
1426         HD(j)->target_to[k][c] = 0;
1427         }
1428
1429   for (i = 0; i < sh[j]->can_queue; i++) {
1430
1431      if (HD(j)->cp_stat[i] == FREE) continue;
1432
1433      if (HD(j)->cp_stat[i] == LOCKED) {
1434         HD(j)->cp_stat[i] = FREE;
1435         printk("%s: reset, locked mbox %d forced free.\n", BN(j), i);
1436         continue;
1437         }
1438
1439      if (!(SCpnt = HD(j)->cp[i].SCpnt))
1440         panic("%s: reset, mbox %d, SCpnt == NULL.\n", BN(j), i);
1441
1442      if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1443         HD(j)->cp_stat[i] = ABORTING;
1444         printk("%s: reset, mbox %d aborting.\n", BN(j), i);
1445         }
1446
1447      else {
1448         HD(j)->cp_stat[i] = IN_RESET;
1449         printk("%s: reset, mbox %d in reset.\n", BN(j), i);
1450         }
1451
1452      if (SCpnt->host_scribble == NULL)
1453         panic("%s: reset, mbox %d, garbled SCpnt.\n", BN(j), i);
1454
1455      if (*(unsigned int *)SCpnt->host_scribble != i)
1456         panic("%s: reset, mbox %d, index mismatch.\n", BN(j), i);
1457
1458      if (SCpnt->scsi_done == NULL)
1459         panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", BN(j), i);
1460
1461      if (SCpnt == SCarg) arg_done = TRUE;
1462      }
1463
1464   if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1465      printk("%s: reset, cannot reset, timeout error.\n", BN(j));
1466      spin_unlock_irq(sh[j]->host_lock);
1467      return FAILED;
1468      }
1469
1470   outb(CMD_RESET, sh[j]->io_port + REG_LCL_INTR);
1471   printk("%s: reset, board reset done, enabling interrupts.\n", BN(j));
1472
1473#if defined(DEBUG_RESET)
1474   do_trace = TRUE;
1475#endif
1476
1477   HD(j)->in_reset = TRUE;
1478
1479   spin_unlock_irq(sh[j]->host_lock);
1480   time = jiffies;
1481   while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L);
1482   spin_lock_irq(sh[j]->host_lock);
1483
1484   printk("%s: reset, interrupts disabled, loops %d.\n", BN(j), limit);
1485
1486   for (i = 0; i < sh[j]->can_queue; i++) {
1487
1488      if (HD(j)->cp_stat[i] == IN_RESET) {
1489         SCpnt = HD(j)->cp[i].SCpnt;
1490         unmap_dma(i, j);
1491         SCpnt->result = DID_RESET << 16;
1492         SCpnt->host_scribble = NULL;
1493
1494         /* This mailbox is still waiting for its interrupt */
1495         HD(j)->cp_stat[i] = LOCKED;
1496
1497         printk("%s, reset, mbox %d locked, DID_RESET, done.\n", BN(j), i);
1498         }
1499
1500      else if (HD(j)->cp_stat[i] == ABORTING) {
1501         SCpnt = HD(j)->cp[i].SCpnt;
1502         unmap_dma(i, j);
1503         SCpnt->result = DID_RESET << 16;
1504         SCpnt->host_scribble = NULL;
1505
1506         /* This mailbox was never queued to the adapter */
1507         HD(j)->cp_stat[i] = FREE;
1508
1509         printk("%s, reset, mbox %d aborting, DID_RESET, done.\n", BN(j), i);
1510         }
1511
1512      else
1513
1514         /* Any other mailbox has already been set free by interrupt */
1515         continue;
1516
1517      SCpnt->scsi_done(SCpnt);
1518      }
1519
1520   HD(j)->in_reset = FALSE;
1521   do_trace = FALSE;
1522
1523   if (arg_done) printk("%s: reset, exit, done.\n", BN(j));
1524   else          printk("%s: reset, exit.\n", BN(j));
1525
1526   spin_unlock_irq(sh[j]->host_lock);
1527   return SUCCESS;
1528}
1529
1530static int u14_34f_bios_param(struct scsi_device *disk,
1531                 struct block_device *bdev, sector_t capacity, int *dkinfo) {
1532   unsigned int j = 0;
1533   unsigned int size = capacity;
1534
1535   dkinfo[0] = HD(j)->heads;
1536   dkinfo[1] = HD(j)->sectors;
1537   dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
1538
1539   if (ext_tran && (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) {
1540      dkinfo[0] = 255;
1541      dkinfo[1] = 63;
1542      dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
1543      }
1544
1545#if defined (DEBUG_GEOMETRY)
1546   printk ("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name,
1547           dkinfo[0], dkinfo[1], dkinfo[2]);
1548#endif
1549
1550   return FALSE;
1551}
1552
1553static void sort(unsigned long sk[], unsigned int da[], unsigned int n,
1554                 unsigned int rev) {
1555   unsigned int i, j, k, y;
1556   unsigned long x;
1557
1558   for (i = 0; i < n - 1; i++) {
1559      k = i;
1560
1561      for (j = k + 1; j < n; j++)
1562         if (rev) {
1563            if (sk[j] > sk[k]) k = j;
1564            }
1565         else {
1566            if (sk[j] < sk[k]) k = j;
1567            }
1568
1569      if (k != i) {
1570         x = sk[k]; sk[k] = sk[i]; sk[i] = x;
1571         y = da[k]; da[k] = da[i]; da[i] = y;
1572         }
1573      }
1574
1575   return;
1576   }
1577
1578static int reorder(unsigned int j, unsigned long cursec,
1579                 unsigned int ihdlr, unsigned int il[], unsigned int n_ready) {
1580   struct scsi_cmnd *SCpnt;
1581   struct mscp *cpp;
1582   unsigned int k, n;
1583   unsigned int rev = FALSE, s = TRUE, r = TRUE;
1584   unsigned int input_only = TRUE, overlap = FALSE;
1585   unsigned long sl[n_ready], pl[n_ready], ll[n_ready];
1586   unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0;
1587   unsigned long ioseek = 0;
1588
1589   static unsigned int flushcount = 0, batchcount = 0, sortcount = 0;
1590   static unsigned int readycount = 0, ovlcount = 0, inputcount = 0;
1591   static unsigned int readysorted = 0, revcount = 0;
1592   static unsigned long seeksorted = 0, seeknosort = 0;
1593
1594   if (link_statistics && !(++flushcount % link_statistics))
1595      printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"\
1596             " av %ldK as %ldK.\n", flushcount, batchcount, inputcount,
1597             ovlcount, readycount, readysorted, sortcount, revcount,
1598             seeknosort / (readycount + 1),
1599             seeksorted / (readycount + 1));
1600
1601   if (n_ready <= 1) return FALSE;
1602
1603   for (n = 0; n < n_ready; n++) {
1604      k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1605
1606      if (!(cpp->xdir == DTD_IN)) input_only = FALSE;
1607
1608      if (blk_rq_pos(SCpnt->request) < minsec)
1609         minsec = blk_rq_pos(SCpnt->request);
1610      if (blk_rq_pos(SCpnt->request) > maxsec)
1611         maxsec = blk_rq_pos(SCpnt->request);
1612
1613      sl[n] = blk_rq_pos(SCpnt->request);
1614      ioseek += blk_rq_sectors(SCpnt->request);
1615
1616      if (!n) continue;
1617
1618      if (sl[n] < sl[n - 1]) s = FALSE;
1619      if (sl[n] > sl[n - 1]) r = FALSE;
1620
1621      if (link_statistics) {
1622         if (sl[n] > sl[n - 1])
1623            seek += sl[n] - sl[n - 1];
1624         else
1625            seek += sl[n - 1] - sl[n];
1626         }
1627
1628      }
1629
1630   if (link_statistics) {
1631      if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec;
1632      }
1633
1634   if (cursec > ((maxsec + minsec) / 2)) rev = TRUE;
1635
1636   if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE;
1637
1638   if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev);
1639
1640   if (!input_only) for (n = 0; n < n_ready; n++) {
1641      k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1642      ll[n] = blk_rq_sectors(SCpnt->request); pl[n] = SCpnt->serial_number;
1643
1644      if (!n) continue;
1645
1646      if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n]))
1647          || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE;
1648      }
1649
1650   if (overlap) sort(pl, il, n_ready, FALSE);
1651
1652   if (link_statistics) {
1653      if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec;
1654      batchcount++; readycount += n_ready; seeknosort += seek / 1024;
1655      if (input_only) inputcount++;
1656      if (overlap) { ovlcount++; seeksorted += iseek / 1024; }
1657      else seeksorted += (iseek + maxsec - minsec) / 1024;
1658      if (rev && !r)     {  revcount++; readysorted += n_ready; }
1659      if (!rev && !s)    { sortcount++; readysorted += n_ready; }
1660      }
1661
1662#if defined(DEBUG_LINKED_COMMANDS)
1663   if (link_statistics && (overlap || !(flushcount % link_statistics)))
1664      for (n = 0; n < n_ready; n++) {
1665         k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1666         printk("%s %d.%d:%d mb %d fc %d nr %d sec %ld ns %u"\
1667                " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
1668                (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
1669                SCpnt->lun, k, flushcount, n_ready,
1670                blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
1671                cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
1672                YESNO(overlap), cpp->xdir);
1673         }
1674#endif
1675   return overlap;
1676}
1677
1678static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned int j,
1679                      unsigned int ihdlr) {
1680   struct scsi_cmnd *SCpnt;
1681   struct mscp *cpp;
1682   unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES];
1683
1684   for (k = 0; k < sh[j]->can_queue; k++) {
1685
1686      if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue;
1687
1688      cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1689
1690      if (SCpnt->device != dev) continue;
1691
1692      if (HD(j)->cp_stat[k] == IN_USE) return;
1693
1694      il[n_ready++] = k;
1695      }
1696
1697   if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1;
1698
1699   for (n = 0; n < n_ready; n++) {
1700      k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1701
1702      if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1703         scmd_printk(KERN_INFO, SCpnt,
1704                "%s, mbox %d, adapter"
1705                " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"),
1706                k);
1707         HD(j)->cp_stat[k] = ABORTING;
1708         continue;
1709         }
1710
1711      outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM);
1712      outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR);
1713      HD(j)->cp_stat[k] = IN_USE;
1714      }
1715
1716}
1717
1718static irqreturn_t ihdlr(unsigned int j)
1719{
1720   struct scsi_cmnd *SCpnt;
1721   unsigned int i, k, c, status, tstatus, reg, ret;
1722   struct mscp *spp, *cpp;
1723   int irq = sh[j]->irq;
1724
1725   /* Check if this board need to be serviced */
1726   if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none;
1727
1728   HD(j)->iocount++;
1729
1730   if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.\n", BN(j), irq,
1731                        HD(j)->iocount);
1732
1733   /* Check if this board is still busy */
1734   if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) {
1735      outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1736      printk("%s: ihdlr, busy timeout error,  irq %d, reg 0x%x, count %d.\n",
1737             BN(j), irq, reg, HD(j)->iocount);
1738      goto none;
1739      }
1740
1741   ret = inl(sh[j]->io_port + REG_ICM);
1742
1743   /* Clear interrupt pending flag */
1744   outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR);
1745
1746   /* Find the mailbox to be serviced on this board */
1747   for (i = 0; i < sh[j]->can_queue; i++)
1748      if (H2DEV(HD(j)->cp[i].cp_dma_addr) == ret) break;
1749
1750   if (i >= sh[j]->can_queue)
1751      panic("%s: ihdlr, invalid mscp bus address %p, cp0 %p.\n", BN(j),
1752            (void *)ret, (void *)H2DEV(HD(j)->cp[0].cp_dma_addr));
1753
1754   cpp = &(HD(j)->cp[i]);
1755   spp = cpp;
1756
1757#if defined(DEBUG_GENERATE_ABORTS)
1758   if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) goto handled;
1759#endif
1760
1761   if (HD(j)->cp_stat[i] == IGNORE) {
1762      HD(j)->cp_stat[i] = FREE;
1763      goto handled;
1764      }
1765   else if (HD(j)->cp_stat[i] == LOCKED) {
1766      HD(j)->cp_stat[i] = FREE;
1767      printk("%s: ihdlr, mbox %d unlocked, count %d.\n", BN(j), i,
1768             HD(j)->iocount);
1769      goto handled;
1770      }
1771   else if (HD(j)->cp_stat[i] == FREE) {
1772      printk("%s: ihdlr, mbox %d is free, count %d.\n", BN(j), i,
1773             HD(j)->iocount);
1774      goto handled;
1775      }
1776   else if (HD(j)->cp_stat[i] == IN_RESET)
1777      printk("%s: ihdlr, mbox %d is in reset.\n", BN(j), i);
1778   else if (HD(j)->cp_stat[i] != IN_USE)
1779      panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n",
1780            BN(j), i, HD(j)->cp_stat[i]);
1781
1782   HD(j)->cp_stat[i] = FREE;
1783   SCpnt = cpp->SCpnt;
1784
1785   if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
1786
1787   if (SCpnt->host_scribble == NULL)
1788      panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", BN(j), i,
1789            SCpnt);
1790
1791   if (*(unsigned int *)SCpnt->host_scribble != i)
1792      panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
1793            BN(j), i, *(unsigned int *)SCpnt->host_scribble);
1794
1795   sync_dma(i, j);
1796
1797   if (linked_comm && SCpnt->device->queue_depth > 2
1798                                     && TLDEV(SCpnt->device->type))
1799      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, TRUE);
1800
1801   tstatus = status_byte(spp->target_status);
1802
1803#if defined(DEBUG_GENERATE_ERRORS)
1804   if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2))
1805                                           spp->adapter_status = 0x01;
1806#endif
1807
1808   switch (spp->adapter_status) {
1809      case ASOK:     /* status OK */
1810
1811         /* Forces a reset if a disk drive keeps returning BUSY */
1812         if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE)
1813            status = DID_ERROR << 16;
1814
1815         /* If there was a bus reset, redo operation on each target */
1816         else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK
1817                  && HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)])
1818            status = DID_BUS_BUSY << 16;
1819
1820         /* Works around a flaw in scsi.c */
1821         else if (tstatus == CHECK_CONDITION
1822                  && SCpnt->device->type == TYPE_DISK
1823                  && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
1824            status = DID_BUS_BUSY << 16;
1825
1826         else
1827            status = DID_OK << 16;
1828
1829         if (tstatus == GOOD)
1830            HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)] = FALSE;
1831
1832         if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
1833             (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
1834               (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
1835            scmd_printk(KERN_INFO, SCpnt,
1836                "ihdlr, target_status 0x%x, sense key 0x%x.\n",
1837                   spp->target_status,
1838                   SCpnt->sense_buffer[2]);
1839
1840         HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0;
1841
1842         if (HD(j)->last_retried_pid == SCpnt->serial_number) HD(j)->retries = 0;
1843
1844         break;
1845      case ASST:     /* Selection Time Out */
1846
1847         if (HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] > 1)
1848            status = DID_ERROR << 16;
1849         else {
1850            status = DID_TIME_OUT << 16;
1851            HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)]++;
1852            }
1853
1854         break;
1855
1856      /* Perform a limited number of internal retries */
1857      case 0x93:     /* Unexpected bus free */
1858      case 0x94:     /* Target bus phase sequence failure */
1859      case 0x96:     /* Illegal SCSI command */
1860      case 0xa3:     /* SCSI bus reset error */
1861
1862         for (c = 0; c <= sh[j]->max_channel; c++)
1863            for (k = 0; k < sh[j]->max_id; k++)
1864               HD(j)->target_redo[k][c] = TRUE;
1865
1866
1867      case 0x92:     /* Data over/under-run */
1868
1869         if (SCpnt->device->type != TYPE_TAPE
1870             && HD(j)->retries < MAX_INTERNAL_RETRIES) {
1871
1872#if defined(DID_SOFT_ERROR)
1873            status = DID_SOFT_ERROR << 16;
1874#else
1875            status = DID_BUS_BUSY << 16;
1876#endif
1877
1878            HD(j)->retries++;
1879            HD(j)->last_retried_pid = SCpnt->serial_number;
1880            }
1881         else
1882            status = DID_ERROR << 16;
1883
1884         break;
1885      case 0x01:     /* Invalid command */
1886      case 0x02:     /* Invalid parameters */
1887      case 0x03:     /* Invalid data list */
1888      case 0x84:     /* SCSI bus abort error */
1889      case 0x9b:     /* Auto request sense error */
1890      case 0x9f:     /* Unexpected command complete message error */
1891      case 0xff:     /* Invalid parameter in the S/G list */
1892      default:
1893         status = DID_ERROR << 16;
1894         break;
1895      }
1896
1897   SCpnt->result = status | spp->target_status;
1898
1899#if defined(DEBUG_INTERRUPT)
1900   if (SCpnt->result || do_trace)
1901#else
1902   if ((spp->adapter_status != ASOK && HD(j)->iocount >  1000) ||
1903       (spp->adapter_status != ASOK &&
1904        spp->adapter_status != ASST && HD(j)->iocount <= 1000) ||
1905        do_trace || msg_byte(spp->target_status))
1906#endif
1907      scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\
1908             " reg 0x%x, count %d.\n",
1909             i, spp->adapter_status, spp->target_status,
1910             reg, HD(j)->iocount);
1911
1912   unmap_dma(i, j);
1913
1914   /* Set the command state to inactive */
1915   SCpnt->host_scribble = NULL;
1916
1917   SCpnt->scsi_done(SCpnt);
1918
1919   if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.\n", BN(j), irq,
1920                        HD(j)->iocount);
1921
1922handled:
1923   return IRQ_HANDLED;
1924none:
1925   return IRQ_NONE;
1926}
1927
1928static irqreturn_t do_interrupt_handler(int irq, void *shap) {
1929   unsigned int j;
1930   unsigned long spin_flags;
1931   irqreturn_t ret;
1932
1933   /* Check if the interrupt must be processed by this handler */
1934   if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE;
1935
1936   spin_lock_irqsave(sh[j]->host_lock, spin_flags);
1937   ret = ihdlr(j);
1938   spin_unlock_irqrestore(sh[j]->host_lock, spin_flags);
1939   return ret;
1940}
1941
1942static int u14_34f_release(struct Scsi_Host *shpnt) {
1943   unsigned int i, j;
1944
1945   for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++);
1946
1947   if (sh[j] == NULL)
1948      panic("%s: release, invalid Scsi_Host pointer.\n", driver_name);
1949
1950   for (i = 0; i < sh[j]->can_queue; i++)
1951      kfree((&HD(j)->cp[i])->sglist);
1952
1953   for (i = 0; i < sh[j]->can_queue; i++)
1954      pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr,
1955                     sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL);
1956
1957   free_irq(sh[j]->irq, &sha[j]);
1958
1959   if (sh[j]->dma_channel != NO_DMA)
1960      free_dma(sh[j]->dma_channel);
1961
1962   release_region(sh[j]->io_port, sh[j]->n_io_port);
1963   scsi_unregister(sh[j]);
1964   return FALSE;
1965}
1966
1967#include "scsi_module.c"
1968
1969#ifndef MODULE
1970__setup("u14-34f=", option_setup);
1971#endif /* end MODULE */
1972
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.