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