u14-34f.c revision 7d12e780e003f93433d49ce78cfedf4b4c52adc5
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, 4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .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; 11141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scatterlist *sgpnt; 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, 11231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sizeof SCpnt->sense_buffer, PCI_DMA_FROMDEVICE)); 11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sense_len = sizeof SCpnt->sense_buffer; 11261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!SCpnt->use_sg) { 11281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If we get here with PCI_DMA_NONE, pci_map_single triggers a BUG() */ 11301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!SCpnt->request_bufflen) pci_dir = PCI_DMA_BIDIRECTIONAL; 11311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request_buffer) 11331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev, 11341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->request_buffer, SCpnt->request_bufflen, pci_dir)); 11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_len = H2DEV(SCpnt->request_bufflen); 11371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 11381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sgpnt = (struct scatterlist *) SCpnt->request_buffer; 11411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count = pci_map_sg(HD(j)->pdev, sgpnt, SCpnt->use_sg, pci_dir); 11421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < count; k++) { 11441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sglist[k].address = H2DEV(sg_dma_address(&sgpnt[k])); 11451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sglist[k].num_bytes = H2DEV(sg_dma_len(&sgpnt[k])); 11461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds data_len += sgpnt[k].length; 11471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->sg = TRUE; 11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->use_sg = SCpnt->use_sg; 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_address = H2DEV(pci_map_single(HD(j)->pdev, cpp->sglist, 11521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->use_sg * sizeof(struct sg_list), pci_dir)); 11531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->data_len = H2DEV(data_len); 11541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void unmap_dma(unsigned int i, unsigned int j) { 11571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int pci_dir; 11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->sense_addr)) 11651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, DEV2H(cpp->sense_addr), 11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE); 11671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->use_sg) 11691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_sg(HD(j)->pdev, SCpnt->request_buffer, SCpnt->use_sg, pci_dir); 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL; 11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->data_address)) 11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, DEV2H(cpp->data_address), 11751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->data_len), pci_dir); 11761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void sync_dma(unsigned int i, unsigned int j) { 11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int pci_dir; 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 11841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dir = SCpnt->sc_data_direction; 11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->sense_addr)) 11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->sense_addr), 11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->sense_len), PCI_DMA_FROMDEVICE); 11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->use_sg) 11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_sg_for_cpu(HD(j)->pdev, SCpnt->request_buffer, 11921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->use_sg, pci_dir); 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!DEV2H(cpp->data_len)) pci_dir = PCI_DMA_BIDIRECTIONAL; 11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (DEV2H(cpp->data_address)) 11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_dma_sync_single_for_cpu(HD(j)->pdev, DEV2H(cpp->data_address), 11981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEV2H(cpp->data_len), pci_dir); 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void scsi_to_dev_dir(unsigned int i, unsigned int j) { 12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k; 12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static const unsigned char data_out_cmds[] = { 12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x0a, 0x2a, 0x15, 0x55, 0x04, 0x07, 0x18, 0x1d, 0x24, 0x2e, 12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x30, 0x31, 0x32, 0x38, 0x39, 0x3a, 0x3b, 0x3d, 0x3f, 0x40, 12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x41, 0x4c, 0xaa, 0xae, 0xb0, 0xb1, 0xb2, 0xb6, 0xea, 0x1b, 0x5d 12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static const unsigned char data_none_cmds[] = { 12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x01, 0x0b, 0x10, 0x11, 0x13, 0x16, 0x17, 0x19, 0x2b, 0x1e, 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x2c, 0xac, 0x2f, 0xaf, 0x33, 0xb3, 0x35, 0x36, 0x45, 0x47, 12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 0x48, 0x49, 0xa9, 0x4b, 0xa5, 0xa6, 0xb5, 0x00 12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }; 12151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; SCpnt = cpp->SCpnt; 12201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (SCpnt->sc_data_direction == DMA_FROM_DEVICE) { 12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_OUT; 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (SCpnt->sc_data_direction == DMA_NONE) { 12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_NONE; 12311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->sc_data_direction != DMA_BIDIRECTIONAL) 12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: qcomm, invalid SCpnt->sc_data_direction.\n", BN(j)); 12361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_IN; 12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < ARRAY_SIZE(data_out_cmds); k++) 12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->cmnd[0] == data_out_cmds[k]) { 12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_OUT; 12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cpp->xdir == DTD_IN) 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < ARRAY_SIZE(data_none_cmds); k++) 12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->cmnd[0] == data_none_cmds[k]) { 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->xdir = DTD_NONE; 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) { 12551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, k; 12561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 12571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* j is the board number */ 12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number; 12601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble) 12621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", 12631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), SCpnt->pid, SCpnt); 12641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* i is the mailbox number, look for the first free mailbox 12661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds starting from last_cp_used */ 12671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = HD(j)->last_cp_used + 1; 12681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->can_queue; k++, i++) { 12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) i = 0; 12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) { 12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->last_cp_used = i; 12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (k == sh[j]->can_queue) { 12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: qcomm, no free mailbox.\n", BN(j)); 12811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 12821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Set pointer to control packet structure */ 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[i]; 12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cpp, 0, sizeof(struct mscp) - CP_TAIL_SIZE); 12881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done = done; 12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cpp_index = i; 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index; 12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n", 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->device->channel, SCpnt->device->id, 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->device->lun, SCpnt->pid); 12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->opcode = OP_SCSI; 12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->channel = SCpnt->device->channel; 12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->target = SCpnt->device->id; 12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->lun = SCpnt->device->lun; 13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->SCpnt = SCpnt; 13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp->cdb_len = SCpnt->cmd_len; 13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len); 13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Use data transfer direction SCpnt->sc_data_direction */ 13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_to_dev_dir(i, j); 13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Map DMA buffers and SG list */ 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds map_dma(i, j); 13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (linked_comm && SCpnt->device->queue_depth > 2 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && TLDEV(SCpnt->device->type)) { 13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = READY; 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE); 13141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 13151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 13181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 1320017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCpnt, 1321017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "qcomm, pid %ld, adapter busy.\n", SCpnt->pid); 13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Store pointer in OGM address bytes */ 13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Issue OGM interrupt */ 13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = IN_USE; 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_abort(struct scsi_cmnd *SCarg) { 13361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j; 13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg->host_scribble == NULL) { 1341017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCarg, "abort, pid %ld inactive.\n", 1342017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik SCarg->pid); 13431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = *(unsigned int *)SCarg->host_scribble; 1347017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCarg, "abort, mbox %d, pid %ld.\n", 1348017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik i, SCarg->pid); 13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) 13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j)); 13521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 13541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, timeout error.\n", BN(j)); 13551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) { 13591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is free.\n", BN(j), i); 13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_USE) { 13641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is in use.\n", BN(j), i); 13651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg != HD(j)->cp[i].SCpnt) 13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, mbox %d, SCarg %p, cp SCpnt %p.\n", 13681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCarg, HD(j)->cp[i].SCpnt); 13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (inb(sh[j]->io_port + REG_SYS_INTR) & IRQ_ASSERTED) 13711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d, interrupt pending.\n", BN(j), i); 13721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_RESET) { 13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is in reset.\n", BN(j), i); 13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 13791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == LOCKED) { 13821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: abort, mbox %d is locked.\n", BN(j), i); 13831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { 13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->result = DID_ABORT << 16; 13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->host_scribble = NULL; 13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 13911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", 13921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCarg->pid); 13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCarg->scsi_done(SCarg); 13941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 13951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: abort, mbox %d, invalid cp_stat.\n", BN(j), i); 13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) { 14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, time, k, c, limit = 0; 14021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int arg_done = FALSE; 14031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 1406017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCarg, "reset, enter, pid %ld.\n", SCarg->pid); 14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1408df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_lock_irq(sh[j]->host_lock); 1409df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik 14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCarg->host_scribble == NULL) 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->pid); 14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->in_reset) { 14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, exit, already in reset.\n", BN(j)); 1415df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 14201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, exit, timeout error.\n", BN(j)); 1421df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->retries = 0; 14261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (c = 0; c <= sh[j]->max_channel; c++) 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->max_id; k++) { 14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_redo[k][c] = TRUE; 14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_to[k][c] = 0; 14311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) { 14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == FREE) continue; 14361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == LOCKED) { 14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 14391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, locked mbox %d forced free.\n", BN(j), i); 14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(SCpnt = HD(j)->cp[i].SCpnt)) 14441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, SCpnt == NULL.\n", BN(j), i); 14451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { 14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = ABORTING; 14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, mbox %d aborting, pid %ld.\n", 14491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 14501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 14531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = IN_RESET; 14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, mbox %d in reset, pid %ld.\n", 14551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble == NULL) 14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, garbled SCpnt.\n", BN(j), i); 14601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*(unsigned int *)SCpnt->host_scribble != i) 14621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, index mismatch.\n", BN(j), i); 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->scsi_done == NULL) 14651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: reset, mbox %d, SCpnt->scsi_done == NULL.\n", BN(j), i); 14661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt == SCarg) arg_done = TRUE; 14681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 14711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, cannot reset, timeout error.\n", BN(j)); 1472df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_RESET, sh[j]->io_port + REG_LCL_INTR); 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, board reset done, enabling interrupts.\n", BN(j)); 14781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_RESET) 14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace = TRUE; 14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->in_reset = TRUE; 14841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(sh[j]->host_lock); 14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds time = jiffies; 14871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while ((jiffies - time) < (10 * HZ) && limit++ < 200000) udelay(100L); 14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(sh[j]->host_lock); 14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: reset, interrupts disabled, loops %d.\n", BN(j), limit); 14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) { 14931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IN_RESET) { 14951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = HD(j)->cp[i].SCpnt; 14961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = DID_RESET << 16; 14981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* This mailbox is still waiting for its interrupt */ 15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = LOCKED; 15021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", 15041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 15051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == ABORTING) { 15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = HD(j)->cp[i].SCpnt; 15091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = DID_RESET << 16; 15111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* This mailbox was never queued to the adapter */ 15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", 15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid); 15181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Any other mailbox has already been set free by interrupt */ 15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done(SCpnt); 15261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->in_reset = FALSE; 15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace = FALSE; 15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->pid); 15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else printk("%s: reset, exit.\n", BN(j)); 15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1534df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(sh[j]->host_lock); 15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_bios_param(struct scsi_device *disk, 15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct block_device *bdev, sector_t capacity, int *dkinfo) { 15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j = 0; 15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int size = capacity; 15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0] = HD(j)->heads; 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[1] = HD(j)->sectors; 15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors); 15461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ext_tran && (scsicam_bios_param(bdev, capacity, dkinfo) < 0)) { 15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0] = 255; 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[1] = 63; 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[2] = size / (dkinfo[0] * dkinfo[1]); 15511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined (DEBUG_GEOMETRY) 15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk ("%s: bios_param, head=%d, sec=%d, cyl=%d.\n", driver_name, 15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dkinfo[0], dkinfo[1], dkinfo[2]); 15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 15571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 15591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void sort(unsigned long sk[], unsigned int da[], unsigned int n, 15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int rev) { 15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j, k, y; 15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long x; 15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < n - 1; i++) { 15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = i; 15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (j = k + 1; j < n; j++) 15701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rev) { 15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sk[j] > sk[k]) k = j; 15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sk[j] < sk[k]) k = j; 15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (k != i) { 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds x = sk[k]; sk[k] = sk[i]; sk[i] = x; 15791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds y = da[k]; da[k] = da[i]; da[i] = y; 15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int reorder(unsigned int j, unsigned long cursec, 15871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int ihdlr, unsigned int il[], unsigned int n_ready) { 15881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 15901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, n; 15911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int rev = FALSE, s = TRUE, r = TRUE; 15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int input_only = TRUE, overlap = FALSE; 15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long sl[n_ready], pl[n_ready], ll[n_ready]; 15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long maxsec = 0, minsec = ULONG_MAX, seek = 0, iseek = 0; 15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long ioseek = 0; 15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int flushcount = 0, batchcount = 0, sortcount = 0; 15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int readycount = 0, ovlcount = 0, inputcount = 0; 15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned int readysorted = 0, revcount = 0; 16001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static unsigned long seeksorted = 0, seeknosort = 0; 16011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics && !(++flushcount % link_statistics)) 16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("fc %d bc %d ic %d oc %d rc %d rs %d sc %d re %d"\ 16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " av %ldK as %ldK.\n", flushcount, batchcount, inputcount, 16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ovlcount, readycount, readysorted, sortcount, revcount, 16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seeknosort / (readycount + 1), 16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seeksorted / (readycount + 1)); 16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (n_ready <= 1) return FALSE; 16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(cpp->xdir == DTD_IN)) input_only = FALSE; 16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector; 16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector; 16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sl[n] = SCpnt->request->sector; 16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ioseek += SCpnt->request->nr_sectors; 16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!n) continue; 16231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] < sl[n - 1]) s = FALSE; 16251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] > sl[n - 1]) r = FALSE; 16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sl[n] > sl[n - 1]) 16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seek += sl[n] - sl[n - 1]; 16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds seek += sl[n - 1] - sl[n]; 16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > sl[0]) seek += cursec - sl[0]; else seek += sl[0] - cursec; 16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > ((maxsec + minsec) / 2)) rev = TRUE; 16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ioseek > ((maxsec - minsec) / 2)) rev = FALSE; 16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((rev && r) || (!rev && s))) sort(sl, il, n_ready, rev); 16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!input_only) for (n = 0; n < n_ready; n++) { 16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->pid; 16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!n) continue; 16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((sl[n] == sl[n - 1]) || (!rev && ((sl[n - 1] + ll[n - 1]) > sl[n])) 16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || (rev && ((sl[n] + ll[n]) > sl[n - 1]))) overlap = TRUE; 16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (overlap) sort(pl, il, n_ready, FALSE); 16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics) { 16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cursec > sl[0]) iseek = cursec - sl[0]; else iseek = sl[0] - cursec; 16601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds batchcount++; readycount += n_ready; seeknosort += seek / 1024; 16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (input_only) inputcount++; 16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (overlap) { ovlcount++; seeksorted += iseek / 1024; } 16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else seeksorted += (iseek + maxsec - minsec) / 1024; 16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (rev && !r) { revcount++; readysorted += n_ready; } 16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!rev && !s) { sortcount++; readysorted += n_ready; } 16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_LINKED_COMMANDS) 16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (link_statistics && (overlap || !(flushcount % link_statistics))) 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\ 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", 16741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target, 16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->lun, SCpnt->pid, k, flushcount, n_ready, 16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->request->sector, SCpnt->request->nr_sectors, cursec, 16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only), 16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds YESNO(overlap), cpp->xdir); 16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return overlap; 16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned int j, 16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int ihdlr) { 16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *cpp; 16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int k, n, n_ready = 0, il[MAX_MAILBOXES]; 16891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->can_queue; k++) { 16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[k] != READY && HD(j)->cp_stat[k] != IN_USE) continue; 16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->device != dev) continue; 16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[k] == IN_USE) return; 16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds il[n_ready++] = k; 17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (reorder(j, cursec, ihdlr, il, n_ready)) n_ready = 1; 17041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (n = 0; n < n_ready; n++) { 17061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 1709017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCpnt, 1710017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "%s, pid %ld, mbox %d, adapter" 1711017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"), 1712017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik SCpnt->pid, k); 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[k] = ABORTING; 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outl(H2DEV(cpp->cp_dma_addr), sh[j]->io_port + REG_OGM); 17181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_OGM_INTR, sh[j]->io_port + REG_LCL_INTR); 17191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[k] = IN_USE; 17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic irqreturn_t ihdlr(int irq, unsigned int j) { 17251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCpnt; 17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, k, c, status, tstatus, reg, ret; 17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mscp *spp, *cpp; 17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sh[j]->irq != irq) 17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, irq %d, sh[j]->irq %d.\n", BN(j), irq, sh[j]->irq); 17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if this board need to be serviced */ 17331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!((reg = inb(sh[j]->io_port + REG_SYS_INTR)) & IRQ_ASSERTED)) goto none; 17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount++; 17361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: ihdlr, enter, irq %d, count %d.\n", BN(j), irq, 17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if this board is still busy */ 17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (wait_on_busy(sh[j]->io_port, 20 * MAXLOOP)) { 17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, busy timeout error, irq %d, reg 0x%x, count %d.\n", 17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), irq, reg, HD(j)->iocount); 17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto none; 17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret = inl(sh[j]->io_port + REG_ICM); 17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear interrupt pending flag */ 17511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds outb(CMD_CLR_INTR, sh[j]->io_port + REG_SYS_INTR); 17521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Find the mailbox to be serviced on this board */ 17541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 17551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (H2DEV(HD(j)->cp[i].cp_dma_addr) == ret) break; 17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (i >= sh[j]->can_queue) 17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, invalid mscp bus address %p, cp0 %p.\n", BN(j), 17591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (void *)ret, (void *)H2DEV(HD(j)->cp[0].cp_dma_addr)); 17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cpp = &(HD(j)->cp[i]); 17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp = cpp; 17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_GENERATE_ABORTS) 17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 500) < 3)) goto handled; 17661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->cp_stat[i] == IGNORE) { 17691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == LOCKED) { 17731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d unlocked, count %d.\n", BN(j), i, 17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == FREE) { 17791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d is free, count %d.\n", BN(j), i, 17801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto handled; 17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] == IN_RESET) 17841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("%s: ihdlr, mbox %d is in reset.\n", BN(j), i); 17851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (HD(j)->cp_stat[i] != IN_USE) 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, invalid cp_stat: %d.\n", 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, HD(j)->cp_stat[i]); 17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->cp_stat[i] = FREE; 17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt = cpp->SCpnt; 17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i); 17931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->host_scribble == NULL) 17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i, 17961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->pid, SCpnt); 17971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*(unsigned int *)SCpnt->host_scribble != i) 17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", 18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BN(j), i, SCpnt->pid, *(unsigned int *)SCpnt->host_scribble); 18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sync_dma(i, j); 18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (linked_comm && SCpnt->device->queue_depth > 2 18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && TLDEV(SCpnt->device->type)) 18061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE); 18071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tstatus = status_byte(spp->target_status); 18091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_GENERATE_ERRORS) 18111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((HD(j)->iocount > 500) && ((HD(j)->iocount % 200) < 2)) 18121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp->adapter_status = 0x01; 18131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (spp->adapter_status) { 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case ASOK: /* status OK */ 18171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Forces a reset if a disk drive keeps returning BUSY */ 18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If there was a bus reset, redo operation on each target */ 18231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tstatus != GOOD && SCpnt->device->type == TYPE_DISK 1824422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik && HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)]) 18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Works around a flaw in scsi.c */ 18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (tstatus == CHECK_CONDITION 18291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && SCpnt->device->type == TYPE_DISK 18301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR) 18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_OK << 16; 18351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tstatus == GOOD) 1837422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik HD(j)->target_redo[scmd_id(SCpnt)][scmd_channel(SCpnt)] = FALSE; 18381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (spp->target_status && SCpnt->device->type == TYPE_DISK && 18401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 && 18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) 1842422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik scmd_printk(KERN_INFO, SCpnt, 1843422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik "ihdlr, pid %ld, target_status 0x%x, sense key 0x%x.\n", 18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->pid, spp->target_status, 18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->sense_buffer[2]); 18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1847422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0; 18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (HD(j)->last_retried_pid == SCpnt->pid) HD(j)->retries = 0; 18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case ASST: /* Selection Time Out */ 18531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1854422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik if (HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] > 1) 18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_TIME_OUT << 16; 1858422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)]++; 18591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Perform a limited number of internal retries */ 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x93: /* Unexpected bus free */ 18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x94: /* Target bus phase sequence failure */ 18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x96: /* Illegal SCSI command */ 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0xa3: /* SCSI bus reset error */ 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (c = 0; c <= sh[j]->max_channel; c++) 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (k = 0; k < sh[j]->max_id; k++) 18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->target_redo[k][c] = TRUE; 18721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x92: /* Data over/under-run */ 18751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->device->type != TYPE_TAPE 18771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && HD(j)->retries < MAX_INTERNAL_RETRIES) { 18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DID_SOFT_ERROR) 18801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_SOFT_ERROR << 16; 18811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_BUS_BUSY << 16; 18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->retries++; 18861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->last_retried_pid = SCpnt->pid; 18871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 18891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x01: /* Invalid command */ 18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x02: /* Invalid parameters */ 18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x03: /* Invalid data list */ 18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x84: /* SCSI bus abort error */ 18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x9b: /* Auto request sense error */ 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0x9f: /* Unexpected command complete message error */ 18981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case 0xff: /* Invalid parameter in the S/G list */ 18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 19001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = DID_ERROR << 16; 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->result = status | spp->target_status; 19051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(DEBUG_INTERRUPT) 19071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (SCpnt->result || do_trace) 19081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 19091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((spp->adapter_status != ASOK && HD(j)->iocount > 1000) || 19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (spp->adapter_status != ASOK && 19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spp->adapter_status != ASST && HD(j)->iocount <= 1000) || 19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds do_trace || msg_byte(spp->target_status)) 19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 1914017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\ 1915017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik " pid %ld, reg 0x%x, count %d.\n", 1916017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik i, spp->adapter_status, spp->target_status, SCpnt->pid, 19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reg, HD(j)->iocount); 19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unmap_dma(i, j); 19201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Set the command state to inactive */ 19221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->host_scribble = NULL; 19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCpnt->scsi_done(SCpnt); 19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (do_trace) printk("%s: ihdlr, exit, irq %d, count %d.\n", BN(j), irq, 19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds HD(j)->iocount); 19281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldshandled: 19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_HANDLED; 19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsnone: 19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_NONE; 19331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19357d12e780e003f93433d49ce78cfedf4b4c52adc5David Howellsstatic irqreturn_t do_interrupt_handler(int irq, void *shap) { 19361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int j; 19371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long spin_flags; 19381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds irqreturn_t ret; 19391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Check if the interrupt must be processed by this handler */ 19411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((j = (unsigned int)((char *)shap - sha)) >= num_boards) return IRQ_NONE; 19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(sh[j]->host_lock, spin_flags); 19441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret = ihdlr(irq, j); 19451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(sh[j]->host_lock, spin_flags); 19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ret; 19471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int u14_34f_release(struct Scsi_Host *shpnt) { 19501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int i, j; 19511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (j = 0; sh[j] != NULL && sh[j] != shpnt; j++); 19531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1954c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl if (sh[j] == NULL) 1955c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl panic("%s: release, invalid Scsi_Host pointer.\n", driver_name); 19561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 1958c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl kfree((&HD(j)->cp[i])->sglist); 19591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < sh[j]->can_queue; i++) 19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pci_unmap_single(HD(j)->pdev, HD(j)->cp[i].cp_dma_addr, 19621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sizeof(struct mscp), PCI_DMA_BIDIRECTIONAL); 19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_irq(sh[j]->irq, &sha[j]); 19651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1966c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl if (sh[j]->dma_channel != NO_DMA) 1967c9475cb0c358ff0dd473544280d92482df491913Jesper Juhl free_dma(sh[j]->dma_channel); 19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_region(sh[j]->io_port, sh[j]->n_io_port); 19701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_unregister(sh[j]); 19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FALSE; 19721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "scsi_module.c" 19751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifndef MODULE 19771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds__setup("u14-34f=", option_setup); 19781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif /* end MODULE */ 1979