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