u14-34f.c revision df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0
11da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 21da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * u14-34f.c - Low-level driver for UltraStor 14F/34F SCSI host adapters. 31da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 41da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 03 Jun 2003 Rev. 8.10 for linux-2.5.70 51da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Update for new IRQ API. 61da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Use "goto" when appropriate. 71da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Drop u14-34f.h. 81da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Update for new module_param API. 91da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Module parameters can now be specified only in the 101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * same format as the kernel boot options. 111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * boot option old module param 131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ----------- ------------------ 141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * addr,... io_port=addr,... 151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * lc:[y|n] linked_comm=[1|0] 161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mq:xx max_queue_depth=xx 171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * tm:[0|1|2] tag_mode=[0|1|2] 181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * et:[y|n] ext_tran=[1|0] 191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of:[y|n] have_old_firmware=[1|0] 201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * A valid example using the new parameter format is: 221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * modprobe u14-34f "u14-34f=0x340,0x330,lc:y,tm:0,mq:4" 231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * which is equivalent to the old format: 251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * modprobe u14-34f io_port=0x340,0x330 linked_comm=1 tag_mode=0 \ 261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * max_queue_depth=4 271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * With actual module code, u14-34f and u14_34f are equivalent 291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * as module parameter names. 301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 12 Feb 2003 Rev. 8.04 for linux 2.5.60 321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Release irq before calling scsi_register. 331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 12 Nov 2002 Rev. 8.02 for linux 2.5.47 351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Release driver_lock before calling scsi_register. 361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11 Nov 2002 Rev. 8.01 for linux 2.5.47 381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Fixed bios_param and scsicam_bios_param calling parameters. 391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 28 Oct 2002 Rev. 8.00 for linux 2.5.44-ac4 411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Use new tcq and adjust_queue_depth api. 421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + New command line option (tm:[0-2]) to choose the type of tags: 431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 0 -> disable tagging ; 1 -> simple tags ; 2 -> ordered tags. 441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Default is tm:0 (tagged commands disabled). 451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * For compatibility the "tc:" option is an alias of the "tm:" 461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * option; tc:n is equivalent to tm:0 and tc:y is equivalent to 471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * tm:1. 481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 10 Oct 2002 Rev. 7.70 for linux 2.5.42 501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Foreport from revision 6.70. 511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 25 Jun 2002 Rev. 6.70 for linux 2.4.19 531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Fixed endian-ness problem due to bitfields. 541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 21 Feb 2002 Rev. 6.52 for linux 2.4.18 561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Backport from rev. 7.22 (use io_request_lock). 571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 20 Feb 2002 Rev. 7.22 for linux 2.5.5 591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Remove any reference to virt_to_bus(). 601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Fix pio hang while detecting multiple HBAs. 611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 01 Jan 2002 Rev. 7.20 for linux 2.5.1 631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Use the dynamic DMA mapping API. 641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 19 Dec 2001 Rev. 7.02 for linux 2.5.1 661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Use SCpnt->sc_data_direction if set. 671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Use sglist.page instead of sglist.address. 681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11 Dec 2001 Rev. 7.00 for linux 2.5.1 701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Use host->host_lock instead of io_request_lock. 711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1 May 2001 Rev. 6.05 for linux 2.4.4 731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Fix data transfer direction for opcode SEND_CUE_SHEET (0x5d) 741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 25 Jan 2001 Rev. 6.03 for linux 2.4.0 761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + "check_region" call replaced by "request_region". 771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 22 Nov 2000 Rev. 6.02 for linux 2.4.0-test11 791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Removed old scsi error handling support. 801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + The obsolete boot option flag eh:n is silently ignored. 811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Removed error messages while a disk drive is powered up at 821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * boot time. 831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Improved boot messages: all tagged capable device are 841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * indicated as "tagged". 851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16 Sep 1999 Rev. 5.11 for linux 2.2.12 and 2.3.18 871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Updated to the new __setup interface for boot command line options. 881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + When loaded as a module, accepts the new parameter boot_options 891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * which value is a string with the same format of the kernel boot 901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * command line options. A valid example is: 911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * modprobe u14-34f 'boot_options="0x230,0x340,lc:y,mq:4"' 921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 22 Jul 1999 Rev. 5.00 for linux 2.2.10 and 2.3.11 941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * + Removed pre-2.2 source code compatibility. 951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 26 Jul 1998 Rev. 4.33 for linux 2.0.35 and 2.1.111 971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added command line option (et:[y|n]) to use the existing 981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * translation (returned by scsicam_bios_param) as disk geometry. 991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The default is et:n, which uses the disk geometry jumpered 1001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * on the board. 1011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The default value et:n is compatible with all previous revisions 1021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of this driver. 1031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 28 May 1998 Rev. 4.32 for linux 2.0.33 and 2.1.104 1051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Increased busy timeout from 10 msec. to 200 msec. while 1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * processing interrupts. 1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 18 May 1998 Rev. 4.31 for linux 2.0.33 and 2.1.102 1091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Improved abort handling during the eh recovery process. 1101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 13 May 1998 Rev. 4.30 for linux 2.0.33 and 2.1.101 1121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The driver is now fully SMP safe, including the 1131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * abort and reset routines. 1141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added command line options (eh:[y|n]) to choose between 1151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * new_eh_code and the old scsi code. 1161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If linux version >= 2.1.101 the default is eh:y, while the eh 1171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * option is ignored for previous releases and the old scsi code 1181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * is used. 1191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 18 Apr 1998 Rev. 4.20 for linux 2.0.33 and 2.1.97 1211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Reworked interrupt handler. 1221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11 Apr 1998 rev. 4.05 for linux 2.0.33 and 2.1.95 1241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Major reliability improvement: when a batch with overlapping 1251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * requests is detected, requests are queued one at a time 1261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * eliminating any possible board or drive reordering. 1271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 10 Apr 1998 rev. 4.04 for linux 2.0.33 and 2.1.95 1291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Improved SMP support (if linux version >= 2.1.95). 1301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 9 Apr 1998 rev. 4.03 for linux 2.0.33 and 2.1.94 1321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Performance improvement: when sequential i/o is detected, 1331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * always use direct sort instead of reverse sort. 1341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4 Apr 1998 rev. 4.02 for linux 2.0.33 and 2.1.92 1361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * io_port is now unsigned long. 1371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 17 Mar 1998 rev. 4.01 for linux 2.0.33 and 2.1.88 1391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Use new scsi error handling code (if linux version >= 2.1.88). 1401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Use new interrupt code. 1411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 12 Sep 1997 rev. 3.11 for linux 2.0.30 and 2.1.55 1431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Use of udelay inside the wait loops to avoid timeout 1441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * problems with fast cpus. 1451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Removed check about useless calls to the interrupt service 1461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * routine (reported on SMP systems only). 1471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * At initialization time "sorted/unsorted" is displayed instead 1481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of "linked/unlinked" to reinforce the fact that "linking" is 1491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * nothing but "elevator sorting" in the actual implementation. 1501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 17 May 1997 rev. 3.10 for linux 2.0.30 and 2.1.38 1521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Use of serial_number_at_timeout in abort and reset processing. 1531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Use of the __initfunc and __initdata macro in setup code. 1541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Minor cleanups in the list_statistics code. 1551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 24 Feb 1997 rev. 3.00 for linux 2.0.29 and 2.1.26 1571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * When loading as a module, parameter passing is now supported 1581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * both in 2.0 and in 2.1 style. 1591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Fixed data transfer direction for some SCSI opcodes. 1601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Immediate acknowledge to request sense commands. 1611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Linked commands to each disk device are now reordered by elevator 1621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * sorting. Rare cases in which reordering of write requests could 1631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cause wrong results are managed. 1641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 18 Jan 1997 rev. 2.60 for linux 2.1.21 and 2.0.28 1661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added command line options to enable/disable linked commands 1671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * (lc:[y|n]), old firmware support (of:[y|n]) and to set the max 1681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * queue depth (mq:xx). Default is "u14-34f=lc:n,of:n,mq:8". 1691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Improved command linking. 1701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 8 Jan 1997 rev. 2.50 for linux 2.1.20 and 2.0.27 1721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added linked command support. 1731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3 Dec 1996 rev. 2.40 for linux 2.1.14 and 2.0.27 1751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added queue depth adjustment. 1761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 22 Nov 1996 rev. 2.30 for linux 2.1.12 and 2.0.26 1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The list of i/o ports to be probed can be overwritten by the 1791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * "u14-34f=port0,port1,...." boot command line option. 1801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Scatter/gather lists are now allocated by a number of kmalloc 1811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * calls, in order to avoid the previous size limit of 64Kb. 1821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16 Nov 1996 rev. 2.20 for linux 2.1.10 and 2.0.25 1841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added multichannel support. 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 27 Sep 1996 rev. 2.12 for linux 2.1.0 1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Portability cleanups (virtual/bus addressing, little/big endian 1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * support). 1891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 09 Jul 1996 rev. 2.11 for linux 2.0.4 1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * "Data over/under-run" no longer implies a redo on all targets. 1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Number of internal retries is now limited. 1931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16 Apr 1996 rev. 2.10 for linux 1.3.90 1951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * New argument "reset_flags" to the reset routine. 1961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 21 Jul 1995 rev. 2.02 for linux 1.3.11 1981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Fixed Data Transfer Direction for some SCSI commands. 1991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 13 Jun 1995 rev. 2.01 for linux 1.2.10 2011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * HAVE_OLD_UX4F_FIRMWARE should be defined for U34F boards when 2021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the firmware prom is not the latest one (28008-006). 2031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11 Mar 1995 rev. 2.00 for linux 1.2.0 2051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Fixed a bug which prevented media change detection for removable 2061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * disk drives. 2071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 23 Feb 1995 rev. 1.18 for linux 1.1.94 2091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added a check for scsi_register returning NULL. 2101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 11 Feb 1995 rev. 1.17 for linux 1.1.91 2121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * U14F qualified to run with 32 sglists. 2131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Now DEBUG_RESET is disabled by default. 2141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 9 Feb 1995 rev. 1.16 for linux 1.1.90 2161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Use host->wish_block instead of host->block. 2171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 8 Feb 1995 rev. 1.15 for linux 1.1.89 2191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Cleared target_time_out counter while performing a reset. 2201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 28 Jan 1995 rev. 1.14 for linux 1.1.86 2221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added module support. 2231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Log and do a retry when a disk drive returns a target status 2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * different from zero on a recovered error. 2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Auto detects if U14F boards have an old firmware revision. 2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Max number of scatter/gather lists set to 16 for all boards 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * (most installation run fine using 33 sglists, while other 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * has problems when using more than 16). 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16 Jan 1995 rev. 1.13 for linux 1.1.81 2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Display a message if check_region detects a port address 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * already in use. 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 15 Dec 1994 rev. 1.12 for linux 1.1.74 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The host->block flag is set for all the detected ISA boards. 2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 30 Nov 1994 rev. 1.11 for linux 1.1.68 2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Redo i/o on target status CHECK_CONDITION for TYPE_DISK only. 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added optional support for using a single board at a time. 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 14 Nov 1994 rev. 1.10 for linux 1.1.63 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 28 Oct 1994 rev. 1.09 for linux 1.1.58 Final BETA release. 2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16 Jul 1994 rev. 1.00 for linux 1.1.29 Initial ALPHA release. 2451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This driver is a total replacement of the original UltraStor 2471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * scsi driver, but it supports ONLY the 14F and 34F boards. 2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * It can be configured in the same kernel in which the original 2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ultrastor driver is configured to allow the original U24F 2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * support. 2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Multiple U14F and/or U34F host adapters are supported. 2531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (C) 1994-2003 Dario Ballabio (ballabio_dario@emc.com) 2551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Alternate email: dario.ballabio@inwind.it, dario.ballabio@tiscalinet.it 2571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Redistribution and use in source and binary forms, with or without 2591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * modification, are permitted provided that redistributions of source 2601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * code retain the above copyright notice and this comment without 2611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * modification. 2621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * WARNING: if your 14/34F board has an old firmware revision (see below) 2641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * you must change "#undef" into "#define" in the following 2651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * statement. 2661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 2671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef HAVE_OLD_UX4F_FIRMWARE 2681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 2691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The UltraStor 14F, 24F, and 34F are a family of intelligent, high 2701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * performance SCSI-2 host adapters. 2711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Here is the scoop on the various models: 2721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 14F - ISA first-party DMA HA with floppy support and WD1003 emulation. 2741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 24F - EISA Bus Master HA with floppy support and WD1003 emulation. 2751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 34F - VESA Local-Bus Bus Master HA (no WD1003 emulation). 2761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This code has been tested with up to two U14F boards, using both 2781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * firmware 28004-005/38004-004 (BIOS rev. 2.00) and the latest firmware 2791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 28004-006/38004-005 (BIOS rev. 2.01). 2801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The latest firmware is required in order to get reliable operations when 2821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * clustering is enabled. ENABLE_CLUSTERING provides a performance increase 2831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * up to 50% on sequential access. 2841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Since the Scsi_Host_Template structure is shared among all 14F and 34F, 2861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the last setting of use_clustering is in effect for all of these boards. 2871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Here a sample configuration using two U14F boards: 2891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds U14F0: ISA 0x330, BIOS 0xc8000, IRQ 11, DMA 5, SG 32, MB 16, of:n, lc:y, mq:8. 2911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds U14F1: ISA 0x340, BIOS 0x00000, IRQ 10, DMA 6, SG 32, MB 16, of:n, lc:y, mq:8. 2921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The boot controller must have its BIOS enabled, while other boards can 2941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * have their BIOS disabled, or enabled to an higher address. 2951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Boards are named Ux4F0, Ux4F1..., according to the port address order in 2961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the io_port[] array. 2971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The following facts are based on real testing results (not on 2991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * documentation) on the above U14F board. 3001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * - The U14F board should be jumpered for bus on time less or equal to 7 3021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * microseconds, while the default is 11 microseconds. This is order to 3031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * get acceptable performance while using floppy drive and hard disk 3041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * together. The jumpering for 7 microseconds is: JP13 pin 15-16, 3051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * JP14 pin 7-8 and pin 9-10. 3061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The reduction has a little impact on scsi performance. 3071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * - If scsi bus length exceeds 3m., the scsi bus speed needs to be reduced 3091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * from 10Mhz to 5Mhz (do this by inserting a jumper on JP13 pin 7-8). 3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * - If U14F on board firmware is older than 28004-006/38004-005, 3121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the U14F board is unable to provide reliable operations if the scsi 3131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * request length exceeds 16Kbyte. When this length is exceeded the 3141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * behavior is: 3151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * - adapter_status equal 0x96 or 0xa3 or 0x93 or 0x94; 3161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * - adapter_status equal 0 and target_status equal 2 on for all targets 3171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in the next operation following the reset. 3181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This sequence takes a long time (>3 seconds), so in the meantime 3191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the SD_TIMEOUT in sd.c could expire giving rise to scsi aborts 3201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * (SD_TIMEOUT has been increased from 3 to 6 seconds in 1.1.31). 3211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Because of this I had to DISABLE_CLUSTERING and to work around the 3221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * bus reset in the interrupt service routine, returning DID_BUS_BUSY 3231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so that the operations are retried without complains from the scsi.c 3241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * code. 3251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Any reset of the scsi bus is going to kill tape operations, since 3261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * no retry is allowed for tapes. Bus resets are more likely when the 3271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * scsi bus is under heavy load. 3281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Requests using scatter/gather have a maximum length of 16 x 1024 bytes 3291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * when DISABLE_CLUSTERING is in effect, but unscattered requests could be 3301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * larger than 16Kbyte. 3311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The new firmware has fixed all the above problems. 3331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * For U34F boards the latest bios prom is 38008-002 (BIOS rev. 2.01), 3351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the latest firmware prom is 28008-006. Older firmware 28008-005 has 3361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * problems when using more than 16 scatter/gather lists. 3371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The list of i/o ports to be probed can be totally replaced by the 3391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * boot command line option: "u14-34f=port0,port1,port2,...", where the 3401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * port0, port1... arguments are ISA/VESA addresses to be probed. 3411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * For example using "u14-34f=0x230,0x340", the driver probes only the two 3421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * addresses 0x230 and 0x340 in this order; "u14-34f=0" totally disables 3431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this driver. 3441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * After the optional list of detection probes, other possible command line 3461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * options are: 3471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * et:y use disk geometry returned by scsicam_bios_param; 3491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * et:n use disk geometry jumpered on the board; 3501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * lc:y enables linked commands; 3511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * lc:n disables linked commands; 3521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * tm:0 disables tagged commands (same as tc:n); 3531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * tm:1 use simple queue tags (same as tc:y); 3541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * tm:2 use ordered queue tags (same as tc:2); 3551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of:y enables old firmware support; 3561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of:n disables old firmware support; 3571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mq:xx set the max queue depth to the value xx (2 <= xx <= 8). 3581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The default value is: "u14-34f=lc:n,of:n,mq:8,tm:0,et:n". 3601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * An example using the list of detection probes could be: 3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * "u14-34f=0x230,0x340,lc:y,tm:2,of:n,mq:4,et:n". 3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * When loading as a module, parameters can be specified as well. 3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The above example would be (use 1 in place of y and 0 in place of n): 3651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * modprobe u14-34f io_port=0x230,0x340 linked_comm=1 have_old_firmware=0 \ 3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * max_queue_depth=4 ext_tran=0 tag_mode=2 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ---------------------------------------------------------------------------- 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * In this implementation, linked commands are designed to work with any DISK 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * or CD-ROM, since this linking has only the intent of clustering (time-wise) 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * and reordering by elevator sorting commands directed to each device, 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * without any relation with the actual SCSI protocol between the controller 3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * and the device. 3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If Q is the queue depth reported at boot time for each device (also named 3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cmds/lun) and Q > 2, whenever there is already an active command to the 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * device all other commands to the same device (up to Q-1) are kept waiting 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in the elevator sorting queue. When the active command completes, the 3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * commands in this queue are sorted by sector address. The sort is chosen 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * between increasing or decreasing by minimizing the seek distance between 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the sector of the commands just completed and the sector of the first 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * command in the list to be sorted. 3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Trivial math assures that the unsorted average seek distance when doing 3841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * random seeks over S sectors is S/3. 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * When (Q-1) requests are uniformly distributed over S sectors, the average 3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * distance between two adjacent requests is S/((Q-1) + 1), so the sorted 3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * average seek distance for (Q-1) random requests over S sectors is S/Q. 3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The elevator sorting hence divides the seek distance by a factor Q/3. 3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The above pure geometric remarks are valid in all cases and the 3901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * driver effectively reduces the seek distance by the predicted factor 3911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * when there are Q concurrent read i/o operations on the device, but this 3921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * does not necessarily results in a noticeable performance improvement: 3931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * your mileage may vary.... 3941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Note: command reordering inside a batch of queued commands could cause 3961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * wrong results only if there is at least one write request and the 3971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * intersection (sector-wise) of all requests is not empty. 3981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * When the driver detects a batch including overlapping requests 3991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * (a really rare event) strict serial (pid) order is enforced. 4001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ---------------------------------------------------------------------------- 4011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The boards are named Ux4F0, Ux4F1,... according to the detection order. 4031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * In order to support multiple ISA boards in a reliable way, 4051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the driver sets host->wish_block = TRUE for all ISA boards. 4061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/config.h> 4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/string.h> 4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/kernel.h> 4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/ioport.h> 4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/delay.h> 4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/io.h> 4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/system.h> 4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/byteorder.h> 4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/proc_fs.h> 4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/blkdev.h> 4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/interrupt.h> 4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/stat.h> 4201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/pci.h> 4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/init.h> 4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/ctype.h> 4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/spinlock.h> 4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/dma.h> 4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/irq.h> 4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi.h> 4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_cmnd.h> 4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_device.h> 4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_host.h> 4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_tcq.h> 4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsicam.h> 4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_detect(struct scsi_host_template *); 4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_release(struct Scsi_Host *); 4361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *)); 4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_abort(struct scsi_cmnd *); 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_host_reset(struct scsi_cmnd *); 4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_bios_param(struct scsi_device *, struct block_device *, 4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sector_t, int *); 4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_slave_configure(struct scsi_device *); 4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct scsi_host_template driver_template = { 4441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .name = "UltraStor 14F/34F rev. 8.10.00 ", 4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .detect = u14_34f_detect, 4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .release = u14_34f_release, 4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .queuecommand = u14_34f_queuecommand, 4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .eh_abort_handler = u14_34f_eh_abort, 4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .eh_host_reset_handler = u14_34f_eh_host_reset, 4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .bios_param = u14_34f_bios_param, 4511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .slave_configure = u14_34f_slave_configure, 4521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .this_id = 7, 4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .unchecked_isa_dma = 1, 4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .use_clustering = ENABLE_CLUSTERING 4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD) 4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#error "Adjust your <asm/byteorder.h> defines" 4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Values for the PRODUCT_ID ports for the 14/34F */ 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define PRODUCT_ID1 0x56 4631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define PRODUCT_ID2 0x40 /* NOTE: Only upper nibble is used */ 4641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Subversion values */ 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ISA 0 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ESA 1 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define OP_HOST_ADAPTER 0x1 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define OP_SCSI 0x2 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define OP_RESET 0x4 4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_SCSI 0x0 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_IN 0x1 4741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_OUT 0x2 4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_NONE 0x3 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_INQUIRY 0x1 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_SELF_DIAG 0x2 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_READ_BUFF 0x3 4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_WRITE_BUFF 0x4 4801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_LINKED_COMMANDS 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_DETECT 4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_INTERRUPT 4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_RESET 4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_GENERATE_ERRORS 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_GENERATE_ABORTS 4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_GEOMETRY 4881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_ISA 3 4901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_VESA 1 4911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_EISA 0 4921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_PCI 0 4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI) 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_CHANNEL 1 4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_LUN 8 4961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_TARGET 8 4971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_MAILBOXES 16 4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_SGLIST 32 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_SAFE_SGLIST 16 5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_INTERNAL_RETRIES 64 5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_CMD_PER_LUN 2 5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN) 5031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define SKIP ULONG_MAX 5051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FALSE 0 5061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TRUE 1 5071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FREE 0 5081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IN_USE 1 5091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define LOCKED 2 5101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IN_RESET 3 5111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IGNORE 4 5121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define READY 5 5131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ABORTING 6 5141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define NO_DMA 0xff 5151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAXLOOP 10000 5161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TAG_DISABLED 0 5171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TAG_SIMPLE 1 5181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TAG_ORDERED 2 5191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_LCL_MASK 0 5211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_LCL_INTR 1 5221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_SYS_MASK 2 5231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_SYS_INTR 3 5241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_PRODUCT_ID1 4 5251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_PRODUCT_ID2 5 5261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_CONFIG1 6 5271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_CONFIG2 7 5281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_OGM 8 5291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_ICM 12 5301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REGION_SIZE 13UL 5311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define BSY_ASSERTED 0x01 5321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IRQ_ASSERTED 0x01 5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_RESET 0xc0 5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_OGM_INTR 0x01 5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_CLR_INTR 0x01 5361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_ENA_INTR 0x81 5371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ASOK 0x00 5381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ASST 0x91 5391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define YESNO(a) ((a) ? 'y' : 'n') 5411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM) 5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define PACKED __attribute__((packed)) 5441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct sg_list { 5461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int address; /* Segment Address */ 5471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int num_bytes; /* Segment Length */ 5481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 5491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* MailBox SCSI Command Packet */ 5511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct mscp { 5521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(__BIG_ENDIAN_BITFIELD) 5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sg:1, ca:1, dcn:1, xdir:2, opcode:3; 5551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char lun: 3, channel:2, target:3; 5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char opcode: 3, /* type of command */ 5581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds xdir: 2, /* data transfer direction */ 5591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dcn: 1, /* disable disconnect */ 5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ca: 1, /* use cache (if available) */ 5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sg: 1; /* scatter/gather operation */ 5621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char target: 3, /* SCSI target id */ 5631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds channel: 2, /* SCSI channel number */ 5641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lun: 3; /* SCSI logical unit number */ 5651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 5661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int data_address PACKED; /* transfer data pointer */ 5681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int data_len PACKED; /* length in bytes */ 5691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int link_address PACKED; /* for linking command chains */ 5701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char clink_id; /* identifies command in chain */ 5711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char use_sg; /* (if sg is set) 8 bytes per list */ 5721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sense_len; 5731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char cdb_len; /* 6, 10, or 12 */ 5741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char cdb[12]; /* SCSI Command Descriptor Block */ 5751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char adapter_status; /* non-zero indicates HA error */ 5761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char target_status; /* non-zero indicates target error */ 5771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int sense_addr PACKED; 5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Additional fields begin here. */ 5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int cpp_index; /* cp index */ 5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* All the cp structure is zero filled by queuecommand except the 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds following CP_TAIL_SIZE bytes, initialized by detect */ 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t cp_dma_addr; /* dma handle for this cp structure */ 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct sg_list *sglist; /* pointer to the allocated SG list */ 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t)) 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct hostdata { 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp cp[MAX_MAILBOXES]; /* Mailboxes for this board */ 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */ 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int last_cp_used; /* Index of last mailbox used */ 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int iocount; /* Total i/o done for this board */ 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int board_number; /* Number of this board */ 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char board_name[16]; /* Name of this board */ 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int in_reset; /* True if board is doing a reset */ 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */ 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If TRUE redo i/o on target */ 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int retries; /* Number of internal retries */ 6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long last_retried_pid; /* Pid of last retried command */ 6031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char subversion; /* Bus type, either ISA or ESA */ 6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_dev *pdev; /* Always NULL */ 6051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char heads; 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sectors; 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char board_id[256]; /* data from INQUIRY on this board */ 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 6091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct Scsi_Host *sh[MAX_BOARDS + 1]; 6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic const char *driver_name = "Ux4F"; 6121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char sha[MAX_BOARDS]; 6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic DEFINE_SPINLOCK(driver_lock); 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Initialize num_boards so that ihdlr can work while detect is in progress */ 6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic unsigned int num_boards = MAX_BOARDS; 6171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic unsigned long io_port[] = { 6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Space for MAX_INT_PARAM ports usable while loading as a module */ 6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, 6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SKIP, SKIP, 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Possible ISA/VESA ports */ 6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x330, 0x340, 0x230, 0x240, 0x210, 0x130, 0x140, 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* End of list */ 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x0 6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HD(board) ((struct hostdata *) &sh[board]->hostdata) 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define BN(board) (HD(board)->board_name) 6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Device is Little Endian */ 6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define H2DEV(x) cpu_to_le32(x) 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DEV2H(x) le32_to_cpu(x) 6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic irqreturn_t do_interrupt_handler(int, void *, struct pt_regs *); 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void flush_dev(struct scsi_device *, unsigned long, unsigned int, unsigned int); 6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int do_trace = FALSE; 6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int setup_done = FALSE; 6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int link_statistics; 6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int ext_tran = FALSE; 6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(HAVE_OLD_UX4F_FIRMWARE) 6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int have_old_firmware = TRUE; 6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int have_old_firmware = FALSE; 6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_SCSI_U14_34F_TAGGED_QUEUE) 6521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int tag_mode = TAG_SIMPLE; 6531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int tag_mode = TAG_DISABLED; 6551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_SCSI_U14_34F_LINKED_COMMANDS) 6581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int linked_comm = TRUE; 6591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int linked_comm = FALSE; 6611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_SCSI_U14_34F_MAX_TAGS) 6641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int max_queue_depth = CONFIG_SCSI_U14_34F_MAX_TAGS; 6651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int max_queue_depth = MAX_CMD_PER_LUN; 6671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_INT_PARAM 10 6701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_BOOT_OPTIONS_SIZE 256 6711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char boot_options[MAX_BOOT_OPTIONS_SIZE]; 6721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(MODULE) 6741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/module.h> 6751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/moduleparam.h> 6761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_param_string(u14_34f, boot_options, MAX_BOOT_OPTIONS_SIZE, 0); 6781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_PARM_DESC(u14_34f, " equivalent to the \"u14-34f=...\" kernel boot " \ 6791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds"option." \ 6801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds" Example: modprobe u14-34f \"u14_34f=0x340,0x330,lc:y,tm:0,mq:4\""); 6811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_AUTHOR("Dario Ballabio"); 6821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_LICENSE("GPL"); 6831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_DESCRIPTION("UltraStor 14F/34F SCSI Driver"); 6841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_slave_configure(struct scsi_device *dev) { 6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int j, tqd, utqd; 6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *tag_suffix, *link_suffix; 6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct Scsi_Host *host = dev->host; 6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) host->hostdata)->board_number; 6931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds utqd = MAX_CMD_PER_LUN; 6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tqd = max_queue_depth; 6961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (TLDEV(dev->type) && dev->tagged_supported) 6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tag_mode == TAG_SIMPLE) { 7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd); 7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", simple tags"; 7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tag_mode == TAG_ORDERED) { 7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd); 7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", ordered tags"; 7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, 0, tqd); 7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", no tags"; 7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (TLDEV(dev->type) && linked_comm) { 7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, 0, tqd); 7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", untagged"; 7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, 0, utqd); 7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ""; 7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2) 7231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds link_suffix = ", sorted"; 7241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (TLDEV(dev->type)) 7251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds link_suffix = ", unsorted"; 7261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds link_suffix = ""; 7281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: scsi%d, channel %d, id %d, lun %d, cmds/lun %d%s%s.\n", 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), host->host_no, dev->channel, dev->id, dev->lun, 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->queue_depth, link_suffix, tag_suffix); 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int wait_on_busy(unsigned long iobase, unsigned int loop) { 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (inb(iobase + REG_LCL_INTR) & BSY_ASSERTED) { 7391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(1L); 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (--loop == 0) return TRUE; 7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int board_inquiry(unsigned int j) { 7471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 7481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t id_dma_addr; 7491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int time, limit = 0; 7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds id_dma_addr = pci_map_single(HD(j)->pdev, HD(j)->board_id, 7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sizeof(HD(j)->board_id), PCI_DMA_BIDIRECTIONAL); 7531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[0]; 7541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cp_dma_addr = pci_map_single(HD(j)->pdev, cpp, sizeof(struct mscp), 7551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_DMA_BIDIRECTIONAL); 7561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE); 7571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->opcode = OP_HOST_ADAPTER; 7581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 7591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_address = H2DEV(id_dma_addr); 7601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_len = H2DEV(sizeof(HD(j)->board_id)); 7611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cdb_len = 6; 7621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cdb[0] = HA_CMD_INQUIRY; 7631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 7651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: board_inquiry, adapter busy.\n", BN(j)); 7661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return TRUE; 7671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[0] = IGNORE; 7701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear the interrupt indication */ 7721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 7731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Store pointer in OGM address bytes */ 7751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Issue OGM interrupt */ 7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 7791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 7811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds time = jiffies; 7821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((jiffies - time) < HZ && limit++ < 20000) udelay(100L); 7831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(&driver_lock); 7841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpp->adapter_status || HD(j)->cp_stat[0] != FREE) { 7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[0] = FREE; 7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: board_inquiry, err 0x%x.\n", BN(j), cpp->adapter_status); 7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return TRUE; 7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, cpp->cp_dma_addr, sizeof(struct mscp), 7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_DMA_BIDIRECTIONAL); 7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, id_dma_addr, sizeof(HD(j)->board_id), 7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_DMA_BIDIRECTIONAL); 7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int port_detect \ 7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (unsigned long port_base, unsigned int j, struct scsi_host_template *tpnt) { 8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char irq, dma_channel, subversion, i; 8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char in_byte; 8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *bus_type, dma_name[16]; 8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Allowed BIOS base addresses (NULL indicates reserved) */ 8051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long bios_segment_table[8] = { 8061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0, 8071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0xc4000, 0xc8000, 0xcc000, 0xd0000, 8081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0xd4000, 0xd8000, 0xdc000 8091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 8101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Allowed IRQs */ 8121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char interrupt_table[4] = { 15, 14, 11, 10 }; 8131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Allowed DMA channels for ISA (0 indicates reserved) */ 8151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char dma_channel_table[4] = { 5, 6, 7, 0 }; 8161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Head/sector mappings */ 8181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct { 8191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char heads; 8201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sectors; 8211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } mapping_table[4] = { 8221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 } 8231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 8241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct config_1 { 8261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(__BIG_ENDIAN_BITFIELD) 8281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char dma_channel: 2, interrupt:2, 8291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds removable_disks_as_fixed:1, bios_segment: 3; 8301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 8311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char bios_segment: 3, removable_disks_as_fixed: 1, 8321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds interrupt: 2, dma_channel: 2; 8331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 8341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } config_1; 8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct config_2 { 8381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(__BIG_ENDIAN_BITFIELD) 8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char tfr_port: 2, bios_drive_number: 1, 8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mapping_mode: 2, ha_scsi_id: 3; 8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char ha_scsi_id: 3, mapping_mode: 2, 8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bios_drive_number: 1, tfr_port: 2; 8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 8461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } config_2; 8481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char name[16]; 8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sprintf(name, "%s%d", driver_name, j); 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!request_region(port_base, REGION_SIZE, driver_name)) { 8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_DETECT) 8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: address 0x%03lx in use, skipping probe.\n", name, port_base); 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto fail; 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(&driver_lock); 8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (inb(port_base + REG_PRODUCT_ID1) != PRODUCT_ID1) goto freelock; 8631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds in_byte = inb(port_base + REG_PRODUCT_ID2); 8651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((in_byte & 0xf0) != PRODUCT_ID2) goto freelock; 8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *(char *)&config_1 = inb(port_base + REG_CONFIG1); 8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *(char *)&config_2 = inb(port_base + REG_CONFIG2); 8701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irq = interrupt_table[config_1.interrupt]; 8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_channel = dma_channel_table[config_1.dma_channel]; 8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds subversion = (in_byte & 0x0f); 8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Board detected, allocate its IRQ */ 8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (request_irq(irq, do_interrupt_handler, 8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SA_INTERRUPT | ((subversion == ESA) ? SA_SHIRQ : 0), 8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds driver_name, (void *) &sha[j])) { 8791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: unable to allocate IRQ %u, detaching.\n", name, irq); 8801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto freelock; 8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (subversion == ISA && request_dma(dma_channel, driver_name)) { 8841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: unable to allocate DMA channel %u, detaching.\n", 8851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds name, dma_channel); 8861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto freeirq; 8871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (have_old_firmware) tpnt->use_clustering = DISABLE_CLUSTERING; 8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 8921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j] = scsi_register(tpnt, sizeof(struct hostdata)); 8931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(&driver_lock); 8941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j] == NULL) { 8961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: unable to register host, detaching.\n", name); 8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto freedma; 8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->io_port = port_base; 9011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->unique_id = port_base; 9021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->n_io_port = REGION_SIZE; 9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->base = bios_segment_table[config_1.bios_segment]; 9041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->irq = irq; 9051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->sg_tablesize = MAX_SGLIST; 9061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->this_id = config_2.ha_scsi_id; 9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->can_queue = MAX_MAILBOXES; 9081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->cmd_per_lun = MAX_CMD_PER_LUN; 9091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_DETECT) 9111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds { 9121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sys_mask, lcl_mask; 9131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sys_mask = inb(sh[j]->io_port + REG_SYS_MASK); 9151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lcl_mask = inb(sh[j]->io_port + REG_LCL_MASK); 9161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("SYS_MASK 0x%x, LCL_MASK 0x%x.\n", sys_mask, lcl_mask); 9171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Probably a bogus host scsi id, set it to the dummy value */ 9211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->this_id == 0) sh[j]->this_id = -1; 9221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If BIOS is disabled, force enable interrupts */ 9241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->base == 0) outb(CMD_ENA_INTR, sh[j]->io_port + REG_SYS_MASK); 9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(HD(j), 0, sizeof(struct hostdata)); 9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->heads = mapping_table[config_2.mapping_mode].heads; 9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->sectors = mapping_table[config_2.mapping_mode].sectors; 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->subversion = subversion; 9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->pdev = NULL; 9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->board_number = j; 9321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (have_old_firmware) sh[j]->sg_tablesize = MAX_SAFE_SGLIST; 9341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->subversion == ESA) { 9361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->unchecked_isa_dma = FALSE; 9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->dma_channel = NO_DMA; 9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sprintf(BN(j), "U34F%d", j); 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_type = "VESA"; 9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long flags; 9431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->unchecked_isa_dma = TRUE; 9441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flags=claim_dma_lock(); 9461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds disable_dma(dma_channel); 9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds clear_dma_ff(dma_channel); 9481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_dma_mode(dma_channel, DMA_MODE_CASCADE); 9491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enable_dma(dma_channel); 9501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_dma_lock(flags); 9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->dma_channel = dma_channel; 9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sprintf(BN(j), "U14F%d", j); 9541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_type = "ISA"; 9551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->max_channel = MAX_CHANNEL - 1; 9581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->max_id = MAX_TARGET; 9591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->max_lun = MAX_LUN; 9601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->subversion == ISA && !board_inquiry(j)) { 9621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->board_id[40] = 0; 9631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (strcmp(&HD(j)->board_id[32], "06000600")) { 9651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: %s.\n", BN(j), &HD(j)->board_id[8]); 9661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: firmware %s is outdated, FW PROM should be 28004-006.\n", 9671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), &HD(j)->board_id[32]); 9681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->hostt->use_clustering = DISABLE_CLUSTERING; 9691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->sg_tablesize = MAX_SAFE_SGLIST; 9701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dma_channel == NO_DMA) sprintf(dma_name, "%s", "BMST"); 9741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else sprintf(dma_name, "DMA %u", dma_channel); 9751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 9771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 9791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp[i].cp_dma_addr = pci_map_single(HD(j)->pdev, 9801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &HD(j)->cp[i], sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL); 9811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (! ((&HD(j)->cp[i])->sglist = kmalloc( 9841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->sg_tablesize * sizeof(struct sg_list), 9851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (sh[j]->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC))) { 9861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: kmalloc SGlist failed, mbox %d, detaching.\n", BN(j), i); 9871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto release; 9881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN) 9911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max_queue_depth = MAX_TAGGED_CMD_PER_LUN; 9921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max_queue_depth < MAX_CMD_PER_LUN) max_queue_depth = MAX_CMD_PER_LUN; 9941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE) 9961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_mode = TAG_ORDERED; 9971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (j == 0) { 9991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("UltraStor 14F/34F: Copyright (C) 1994-2003 Dario Ballabio.\n"); 10001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s config options -> of:%c, tm:%d, lc:%c, mq:%d, et:%c.\n", 10011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds driver_name, YESNO(have_old_firmware), tag_mode, 10021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(linked_comm), max_queue_depth, YESNO(ext_tran)); 10031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: %s 0x%03lx, BIOS 0x%05x, IRQ %u, %s, SG %d, MB %d.\n", 10061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), bus_type, (unsigned long)sh[j]->io_port, (int)sh[j]->base, 10071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->irq, dma_name, sh[j]->sg_tablesize, sh[j]->can_queue); 10081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->max_id > 8 || sh[j]->max_lun > 8) 10101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n", 10111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), sh[j]->max_id, sh[j]->max_lun); 10121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i <= sh[j]->max_channel; i++) 10141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: SCSI channel %u enabled, host target ID %d.\n", 10151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, sh[j]->this_id); 10161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return TRUE; 10181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfreedma: 10201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (subversion == ISA) free_dma(dma_channel); 10211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfreeirq: 10221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_irq(irq, &sha[j]); 10231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfreelock: 10241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 10251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_region(port_base, REGION_SIZE); 10261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfail: 10271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 10281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsrelease: 10301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u14_34f_release(sh[j]); 10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 10321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void internal_setup(char *str, int *ints) { 10351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i, argc = ints[0]; 10361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *cur = str, *pc; 10371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (argc > 0) { 10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (argc > MAX_INT_PARAM) argc = MAX_INT_PARAM; 10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < argc; i++) io_port[i] = ints[i + 1]; 10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_port[i] = 0; 10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds setup_done = TRUE; 10461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (cur && (pc = strchr(cur, ':'))) { 10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int val = 0, c = *++pc; 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (c == 'n' || c == 'N') val = FALSE; 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (c == 'y' || c == 'Y') val = TRUE; 10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else val = (int) simple_strtoul(pc, NULL, 0); 10541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!strncmp(cur, "lc:", 3)) linked_comm = val; 10561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "of:", 3)) have_old_firmware = val; 10571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "tm:", 3)) tag_mode = val; 10581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "tc:", 3)) tag_mode = val; 10591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "mq:", 3)) max_queue_depth = val; 10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "ls:", 3)) link_statistics = val; 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "et:", 3)) ext_tran = val; 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((cur = strchr(cur, ','))) ++cur; 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int option_setup(char *str) { 10701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int ints[MAX_INT_PARAM]; 10711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *cur = str; 10721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i = 1; 10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) { 10751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ints[i++] = simple_strtoul(cur, NULL, 0); 10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((cur = strchr(cur, ',')) != NULL) cur++; 10781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ints[0] = i - 1; 10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds internal_setup(cur, ints); 10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_detect(struct scsi_host_template *tpnt) { 10861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j = 0, k; 10871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->proc_name = "u14-34f"; 10891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(strlen(boot_options)) option_setup(boot_options); 10911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(MODULE) 10931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* io_port could have been modified when loading as a module */ 10941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(io_port[0] != SKIP) { 10951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds setup_done = TRUE; 10961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_port[MAX_INT_PARAM] = 0; 10971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 10991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < MAX_BOARDS + 1; k++) sh[k] = NULL; 11011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; io_port[k]; k++) { 11031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_port[k] == SKIP) continue; 11051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt)) j++; 11071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds num_boards = j; 11101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return j; 11111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void map_dma(unsigned int i, unsigned int j) { 11141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int data_len = 0; 11151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, count, pci_dir; 11161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scatterlist *sgpnt; 11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sense_buffer) 11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sense_addr = H2DEV(pci_map_single(HD(j)->pdev, SCpnt->sense_buffer, 11251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE)); 11261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sense_len = sizeof SCpnt->sense_buffer; 11281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!SCpnt->use_sg) { 11301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */ 11321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!SCpnt->request_bufflen) pci_dir = PCI_DMA_BIDIRECTIONAL; 11331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request_buffer) 11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev, 11361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->request_buffer, SCpnt->request_bufflen, pci_dir)); 11371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_len = H2DEV(SCpnt->request_bufflen); 11391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 11401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sgpnt = (struct scatterlist *) SCpnt->request_buffer; 11431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count = pci_map_sg(HD(j)->pdev, sgpnt, SCpnt->use_sg, pci_dir); 11441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < count; k++) { 11461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k])); 11471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k])); 11481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds data_len += sgpnt[k].length; 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sg = TRUE; 11521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->use_sg = SCpnt->use_sg; 11531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist, 11541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->use_sg * sizeof(struct sg_list), pci_dir)); 11551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_len = H2DEV(data_len); 11561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void unmap_dma(unsigned int i, unsigned int j) { 11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int pci_dir; 11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->sense_addr)) 11671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr), 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE); 11691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->use_sg) 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_sg(HD(j)->pdev, SCpnt->request_buffer, SCpnt->use_sg, pci_dir); 11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL; 11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->data_address)) 11761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address), 11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->data_len), pci_dir); 11781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void sync_dma(unsigned int i, unsigned int j) { 11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int pci_dir; 11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->sense_addr)) 11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr), 11901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE); 11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->use_sg) 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_sg_for_cpu(HD(j)->pdev, SCpnt->request_buffer, 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->use_sg, pci_dir); 11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL; 11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->data_address)) 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address), 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->data_len), pci_dir); 12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void scsi_to_dev_dir(unsigned int i, unsigned int j) { 12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k; 12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static const unsigned char data_out_cmds[] = { 12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e, 12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40, 12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d 12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static const unsigned char data_none_cmds[] = { 12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e, 12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47, 12151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00 12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 12191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 12201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_OUT; 12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (SCpnt->sc_data_direction == DMA_NONE) { 12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_NONE; 12331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL) 12371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", BN(j)); 12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++) 12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->cmnd[0] == data_out_cmds[k]) { 12431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_OUT; 12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpp->xdir == DTD_IN) 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++) 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->cmnd[0] == data_none_cmds[k]) { 12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_NONE; 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) { 12571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, k; 12581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* j is the board number */ 12611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number; 12621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble) 12641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", 12651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), SCpnt->pid, SCpnt); 12661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* i is the mailbox number, look for the first free mailbox 12681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds starting from last_cp_used */ 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = HD(j)->last_cp_used + 1; 12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->can_queue; k++, i++) { 12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) i = 0; 12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) { 12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->last_cp_used = i; 12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (k == sh[j]->can_queue) { 12821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: qcomm, no free mailbox.\n", BN(j)); 12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 12841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Set pointer to control packet structure */ 12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; 12881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE); 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done = done; 12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cpp_index = i; 12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index; 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n", 12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->device->channel, SCpnt->device->id, 12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->device->lun, SCpnt->pid); 12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->opcode = OP_SCSI; 12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->channel = SCpnt->device->channel; 13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->target = SCpnt->device->id; 13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->lun = SCpnt->device->lun; 13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->SCpnt = SCpnt; 13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cdb_len = SCpnt->cmd_len; 13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len); 13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Use data transfer direction SCpnt->sc_data_direction */ 13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_to_dev_dir(i, j); 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map DMA buffers and SG list */ 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds map_dma(i, j); 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (linked_comm && SCpnt->device->queue_depth > 2 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && TLDEV(SCpnt->device->type)) { 13141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = READY; 13151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE); 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 13201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: qcomm, target %d.%d:%d, pid %ld, adapter busy.\n", 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, SCpnt->pid); 13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Store pointer in OGM address bytes */ 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Issue OGM interrupt */ 13311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = IN_USE; 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 13351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_abort(struct scsi_cmnd *SCarg) { 13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j; 13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 13411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg->host_scribble == NULL) { 13431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, target %d.%d:%d, pid %ld inactive.\n", 13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid); 13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = *(unsigned int *)SCarg->host_scribble; 13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d, target %d.%d:%d, pid %ld.\n", 13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid); 13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) 13531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j)); 13541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 13561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, timeout error.\n", BN(j)); 13571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) { 13611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is free.\n", BN(j), i); 13621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_USE) { 13661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is in use.\n", BN(j), i); 13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg != HD(j)->cp[i].SCpnt) 13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n", 13701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCarg, HD(j)->cp[i].SCpnt); 13711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (inb(sh[j]->io_port + REG_SYS_INTR) & IRQ_ASSERTED) 13731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d, interrupt pending.\n", BN(j), i); 13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg->eh_state == SCSI_STATE_TIMEOUT) { 13761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->host_scribble = NULL; 13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 13791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, abort, mbox %d, eh_state timeout, pid %ld.\n", 13801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCarg->pid); 13811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_RESET) { 13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is in reset.\n", BN(j), i); 13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == LOCKED) { 13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is locked.\n", BN(j), i); 13941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { 13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->result = DID_ABORT << 16; 14001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->host_scribble = NULL; 14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 14021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", 14031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCarg->pid); 14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->scsi_done(SCarg); 14051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 14061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, mbox %d, invalid cp_stat.\n", BN(j), i); 14091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) { 14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, time, k, c, limit = 0; 14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int arg_done = FALSE; 14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 14151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 14171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, enter, target %d.%d:%d, pid %ld.\n", 14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), SCarg->device->channel, SCarg->device->id, SCarg->device->lun, SCarg->pid); 14191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1420df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_lock_irq(sh[j]->host_lock); 1421df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik 14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg->host_scribble == NULL) 14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->pid); 14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->in_reset) { 14261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, exit, already in reset.\n", BN(j)); 1427df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, exit, timeout error.\n", BN(j)); 1433df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->retries = 0; 14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (c = 0; c <= sh[j]->max_channel; c++) 14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->max_id; k++) { 14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_redo[k][c] = TRUE; 14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_to[k][c] = 0; 14431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) { 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) continue; 14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == LOCKED) { 14501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 14511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, locked mbox %d forced free.\n", BN(j), i); 14521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 14531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(SCpnt = HD(j)->cp[i].SCpnt)) 14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, SCpnt == NULL.\n", BN(j), i); 14571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { 14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = ABORTING; 14601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, mbox %d aborting, pid %ld.\n", 14611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 14621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 14651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = IN_RESET; 14661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, mbox %d in reset, pid %ld.\n", 14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 14681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble == NULL) 14711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, garbled SCpnt.\n", BN(j), i); 14721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*(unsigned int *)SCpnt->host_scribble != i) 14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, index mismatch.\n", BN(j), i); 14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->scsi_done == NULL) 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", BN(j), i); 14781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt == SCarg) arg_done = TRUE; 14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 14831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, cannot reset, timeout error.\n", BN(j)); 1484df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_RESET, sh[j]->io_port + REG_LCL_INTR); 14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, board reset done, enabling interrupts.\n", BN(j)); 14901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_RESET) 14921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace = TRUE; 14931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->in_reset = TRUE; 14961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(sh[j]->host_lock); 14981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds time = jiffies; 14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L); 15001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(sh[j]->host_lock); 15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, interrupts disabled, loops %d.\n", BN(j), limit); 15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) { 15051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_RESET) { 15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = HD(j)->cp[i].SCpnt; 15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 15091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = DID_RESET << 16; 15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 15111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* This mailbox is still waiting for its interrupt */ 15131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = LOCKED; 15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", 15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == ABORTING) { 15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = HD(j)->cp[i].SCpnt; 15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = DID_RESET << 16; 15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* This mailbox was never queued to the adapter */ 15261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", 15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Any other mailbox has already been set free by interrupt */ 15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done(SCpnt); 15381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->in_reset = FALSE; 15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace = FALSE; 15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->pid); 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else printk("%s: reset, exit.\n", BN(j)); 15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1546df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 15471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_bios_param(struct scsi_device *disk, 15511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct block_device *bdev, sector_t capacity, int *dkinfo) { 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j = 0; 15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int size = capacity; 15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0] = HD(j)->heads; 15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[1] = HD(j)->sectors; 15571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors); 15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ext_tran && (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) { 15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0] = 255; 15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[1] = 63; 15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[2] = size / (dkinfo[0] * dkinfo[1]); 15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined (DEBUG_GEOMETRY) 15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk ("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name, 15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0], dkinfo[1], dkinfo[2]); 15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void sort(unsigned long sk[], unsigned int da[], unsigned int n, 15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int rev) { 15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, k, y; 15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long x; 15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < n - 1; i++) { 15791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = i; 15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (j = k + 1; j < n; j++) 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rev) { 15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sk[j] > sk[k]) k = j; 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sk[j] < sk[k]) k = j; 15871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (k != i) { 15901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds x = sk[k]; sk[k] = sk[i]; sk[i] = x; 15911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds y = da[k]; da[k] = da[i]; da[i] = y; 15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int reorder(unsigned int j, unsigned long cursec, 15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int ihdlr, unsigned int il[], unsigned int n_ready) { 16001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 16011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 16021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, n; 16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int rev = FALSE, s = TRUE, r = TRUE; 16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int input_only = TRUE, overlap = FALSE; 16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long sl[n_ready], pl[n_ready], ll[n_ready]; 16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0; 16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long ioseek = 0; 16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int flushcount = 0, batchcount = 0, sortcount = 0; 16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int readycount = 0, ovlcount = 0, inputcount = 0; 16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int readysorted = 0, revcount = 0; 16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned long seeksorted = 0, seeknosort = 0; 16131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics && !(++flushcount % link_statistics)) 16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"\ 16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " av %ldK as %ldK.\n", flushcount, batchcount, inputcount, 16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ovlcount, readycount, readysorted, sortcount, revcount, 16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seeknosort / (readycount + 1), 16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seeksorted / (readycount + 1)); 16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (n_ready <= 1) return FALSE; 16221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 16241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(cpp->xdir == DTD_IN)) input_only = FALSE; 16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector; 16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector; 16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sl[n] = SCpnt->request->sector; 16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ioseek += SCpnt->request->nr_sectors; 16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!n) continue; 16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] < sl[n - 1]) s = FALSE; 16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] > sl[n - 1]) r = FALSE; 16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] > sl[n - 1]) 16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seek += sl[n] - sl[n - 1]; 16421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seek += sl[n - 1] - sl[n]; 16441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec; 16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > ((maxsec + minsec) / 2)) rev = TRUE; 16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE; 16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev); 16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!input_only) for (n = 0; n < n_ready; n++) { 16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->pid; 16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!n) continue; 16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n])) 16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE; 16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (overlap) sort(pl, il, n_ready, FALSE); 16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec; 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds batchcount++; readycount += n_ready; seeknosort += seek / 1024; 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (input_only) inputcount++; 16741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (overlap) { ovlcount++; seeksorted += iseek / 1024; } 16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else seeksorted += (iseek + maxsec - minsec) / 1024; 16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rev && !r) { revcount++; readysorted += n_ready; } 16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!rev && !s) { sortcount++; readysorted += n_ready; } 16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_LINKED_COMMANDS) 16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics && (overlap || !(flushcount % link_statistics))) 16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\ 16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", 16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target, 16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->lun, SCpnt->pid, k, flushcount, n_ready, 16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->request->sector, SCpnt->request->nr_sectors, cursec, 16891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only), 16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(overlap), cpp->xdir); 16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return overlap; 16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned int j, 16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int ihdlr) { 16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES]; 17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->can_queue; k++) { 17031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue; 17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->device != dev) continue; 17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[k] == IN_USE) return; 17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds il[n_ready++] = k; 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1; 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 17181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 17191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: %s, target %d.%d:%d, pid %ld, mbox %d, adapter"\ 17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " busy, will abort.\n", BN(j), (ihdlr ? "ihdlr" : "qcomm"), 17231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, SCpnt->pid, k); 17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[k] = ABORTING; 17251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[k] = IN_USE; 17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic irqreturn_t ihdlr(int irq, unsigned int j) { 17361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, k, c, status, tstatus, reg, ret; 17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *spp, *cpp; 17391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->irq != irq) 17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, irq %d, sh[j]->irq %d.\n", BN(j), irq, sh[j]->irq); 17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if this board need to be serviced */ 17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none; 17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount++; 17471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.\n", BN(j), irq, 17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if this board is still busy */ 17521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) { 17531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 17541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n", 17551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), irq, reg, HD(j)->iocount); 17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto none; 17571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret = inl(sh[j]->io_port + REG_ICM); 17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear interrupt pending flag */ 17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Find the mailbox to be serviced on this board */ 17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 17661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (H2DEV(HD(j)->cp[i].cp_dma_addr) == ret) break; 17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) 17691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, invalid mscp bus address %p, cp0 %p.\n", BN(j), 17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (void *)ret, (void *)H2DEV(HD(j)->cp[0].cp_dma_addr)); 17711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &(HD(j)->cp[i]); 17731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp = cpp; 17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_GENERATE_ABORTS) 17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) goto handled; 17771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IGNORE) { 17801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == LOCKED) { 17841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d unlocked, count %d.\n", BN(j), i, 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == FREE) { 17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d is free, count %d.\n", BN(j), i, 17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == IN_RESET) 17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d is in reset.\n", BN(j), i); 17961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] != IN_USE) 17971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n", 17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, HD(j)->cp_stat[i]); 17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = cpp->SCpnt; 18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i); 18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble == NULL) 18061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i, 18071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->pid, SCpnt); 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*(unsigned int *)SCpnt->host_scribble != i) 18101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", 18111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid, *(unsigned int *)SCpnt->host_scribble); 18121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sync_dma(i, j); 18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (linked_comm && SCpnt->device->queue_depth > 2 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && TLDEV(SCpnt->device->type)) 18171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE); 18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tstatus = status_byte(spp->target_status); 18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_GENERATE_ERRORS) 18221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2)) 18231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp->adapter_status = 0x01; 18241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (spp->adapter_status) { 18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case ASOK: /* status OK */ 18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Forces a reset if a disk drive keeps returning BUSY */ 18301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If there was a bus reset, redo operation on each target */ 18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK 18351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && HD(j)->target_redo[SCpnt->device->id][SCpnt->device->channel]) 18361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Works around a flaw in scsi.c */ 18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tstatus == CHECK_CONDITION 18401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && SCpnt->device->type == TYPE_DISK 18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR) 18421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_OK << 16; 18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tstatus == GOOD) 18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_redo[SCpnt->device->id][SCpnt->device->channel] = FALSE; 18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (spp->target_status && SCpnt->device->type == TYPE_DISK && 18511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 && 18521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) 18531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, target %d.%d:%d, pid %ld, "\ 18541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "target_status 0x%x, sense key 0x%x.\n", BN(j), 18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, 18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->pid, spp->target_status, 18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->sense_buffer[2]); 18581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_to[SCpnt->device->id][SCpnt->device->channel] = 0; 18601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->last_retried_pid == SCpnt->pid) HD(j)->retries = 0; 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case ASST: /* Selection Time Out */ 18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->target_to[SCpnt->device->id][SCpnt->device->channel] > 1) 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_TIME_OUT << 16; 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_to[SCpnt->device->id][SCpnt->device->channel]++; 18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Perform a limited number of internal retries */ 18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x93: /* Unexpected bus free */ 18771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x94: /* Target bus phase sequence failure */ 18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x96: /* Illegal SCSI command */ 18791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0xa3: /* SCSI bus reset error */ 18801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (c = 0; c <= sh[j]->max_channel; c++) 18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->max_id; k++) 18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_redo[k][c] = TRUE; 18841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x92: /* Data over/under-run */ 18871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->device->type != TYPE_TAPE 18891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && HD(j)->retries < MAX_INTERNAL_RETRIES) { 18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DID_SOFT_ERROR) 18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_SOFT_ERROR << 16; 18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->retries++; 18981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->last_retried_pid = SCpnt->pid; 18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x01: /* Invalid command */ 19051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x02: /* Invalid parameters */ 19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x03: /* Invalid data list */ 19071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x84: /* SCSI bus abort error */ 19081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x9b: /* Auto request sense error */ 19091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x9f: /* Unexpected command complete message error */ 19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0xff: /* Invalid parameter in the S/G list */ 19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 19141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = status | spp->target_status; 19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_INTERRUPT) 19191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->result || do_trace) 19201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((spp->adapter_status != ASOK && HD(j)->iocount > 1000) || 19221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (spp->adapter_status != ASOK && 19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp->adapter_status != ASST && HD(j)->iocount <= 1000) || 19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace || msg_byte(spp->target_status)) 19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %2d, err 0x%x:%x,"\ 19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " target %d.%d:%d, pid %ld, reg 0x%x, count %d.\n", 19281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, spp->adapter_status, spp->target_status, 19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, SCpnt->pid, 19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg, HD(j)->iocount); 19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 19331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Set the command state to inactive */ 19351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 19361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done(SCpnt); 19381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.\n", BN(j), irq, 19401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 19411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldshandled: 19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_HANDLED; 19441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsnone: 19451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_NONE; 19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic irqreturn_t do_interrupt_handler(int irq, void *shap, 19491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pt_regs *regs) { 19501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j; 19511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long spin_flags; 19521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqreturn_t ret; 19531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if the interrupt must be processed by this handler */ 19551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE; 19561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(sh[j]->host_lock, spin_flags); 19581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret = ihdlr(irq, j); 19591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(sh[j]->host_lock, spin_flags); 19601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ret; 19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_release(struct Scsi_Host *shpnt) { 19641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j; 19651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++); 19671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j] == NULL) panic("%s: release, invalid Scsi_Host pointer.\n", 19691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds driver_name); 19701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 19721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((&HD(j)->cp[i])->sglist) kfree((&HD(j)->cp[i])->sglist); 19731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 19751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr, 19761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL); 19771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_irq(sh[j]->irq, &sha[j]); 19791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->dma_channel != NO_DMA) free_dma(sh[j]->dma_channel); 19811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_region(sh[j]->io_port, sh[j]->n_io_port); 19831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_unregister(sh[j]); 19841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 19851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "scsi_module.c" 19881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifndef MODULE 19901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds__setup("u14-34f=", option_setup); 19911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif /* end MODULE */ 1992