u14-34f.c revision e19166d5df10be0ea404c4e346cf6be93bfb1d63
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 * 285d0be4a7d29ad0bd3ce2209dd9e46d410b632db59Christoph Hellwig * Since the struct 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/string.h> 4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/kernel.h> 4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/ioport.h> 4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/delay.h> 4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/io.h> 4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/system.h> 4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/byteorder.h> 4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/proc_fs.h> 4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/blkdev.h> 4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/interrupt.h> 4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/stat.h> 4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/pci.h> 4201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/init.h> 4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/ctype.h> 4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/spinlock.h> 4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/dma.h> 4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/irq.h> 4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi.h> 4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_cmnd.h> 4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_device.h> 4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_host.h> 4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_tcq.h> 4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsicam.h> 4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_detect(struct scsi_host_template *); 4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_release(struct Scsi_Host *); 4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *)); 4361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_abort(struct scsi_cmnd *); 4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_host_reset(struct scsi_cmnd *); 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_bios_param(struct scsi_device *, struct block_device *, 4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sector_t, int *); 4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_slave_configure(struct scsi_device *); 4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct scsi_host_template driver_template = { 4431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .name = "UltraStor 14F/34F rev. 8.10.00 ", 4441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .detect = u14_34f_detect, 4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .release = u14_34f_release, 4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .queuecommand = u14_34f_queuecommand, 4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .eh_abort_handler = u14_34f_eh_abort, 4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .eh_host_reset_handler = u14_34f_eh_host_reset, 4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .bios_param = u14_34f_bios_param, 4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .slave_configure = u14_34f_slave_configure, 4511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .this_id = 7, 4521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .unchecked_isa_dma = 1, 4537530c20f2ab2f55b99c666b03728df7d8b59a80cAndrew Morton .use_clustering = ENABLE_CLUSTERING, 4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if !defined(__BIG_ENDIAN_BITFIELD) && !defined(__LITTLE_ENDIAN_BITFIELD) 4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#error "Adjust your <asm/byteorder.h> defines" 4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Values for the PRODUCT_ID ports for the 14/34F */ 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define PRODUCT_ID1 0x56 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define PRODUCT_ID2 0x40 /* NOTE: Only upper nibble is used */ 4631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Subversion values */ 4651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ISA 0 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ESA 1 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define OP_HOST_ADAPTER 0x1 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define OP_SCSI 0x2 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define OP_RESET 0x4 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_SCSI 0x0 4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_IN 0x1 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_OUT 0x2 4741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DTD_NONE 0x3 4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_INQUIRY 0x1 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_SELF_DIAG 0x2 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_READ_BUFF 0x3 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HA_CMD_WRITE_BUFF 0x4 4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_LINKED_COMMANDS 4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_DETECT 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_INTERRUPT 4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_RESET 4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_GENERATE_ERRORS 4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_GENERATE_ABORTS 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#undef DEBUG_GEOMETRY 4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_ISA 3 4891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_VESA 1 4901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_EISA 0 4911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_PCI 0 4921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_BOARDS (MAX_ISA + MAX_VESA + MAX_EISA + MAX_PCI) 4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_CHANNEL 1 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_LUN 8 4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_TARGET 8 4961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_MAILBOXES 16 4971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_SGLIST 32 4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_SAFE_SGLIST 16 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_INTERNAL_RETRIES 64 5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_CMD_PER_LUN 2 5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_TAGGED_CMD_PER_LUN (MAX_MAILBOXES - MAX_CMD_PER_LUN) 5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define SKIP ULONG_MAX 5041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FALSE 0 5051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TRUE 1 5061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define FREE 0 5071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IN_USE 1 5081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define LOCKED 2 5091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IN_RESET 3 5101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IGNORE 4 5111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define READY 5 5121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ABORTING 6 5131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define NO_DMA 0xff 5141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAXLOOP 10000 5151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TAG_DISABLED 0 5161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TAG_SIMPLE 1 5171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TAG_ORDERED 2 5181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_LCL_MASK 0 5201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_LCL_INTR 1 5211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_SYS_MASK 2 5221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_SYS_INTR 3 5231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_PRODUCT_ID1 4 5241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_PRODUCT_ID2 5 5251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_CONFIG1 6 5261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_CONFIG2 7 5271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_OGM 8 5281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REG_ICM 12 5291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define REGION_SIZE 13UL 5301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define BSY_ASSERTED 0x01 5311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define IRQ_ASSERTED 0x01 5321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_RESET 0xc0 5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_OGM_INTR 0x01 5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_CLR_INTR 0x01 5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CMD_ENA_INTR 0x81 5361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ASOK 0x00 5371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define ASST 0x91 5381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define YESNO(a) ((a) ? 'y' : 'n') 5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define TLDEV(type) ((type) == TYPE_DISK || (type) == TYPE_ROM) 5411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define PACKED __attribute__((packed)) 5431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct sg_list { 5451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int address; /* Segment Address */ 5461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int num_bytes; /* Segment Length */ 5471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 5481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* MailBox SCSI Command Packet */ 5501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct mscp { 5511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(__BIG_ENDIAN_BITFIELD) 5531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sg:1, ca:1, dcn:1, xdir:2, opcode:3; 5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char lun: 3, channel:2, target:3; 5551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char opcode: 3, /* type of command */ 5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds xdir: 2, /* data transfer direction */ 5581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dcn: 1, /* disable disconnect */ 5591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ca: 1, /* use cache (if available) */ 5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sg: 1; /* scatter/gather operation */ 5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char target: 3, /* SCSI target id */ 5621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds channel: 2, /* SCSI channel number */ 5631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lun: 3; /* SCSI logical unit number */ 5641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 5651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int data_address PACKED; /* transfer data pointer */ 5671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int data_len PACKED; /* length in bytes */ 5681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int link_address PACKED; /* for linking command chains */ 5691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char clink_id; /* identifies command in chain */ 5701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char use_sg; /* (if sg is set) 8 bytes per list */ 5711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sense_len; 5721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char cdb_len; /* 6, 10, or 12 */ 5731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char cdb[12]; /* SCSI Command Descriptor Block */ 5741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char adapter_status; /* non-zero indicates HA error */ 5751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char target_status; /* non-zero indicates target error */ 5761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int sense_addr PACKED; 5771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Additional fields begin here. */ 5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int cpp_index; /* cp index */ 5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* All the cp structure is zero filled by queuecommand except the 5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds following CP_TAIL_SIZE bytes, initialized by detect */ 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t cp_dma_addr; /* dma handle for this cp structure */ 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct sg_list *sglist; /* pointer to the allocated SG list */ 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define CP_TAIL_SIZE (sizeof(struct sglist *) + sizeof(dma_addr_t)) 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct hostdata { 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp cp[MAX_MAILBOXES]; /* Mailboxes for this board */ 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int cp_stat[MAX_MAILBOXES]; /* FREE, IN_USE, LOCKED, IN_RESET */ 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int last_cp_used; /* Index of last mailbox used */ 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int iocount; /* Total i/o done for this board */ 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int board_number; /* Number of this board */ 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char board_name[16]; /* Name of this board */ 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int in_reset; /* True if board is doing a reset */ 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int target_to[MAX_TARGET][MAX_CHANNEL]; /* N. of timeout errors on target */ 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int target_redo[MAX_TARGET][MAX_CHANNEL]; /* If TRUE redo i/o on target */ 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int retries; /* Number of internal retries */ 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long last_retried_pid; /* Pid of last retried command */ 6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char subversion; /* Bus type, either ISA or ESA */ 6031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct pci_dev *pdev; /* Always NULL */ 6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char heads; 6051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sectors; 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char board_id[256]; /* data from INQUIRY on this board */ 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct Scsi_Host *sh[MAX_BOARDS + 1]; 6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic const char *driver_name = "Ux4F"; 6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char sha[MAX_BOARDS]; 6121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic DEFINE_SPINLOCK(driver_lock); 6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Initialize num_boards so that ihdlr can work while detect is in progress */ 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic unsigned int num_boards = MAX_BOARDS; 6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic unsigned long io_port[] = { 6181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Space for MAX_INT_PARAM ports usable while loading as a module */ 6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, 6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SKIP, SKIP, 6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Possible ISA/VESA ports */ 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x330, 0x340, 0x230, 0x240, 0x210, 0x130, 0x140, 6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* End of list */ 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x0 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define HD(board) ((struct hostdata *) &sh[board]->hostdata) 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define BN(board) (HD(board)->board_name) 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Device is Little Endian */ 6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define H2DEV(x) cpu_to_le32(x) 6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define DEV2H(x) le32_to_cpu(x) 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6377d12e780e003f93433d49ce78cfedf4b4c52adc5David Howellsstatic irqreturn_t do_interrupt_handler(int, void *); 6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void flush_dev(struct scsi_device *, unsigned long, unsigned int, unsigned int); 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int do_trace = FALSE; 6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int setup_done = FALSE; 6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int link_statistics; 6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int ext_tran = FALSE; 6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(HAVE_OLD_UX4F_FIRMWARE) 6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int have_old_firmware = TRUE; 6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int have_old_firmware = FALSE; 6481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_SCSI_U14_34F_TAGGED_QUEUE) 6511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int tag_mode = TAG_SIMPLE; 6521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int tag_mode = TAG_DISABLED; 6541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_SCSI_U14_34F_LINKED_COMMANDS) 6571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int linked_comm = TRUE; 6581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int linked_comm = FALSE; 6601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_SCSI_U14_34F_MAX_TAGS) 6631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int max_queue_depth = CONFIG_SCSI_U14_34F_MAX_TAGS; 6641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 6651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int max_queue_depth = MAX_CMD_PER_LUN; 6661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_INT_PARAM 10 6691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MAX_BOOT_OPTIONS_SIZE 256 6701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char boot_options[MAX_BOOT_OPTIONS_SIZE]; 6711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(MODULE) 6731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/module.h> 6741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/moduleparam.h> 6751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_param_string(u14_34f, boot_options, MAX_BOOT_OPTIONS_SIZE, 0); 6771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_PARM_DESC(u14_34f, " equivalent to the \"u14-34f=...\" kernel boot " \ 6781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds"option." \ 6791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds" Example: modprobe u14-34f \"u14_34f=0x340,0x330,lc:y,tm:0,mq:4\""); 6801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_AUTHOR("Dario Ballabio"); 6811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_LICENSE("GPL"); 6821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_DESCRIPTION("UltraStor 14F/34F SCSI Driver"); 6831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 6851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_slave_configure(struct scsi_device *dev) { 6871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int j, tqd, utqd; 6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *tag_suffix, *link_suffix; 6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct Scsi_Host *host = dev->host; 6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) host->hostdata)->board_number; 6921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds utqd = MAX_CMD_PER_LUN; 6941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tqd = max_queue_depth; 6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (TLDEV(dev->type) && dev->tagged_supported) 6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tag_mode == TAG_SIMPLE) { 6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd); 7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", simple tags"; 7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tag_mode == TAG_ORDERED) { 7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd); 7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", ordered tags"; 7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, 0, tqd); 7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", no tags"; 7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (TLDEV(dev->type) && linked_comm) { 7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, 0, tqd); 7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ", untagged"; 7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(dev, 0, utqd); 7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_suffix = ""; 7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (TLDEV(dev->type) && linked_comm && dev->queue_depth > 2) 7221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds link_suffix = ", sorted"; 7231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (TLDEV(dev->type)) 7241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds link_suffix = ", unsorted"; 7251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 7261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds link_suffix = ""; 7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 728017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik sdev_printk(KERN_INFO, dev, "cmds/lun %d%s%s.\n", 7291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->queue_depth, link_suffix, tag_suffix); 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int wait_on_busy(unsigned long iobase, unsigned int loop) { 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (inb(iobase + REG_LCL_INTR) & BSY_ASSERTED) { 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(1L); 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (--loop == 0) return TRUE; 7391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 7421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int board_inquiry(unsigned int j) { 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t id_dma_addr; 7471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int time, limit = 0; 7481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds id_dma_addr = pci_map_single(HD(j)->pdev, HD(j)->board_id, 7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sizeof(HD(j)->board_id), PCI_DMA_BIDIRECTIONAL); 7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[0]; 7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cp_dma_addr = pci_map_single(HD(j)->pdev, cpp, sizeof(struct mscp), 7531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_DMA_BIDIRECTIONAL); 7541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE); 7551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->opcode = OP_HOST_ADAPTER; 7561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 7571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_address = H2DEV(id_dma_addr); 7581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_len = H2DEV(sizeof(HD(j)->board_id)); 7591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cdb_len = 6; 7601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cdb[0] = HA_CMD_INQUIRY; 7611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 7631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: board_inquiry, adapter busy.\n", BN(j)); 7641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return TRUE; 7651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[0] = IGNORE; 7681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear the interrupt indication */ 7701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Store pointer in OGM address bytes */ 7731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 7741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Issue OGM interrupt */ 7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 7791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds time = jiffies; 7801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((jiffies - time) < HZ && limit++ < 20000) udelay(100L); 7811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(&driver_lock); 7821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpp->adapter_status || HD(j)->cp_stat[0] != FREE) { 7841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[0] = FREE; 7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: board_inquiry, err 0x%x.\n", BN(j), cpp->adapter_status); 7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return TRUE; 7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, cpp->cp_dma_addr, sizeof(struct mscp), 7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_DMA_BIDIRECTIONAL); 7911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, id_dma_addr, sizeof(HD(j)->board_id), 7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds PCI_DMA_BIDIRECTIONAL); 7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int port_detect \ 7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (unsigned long port_base, unsigned int j, struct scsi_host_template *tpnt) { 7981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char irq, dma_channel, subversion, i; 7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char in_byte; 8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *bus_type, dma_name[16]; 8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Allowed BIOS base addresses (NULL indicates reserved) */ 8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long bios_segment_table[8] = { 8041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0, 8051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0xc4000, 0xc8000, 0xcc000, 0xd0000, 8061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0xd4000, 0xd8000, 0xdc000 8071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 8081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Allowed IRQs */ 8101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char interrupt_table[4] = { 15, 14, 11, 10 }; 8111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Allowed DMA channels for ISA (0 indicates reserved) */ 8131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char dma_channel_table[4] = { 5, 6, 7, 0 }; 8141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Head/sector mappings */ 8161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct { 8171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char heads; 8181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sectors; 8191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } mapping_table[4] = { 8201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 } 8211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 8221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct config_1 { 8241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(__BIG_ENDIAN_BITFIELD) 8261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char dma_channel: 2, interrupt:2, 8271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds removable_disks_as_fixed:1, bios_segment: 3; 8281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 8291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char bios_segment: 3, removable_disks_as_fixed: 1, 8301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds interrupt: 2, dma_channel: 2; 8311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 8321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } config_1; 8341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct config_2 { 8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(__BIG_ENDIAN_BITFIELD) 8381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char tfr_port: 2, bios_drive_number: 1, 8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mapping_mode: 2, ha_scsi_id: 3; 8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char ha_scsi_id: 3, mapping_mode: 2, 8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bios_drive_number: 1, tfr_port: 2; 8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } config_2; 8461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char name[16]; 8481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sprintf(name, "%s%d", driver_name, j); 8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!request_region(port_base, REGION_SIZE, driver_name)) { 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_DETECT) 8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: address 0x%03lx in use, skipping probe.\n", name, port_base); 8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto fail; 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(&driver_lock); 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (inb(port_base + REG_PRODUCT_ID1) != PRODUCT_ID1) goto freelock; 8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds in_byte = inb(port_base + REG_PRODUCT_ID2); 8631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((in_byte & 0xf0) != PRODUCT_ID2) goto freelock; 8651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *(char *)&config_1 = inb(port_base + REG_CONFIG1); 8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *(char *)&config_2 = inb(port_base + REG_CONFIG2); 8681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irq = interrupt_table[config_1.interrupt]; 8701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_channel = dma_channel_table[config_1.dma_channel]; 8711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds subversion = (in_byte & 0x0f); 8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Board detected, allocate its IRQ */ 8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (request_irq(irq, do_interrupt_handler, 8751d6f359a2e06296418481239f8054a878f36e819Thomas Gleixner IRQF_DISABLED | ((subversion == ESA) ? IRQF_SHARED : 0), 8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds driver_name, (void *) &sha[j])) { 8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: unable to allocate IRQ %u, detaching.\n", name, irq); 8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto freelock; 8791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (subversion == ISA && request_dma(dma_channel, driver_name)) { 8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: unable to allocate DMA channel %u, detaching.\n", 8831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds name, dma_channel); 8841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto freeirq; 8851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (have_old_firmware) tpnt->use_clustering = DISABLE_CLUSTERING; 8881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j] = scsi_register(tpnt, sizeof(struct hostdata)); 8911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(&driver_lock); 8921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j] == NULL) { 8941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: unable to register host, detaching.\n", name); 8951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto freedma; 8961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->io_port = port_base; 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->unique_id = port_base; 9001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->n_io_port = REGION_SIZE; 9011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->base = bios_segment_table[config_1.bios_segment]; 9021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->irq = irq; 9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->sg_tablesize = MAX_SGLIST; 9041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->this_id = config_2.ha_scsi_id; 9051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->can_queue = MAX_MAILBOXES; 9061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->cmd_per_lun = MAX_CMD_PER_LUN; 9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_DETECT) 9091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds { 9101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned char sys_mask, lcl_mask; 9111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sys_mask = inb(sh[j]->io_port + REG_SYS_MASK); 9131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lcl_mask = inb(sh[j]->io_port + REG_LCL_MASK); 9141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("SYS_MASK 0x%x, LCL_MASK 0x%x.\n", sys_mask, lcl_mask); 9151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 9171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Probably a bogus host scsi id, set it to the dummy value */ 9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->this_id == 0) sh[j]->this_id = -1; 9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If BIOS is disabled, force enable interrupts */ 9221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->base == 0) outb(CMD_ENA_INTR, sh[j]->io_port + REG_SYS_MASK); 9231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(HD(j), 0, sizeof(struct hostdata)); 9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->heads = mapping_table[config_2.mapping_mode].heads; 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->sectors = mapping_table[config_2.mapping_mode].sectors; 9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->subversion = subversion; 9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->pdev = NULL; 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->board_number = j; 9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (have_old_firmware) sh[j]->sg_tablesize = MAX_SAFE_SGLIST; 9321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->subversion == ESA) { 9341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->unchecked_isa_dma = FALSE; 9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->dma_channel = NO_DMA; 9361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sprintf(BN(j), "U34F%d", j); 9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_type = "VESA"; 9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long flags; 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->unchecked_isa_dma = TRUE; 9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flags=claim_dma_lock(); 9441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds disable_dma(dma_channel); 9451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds clear_dma_ff(dma_channel); 9461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_dma_mode(dma_channel, DMA_MODE_CASCADE); 9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enable_dma(dma_channel); 9481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_dma_lock(flags); 9491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->dma_channel = dma_channel; 9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sprintf(BN(j), "U14F%d", j); 9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bus_type = "ISA"; 9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->max_channel = MAX_CHANNEL - 1; 9561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->max_id = MAX_TARGET; 9571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->max_lun = MAX_LUN; 9581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->subversion == ISA && !board_inquiry(j)) { 9601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->board_id[40] = 0; 9611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (strcmp(&HD(j)->board_id[32], "06000600")) { 9631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: %s.\n", BN(j), &HD(j)->board_id[8]); 9641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: firmware %s is outdated, FW PROM should be 28004-006.\n", 9651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), &HD(j)->board_id[32]); 9661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->hostt->use_clustering = DISABLE_CLUSTERING; 9671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->sg_tablesize = MAX_SAFE_SGLIST; 9681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dma_channel == NO_DMA) sprintf(dma_name, "%s", "BMST"); 9721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else sprintf(dma_name, "DMA %u", dma_channel); 9731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 9751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 9771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp[i].cp_dma_addr = pci_map_single(HD(j)->pdev, 9781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &HD(j)->cp[i], sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL); 9791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 9811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (! ((&HD(j)->cp[i])->sglist = kmalloc( 9821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->sg_tablesize * sizeof(struct sg_list), 9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (sh[j]->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC))) { 9841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: kmalloc SGlist failed, mbox %d, detaching.\n", BN(j), i); 9851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto release; 9861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max_queue_depth > MAX_TAGGED_CMD_PER_LUN) 9891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds max_queue_depth = MAX_TAGGED_CMD_PER_LUN; 9901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (max_queue_depth < MAX_CMD_PER_LUN) max_queue_depth = MAX_CMD_PER_LUN; 9921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tag_mode != TAG_DISABLED && tag_mode != TAG_SIMPLE) 9941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tag_mode = TAG_ORDERED; 9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (j == 0) { 9971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("UltraStor 14F/34F: Copyright (C) 1994-2003 Dario Ballabio.\n"); 9981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s config options -> of:%c, tm:%d, lc:%c, mq:%d, et:%c.\n", 9991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds driver_name, YESNO(have_old_firmware), tag_mode, 10001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(linked_comm), max_queue_depth, YESNO(ext_tran)); 10011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: %s 0x%03lx, BIOS 0x%05x, IRQ %u, %s, SG %d, MB %d.\n", 10041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), bus_type, (unsigned long)sh[j]->io_port, (int)sh[j]->base, 10051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sh[j]->irq, dma_name, sh[j]->sg_tablesize, sh[j]->can_queue); 10061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->max_id > 8 || sh[j]->max_lun > 8) 10081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: wide SCSI support enabled, max_id %u, max_lun %u.\n", 10091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), sh[j]->max_id, sh[j]->max_lun); 10101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i <= sh[j]->max_channel; i++) 10121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: SCSI channel %u enabled, host target ID %d.\n", 10131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, sh[j]->this_id); 10141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return TRUE; 10161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfreedma: 10181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (subversion == ISA) free_dma(dma_channel); 10191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfreeirq: 10201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_irq(irq, &sha[j]); 10211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfreelock: 10221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(&driver_lock); 10231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_region(port_base, REGION_SIZE); 10241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfail: 10251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 10261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsrelease: 10281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u14_34f_release(sh[j]); 10291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 10301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void internal_setup(char *str, int *ints) { 10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i, argc = ints[0]; 10341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *cur = str, *pc; 10351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (argc > 0) { 10371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (argc > MAX_INT_PARAM) argc = MAX_INT_PARAM; 10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < argc; i++) io_port[i] = ints[i + 1]; 10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_port[i] = 0; 10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds setup_done = TRUE; 10441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (cur && (pc = strchr(cur, ':'))) { 10471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int val = 0, c = *++pc; 10481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (c == 'n' || c == 'N') val = FALSE; 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (c == 'y' || c == 'Y') val = TRUE; 10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else val = (int) simple_strtoul(pc, NULL, 0); 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!strncmp(cur, "lc:", 3)) linked_comm = val; 10541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "of:", 3)) have_old_firmware = val; 10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "tm:", 3)) tag_mode = val; 10561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "tc:", 3)) tag_mode = val; 10571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "mq:", 3)) max_queue_depth = val; 10581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "ls:", 3)) link_statistics = val; 10591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!strncmp(cur, "et:", 3)) ext_tran = val; 10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((cur = strchr(cur, ','))) ++cur; 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int option_setup(char *str) { 10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int ints[MAX_INT_PARAM]; 10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *cur = str; 10701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i = 1; 10711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) { 10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ints[i++] = simple_strtoul(cur, NULL, 0); 10741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((cur = strchr(cur, ',')) != NULL) cur++; 10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ints[0] = i - 1; 10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds internal_setup(cur, ints); 10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_detect(struct scsi_host_template *tpnt) { 10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j = 0, k; 10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->proc_name = "u14-34f"; 10871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(strlen(boot_options)) option_setup(boot_options); 10891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(MODULE) 10911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* io_port could have been modified when loading as a module */ 10921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(io_port[0] != SKIP) { 10931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds setup_done = TRUE; 10941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds io_port[MAX_INT_PARAM] = 0; 10951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 10971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < MAX_BOARDS + 1; k++) sh[k] = NULL; 10991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; io_port[k]; k++) { 11011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (io_port[k] == SKIP) continue; 11031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (j < MAX_BOARDS && port_detect(io_port[k], j, tpnt)) j++; 11051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds num_boards = j; 11081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return j; 11091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void map_dma(unsigned int i, unsigned int j) { 11121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int data_len = 0; 11131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, count, pci_dir; 1114fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori struct scatterlist *sg; 11151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sense_buffer) 11221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sense_addr = H2DEV(pci_map_single(HD(j)->pdev, SCpnt->sense_buffer, 1123b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE)); 11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1125b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori cpp->sense_len = SCSI_SENSE_BUFFERSIZE; 11261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1127fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori if (scsi_bufflen(SCpnt)) { 1128fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori count = scsi_dma_map(SCpnt); 1129fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori BUG_ON(count < 0); 1130fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori 1131fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori scsi_for_each_sg(SCpnt, sg, count, k) { 1132fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->sglist[k].address = H2DEV(sg_dma_address(sg)); 1133fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(sg)); 1134fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori data_len += sg->length; 1135fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori } 1136fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori 1137fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->sg = TRUE; 1138fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->use_sg = scsi_sg_count(SCpnt); 1139fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->data_address = 1140fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist, 1141fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->use_sg * sizeof(struct sg_list), 1142fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori pci_dir)); 1143fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->data_len = H2DEV(data_len); 1144fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori 1145fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori } else { 1146fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori pci_dir = PCI_DMA_BIDIRECTIONAL; 1147fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori cpp->data_len = H2DEV(scsi_bufflen(SCpnt)); 1148fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori } 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void unmap_dma(unsigned int i, unsigned int j) { 11521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int pci_dir; 11531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->sense_addr)) 11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr), 11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE); 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1163fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori scsi_dma_unmap(SCpnt); 11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL; 11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->data_address)) 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address), 11691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->data_len), pci_dir); 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void sync_dma(unsigned int i, unsigned int j) { 11731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int pci_dir; 11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->sense_addr)) 11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr), 11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE); 11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1184fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori if (scsi_sg_count(SCpnt)) 1185fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori pci_dma_sync_sg_for_cpu(HD(j)->pdev, scsi_sglist(SCpnt), 1186fea97f9ab26a17c29eadc102c04b88776d6262d4FUJITA Tomonori scsi_sg_count(SCpnt), pci_dir); 11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL; 11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->data_address)) 11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address), 11921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->data_len), pci_dir); 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void scsi_to_dev_dir(unsigned int i, unsigned int j) { 11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k; 11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static const unsigned char data_out_cmds[] = { 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e, 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40, 12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d 12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static const unsigned char data_none_cmds[] = { 12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e, 12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47, 12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00 12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1219d6a451dd4d7ec805f9a21bb1994ce8ceaecc8fe6Roel Kluin else if (SCpnt->sc_data_direction == DMA_TO_DEVICE) { 12201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_OUT; 12211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (SCpnt->sc_data_direction == DMA_NONE) { 12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_NONE; 12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL) 12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", BN(j)); 12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++) 12341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->cmnd[0] == data_out_cmds[k]) { 12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_OUT; 12361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpp->xdir == DTD_IN) 12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++) 12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->cmnd[0] == data_none_cmds[k]) { 12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_NONE; 12431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) { 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, k; 12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* j is the board number */ 12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number; 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble) 12561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", 125712a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox BN(j), SCpnt->serial_number, SCpnt); 12581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* i is the mailbox number, look for the first free mailbox 12601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds starting from last_cp_used */ 12611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = HD(j)->last_cp_used + 1; 12621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->can_queue; k++, i++) { 12641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) i = 0; 12661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) { 12681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->last_cp_used = i; 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (k == sh[j]->can_queue) { 12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: qcomm, no free mailbox.\n", BN(j)); 12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Set pointer to control packet structure */ 12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; 12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE); 12821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done = done; 12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cpp_index = i; 12841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index; 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n", 12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->device->channel, SCpnt->device->id, 128812a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox SCpnt->device->lun, SCpnt->serial_number); 12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->opcode = OP_SCSI; 12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->channel = SCpnt->device->channel; 12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->target = SCpnt->device->id; 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->lun = SCpnt->device->lun; 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->SCpnt = SCpnt; 12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cdb_len = SCpnt->cmd_len; 12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len); 12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Use data transfer direction SCpnt->sc_data_direction */ 12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_to_dev_dir(i, j); 13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map DMA buffers and SG list */ 13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds map_dma(i, j); 13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (linked_comm && SCpnt->device->queue_depth > 2 13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && TLDEV(SCpnt->device->type)) { 13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = READY; 13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE); 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 1314017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCpnt, 131512a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number); 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Store pointer in OGM address bytes */ 13201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Issue OGM interrupt */ 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = IN_USE; 13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_abort(struct scsi_cmnd *SCarg) { 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j; 13311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg->host_scribble == NULL) { 1335017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCarg, "abort, pid %ld inactive.\n", 133612a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox SCarg->serial_number); 13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = *(unsigned int *)SCarg->host_scribble; 1341017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCarg, "abort, mbox %d, pid %ld.\n", 134212a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox i, SCarg->serial_number); 13431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) 13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j)); 13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 13481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, timeout error.\n", BN(j)); 13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) { 13531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is free.\n", BN(j), i); 13541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_USE) { 13581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is in use.\n", BN(j), i); 13591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg != HD(j)->cp[i].SCpnt) 13611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n", 13621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCarg, HD(j)->cp[i].SCpnt); 13631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (inb(sh[j]->io_port + REG_SYS_INTR) & IRQ_ASSERTED) 13651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d, interrupt pending.\n", BN(j), i); 13661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_RESET) { 13711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is in reset.\n", BN(j), i); 13721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == LOCKED) { 13761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is locked.\n", BN(j), i); 13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { 13811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 13821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->result = DID_ABORT << 16; 13831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->host_scribble = NULL; 13841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 13851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", 138612a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox BN(j), i, SCarg->serial_number); 13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->scsi_done(SCarg); 13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, mbox %d, invalid cp_stat.\n", BN(j), i); 13921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) { 13951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, time, k, c, limit = 0; 13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int arg_done = FALSE; 13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 140012a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox scmd_printk(KERN_INFO, SCarg, "reset, enter, pid %ld.\n", SCarg->serial_number); 14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1402df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_lock_irq(sh[j]->host_lock); 1403df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik 14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg->host_scribble == NULL) 140512a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->serial_number); 14061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->in_reset) { 14081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, exit, already in reset.\n", BN(j)); 1409df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, exit, timeout error.\n", BN(j)); 1415df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->retries = 0; 14201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (c = 0; c <= sh[j]->max_channel; c++) 14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->max_id; k++) { 14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_redo[k][c] = TRUE; 14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_to[k][c] = 0; 14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) { 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) continue; 14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == LOCKED) { 14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 14331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, locked mbox %d forced free.\n", BN(j), i); 14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 14351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(SCpnt = HD(j)->cp[i].SCpnt)) 14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, SCpnt == NULL.\n", BN(j), i); 14391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { 14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = ABORTING; 14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, mbox %d aborting, pid %ld.\n", 144312a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox BN(j), i, SCpnt->serial_number); 14441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = IN_RESET; 14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, mbox %d in reset, pid %ld.\n", 144912a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox BN(j), i, SCpnt->serial_number); 14501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble == NULL) 14531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, garbled SCpnt.\n", BN(j), i); 14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*(unsigned int *)SCpnt->host_scribble != i) 14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, index mismatch.\n", BN(j), i); 14571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->scsi_done == NULL) 14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", BN(j), i); 14601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt == SCarg) arg_done = TRUE; 14621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 14651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, cannot reset, timeout error.\n", BN(j)); 1466df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_RESET, sh[j]->io_port + REG_LCL_INTR); 14711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, board reset done, enabling interrupts.\n", BN(j)); 14721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_RESET) 14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace = TRUE; 14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->in_reset = TRUE; 14781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(sh[j]->host_lock); 14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds time = jiffies; 14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L); 14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(sh[j]->host_lock); 14831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, interrupts disabled, loops %d.\n", BN(j), limit); 14851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) { 14871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_RESET) { 14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = HD(j)->cp[i].SCpnt; 14901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = DID_RESET << 16; 14921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 14931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* This mailbox is still waiting for its interrupt */ 14951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = LOCKED; 14961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", 149812a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox BN(j), i, SCpnt->serial_number); 14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == ABORTING) { 15021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = HD(j)->cp[i].SCpnt; 15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 15041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = DID_RESET << 16; 15051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 15061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* This mailbox was never queued to the adapter */ 15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 15091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", 151112a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox BN(j), i, SCpnt->serial_number); 15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Any other mailbox has already been set free by interrupt */ 15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 15181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done(SCpnt); 15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->in_reset = FALSE; 15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace = FALSE; 15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 152512a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->serial_number); 15261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else printk("%s: reset, exit.\n", BN(j)); 15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1528df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_bios_param(struct scsi_device *disk, 15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct block_device *bdev, sector_t capacity, int *dkinfo) { 15341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j = 0; 15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int size = capacity; 15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0] = HD(j)->heads; 15381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[1] = HD(j)->sectors; 15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors); 15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ext_tran && (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) { 15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0] = 255; 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[1] = 63; 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[2] = size / (dkinfo[0] * dkinfo[1]); 15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined (DEBUG_GEOMETRY) 15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk ("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name, 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0], dkinfo[1], dkinfo[2]); 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 15511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void sort(unsigned long sk[], unsigned int da[], unsigned int n, 15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int rev) { 15571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, k, y; 15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long x; 15591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < n - 1; i++) { 15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = i; 15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (j = k + 1; j < n; j++) 15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rev) { 15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sk[j] > sk[k]) k = j; 15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sk[j] < sk[k]) k = j; 15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (k != i) { 15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds x = sk[k]; sk[k] = sk[i]; sk[i] = x; 15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds y = da[k]; da[k] = da[i]; da[i] = y; 15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int reorder(unsigned int j, unsigned long cursec, 15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int ihdlr, unsigned int il[], unsigned int n_ready) { 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, n; 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int rev = FALSE, s = TRUE, r = TRUE; 15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int input_only = TRUE, overlap = FALSE; 15871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long sl[n_ready], pl[n_ready], ll[n_ready]; 15881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0; 15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long ioseek = 0; 15901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int flushcount = 0, batchcount = 0, sortcount = 0; 15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int readycount = 0, ovlcount = 0, inputcount = 0; 15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int readysorted = 0, revcount = 0; 15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned long seeksorted = 0, seeknosort = 0; 15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics && !(++flushcount % link_statistics)) 15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"\ 15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " av %ldK as %ldK.\n", flushcount, batchcount, inputcount, 15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ovlcount, readycount, readysorted, sortcount, revcount, 16001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seeknosort / (readycount + 1), 16011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seeksorted / (readycount + 1)); 16021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (n_ready <= 1) return FALSE; 16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(cpp->xdir == DTD_IN)) input_only = FALSE; 16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector; 16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector; 16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sl[n] = SCpnt->request->sector; 16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ioseek += SCpnt->request->nr_sectors; 16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!n) continue; 16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] < sl[n - 1]) s = FALSE; 16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] > sl[n - 1]) r = FALSE; 16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] > sl[n - 1]) 16231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seek += sl[n] - sl[n - 1]; 16241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 16251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seek += sl[n - 1] - sl[n]; 16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec; 16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > ((maxsec + minsec) / 2)) rev = TRUE; 16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE; 16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev); 16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!input_only) for (n = 0; n < n_ready; n++) { 16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 164212a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->serial_number; 16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!n) continue; 16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n])) 16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE; 16481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (overlap) sort(pl, il, n_ready, FALSE); 16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec; 16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds batchcount++; readycount += n_ready; seeknosort += seek / 1024; 16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (input_only) inputcount++; 16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (overlap) { ovlcount++; seeksorted += iseek / 1024; } 16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else seeksorted += (iseek + maxsec - minsec) / 1024; 16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rev && !r) { revcount++; readysorted += n_ready; } 16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!rev && !s) { sortcount++; readysorted += n_ready; } 16601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_LINKED_COMMANDS) 16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics && (overlap || !(flushcount % link_statistics))) 16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\ 16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target, 166912a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready, 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->request->sector, SCpnt->request->nr_sectors, cursec, 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only), 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(overlap), cpp->xdir); 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return overlap; 16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned int j, 16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int ihdlr) { 16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES]; 16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->can_queue; k++) { 16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue; 16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->device != dev) continue; 16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[k] == IN_USE) return; 16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds il[n_ready++] = k; 16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1; 16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 1703017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCpnt, 1704017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "%s, pid %ld, mbox %d, adapter" 1705017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"), 170612a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox SCpnt->serial_number, k); 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[k] = ABORTING; 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[k] = IN_USE; 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1718e19166d5df10be0ea404c4e346cf6be93bfb1d63Jeff Garzikstatic irqreturn_t ihdlr(unsigned int j) 1719e19166d5df10be0ea404c4e346cf6be93bfb1d63Jeff Garzik{ 17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, k, c, status, tstatus, reg, ret; 17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *spp, *cpp; 1723e19166d5df10be0ea404c4e346cf6be93bfb1d63Jeff Garzik int irq = sh[j]->irq; 17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if this board need to be serviced */ 17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none; 17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount++; 17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.\n", BN(j), irq, 17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if this board is still busy */ 17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) { 17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 17361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n", 17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), irq, reg, HD(j)->iocount); 17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto none; 17391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret = inl(sh[j]->io_port + REG_ICM); 17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear interrupt pending flag */ 17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Find the mailbox to be serviced on this board */ 17471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (H2DEV(HD(j)->cp[i].cp_dma_addr) == ret) break; 17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) 17511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, invalid mscp bus address %p, cp0 %p.\n", BN(j), 17521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (void *)ret, (void *)H2DEV(HD(j)->cp[0].cp_dma_addr)); 17531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &(HD(j)->cp[i]); 17551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp = cpp; 17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_GENERATE_ABORTS) 17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) goto handled; 17591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IGNORE) { 17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == LOCKED) { 17661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d unlocked, count %d.\n", BN(j), i, 17681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == FREE) { 17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d is free, count %d.\n", BN(j), i, 17731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == IN_RESET) 17771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d is in reset.\n", BN(j), i); 17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] != IN_USE) 17791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n", 17801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, HD(j)->cp_stat[i]); 17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = cpp->SCpnt; 17841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i); 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble == NULL) 17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i, 178912a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox SCpnt->serial_number, SCpnt); 17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*(unsigned int *)SCpnt->host_scribble != i) 17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", 179312a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox BN(j), i, SCpnt->serial_number, *(unsigned int *)SCpnt->host_scribble); 17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sync_dma(i, j); 17961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (linked_comm && SCpnt->device->queue_depth > 2 17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && TLDEV(SCpnt->device->type)) 17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE); 18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tstatus = status_byte(spp->target_status); 18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_GENERATE_ERRORS) 18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2)) 18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp->adapter_status = 0x01; 18061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (spp->adapter_status) { 18091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case ASOK: /* status OK */ 18101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Forces a reset if a disk drive keeps returning BUSY */ 18121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 18131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If there was a bus reset, redo operation on each target */ 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK 1817422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik && HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)]) 18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Works around a flaw in scsi.c */ 18211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tstatus == CHECK_CONDITION 18221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && SCpnt->device->type == TYPE_DISK 18231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR) 18241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_OK << 16; 18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tstatus == GOOD) 1830422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)] = FALSE; 18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (spp->target_status && SCpnt->device->type == TYPE_DISK && 18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 && 18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) 1835422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik scmd_printk(KERN_INFO, SCpnt, 1836422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik "ihdlr, pid %ld, target_status 0x%x, sense key 0x%x.\n", 183712a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox SCpnt->serial_number, spp->target_status, 18381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->sense_buffer[2]); 18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1840422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0; 18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 184212a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox if (HD(j)->last_retried_pid == SCpnt->serial_number) HD(j)->retries = 0; 18431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case ASST: /* Selection Time Out */ 18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1847422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik if (HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] > 1) 18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_TIME_OUT << 16; 1851422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)]++; 18521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Perform a limited number of internal retries */ 18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x93: /* Unexpected bus free */ 18581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x94: /* Target bus phase sequence failure */ 18591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x96: /* Illegal SCSI command */ 18601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0xa3: /* SCSI bus reset error */ 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (c = 0; c <= sh[j]->max_channel; c++) 18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->max_id; k++) 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_redo[k][c] = TRUE; 18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x92: /* Data over/under-run */ 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->device->type != TYPE_TAPE 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && HD(j)->retries < MAX_INTERNAL_RETRIES) { 18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DID_SOFT_ERROR) 18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_SOFT_ERROR << 16; 18741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 18751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->retries++; 187912a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox HD(j)->last_retried_pid = SCpnt->serial_number; 18801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x01: /* Invalid command */ 18861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x02: /* Invalid parameters */ 18871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x03: /* Invalid data list */ 18881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x84: /* SCSI bus abort error */ 18891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x9b: /* Auto request sense error */ 18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x9f: /* Unexpected command complete message error */ 18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0xff: /* Invalid parameter in the S/G list */ 18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = status | spp->target_status; 18981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_INTERRUPT) 19001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->result || do_trace) 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((spp->adapter_status != ASOK && HD(j)->iocount > 1000) || 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (spp->adapter_status != ASOK && 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp->adapter_status != ASST && HD(j)->iocount <= 1000) || 19051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace || msg_byte(spp->target_status)) 19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 1907017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\ 1908017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik " pid %ld, reg 0x%x, count %d.\n", 190912a441622b753684cc73d1c6f225e9ac53e0bf77Matthew Wilcox i, spp->adapter_status, spp->target_status, SCpnt->serial_number, 19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg, HD(j)->iocount); 19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Set the command state to inactive */ 19151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 19161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done(SCpnt); 19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.\n", BN(j), irq, 19201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldshandled: 19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_HANDLED; 19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsnone: 19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_NONE; 19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19287d12e780e003f93433d49ce78cfedf4b4c52adc5David Howellsstatic irqreturn_t do_interrupt_handler(int irq, void *shap) { 19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j; 19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long spin_flags; 19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqreturn_t ret; 19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if the interrupt must be processed by this handler */ 19341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE; 19351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(sh[j]->host_lock, spin_flags); 1937e19166d5df10be0ea404c4e346cf6be93bfb1d63Jeff Garzik ret = ihdlr(j); 19381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(sh[j]->host_lock, spin_flags); 19391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ret; 19401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_release(struct Scsi_Host *shpnt) { 19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j; 19441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++); 19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1947c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl if (sh[j] == NULL) 1948c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl panic("%s: release, invalid Scsi_Host pointer.\n", driver_name); 19491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 1951c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl kfree((&HD(j)->cp[i])->sglist); 19521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 19541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr, 19551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL); 19561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_irq(sh[j]->irq, &sha[j]); 19581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1959c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl if (sh[j]->dma_channel != NO_DMA) 1960c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl free_dma(sh[j]->dma_channel); 19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_region(sh[j]->io_port, sh[j]->n_io_port); 19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_unregister(sh[j]); 19641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 19651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "scsi_module.c" 19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifndef MODULE 19701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds__setup("u14-34f=", option_setup); 19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif /* end MODULE */ 1972