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 (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 %llu.\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:%u.\n", 1289 BN(j), i, SCpnt->device->channel, SCpnt->device->id, 1290 (u8)SCpnt->device->lun); 1291 1292 cpp->opcode = OP_SCSI; 1293 cpp->channel = SCpnt->device->channel; 1294 cpp->target = SCpnt->device->id; 1295 cpp->lun = (u8)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:%llu 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 (u8)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