11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds 3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux. 31da177e4SLinus Torvalds 44deedd84Sadam radford Written By: Adam Radford <linuxraid@lsi.com> 54deedd84Sadam radford Modifications By: Tom Couch <linuxraid@lsi.com> 61da177e4SLinus Torvalds 77a252fe7Sadam radford Copyright (C) 2004-2009 Applied Micro Circuits Corporation. 84deedd84Sadam radford Copyright (C) 2010 LSI Corporation. 91da177e4SLinus Torvalds 101da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 111da177e4SLinus Torvalds it under the terms of the GNU General Public License as published by 121da177e4SLinus Torvalds the Free Software Foundation; version 2 of the License. 131da177e4SLinus Torvalds 141da177e4SLinus Torvalds This program is distributed in the hope that it will be useful, 151da177e4SLinus Torvalds but WITHOUT ANY WARRANTY; without even the implied warranty of 161da177e4SLinus Torvalds MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 171da177e4SLinus Torvalds GNU General Public License for more details. 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds NO WARRANTY 201da177e4SLinus Torvalds THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 211da177e4SLinus Torvalds CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 221da177e4SLinus Torvalds LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 231da177e4SLinus Torvalds MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 241da177e4SLinus Torvalds solely responsible for determining the appropriateness of using and 251da177e4SLinus Torvalds distributing the Program and assumes all risks associated with its 261da177e4SLinus Torvalds exercise of rights under this Agreement, including but not limited to 271da177e4SLinus Torvalds the risks and costs of program errors, damage to or loss of data, 281da177e4SLinus Torvalds programs or equipment, and unavailability or interruption of operations. 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds DISCLAIMER OF LIABILITY 311da177e4SLinus Torvalds NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 321da177e4SLinus Torvalds DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 331da177e4SLinus Torvalds DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 341da177e4SLinus Torvalds ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 351da177e4SLinus Torvalds TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 361da177e4SLinus Torvalds USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 371da177e4SLinus Torvalds HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds You should have received a copy of the GNU General Public License 401da177e4SLinus Torvalds along with this program; if not, write to the Free Software 411da177e4SLinus Torvalds Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds Bugs/Comments/Suggestions should be mailed to: 444deedd84Sadam radford linuxraid@lsi.com 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds For more information, goto: 474deedd84Sadam radford http://www.lsi.com 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds Note: This version of the driver does not contain a bundled firmware 501da177e4SLinus Torvalds image. 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds History 531da177e4SLinus Torvalds ------- 541da177e4SLinus Torvalds 2.26.02.000 - Driver cleanup for kernel submission. 551da177e4SLinus Torvalds 2.26.02.001 - Replace schedule_timeout() calls with msleep(). 561da177e4SLinus Torvalds 2.26.02.002 - Add support for PAE mode. 571da177e4SLinus Torvalds Add lun support. 581da177e4SLinus Torvalds Fix twa_remove() to free irq handler/unregister_chrdev() 591da177e4SLinus Torvalds before shutting down card. 601da177e4SLinus Torvalds Change to new 'change_queue_depth' api. 611da177e4SLinus Torvalds Fix 'handled=1' ISR usage, remove bogus IRQ check. 621da177e4SLinus Torvalds Remove un-needed eh_abort handler. 631da177e4SLinus Torvalds Add support for embedded firmware error strings. 64d327d082Sadam radford 2.26.02.003 - Correctly handle single sgl's with use_sg=1. 6549bfd8dbSadam radford 2.26.02.004 - Add support for 9550SX controllers. 6662288f10Sadam radford 2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher. 6775913d9bSadam radford 2.26.02.006 - Fix 9550SX pchip reset timeout. 6875913d9bSadam radford Add big endian support. 691e08dcb3Sadam radford 2.26.02.007 - Disable local interrupts during kmap/unmap_atomic(). 704039c30eSadam radford 2.26.02.008 - Free irq handler in __twa_shutdown(). 714039c30eSadam radford Serialize reset code. 724039c30eSadam radford Add support for 9650SE controllers. 730e78d158Sadam radford 2.26.02.009 - Fix dma mask setting to fallback to 32-bit if 64-bit fails. 740e78d158Sadam radford 2.26.02.010 - Add support for 9690SA controllers. 753dabec71Sadam radford 2.26.02.011 - Increase max AENs drained to 256. 763dabec71Sadam radford Add MSI support and "use_msi" module parameter. 773dabec71Sadam radford Fix bug in twa_get_param() on 4GB+. 783dabec71Sadam radford Use pci_resource_len() for ioremap(). 797a252fe7Sadam radford 2.26.02.012 - Add power management support. 8053ca3535Sadam radford 2.26.02.013 - Fix bug in twa_load_sgl(). 814deedd84Sadam radford 2.26.02.014 - Force 60 second timeout default. 821da177e4SLinus Torvalds */ 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds #include <linux/module.h> 851da177e4SLinus Torvalds #include <linux/reboot.h> 861da177e4SLinus Torvalds #include <linux/spinlock.h> 871da177e4SLinus Torvalds #include <linux/interrupt.h> 881da177e4SLinus Torvalds #include <linux/moduleparam.h> 891da177e4SLinus Torvalds #include <linux/errno.h> 901da177e4SLinus Torvalds #include <linux/types.h> 911da177e4SLinus Torvalds #include <linux/delay.h> 921da177e4SLinus Torvalds #include <linux/pci.h> 931da177e4SLinus Torvalds #include <linux/time.h> 94a12e25bdSJes Sorensen #include <linux/mutex.h> 955a0e3ad6STejun Heo #include <linux/slab.h> 961da177e4SLinus Torvalds #include <asm/io.h> 971da177e4SLinus Torvalds #include <asm/irq.h> 981da177e4SLinus Torvalds #include <asm/uaccess.h> 991da177e4SLinus Torvalds #include <scsi/scsi.h> 1001da177e4SLinus Torvalds #include <scsi/scsi_host.h> 1011da177e4SLinus Torvalds #include <scsi/scsi_tcq.h> 1021da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 1031da177e4SLinus Torvalds #include "3w-9xxx.h" 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds /* Globals */ 1064deedd84Sadam radford #define TW_DRIVER_VERSION "2.26.02.014" 107c45d15d2SArnd Bergmann static DEFINE_MUTEX(twa_chrdev_mutex); 1081da177e4SLinus Torvalds static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT]; 1091da177e4SLinus Torvalds static unsigned int twa_device_extension_count; 1101da177e4SLinus Torvalds static int twa_major = -1; 1111da177e4SLinus Torvalds extern struct timezone sys_tz; 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds /* Module parameters */ 1144deedd84Sadam radford MODULE_AUTHOR ("LSI"); 1151da177e4SLinus Torvalds MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver"); 1161da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1171da177e4SLinus Torvalds MODULE_VERSION(TW_DRIVER_VERSION); 1181da177e4SLinus Torvalds 1193dabec71Sadam radford static int use_msi = 0; 1203dabec71Sadam radford module_param(use_msi, int, S_IRUGO); 1213dabec71Sadam radford MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0"); 1223dabec71Sadam radford 1231da177e4SLinus Torvalds /* Function prototypes */ 1241da177e4SLinus Torvalds static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header); 1251da177e4SLinus Torvalds static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id); 1261da177e4SLinus Torvalds static char *twa_aen_severity_lookup(unsigned char severity_code); 1271da177e4SLinus Torvalds static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id); 128f4927c45SArnd Bergmann static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 1291da177e4SLinus Torvalds static int twa_chrdev_open(struct inode *inode, struct file *file); 1301da177e4SLinus Torvalds static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host); 1311da177e4SLinus Torvalds static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id); 1321da177e4SLinus Torvalds static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id); 1331da177e4SLinus Torvalds static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits, 1341da177e4SLinus Torvalds u32 set_features, unsigned short current_fw_srl, 1351da177e4SLinus Torvalds unsigned short current_fw_arch_id, 1361da177e4SLinus Torvalds unsigned short current_fw_branch, 1371da177e4SLinus Torvalds unsigned short current_fw_build, 1381da177e4SLinus Torvalds unsigned short *fw_on_ctlr_srl, 1391da177e4SLinus Torvalds unsigned short *fw_on_ctlr_arch_id, 1401da177e4SLinus Torvalds unsigned short *fw_on_ctlr_branch, 1411da177e4SLinus Torvalds unsigned short *fw_on_ctlr_build, 1421da177e4SLinus Torvalds u32 *init_connect_result); 1430e78d158Sadam radford static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length); 1441da177e4SLinus Torvalds static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds); 1451da177e4SLinus Torvalds static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds); 1461da177e4SLinus Torvalds static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal); 1470e78d158Sadam radford static int twa_reset_device_extension(TW_Device_Extension *tw_dev); 1481da177e4SLinus Torvalds static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset); 1491da177e4SLinus Torvalds static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg); 1501da177e4SLinus Torvalds static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id); 1511da177e4SLinus Torvalds static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code); 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds /* Functions */ 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds /* Show some statistics about the card */ 156ee959b00STony Jones static ssize_t twa_show_stats(struct device *dev, 157ee959b00STony Jones struct device_attribute *attr, char *buf) 1581da177e4SLinus Torvalds { 159ee959b00STony Jones struct Scsi_Host *host = class_to_shost(dev); 1601da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 1611da177e4SLinus Torvalds unsigned long flags = 0; 1621da177e4SLinus Torvalds ssize_t len; 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 1651da177e4SLinus Torvalds len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n" 1661da177e4SLinus Torvalds "Current commands posted: %4d\n" 1671da177e4SLinus Torvalds "Max commands posted: %4d\n" 1681da177e4SLinus Torvalds "Current pending commands: %4d\n" 1691da177e4SLinus Torvalds "Max pending commands: %4d\n" 1701da177e4SLinus Torvalds "Last sgl length: %4d\n" 1711da177e4SLinus Torvalds "Max sgl length: %4d\n" 1721da177e4SLinus Torvalds "Last sector count: %4d\n" 1731da177e4SLinus Torvalds "Max sector count: %4d\n" 1741da177e4SLinus Torvalds "SCSI Host Resets: %4d\n" 1751da177e4SLinus Torvalds "AEN's: %4d\n", 1761da177e4SLinus Torvalds TW_DRIVER_VERSION, 1771da177e4SLinus Torvalds tw_dev->posted_request_count, 1781da177e4SLinus Torvalds tw_dev->max_posted_request_count, 1791da177e4SLinus Torvalds tw_dev->pending_request_count, 1801da177e4SLinus Torvalds tw_dev->max_pending_request_count, 1811da177e4SLinus Torvalds tw_dev->sgl_entries, 1821da177e4SLinus Torvalds tw_dev->max_sgl_entries, 1831da177e4SLinus Torvalds tw_dev->sector_count, 1841da177e4SLinus Torvalds tw_dev->max_sector_count, 1851da177e4SLinus Torvalds tw_dev->num_resets, 1861da177e4SLinus Torvalds tw_dev->aen_count); 1871da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1881da177e4SLinus Torvalds return len; 1891da177e4SLinus Torvalds } /* End twa_show_stats() */ 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds /* Create sysfs 'stats' entry */ 192ee959b00STony Jones static struct device_attribute twa_host_stats_attr = { 1931da177e4SLinus Torvalds .attr = { 1941da177e4SLinus Torvalds .name = "stats", 1951da177e4SLinus Torvalds .mode = S_IRUGO, 1961da177e4SLinus Torvalds }, 1971da177e4SLinus Torvalds .show = twa_show_stats 1981da177e4SLinus Torvalds }; 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* Host attributes initializer */ 201ee959b00STony Jones static struct device_attribute *twa_host_attrs[] = { 2021da177e4SLinus Torvalds &twa_host_stats_attr, 2031da177e4SLinus Torvalds NULL, 2041da177e4SLinus Torvalds }; 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds /* File operations struct for character device */ 20700977a59SArjan van de Ven static const struct file_operations twa_fops = { 2081da177e4SLinus Torvalds .owner = THIS_MODULE, 209f4927c45SArnd Bergmann .unlocked_ioctl = twa_chrdev_ioctl, 2101da177e4SLinus Torvalds .open = twa_chrdev_open, 2116038f373SArnd Bergmann .release = NULL, 2126038f373SArnd Bergmann .llseek = noop_llseek, 2131da177e4SLinus Torvalds }; 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds /* This function will complete an aen request from the isr */ 2161da177e4SLinus Torvalds static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id) 2171da177e4SLinus Torvalds { 2181da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 2191da177e4SLinus Torvalds TW_Command *command_packet; 2201da177e4SLinus Torvalds TW_Command_Apache_Header *header; 2211da177e4SLinus Torvalds unsigned short aen; 2221da177e4SLinus Torvalds int retval = 1; 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 2251da177e4SLinus Torvalds tw_dev->posted_request_count--; 22675913d9bSadam radford aen = le16_to_cpu(header->status_block.error); 2271da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 2281da177e4SLinus Torvalds command_packet = &full_command_packet->command.oldcommand; 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds /* First check for internal completion of set param for time sync */ 2311da177e4SLinus Torvalds if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) { 2321da177e4SLinus Torvalds /* Keep reading the queue in case there are more aen's */ 2331da177e4SLinus Torvalds if (twa_aen_read_queue(tw_dev, request_id)) 2341da177e4SLinus Torvalds goto out2; 2351da177e4SLinus Torvalds else { 2361da177e4SLinus Torvalds retval = 0; 2371da177e4SLinus Torvalds goto out; 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds switch (aen) { 2421da177e4SLinus Torvalds case TW_AEN_QUEUE_EMPTY: 2431da177e4SLinus Torvalds /* Quit reading the queue if this is the last one */ 2441da177e4SLinus Torvalds break; 2451da177e4SLinus Torvalds case TW_AEN_SYNC_TIME_WITH_HOST: 2461da177e4SLinus Torvalds twa_aen_sync_time(tw_dev, request_id); 2471da177e4SLinus Torvalds retval = 0; 2481da177e4SLinus Torvalds goto out; 2491da177e4SLinus Torvalds default: 2501da177e4SLinus Torvalds twa_aen_queue_event(tw_dev, header); 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds /* If there are more aen's, keep reading the queue */ 2531da177e4SLinus Torvalds if (twa_aen_read_queue(tw_dev, request_id)) 2541da177e4SLinus Torvalds goto out2; 2551da177e4SLinus Torvalds else { 2561da177e4SLinus Torvalds retval = 0; 2571da177e4SLinus Torvalds goto out; 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds } 2601da177e4SLinus Torvalds retval = 0; 2611da177e4SLinus Torvalds out2: 2621da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 2631da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 2641da177e4SLinus Torvalds clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 2651da177e4SLinus Torvalds out: 2661da177e4SLinus Torvalds return retval; 2671da177e4SLinus Torvalds } /* End twa_aen_complete() */ 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds /* This function will drain aen queue */ 2701da177e4SLinus Torvalds static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset) 2711da177e4SLinus Torvalds { 2721da177e4SLinus Torvalds int request_id = 0; 2731da177e4SLinus Torvalds char cdb[TW_MAX_CDB_LEN]; 2741da177e4SLinus Torvalds TW_SG_Entry sglist[1]; 2751da177e4SLinus Torvalds int finished = 0, count = 0; 2761da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 2771da177e4SLinus Torvalds TW_Command_Apache_Header *header; 2781da177e4SLinus Torvalds unsigned short aen; 2791da177e4SLinus Torvalds int first_reset = 0, queue = 0, retval = 1; 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds if (no_check_reset) 2821da177e4SLinus Torvalds first_reset = 0; 2831da177e4SLinus Torvalds else 2841da177e4SLinus Torvalds first_reset = 1; 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 2871da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds /* Initialize cdb */ 2901da177e4SLinus Torvalds memset(&cdb, 0, TW_MAX_CDB_LEN); 2911da177e4SLinus Torvalds cdb[0] = REQUEST_SENSE; /* opcode */ 2921da177e4SLinus Torvalds cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds /* Initialize sglist */ 2951da177e4SLinus Torvalds memset(&sglist, 0, sizeof(TW_SG_Entry)); 2961da177e4SLinus Torvalds sglist[0].length = TW_SECTOR_SIZE; 2971da177e4SLinus Torvalds sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 2981da177e4SLinus Torvalds 2991da177e4SLinus Torvalds if (sglist[0].address & TW_ALIGNMENT_9000_SGL) { 3001da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain"); 3011da177e4SLinus Torvalds goto out; 3021da177e4SLinus Torvalds } 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds /* Mark internal command */ 3051da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds do { 3081da177e4SLinus Torvalds /* Send command to the board */ 3091da177e4SLinus Torvalds if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 3101da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense"); 3111da177e4SLinus Torvalds goto out; 3121da177e4SLinus Torvalds } 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds /* Now poll for completion */ 3151da177e4SLinus Torvalds if (twa_poll_response(tw_dev, request_id, 30)) { 3161da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue"); 3171da177e4SLinus Torvalds tw_dev->posted_request_count--; 3181da177e4SLinus Torvalds goto out; 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds tw_dev->posted_request_count--; 3221da177e4SLinus Torvalds header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 32375913d9bSadam radford aen = le16_to_cpu(header->status_block.error); 3241da177e4SLinus Torvalds queue = 0; 3251da177e4SLinus Torvalds count++; 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds switch (aen) { 3281da177e4SLinus Torvalds case TW_AEN_QUEUE_EMPTY: 3291da177e4SLinus Torvalds if (first_reset != 1) 3301da177e4SLinus Torvalds goto out; 3311da177e4SLinus Torvalds else 3321da177e4SLinus Torvalds finished = 1; 3331da177e4SLinus Torvalds break; 3341da177e4SLinus Torvalds case TW_AEN_SOFT_RESET: 3351da177e4SLinus Torvalds if (first_reset == 0) 3361da177e4SLinus Torvalds first_reset = 1; 3371da177e4SLinus Torvalds else 3381da177e4SLinus Torvalds queue = 1; 3391da177e4SLinus Torvalds break; 3401da177e4SLinus Torvalds case TW_AEN_SYNC_TIME_WITH_HOST: 3411da177e4SLinus Torvalds break; 3421da177e4SLinus Torvalds default: 3431da177e4SLinus Torvalds queue = 1; 3441da177e4SLinus Torvalds } 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds /* Now queue an event info */ 3471da177e4SLinus Torvalds if (queue) 3481da177e4SLinus Torvalds twa_aen_queue_event(tw_dev, header); 3491da177e4SLinus Torvalds } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN)); 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds if (count == TW_MAX_AEN_DRAIN) 3521da177e4SLinus Torvalds goto out; 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds retval = 0; 3551da177e4SLinus Torvalds out: 3561da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_INITIAL; 3571da177e4SLinus Torvalds return retval; 3581da177e4SLinus Torvalds } /* End twa_aen_drain_queue() */ 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds /* This function will queue an event */ 3611da177e4SLinus Torvalds static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header) 3621da177e4SLinus Torvalds { 3631da177e4SLinus Torvalds u32 local_time; 3641da177e4SLinus Torvalds struct timeval time; 3651da177e4SLinus Torvalds TW_Event *event; 3661da177e4SLinus Torvalds unsigned short aen; 3671da177e4SLinus Torvalds char host[16]; 3681da177e4SLinus Torvalds char *error_str; 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds tw_dev->aen_count++; 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds /* Fill out event info */ 3731da177e4SLinus Torvalds event = tw_dev->event_queue[tw_dev->error_index]; 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds /* Check for clobber */ 3761da177e4SLinus Torvalds host[0] = '\0'; 3771da177e4SLinus Torvalds if (tw_dev->host) { 3781da177e4SLinus Torvalds sprintf(host, " scsi%d:", tw_dev->host->host_no); 3791da177e4SLinus Torvalds if (event->retrieved == TW_AEN_NOT_RETRIEVED) 3801da177e4SLinus Torvalds tw_dev->aen_clobber = 1; 3811da177e4SLinus Torvalds } 3821da177e4SLinus Torvalds 38375913d9bSadam radford aen = le16_to_cpu(header->status_block.error); 3841da177e4SLinus Torvalds memset(event, 0, sizeof(TW_Event)); 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds event->severity = TW_SEV_OUT(header->status_block.severity__reserved); 3871da177e4SLinus Torvalds do_gettimeofday(&time); 3881da177e4SLinus Torvalds local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60)); 3891da177e4SLinus Torvalds event->time_stamp_sec = local_time; 3901da177e4SLinus Torvalds event->aen_code = aen; 3911da177e4SLinus Torvalds event->retrieved = TW_AEN_NOT_RETRIEVED; 3921da177e4SLinus Torvalds event->sequence_id = tw_dev->error_sequence_id; 3931da177e4SLinus Torvalds tw_dev->error_sequence_id++; 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds /* Check for embedded error string */ 3961da177e4SLinus Torvalds error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]); 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0'; 3991da177e4SLinus Torvalds event->parameter_len = strlen(header->err_specific_desc); 40075913d9bSadam radford memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str)))); 4011da177e4SLinus Torvalds if (event->severity != TW_AEN_SEVERITY_DEBUG) 4021da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n", 4031da177e4SLinus Torvalds host, 4041da177e4SLinus Torvalds twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)), 4051da177e4SLinus Torvalds TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, 4061da177e4SLinus Torvalds error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str, 4071da177e4SLinus Torvalds header->err_specific_desc); 4081da177e4SLinus Torvalds else 4091da177e4SLinus Torvalds tw_dev->aen_count--; 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds if ((tw_dev->error_index + 1) == TW_Q_LENGTH) 4121da177e4SLinus Torvalds tw_dev->event_queue_wrapped = 1; 4131da177e4SLinus Torvalds tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH; 4141da177e4SLinus Torvalds } /* End twa_aen_queue_event() */ 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds /* This function will read the aen queue from the isr */ 4171da177e4SLinus Torvalds static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id) 4181da177e4SLinus Torvalds { 4191da177e4SLinus Torvalds char cdb[TW_MAX_CDB_LEN]; 4201da177e4SLinus Torvalds TW_SG_Entry sglist[1]; 4211da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 4221da177e4SLinus Torvalds int retval = 1; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 4251da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 4261da177e4SLinus Torvalds 4271da177e4SLinus Torvalds /* Initialize cdb */ 4281da177e4SLinus Torvalds memset(&cdb, 0, TW_MAX_CDB_LEN); 4291da177e4SLinus Torvalds cdb[0] = REQUEST_SENSE; /* opcode */ 4301da177e4SLinus Torvalds cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds /* Initialize sglist */ 4331da177e4SLinus Torvalds memset(&sglist, 0, sizeof(TW_SG_Entry)); 4341da177e4SLinus Torvalds sglist[0].length = TW_SECTOR_SIZE; 4351da177e4SLinus Torvalds sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds /* Mark internal command */ 4381da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds /* Now post the command packet */ 4411da177e4SLinus Torvalds if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 4421da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue"); 4431da177e4SLinus Torvalds goto out; 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds retval = 0; 4461da177e4SLinus Torvalds out: 4471da177e4SLinus Torvalds return retval; 4481da177e4SLinus Torvalds } /* End twa_aen_read_queue() */ 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds /* This function will look up an AEN severity string */ 4511da177e4SLinus Torvalds static char *twa_aen_severity_lookup(unsigned char severity_code) 4521da177e4SLinus Torvalds { 4531da177e4SLinus Torvalds char *retval = NULL; 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) || 4561da177e4SLinus Torvalds (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG)) 4571da177e4SLinus Torvalds goto out; 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds retval = twa_aen_severity_table[severity_code]; 4601da177e4SLinus Torvalds out: 4611da177e4SLinus Torvalds return retval; 4621da177e4SLinus Torvalds } /* End twa_aen_severity_lookup() */ 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds /* This function will sync firmware time with the host time */ 4651da177e4SLinus Torvalds static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id) 4661da177e4SLinus Torvalds { 4671da177e4SLinus Torvalds u32 schedulertime; 4681da177e4SLinus Torvalds struct timeval utc; 4691da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 4701da177e4SLinus Torvalds TW_Command *command_packet; 4711da177e4SLinus Torvalds TW_Param_Apache *param; 4721da177e4SLinus Torvalds u32 local_time; 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds /* Fill out the command packet */ 4751da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 4761da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 4771da177e4SLinus Torvalds command_packet = &full_command_packet->command.oldcommand; 4781da177e4SLinus Torvalds command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM); 4791da177e4SLinus Torvalds command_packet->request_id = request_id; 48075913d9bSadam radford command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]); 48175913d9bSadam radford command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE); 4821da177e4SLinus Torvalds command_packet->size = TW_COMMAND_SIZE; 48375913d9bSadam radford command_packet->byte6_offset.parameter_count = cpu_to_le16(1); 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds /* Setup the param */ 4861da177e4SLinus Torvalds param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 4871da177e4SLinus Torvalds memset(param, 0, TW_SECTOR_SIZE); 48875913d9bSadam radford param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */ 48975913d9bSadam radford param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */ 49075913d9bSadam radford param->parameter_size_bytes = cpu_to_le16(4); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds /* Convert system time in UTC to local time seconds since last 4931da177e4SLinus Torvalds Sunday 12:00AM */ 4941da177e4SLinus Torvalds do_gettimeofday(&utc); 4951da177e4SLinus Torvalds local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60)); 4961da177e4SLinus Torvalds schedulertime = local_time - (3 * 86400); 49775913d9bSadam radford schedulertime = cpu_to_le32(schedulertime % 604800); 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds memcpy(param->data, &schedulertime, sizeof(u32)); 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds /* Mark internal command */ 5021da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds /* Now post the command */ 5051da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 5061da177e4SLinus Torvalds } /* End twa_aen_sync_time() */ 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds /* This function will allocate memory and check if it is correctly aligned */ 5091da177e4SLinus Torvalds static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) 5101da177e4SLinus Torvalds { 5111da177e4SLinus Torvalds int i; 5121da177e4SLinus Torvalds dma_addr_t dma_handle; 5131da177e4SLinus Torvalds unsigned long *cpu_addr; 5141da177e4SLinus Torvalds int retval = 1; 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle); 5171da177e4SLinus Torvalds if (!cpu_addr) { 5181da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed"); 5191da177e4SLinus Torvalds goto out; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) { 5231da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory"); 5241da177e4SLinus Torvalds pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle); 5251da177e4SLinus Torvalds goto out; 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds memset(cpu_addr, 0, size*TW_Q_LENGTH); 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 5311da177e4SLinus Torvalds switch(which) { 5321da177e4SLinus Torvalds case 0: 5331da177e4SLinus Torvalds tw_dev->command_packet_phys[i] = dma_handle+(i*size); 5341da177e4SLinus Torvalds tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size)); 5351da177e4SLinus Torvalds break; 5361da177e4SLinus Torvalds case 1: 5371da177e4SLinus Torvalds tw_dev->generic_buffer_phys[i] = dma_handle+(i*size); 5381da177e4SLinus Torvalds tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 5391da177e4SLinus Torvalds break; 5401da177e4SLinus Torvalds } 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds retval = 0; 5431da177e4SLinus Torvalds out: 5441da177e4SLinus Torvalds return retval; 5451da177e4SLinus Torvalds } /* End twa_allocate_memory() */ 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds /* This function will check the status register for unexpected bits */ 5481da177e4SLinus Torvalds static int twa_check_bits(u32 status_reg_value) 5491da177e4SLinus Torvalds { 5501da177e4SLinus Torvalds int retval = 1; 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) 5531da177e4SLinus Torvalds goto out; 5541da177e4SLinus Torvalds if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) 5551da177e4SLinus Torvalds goto out; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds retval = 0; 5581da177e4SLinus Torvalds out: 5591da177e4SLinus Torvalds return retval; 5601da177e4SLinus Torvalds } /* End twa_check_bits() */ 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds /* This function will check the srl and decide if we are compatible */ 5631da177e4SLinus Torvalds static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed) 5641da177e4SLinus Torvalds { 5651da177e4SLinus Torvalds int retval = 1; 5661da177e4SLinus Torvalds unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0; 5671da177e4SLinus Torvalds unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0; 5681da177e4SLinus Torvalds u32 init_connect_result = 0; 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS, 5711da177e4SLinus Torvalds TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL, 5721da177e4SLinus Torvalds TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH, 5731da177e4SLinus Torvalds TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl, 5741da177e4SLinus Torvalds &fw_on_ctlr_arch_id, &fw_on_ctlr_branch, 5751da177e4SLinus Torvalds &fw_on_ctlr_build, &init_connect_result)) { 5761da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL"); 5771da177e4SLinus Torvalds goto out; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds 5804039c30eSadam radford tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl; 5814039c30eSadam radford tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch; 5824039c30eSadam radford tw_dev->tw_compat_info.working_build = fw_on_ctlr_build; 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds /* Try base mode compatibility */ 5851da177e4SLinus Torvalds if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) { 5861da177e4SLinus Torvalds if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS, 5871da177e4SLinus Torvalds TW_EXTENDED_INIT_CONNECT, 5881da177e4SLinus Torvalds TW_BASE_FW_SRL, TW_9000_ARCH_ID, 5891da177e4SLinus Torvalds TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD, 5901da177e4SLinus Torvalds &fw_on_ctlr_srl, &fw_on_ctlr_arch_id, 5911da177e4SLinus Torvalds &fw_on_ctlr_branch, &fw_on_ctlr_build, 5921da177e4SLinus Torvalds &init_connect_result)) { 5931da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL"); 5941da177e4SLinus Torvalds goto out; 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) { 5971da177e4SLinus Torvalds if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) { 5981da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware"); 5991da177e4SLinus Torvalds } else { 6001da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver"); 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds goto out; 6031da177e4SLinus Torvalds } 6044039c30eSadam radford tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL; 6054039c30eSadam radford tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH; 6064039c30eSadam radford tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD; 6071da177e4SLinus Torvalds } 6084039c30eSadam radford 6094039c30eSadam radford /* Load rest of compatibility struct */ 6102195d969SRickard Strandqvist strlcpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, 6112195d969SRickard Strandqvist sizeof(tw_dev->tw_compat_info.driver_version)); 6124039c30eSadam radford tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL; 6134039c30eSadam radford tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH; 6144039c30eSadam radford tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD; 6154039c30eSadam radford tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL; 6164039c30eSadam radford tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH; 6174039c30eSadam radford tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD; 6184039c30eSadam radford tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl; 6194039c30eSadam radford tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch; 6204039c30eSadam radford tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build; 6214039c30eSadam radford 6221da177e4SLinus Torvalds retval = 0; 6231da177e4SLinus Torvalds out: 6241da177e4SLinus Torvalds return retval; 6251da177e4SLinus Torvalds } /* End twa_check_srl() */ 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* This function handles ioctl for the character device */ 628f4927c45SArnd Bergmann static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 6291da177e4SLinus Torvalds { 630496ad9aaSAl Viro struct inode *inode = file_inode(file); 6311da177e4SLinus Torvalds long timeout; 6321da177e4SLinus Torvalds unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0; 6331da177e4SLinus Torvalds dma_addr_t dma_handle; 6341da177e4SLinus Torvalds int request_id = 0; 6351da177e4SLinus Torvalds unsigned int sequence_id = 0; 6361da177e4SLinus Torvalds unsigned char event_index, start_index; 6371da177e4SLinus Torvalds TW_Ioctl_Driver_Command driver_command; 6381da177e4SLinus Torvalds TW_Ioctl_Buf_Apache *tw_ioctl; 6391da177e4SLinus Torvalds TW_Lock *tw_lock; 6401da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 6411da177e4SLinus Torvalds TW_Compatibility_Info *tw_compat_info; 6421da177e4SLinus Torvalds TW_Event *event; 6431da177e4SLinus Torvalds struct timeval current_time; 6441da177e4SLinus Torvalds u32 current_time_ms; 6451da177e4SLinus Torvalds TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)]; 6461da177e4SLinus Torvalds int retval = TW_IOCTL_ERROR_OS_EFAULT; 6471da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 6481da177e4SLinus Torvalds 649c45d15d2SArnd Bergmann mutex_lock(&twa_chrdev_mutex); 650f4927c45SArnd Bergmann 6511da177e4SLinus Torvalds /* Only let one of these through at a time */ 652a12e25bdSJes Sorensen if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) { 6531da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_EINTR; 6541da177e4SLinus Torvalds goto out; 6551da177e4SLinus Torvalds } 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds /* First copy down the driver command */ 6581da177e4SLinus Torvalds if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command))) 6591da177e4SLinus Torvalds goto out2; 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds /* Check data buffer size */ 6624039c30eSadam radford if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) { 6631da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_EINVAL; 6641da177e4SLinus Torvalds goto out2; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds /* Hardware can only do multiple of 512 byte transfers */ 6681da177e4SLinus Torvalds data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511; 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds /* Now allocate ioctl buf memory */ 6711da177e4SLinus Torvalds cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, &dma_handle, GFP_KERNEL); 6721da177e4SLinus Torvalds if (!cpu_addr) { 6731da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_ENOMEM; 6741da177e4SLinus Torvalds goto out2; 6751da177e4SLinus Torvalds } 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds /* Now copy down the entire ioctl */ 6801da177e4SLinus Torvalds if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1)) 6811da177e4SLinus Torvalds goto out3; 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds /* See which ioctl we are doing */ 6841da177e4SLinus Torvalds switch (cmd) { 6851da177e4SLinus Torvalds case TW_IOCTL_FIRMWARE_PASS_THROUGH: 6861da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 6871da177e4SLinus Torvalds twa_get_request_id(tw_dev, &request_id); 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds /* Flag internal command */ 6901da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds /* Flag chrdev ioctl */ 6931da177e4SLinus Torvalds tw_dev->chrdev_request_id = request_id; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds full_command_packet = &tw_ioctl->firmware_command; 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds /* Load request id and sglist for both command types */ 6980e78d158Sadam radford twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted); 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full)); 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds /* Now post the command packet to the controller */ 7031da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 7041da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 7051da177e4SLinus Torvalds 7061da177e4SLinus Torvalds timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds /* Now wait for command to complete */ 7091da177e4SLinus Torvalds timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout); 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds /* We timed out, and didn't get an interrupt */ 7121da177e4SLinus Torvalds if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) { 7131da177e4SLinus Torvalds /* Now we need to reset the board */ 7141da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n", 7150e78d158Sadam radford tw_dev->host->host_no, TW_DRIVER, 0x37, 7161da177e4SLinus Torvalds cmd); 7171da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_EIO; 7180e78d158Sadam radford twa_reset_device_extension(tw_dev); 7191da177e4SLinus Torvalds goto out3; 7201da177e4SLinus Torvalds } 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds /* Now copy in the command packet response */ 7231da177e4SLinus Torvalds memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full)); 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds /* Now complete the io */ 7261da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 7271da177e4SLinus Torvalds tw_dev->posted_request_count--; 7281da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 7291da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 7301da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 7311da177e4SLinus Torvalds break; 7321da177e4SLinus Torvalds case TW_IOCTL_GET_COMPATIBILITY_INFO: 7331da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 73406fe9fb4SDirk Hohndel /* Copy compatibility struct into ioctl data buffer */ 7351da177e4SLinus Torvalds tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer; 7364039c30eSadam radford memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info)); 7371da177e4SLinus Torvalds break; 7381da177e4SLinus Torvalds case TW_IOCTL_GET_LAST_EVENT: 7391da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 7401da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 7411da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 7421da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 7431da177e4SLinus Torvalds } else 7441da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7451da177e4SLinus Torvalds } else { 7461da177e4SLinus Torvalds if (!tw_dev->error_index) { 7471da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7481da177e4SLinus Torvalds break; 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7511da177e4SLinus Torvalds } 7521da177e4SLinus Torvalds event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH; 7531da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 7541da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 7551da177e4SLinus Torvalds break; 7561da177e4SLinus Torvalds case TW_IOCTL_GET_FIRST_EVENT: 7571da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 7581da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 7591da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 7601da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 7611da177e4SLinus Torvalds } else 7621da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7631da177e4SLinus Torvalds event_index = tw_dev->error_index; 7641da177e4SLinus Torvalds } else { 7651da177e4SLinus Torvalds if (!tw_dev->error_index) { 7661da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7671da177e4SLinus Torvalds break; 7681da177e4SLinus Torvalds } 7691da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7701da177e4SLinus Torvalds event_index = 0; 7711da177e4SLinus Torvalds } 7721da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 7731da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 7741da177e4SLinus Torvalds break; 7751da177e4SLinus Torvalds case TW_IOCTL_GET_NEXT_EVENT: 7761da177e4SLinus Torvalds event = (TW_Event *)tw_ioctl->data_buffer; 7771da177e4SLinus Torvalds sequence_id = event->sequence_id; 7781da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 7811da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 7821da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 7831da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 7841da177e4SLinus Torvalds } 7851da177e4SLinus Torvalds start_index = tw_dev->error_index; 7861da177e4SLinus Torvalds } else { 7871da177e4SLinus Torvalds if (!tw_dev->error_index) { 7881da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7891da177e4SLinus Torvalds break; 7901da177e4SLinus Torvalds } 7911da177e4SLinus Torvalds start_index = 0; 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH; 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) { 7961da177e4SLinus Torvalds if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER) 7971da177e4SLinus Torvalds tw_dev->aen_clobber = 1; 7981da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7991da177e4SLinus Torvalds break; 8001da177e4SLinus Torvalds } 8011da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 8021da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 8031da177e4SLinus Torvalds break; 8041da177e4SLinus Torvalds case TW_IOCTL_GET_PREVIOUS_EVENT: 8051da177e4SLinus Torvalds event = (TW_Event *)tw_ioctl->data_buffer; 8061da177e4SLinus Torvalds sequence_id = event->sequence_id; 8071da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 8101da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 8111da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 8121da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds start_index = tw_dev->error_index; 8151da177e4SLinus Torvalds } else { 8161da177e4SLinus Torvalds if (!tw_dev->error_index) { 8171da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 8181da177e4SLinus Torvalds break; 8191da177e4SLinus Torvalds } 8201da177e4SLinus Torvalds start_index = 0; 8211da177e4SLinus Torvalds } 8221da177e4SLinus Torvalds event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH; 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) { 8251da177e4SLinus Torvalds if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER) 8261da177e4SLinus Torvalds tw_dev->aen_clobber = 1; 8271da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 8281da177e4SLinus Torvalds break; 8291da177e4SLinus Torvalds } 8301da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 8311da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 8321da177e4SLinus Torvalds break; 8331da177e4SLinus Torvalds case TW_IOCTL_GET_LOCK: 8341da177e4SLinus Torvalds tw_lock = (TW_Lock *)tw_ioctl->data_buffer; 8351da177e4SLinus Torvalds do_gettimeofday(¤t_time); 8361da177e4SLinus Torvalds current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000); 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) { 8391da177e4SLinus Torvalds tw_dev->ioctl_sem_lock = 1; 8401da177e4SLinus Torvalds tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec; 8411da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 8421da177e4SLinus Torvalds tw_lock->time_remaining_msec = tw_lock->timeout_msec; 8431da177e4SLinus Torvalds } else { 8441da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED; 8451da177e4SLinus Torvalds tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms; 8461da177e4SLinus Torvalds } 8471da177e4SLinus Torvalds break; 8481da177e4SLinus Torvalds case TW_IOCTL_RELEASE_LOCK: 8491da177e4SLinus Torvalds if (tw_dev->ioctl_sem_lock == 1) { 8501da177e4SLinus Torvalds tw_dev->ioctl_sem_lock = 0; 8511da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 8521da177e4SLinus Torvalds } else { 8531da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED; 8541da177e4SLinus Torvalds } 8551da177e4SLinus Torvalds break; 8561da177e4SLinus Torvalds default: 8571da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_ENOTTY; 8581da177e4SLinus Torvalds goto out3; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds /* Now copy the entire response to userspace */ 8621da177e4SLinus Torvalds if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0) 8631da177e4SLinus Torvalds retval = 0; 8641da177e4SLinus Torvalds out3: 8651da177e4SLinus Torvalds /* Now free ioctl buf memory */ 8661da177e4SLinus Torvalds dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle); 8671da177e4SLinus Torvalds out2: 868a12e25bdSJes Sorensen mutex_unlock(&tw_dev->ioctl_lock); 8691da177e4SLinus Torvalds out: 870c45d15d2SArnd Bergmann mutex_unlock(&twa_chrdev_mutex); 8711da177e4SLinus Torvalds return retval; 8721da177e4SLinus Torvalds } /* End twa_chrdev_ioctl() */ 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds /* This function handles open for the character device */ 875f2b9857eSJonathan Corbet /* NOTE that this function will race with remove. */ 8761da177e4SLinus Torvalds static int twa_chrdev_open(struct inode *inode, struct file *file) 8771da177e4SLinus Torvalds { 8781da177e4SLinus Torvalds unsigned int minor_number; 8791da177e4SLinus Torvalds int retval = TW_IOCTL_ERROR_OS_ENODEV; 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds minor_number = iminor(inode); 8821da177e4SLinus Torvalds if (minor_number >= twa_device_extension_count) 8831da177e4SLinus Torvalds goto out; 8841da177e4SLinus Torvalds retval = 0; 8851da177e4SLinus Torvalds out: 8861da177e4SLinus Torvalds return retval; 8871da177e4SLinus Torvalds } /* End twa_chrdev_open() */ 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds /* This function will print readable messages from status register errors */ 8901da177e4SLinus Torvalds static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value) 8911da177e4SLinus Torvalds { 8921da177e4SLinus Torvalds int retval = 1; 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds /* Check for various error conditions and handle them appropriately */ 8951da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) { 8961da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing"); 8971da177e4SLinus Torvalds writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_PCI_ABORT) { 9011da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing"); 9021da177e4SLinus Torvalds writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev)); 9031da177e4SLinus Torvalds pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT); 9041da177e4SLinus Torvalds } 9051da177e4SLinus Torvalds 9061da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_QUEUE_ERROR) { 9070e78d158Sadam radford if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) && 9080e78d158Sadam radford (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) || 9090e78d158Sadam radford (!test_bit(TW_IN_RESET, &tw_dev->flags))) 9101da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing"); 9111da177e4SLinus Torvalds writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 9121da177e4SLinus Torvalds } 9131da177e4SLinus Torvalds 9141da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) { 9151da177e4SLinus Torvalds if (tw_dev->reset_print == 0) { 9161da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing"); 9171da177e4SLinus Torvalds tw_dev->reset_print = 1; 9181da177e4SLinus Torvalds } 9191da177e4SLinus Torvalds goto out; 9201da177e4SLinus Torvalds } 9211da177e4SLinus Torvalds retval = 0; 9221da177e4SLinus Torvalds out: 9231da177e4SLinus Torvalds return retval; 9241da177e4SLinus Torvalds } /* End twa_decode_bits() */ 9251da177e4SLinus Torvalds 9261da177e4SLinus Torvalds /* This function will empty the response queue */ 9271da177e4SLinus Torvalds static int twa_empty_response_queue(TW_Device_Extension *tw_dev) 9281da177e4SLinus Torvalds { 9291da177e4SLinus Torvalds u32 status_reg_value, response_que_value; 9301da177e4SLinus Torvalds int count = 0, retval = 1; 9311da177e4SLinus Torvalds 9321da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) { 9351da177e4SLinus Torvalds response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 9361da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 9371da177e4SLinus Torvalds count++; 9381da177e4SLinus Torvalds } 9391da177e4SLinus Torvalds if (count == TW_MAX_RESPONSE_DRAIN) 9401da177e4SLinus Torvalds goto out; 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds retval = 0; 9431da177e4SLinus Torvalds out: 9441da177e4SLinus Torvalds return retval; 9451da177e4SLinus Torvalds } /* End twa_empty_response_queue() */ 9461da177e4SLinus Torvalds 94749bfd8dbSadam radford /* This function will clear the pchip/response queue on 9550SX */ 94849bfd8dbSadam radford static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev) 94949bfd8dbSadam radford { 95075913d9bSadam radford u32 response_que_value = 0; 95175913d9bSadam radford unsigned long before; 95275913d9bSadam radford int retval = 1; 95349bfd8dbSadam radford 9540e78d158Sadam radford if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) { 95575913d9bSadam radford before = jiffies; 95675913d9bSadam radford while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) { 95749bfd8dbSadam radford response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev)); 9584039c30eSadam radford msleep(1); 95975913d9bSadam radford if (time_after(jiffies, before + HZ * 30)) 96075913d9bSadam radford goto out; 96175913d9bSadam radford } 96249bfd8dbSadam radford /* P-chip settle time */ 96349bfd8dbSadam radford msleep(500); 96449bfd8dbSadam radford retval = 0; 96549bfd8dbSadam radford } else 96649bfd8dbSadam radford retval = 0; 96749bfd8dbSadam radford out: 96849bfd8dbSadam radford return retval; 96949bfd8dbSadam radford } /* End twa_empty_response_queue_large() */ 97049bfd8dbSadam radford 9711da177e4SLinus Torvalds /* This function passes sense keys from firmware to scsi layer */ 9721da177e4SLinus Torvalds static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host) 9731da177e4SLinus Torvalds { 9741da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 9751da177e4SLinus Torvalds unsigned short error; 9761da177e4SLinus Torvalds int retval = 1; 9771da177e4SLinus Torvalds char *error_str; 9781da177e4SLinus Torvalds 9791da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds /* Check for embedded error string */ 9821da177e4SLinus Torvalds error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds /* Don't print error for Logical unit not supported during rollcall */ 98575913d9bSadam radford error = le16_to_cpu(full_command_packet->header.status_block.error); 9861da177e4SLinus Torvalds if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) { 9871da177e4SLinus Torvalds if (print_host) 9881da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n", 9891da177e4SLinus Torvalds tw_dev->host->host_no, 9901da177e4SLinus Torvalds TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 9911da177e4SLinus Torvalds full_command_packet->header.status_block.error, 9921da177e4SLinus Torvalds error_str[0] == '\0' ? 9931da177e4SLinus Torvalds twa_string_lookup(twa_error_table, 9941da177e4SLinus Torvalds full_command_packet->header.status_block.error) : error_str, 9951da177e4SLinus Torvalds full_command_packet->header.err_specific_desc); 9961da177e4SLinus Torvalds else 9971da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n", 9981da177e4SLinus Torvalds TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 9991da177e4SLinus Torvalds full_command_packet->header.status_block.error, 10001da177e4SLinus Torvalds error_str[0] == '\0' ? 10011da177e4SLinus Torvalds twa_string_lookup(twa_error_table, 10021da177e4SLinus Torvalds full_command_packet->header.status_block.error) : error_str, 10031da177e4SLinus Torvalds full_command_packet->header.err_specific_desc); 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds if (copy_sense) { 10071da177e4SLinus Torvalds memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH); 10081da177e4SLinus Torvalds tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1); 10091da177e4SLinus Torvalds retval = TW_ISR_DONT_RESULT; 10101da177e4SLinus Torvalds goto out; 10111da177e4SLinus Torvalds } 10121da177e4SLinus Torvalds retval = 0; 10131da177e4SLinus Torvalds out: 10141da177e4SLinus Torvalds return retval; 10151da177e4SLinus Torvalds } /* End twa_fill_sense() */ 10161da177e4SLinus Torvalds 10171da177e4SLinus Torvalds /* This function will free up device extension resources */ 10181da177e4SLinus Torvalds static void twa_free_device_extension(TW_Device_Extension *tw_dev) 10191da177e4SLinus Torvalds { 10201da177e4SLinus Torvalds if (tw_dev->command_packet_virt[0]) 10211da177e4SLinus Torvalds pci_free_consistent(tw_dev->tw_pci_dev, 10221da177e4SLinus Torvalds sizeof(TW_Command_Full)*TW_Q_LENGTH, 10231da177e4SLinus Torvalds tw_dev->command_packet_virt[0], 10241da177e4SLinus Torvalds tw_dev->command_packet_phys[0]); 10251da177e4SLinus Torvalds 10261da177e4SLinus Torvalds if (tw_dev->generic_buffer_virt[0]) 10271da177e4SLinus Torvalds pci_free_consistent(tw_dev->tw_pci_dev, 10281da177e4SLinus Torvalds TW_SECTOR_SIZE*TW_Q_LENGTH, 10291da177e4SLinus Torvalds tw_dev->generic_buffer_virt[0], 10301da177e4SLinus Torvalds tw_dev->generic_buffer_phys[0]); 10311da177e4SLinus Torvalds 10321da177e4SLinus Torvalds kfree(tw_dev->event_queue[0]); 10331da177e4SLinus Torvalds } /* End twa_free_device_extension() */ 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds /* This function will free a request id */ 10361da177e4SLinus Torvalds static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id) 10371da177e4SLinus Torvalds { 10381da177e4SLinus Torvalds tw_dev->free_queue[tw_dev->free_tail] = request_id; 10391da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_FINISHED; 10401da177e4SLinus Torvalds tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH; 10411da177e4SLinus Torvalds } /* End twa_free_request_id() */ 10421da177e4SLinus Torvalds 10437f927fccSAlexey Dobriyan /* This function will get parameter table entries from the firmware */ 10441da177e4SLinus Torvalds static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes) 10451da177e4SLinus Torvalds { 10461da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 10471da177e4SLinus Torvalds TW_Command *command_packet; 10481da177e4SLinus Torvalds TW_Param_Apache *param; 10491da177e4SLinus Torvalds void *retval = NULL; 10501da177e4SLinus Torvalds 10511da177e4SLinus Torvalds /* Setup the command packet */ 10521da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 10531da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 10541da177e4SLinus Torvalds command_packet = &full_command_packet->command.oldcommand; 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 10571da177e4SLinus Torvalds command_packet->size = TW_COMMAND_SIZE; 10581da177e4SLinus Torvalds command_packet->request_id = request_id; 105975913d9bSadam radford command_packet->byte6_offset.block_count = cpu_to_le16(1); 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds /* Now setup the param */ 10621da177e4SLinus Torvalds param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 10631da177e4SLinus Torvalds memset(param, 0, TW_SECTOR_SIZE); 106475913d9bSadam radford param->table_id = cpu_to_le16(table_id | 0x8000); 106575913d9bSadam radford param->parameter_id = cpu_to_le16(parameter_id); 106675913d9bSadam radford param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes); 10671da177e4SLinus Torvalds 10683dabec71Sadam radford command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]); 106975913d9bSadam radford command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE); 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds /* Post the command packet to the board */ 10721da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds /* Poll for completion */ 10751da177e4SLinus Torvalds if (twa_poll_response(tw_dev, request_id, 30)) 10761da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param") 10771da177e4SLinus Torvalds else 10781da177e4SLinus Torvalds retval = (void *)&(param->data[0]); 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds tw_dev->posted_request_count--; 10811da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_INITIAL; 10821da177e4SLinus Torvalds 10831da177e4SLinus Torvalds return retval; 10841da177e4SLinus Torvalds } /* End twa_get_param() */ 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds /* This function will assign an available request id */ 10871da177e4SLinus Torvalds static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id) 10881da177e4SLinus Torvalds { 10891da177e4SLinus Torvalds *request_id = tw_dev->free_queue[tw_dev->free_head]; 10901da177e4SLinus Torvalds tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH; 10911da177e4SLinus Torvalds tw_dev->state[*request_id] = TW_S_STARTED; 10921da177e4SLinus Torvalds } /* End twa_get_request_id() */ 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds /* This function will send an initconnection command to controller */ 10951da177e4SLinus Torvalds static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits, 10961da177e4SLinus Torvalds u32 set_features, unsigned short current_fw_srl, 10971da177e4SLinus Torvalds unsigned short current_fw_arch_id, 10981da177e4SLinus Torvalds unsigned short current_fw_branch, 10991da177e4SLinus Torvalds unsigned short current_fw_build, 11001da177e4SLinus Torvalds unsigned short *fw_on_ctlr_srl, 11011da177e4SLinus Torvalds unsigned short *fw_on_ctlr_arch_id, 11021da177e4SLinus Torvalds unsigned short *fw_on_ctlr_branch, 11031da177e4SLinus Torvalds unsigned short *fw_on_ctlr_build, 11041da177e4SLinus Torvalds u32 *init_connect_result) 11051da177e4SLinus Torvalds { 11061da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 11071da177e4SLinus Torvalds TW_Initconnect *tw_initconnect; 11081da177e4SLinus Torvalds int request_id = 0, retval = 1; 11091da177e4SLinus Torvalds 11101da177e4SLinus Torvalds /* Initialize InitConnection command packet */ 11111da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 11121da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 11131da177e4SLinus Torvalds full_command_packet->header.header_desc.size_header = 128; 11141da177e4SLinus Torvalds 11151da177e4SLinus Torvalds tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand; 11161da177e4SLinus Torvalds tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION); 11171da177e4SLinus Torvalds tw_initconnect->request_id = request_id; 111875913d9bSadam radford tw_initconnect->message_credits = cpu_to_le16(message_credits); 11191da177e4SLinus Torvalds tw_initconnect->features = set_features; 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds /* Turn on 64-bit sgl support if we need to */ 11221da177e4SLinus Torvalds tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0; 11231da177e4SLinus Torvalds 112475913d9bSadam radford tw_initconnect->features = cpu_to_le32(tw_initconnect->features); 112575913d9bSadam radford 11261da177e4SLinus Torvalds if (set_features & TW_EXTENDED_INIT_CONNECT) { 11271da177e4SLinus Torvalds tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED; 112875913d9bSadam radford tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl); 112975913d9bSadam radford tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id); 113075913d9bSadam radford tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch); 113175913d9bSadam radford tw_initconnect->fw_build = cpu_to_le16(current_fw_build); 11321da177e4SLinus Torvalds } else 11331da177e4SLinus Torvalds tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE; 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds /* Send command packet to the board */ 11361da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 11371da177e4SLinus Torvalds 11381da177e4SLinus Torvalds /* Poll for completion */ 11391da177e4SLinus Torvalds if (twa_poll_response(tw_dev, request_id, 30)) { 11401da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection"); 11411da177e4SLinus Torvalds } else { 11421da177e4SLinus Torvalds if (set_features & TW_EXTENDED_INIT_CONNECT) { 114375913d9bSadam radford *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl); 114475913d9bSadam radford *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id); 114575913d9bSadam radford *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch); 114675913d9bSadam radford *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build); 114775913d9bSadam radford *init_connect_result = le32_to_cpu(tw_initconnect->result); 11481da177e4SLinus Torvalds } 11491da177e4SLinus Torvalds retval = 0; 11501da177e4SLinus Torvalds } 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds tw_dev->posted_request_count--; 11531da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_INITIAL; 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds return retval; 11561da177e4SLinus Torvalds } /* End twa_initconnection() */ 11571da177e4SLinus Torvalds 11581da177e4SLinus Torvalds /* This function will initialize the fields of a device extension */ 11591da177e4SLinus Torvalds static int twa_initialize_device_extension(TW_Device_Extension *tw_dev) 11601da177e4SLinus Torvalds { 11611da177e4SLinus Torvalds int i, retval = 1; 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds /* Initialize command packet buffers */ 11641da177e4SLinus Torvalds if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) { 11651da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed"); 11661da177e4SLinus Torvalds goto out; 11671da177e4SLinus Torvalds } 11681da177e4SLinus Torvalds 11691da177e4SLinus Torvalds /* Initialize generic buffer */ 11701da177e4SLinus Torvalds if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) { 11711da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed"); 11721da177e4SLinus Torvalds goto out; 11731da177e4SLinus Torvalds } 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds /* Allocate event info space */ 1176dd00cc48SYoann Padioleau tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL); 11771da177e4SLinus Torvalds if (!tw_dev->event_queue[0]) { 11781da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed"); 11791da177e4SLinus Torvalds goto out; 11801da177e4SLinus Torvalds } 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds 11831da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 11841da177e4SLinus Torvalds tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event))); 11851da177e4SLinus Torvalds tw_dev->free_queue[i] = i; 11861da177e4SLinus Torvalds tw_dev->state[i] = TW_S_INITIAL; 11871da177e4SLinus Torvalds } 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds tw_dev->pending_head = TW_Q_START; 11901da177e4SLinus Torvalds tw_dev->pending_tail = TW_Q_START; 11911da177e4SLinus Torvalds tw_dev->free_head = TW_Q_START; 11921da177e4SLinus Torvalds tw_dev->free_tail = TW_Q_START; 11931da177e4SLinus Torvalds tw_dev->error_sequence_id = 1; 11941da177e4SLinus Torvalds tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 11951da177e4SLinus Torvalds 1196a12e25bdSJes Sorensen mutex_init(&tw_dev->ioctl_lock); 11971da177e4SLinus Torvalds init_waitqueue_head(&tw_dev->ioctl_wqueue); 11981da177e4SLinus Torvalds 11991da177e4SLinus Torvalds retval = 0; 12001da177e4SLinus Torvalds out: 12011da177e4SLinus Torvalds return retval; 12021da177e4SLinus Torvalds } /* End twa_initialize_device_extension() */ 12031da177e4SLinus Torvalds 12041da177e4SLinus Torvalds /* This function is the interrupt service routine */ 12057d12e780SDavid Howells static irqreturn_t twa_interrupt(int irq, void *dev_instance) 12061da177e4SLinus Torvalds { 12071da177e4SLinus Torvalds int request_id, error = 0; 12081da177e4SLinus Torvalds u32 status_reg_value; 12091da177e4SLinus Torvalds TW_Response_Queue response_que; 12101da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 12111da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance; 12121da177e4SLinus Torvalds int handled = 0; 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds /* Get the per adapter lock */ 12151da177e4SLinus Torvalds spin_lock(tw_dev->host->host_lock); 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds /* Read the registers */ 12181da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 12191da177e4SLinus Torvalds 12201da177e4SLinus Torvalds /* Check if this is our interrupt, otherwise bail */ 12211da177e4SLinus Torvalds if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT)) 12221da177e4SLinus Torvalds goto twa_interrupt_bail; 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds handled = 1; 12251da177e4SLinus Torvalds 12264039c30eSadam radford /* If we are resetting, bail */ 12274039c30eSadam radford if (test_bit(TW_IN_RESET, &tw_dev->flags)) 12284039c30eSadam radford goto twa_interrupt_bail; 12294039c30eSadam radford 12301da177e4SLinus Torvalds /* Check controller for errors */ 12311da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) { 12321da177e4SLinus Torvalds if (twa_decode_bits(tw_dev, status_reg_value)) { 12331da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 12341da177e4SLinus Torvalds goto twa_interrupt_bail; 12351da177e4SLinus Torvalds } 12361da177e4SLinus Torvalds } 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds /* Handle host interrupt */ 12391da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_HOST_INTERRUPT) 12401da177e4SLinus Torvalds TW_CLEAR_HOST_INTERRUPT(tw_dev); 12411da177e4SLinus Torvalds 12421da177e4SLinus Torvalds /* Handle attention interrupt */ 12431da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) { 12441da177e4SLinus Torvalds TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 12451da177e4SLinus Torvalds if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) { 12461da177e4SLinus Torvalds twa_get_request_id(tw_dev, &request_id); 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds error = twa_aen_read_queue(tw_dev, request_id); 12491da177e4SLinus Torvalds if (error) { 12501da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 12511da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 12521da177e4SLinus Torvalds clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 12531da177e4SLinus Torvalds } 12541da177e4SLinus Torvalds } 12551da177e4SLinus Torvalds } 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds /* Handle command interrupt */ 12581da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) { 12591da177e4SLinus Torvalds TW_MASK_COMMAND_INTERRUPT(tw_dev); 12601da177e4SLinus Torvalds /* Drain as many pending commands as we can */ 12611da177e4SLinus Torvalds while (tw_dev->pending_request_count > 0) { 12621da177e4SLinus Torvalds request_id = tw_dev->pending_queue[tw_dev->pending_head]; 12631da177e4SLinus Torvalds if (tw_dev->state[request_id] != TW_S_PENDING) { 12641da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending"); 12651da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 12661da177e4SLinus Torvalds goto twa_interrupt_bail; 12671da177e4SLinus Torvalds } 12681da177e4SLinus Torvalds if (twa_post_command_packet(tw_dev, request_id, 1)==0) { 12691da177e4SLinus Torvalds tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH; 12701da177e4SLinus Torvalds tw_dev->pending_request_count--; 12711da177e4SLinus Torvalds } else { 12721da177e4SLinus Torvalds /* If we get here, we will continue re-posting on the next command interrupt */ 12731da177e4SLinus Torvalds break; 12741da177e4SLinus Torvalds } 12751da177e4SLinus Torvalds } 12761da177e4SLinus Torvalds } 12771da177e4SLinus Torvalds 12781da177e4SLinus Torvalds /* Handle response interrupt */ 12791da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) { 12801da177e4SLinus Torvalds 12811da177e4SLinus Torvalds /* Drain the response queue from the board */ 12821da177e4SLinus Torvalds while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 12831da177e4SLinus Torvalds /* Complete the response */ 12841da177e4SLinus Torvalds response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 12851da177e4SLinus Torvalds request_id = TW_RESID_OUT(response_que.response_id); 12861da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 12871da177e4SLinus Torvalds error = 0; 12881da177e4SLinus Torvalds /* Check for command packet errors */ 12891da177e4SLinus Torvalds if (full_command_packet->command.newcommand.status != 0) { 12909bcf0910SHarvey Harrison if (tw_dev->srb[request_id] != NULL) { 12911da177e4SLinus Torvalds error = twa_fill_sense(tw_dev, request_id, 1, 1); 12921da177e4SLinus Torvalds } else { 12931da177e4SLinus Torvalds /* Skip ioctl error prints */ 12941da177e4SLinus Torvalds if (request_id != tw_dev->chrdev_request_id) { 12951da177e4SLinus Torvalds error = twa_fill_sense(tw_dev, request_id, 0, 1); 12961da177e4SLinus Torvalds } 12971da177e4SLinus Torvalds } 12981da177e4SLinus Torvalds } 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds /* Check for correct state */ 13011da177e4SLinus Torvalds if (tw_dev->state[request_id] != TW_S_POSTED) { 13029bcf0910SHarvey Harrison if (tw_dev->srb[request_id] != NULL) { 13031da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted"); 13041da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 13051da177e4SLinus Torvalds goto twa_interrupt_bail; 13061da177e4SLinus Torvalds } 13071da177e4SLinus Torvalds } 13081da177e4SLinus Torvalds 13091da177e4SLinus Torvalds /* Check for internal command completion */ 13109bcf0910SHarvey Harrison if (tw_dev->srb[request_id] == NULL) { 13111da177e4SLinus Torvalds if (request_id != tw_dev->chrdev_request_id) { 13121da177e4SLinus Torvalds if (twa_aen_complete(tw_dev, request_id)) 13131da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt"); 13141da177e4SLinus Torvalds } else { 13151da177e4SLinus Torvalds tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 13161da177e4SLinus Torvalds wake_up(&tw_dev->ioctl_wqueue); 13171da177e4SLinus Torvalds } 13181da177e4SLinus Torvalds } else { 13190debe01dSFUJITA Tomonori struct scsi_cmnd *cmd; 13200debe01dSFUJITA Tomonori 13210debe01dSFUJITA Tomonori cmd = tw_dev->srb[request_id]; 13220debe01dSFUJITA Tomonori 13231da177e4SLinus Torvalds twa_scsiop_execute_scsi_complete(tw_dev, request_id); 13241da177e4SLinus Torvalds /* If no error command was a success */ 13251da177e4SLinus Torvalds if (error == 0) { 13260debe01dSFUJITA Tomonori cmd->result = (DID_OK << 16); 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds /* If error, command failed */ 13301da177e4SLinus Torvalds if (error == 1) { 13311da177e4SLinus Torvalds /* Ask for a host reset */ 13320debe01dSFUJITA Tomonori cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 13331da177e4SLinus Torvalds } 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds /* Report residual bytes for single sgl */ 13360debe01dSFUJITA Tomonori if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) { 13370debe01dSFUJITA Tomonori if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id])) 13380debe01dSFUJITA Tomonori scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length); 13391da177e4SLinus Torvalds } 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds /* Now complete the io */ 1342118c855bSChristoph Hellwig scsi_dma_unmap(cmd); 1343118c855bSChristoph Hellwig cmd->scsi_done(cmd); 13441da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 13451da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 13461da177e4SLinus Torvalds tw_dev->posted_request_count--; 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds /* Check for valid status after each drain */ 13501da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 13511da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) { 13521da177e4SLinus Torvalds if (twa_decode_bits(tw_dev, status_reg_value)) { 13531da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 13541da177e4SLinus Torvalds goto twa_interrupt_bail; 13551da177e4SLinus Torvalds } 13561da177e4SLinus Torvalds } 13571da177e4SLinus Torvalds } 13581da177e4SLinus Torvalds } 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds twa_interrupt_bail: 13611da177e4SLinus Torvalds spin_unlock(tw_dev->host->host_lock); 13621da177e4SLinus Torvalds return IRQ_RETVAL(handled); 13631da177e4SLinus Torvalds } /* End twa_interrupt() */ 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds /* This function will load the request id and various sgls for ioctls */ 13660e78d158Sadam radford static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length) 13671da177e4SLinus Torvalds { 13681da177e4SLinus Torvalds TW_Command *oldcommand; 13691da177e4SLinus Torvalds TW_Command_Apache *newcommand; 13701da177e4SLinus Torvalds TW_SG_Entry *sgl; 13710e78d158Sadam radford unsigned int pae = 0; 13720e78d158Sadam radford 13730e78d158Sadam radford if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4)) 13740e78d158Sadam radford pae = 1; 13751da177e4SLinus Torvalds 13761da177e4SLinus Torvalds if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) { 13771da177e4SLinus Torvalds newcommand = &full_command_packet->command.newcommand; 13781da177e4SLinus Torvalds newcommand->request_id__lunl = 13794039c30eSadam radford cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id)); 138053ca3535Sadam radford if (length) { 138175913d9bSadam radford newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1); 138275913d9bSadam radford newcommand->sg_list[0].length = cpu_to_le32(length); 138353ca3535Sadam radford } 13841da177e4SLinus Torvalds newcommand->sgl_entries__lunh = 138553ca3535Sadam radford cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0)); 13861da177e4SLinus Torvalds } else { 13871da177e4SLinus Torvalds oldcommand = &full_command_packet->command.oldcommand; 13881da177e4SLinus Torvalds oldcommand->request_id = request_id; 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) { 13911da177e4SLinus Torvalds /* Load the sg list */ 13920e78d158Sadam radford if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA) 13930e78d158Sadam radford sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae); 13940e78d158Sadam radford else 13951da177e4SLinus Torvalds sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset)); 139675913d9bSadam radford sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1); 139775913d9bSadam radford sgl->length = cpu_to_le32(length); 13981da177e4SLinus Torvalds 13990e78d158Sadam radford oldcommand->size += pae; 14001da177e4SLinus Torvalds } 14011da177e4SLinus Torvalds } 14021da177e4SLinus Torvalds } /* End twa_load_sgl() */ 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds /* This function will poll for a response interrupt of a request */ 14051da177e4SLinus Torvalds static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds) 14061da177e4SLinus Torvalds { 14071da177e4SLinus Torvalds int retval = 1, found = 0, response_request_id; 14081da177e4SLinus Torvalds TW_Response_Queue response_queue; 14091da177e4SLinus Torvalds TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id]; 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) { 14121da177e4SLinus Torvalds response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 14131da177e4SLinus Torvalds response_request_id = TW_RESID_OUT(response_queue.response_id); 14141da177e4SLinus Torvalds if (request_id != response_request_id) { 14151da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response"); 14161da177e4SLinus Torvalds goto out; 14171da177e4SLinus Torvalds } 14181da177e4SLinus Torvalds if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) { 14191da177e4SLinus Torvalds if (full_command_packet->command.newcommand.status != 0) { 14201da177e4SLinus Torvalds /* bad response */ 14211da177e4SLinus Torvalds twa_fill_sense(tw_dev, request_id, 0, 0); 14221da177e4SLinus Torvalds goto out; 14231da177e4SLinus Torvalds } 14241da177e4SLinus Torvalds found = 1; 14251da177e4SLinus Torvalds } else { 14261da177e4SLinus Torvalds if (full_command_packet->command.oldcommand.status != 0) { 14271da177e4SLinus Torvalds /* bad response */ 14281da177e4SLinus Torvalds twa_fill_sense(tw_dev, request_id, 0, 0); 14291da177e4SLinus Torvalds goto out; 14301da177e4SLinus Torvalds } 14311da177e4SLinus Torvalds found = 1; 14321da177e4SLinus Torvalds } 14331da177e4SLinus Torvalds } 14341da177e4SLinus Torvalds 14351da177e4SLinus Torvalds if (found) 14361da177e4SLinus Torvalds retval = 0; 14371da177e4SLinus Torvalds out: 14381da177e4SLinus Torvalds return retval; 14391da177e4SLinus Torvalds } /* End twa_poll_response() */ 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds /* This function will poll the status register for a flag */ 14421da177e4SLinus Torvalds static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds) 14431da177e4SLinus Torvalds { 14441da177e4SLinus Torvalds u32 status_reg_value; 14451da177e4SLinus Torvalds unsigned long before; 14461da177e4SLinus Torvalds int retval = 1; 14471da177e4SLinus Torvalds 14481da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 14491da177e4SLinus Torvalds before = jiffies; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 14521da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds while ((status_reg_value & flag) != flag) { 14551da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 14581da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds if (time_after(jiffies, before + HZ * seconds)) 14611da177e4SLinus Torvalds goto out; 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds msleep(50); 14641da177e4SLinus Torvalds } 14651da177e4SLinus Torvalds retval = 0; 14661da177e4SLinus Torvalds out: 14671da177e4SLinus Torvalds return retval; 14681da177e4SLinus Torvalds } /* End twa_poll_status() */ 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds /* This function will poll the status register for disappearance of a flag */ 14711da177e4SLinus Torvalds static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds) 14721da177e4SLinus Torvalds { 14731da177e4SLinus Torvalds u32 status_reg_value; 14741da177e4SLinus Torvalds unsigned long before; 14751da177e4SLinus Torvalds int retval = 1; 14761da177e4SLinus Torvalds 14771da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 14781da177e4SLinus Torvalds before = jiffies; 14791da177e4SLinus Torvalds 14801da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 14811da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 14821da177e4SLinus Torvalds 14831da177e4SLinus Torvalds while ((status_reg_value & flag) != 0) { 14841da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 14851da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 14861da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds if (time_after(jiffies, before + HZ * seconds)) 14891da177e4SLinus Torvalds goto out; 14901da177e4SLinus Torvalds 14911da177e4SLinus Torvalds msleep(50); 14921da177e4SLinus Torvalds } 14931da177e4SLinus Torvalds retval = 0; 14941da177e4SLinus Torvalds out: 14951da177e4SLinus Torvalds return retval; 14961da177e4SLinus Torvalds } /* End twa_poll_status_gone() */ 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds /* This function will attempt to post a command packet to the board */ 14991da177e4SLinus Torvalds static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal) 15001da177e4SLinus Torvalds { 15011da177e4SLinus Torvalds u32 status_reg_value; 15021da177e4SLinus Torvalds dma_addr_t command_que_value; 15031da177e4SLinus Torvalds int retval = 1; 15041da177e4SLinus Torvalds 15051da177e4SLinus Torvalds command_que_value = tw_dev->command_packet_phys[request_id]; 15064039c30eSadam radford 15074039c30eSadam radford /* For 9650SE write low 4 bytes first */ 15080e78d158Sadam radford if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) || 15090e78d158Sadam radford (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) { 15104039c30eSadam radford command_que_value += TW_COMMAND_OFFSET; 15114039c30eSadam radford writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev)); 15124039c30eSadam radford } 15134039c30eSadam radford 15141da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 15151da177e4SLinus Torvalds 15161da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 15171da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 15181da177e4SLinus Torvalds 15191da177e4SLinus Torvalds if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) { 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds /* Only pend internal driver commands */ 15221da177e4SLinus Torvalds if (!internal) { 15231da177e4SLinus Torvalds retval = SCSI_MLQUEUE_HOST_BUSY; 15241da177e4SLinus Torvalds goto out; 15251da177e4SLinus Torvalds } 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds /* Couldn't post the command packet, so we do it later */ 15281da177e4SLinus Torvalds if (tw_dev->state[request_id] != TW_S_PENDING) { 15291da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_PENDING; 15301da177e4SLinus Torvalds tw_dev->pending_request_count++; 15311da177e4SLinus Torvalds if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) { 15321da177e4SLinus Torvalds tw_dev->max_pending_request_count = tw_dev->pending_request_count; 15331da177e4SLinus Torvalds } 15341da177e4SLinus Torvalds tw_dev->pending_queue[tw_dev->pending_tail] = request_id; 15351da177e4SLinus Torvalds tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH; 15361da177e4SLinus Torvalds } 15371da177e4SLinus Torvalds TW_UNMASK_COMMAND_INTERRUPT(tw_dev); 15381da177e4SLinus Torvalds goto out; 15391da177e4SLinus Torvalds } else { 15400e78d158Sadam radford if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) || 15410e78d158Sadam radford (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) { 15424039c30eSadam radford /* Now write upper 4 bytes */ 15434039c30eSadam radford writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4); 15444039c30eSadam radford } else { 15451da177e4SLinus Torvalds if (sizeof(dma_addr_t) > 4) { 15461da177e4SLinus Torvalds command_que_value += TW_COMMAND_OFFSET; 15471da177e4SLinus Torvalds writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 15481da177e4SLinus Torvalds writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4); 15491da177e4SLinus Torvalds } else { 15501da177e4SLinus Torvalds writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 15511da177e4SLinus Torvalds } 15524039c30eSadam radford } 15531da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_POSTED; 15541da177e4SLinus Torvalds tw_dev->posted_request_count++; 15551da177e4SLinus Torvalds if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) { 15561da177e4SLinus Torvalds tw_dev->max_posted_request_count = tw_dev->posted_request_count; 15571da177e4SLinus Torvalds } 15581da177e4SLinus Torvalds } 15591da177e4SLinus Torvalds retval = 0; 15601da177e4SLinus Torvalds out: 15611da177e4SLinus Torvalds return retval; 15621da177e4SLinus Torvalds } /* End twa_post_command_packet() */ 15631da177e4SLinus Torvalds 15641da177e4SLinus Torvalds /* This function will reset a device extension */ 15650e78d158Sadam radford static int twa_reset_device_extension(TW_Device_Extension *tw_dev) 15661da177e4SLinus Torvalds { 15671da177e4SLinus Torvalds int i = 0; 15681da177e4SLinus Torvalds int retval = 1; 15691da177e4SLinus Torvalds unsigned long flags = 0; 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds set_bit(TW_IN_RESET, &tw_dev->flags); 15721da177e4SLinus Torvalds TW_DISABLE_INTERRUPTS(tw_dev); 15731da177e4SLinus Torvalds TW_MASK_COMMAND_INTERRUPT(tw_dev); 15741da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds /* Abort all requests that are in progress */ 15771da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 15781da177e4SLinus Torvalds if ((tw_dev->state[i] != TW_S_FINISHED) && 15791da177e4SLinus Torvalds (tw_dev->state[i] != TW_S_INITIAL) && 15801da177e4SLinus Torvalds (tw_dev->state[i] != TW_S_COMPLETED)) { 15811da177e4SLinus Torvalds if (tw_dev->srb[i]) { 1582118c855bSChristoph Hellwig struct scsi_cmnd *cmd = tw_dev->srb[i]; 1583118c855bSChristoph Hellwig 1584118c855bSChristoph Hellwig cmd->result = (DID_RESET << 16); 1585118c855bSChristoph Hellwig scsi_dma_unmap(cmd); 1586118c855bSChristoph Hellwig cmd->scsi_done(cmd); 15871da177e4SLinus Torvalds } 15881da177e4SLinus Torvalds } 15891da177e4SLinus Torvalds } 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds /* Reset queues and counts */ 15921da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 15931da177e4SLinus Torvalds tw_dev->free_queue[i] = i; 15941da177e4SLinus Torvalds tw_dev->state[i] = TW_S_INITIAL; 15951da177e4SLinus Torvalds } 15961da177e4SLinus Torvalds tw_dev->free_head = TW_Q_START; 15971da177e4SLinus Torvalds tw_dev->free_tail = TW_Q_START; 15981da177e4SLinus Torvalds tw_dev->posted_request_count = 0; 15991da177e4SLinus Torvalds tw_dev->pending_request_count = 0; 16001da177e4SLinus Torvalds tw_dev->pending_head = TW_Q_START; 16011da177e4SLinus Torvalds tw_dev->pending_tail = TW_Q_START; 16021da177e4SLinus Torvalds tw_dev->reset_print = 0; 16031da177e4SLinus Torvalds 16041da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds if (twa_reset_sequence(tw_dev, 1)) 16071da177e4SLinus Torvalds goto out; 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 16101da177e4SLinus Torvalds clear_bit(TW_IN_RESET, &tw_dev->flags); 16111da177e4SLinus Torvalds tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 16124039c30eSadam radford 16131da177e4SLinus Torvalds retval = 0; 16141da177e4SLinus Torvalds out: 16151da177e4SLinus Torvalds return retval; 16161da177e4SLinus Torvalds } /* End twa_reset_device_extension() */ 16171da177e4SLinus Torvalds 16181da177e4SLinus Torvalds /* This function will reset a controller */ 16191da177e4SLinus Torvalds static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset) 16201da177e4SLinus Torvalds { 16211da177e4SLinus Torvalds int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset; 16221da177e4SLinus Torvalds 16231da177e4SLinus Torvalds while (tries < TW_MAX_RESET_TRIES) { 162449bfd8dbSadam radford if (do_soft_reset) { 16251da177e4SLinus Torvalds TW_SOFT_RESET(tw_dev); 162649bfd8dbSadam radford /* Clear pchip/response queue on 9550SX */ 162749bfd8dbSadam radford if (twa_empty_response_queue_large(tw_dev)) { 162849bfd8dbSadam radford TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence"); 162949bfd8dbSadam radford do_soft_reset = 1; 163049bfd8dbSadam radford tries++; 163149bfd8dbSadam radford continue; 163249bfd8dbSadam radford } 163349bfd8dbSadam radford } 16341da177e4SLinus Torvalds 16351da177e4SLinus Torvalds /* Make sure controller is in a good state */ 16361da177e4SLinus Torvalds if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) { 16371da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence"); 16381da177e4SLinus Torvalds do_soft_reset = 1; 16391da177e4SLinus Torvalds tries++; 16401da177e4SLinus Torvalds continue; 16411da177e4SLinus Torvalds } 16421da177e4SLinus Torvalds 16431da177e4SLinus Torvalds /* Empty response queue */ 16441da177e4SLinus Torvalds if (twa_empty_response_queue(tw_dev)) { 16451da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence"); 16461da177e4SLinus Torvalds do_soft_reset = 1; 16471da177e4SLinus Torvalds tries++; 16481da177e4SLinus Torvalds continue; 16491da177e4SLinus Torvalds } 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds flashed = 0; 16521da177e4SLinus Torvalds 16531da177e4SLinus Torvalds /* Check for compatibility/flash */ 16541da177e4SLinus Torvalds if (twa_check_srl(tw_dev, &flashed)) { 16551da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence"); 16561da177e4SLinus Torvalds do_soft_reset = 1; 16571da177e4SLinus Torvalds tries++; 16581da177e4SLinus Torvalds continue; 16591da177e4SLinus Torvalds } else { 16601da177e4SLinus Torvalds if (flashed) { 16611da177e4SLinus Torvalds tries++; 16621da177e4SLinus Torvalds continue; 16631da177e4SLinus Torvalds } 16641da177e4SLinus Torvalds } 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds /* Drain the AEN queue */ 16671da177e4SLinus Torvalds if (twa_aen_drain_queue(tw_dev, soft_reset)) { 16681da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence"); 16691da177e4SLinus Torvalds do_soft_reset = 1; 16701da177e4SLinus Torvalds tries++; 16711da177e4SLinus Torvalds continue; 16721da177e4SLinus Torvalds } 16731da177e4SLinus Torvalds 16741da177e4SLinus Torvalds /* If we got here, controller is in a good state */ 16751da177e4SLinus Torvalds retval = 0; 16761da177e4SLinus Torvalds goto out; 16771da177e4SLinus Torvalds } 16781da177e4SLinus Torvalds out: 16791da177e4SLinus Torvalds return retval; 16801da177e4SLinus Torvalds } /* End twa_reset_sequence() */ 16811da177e4SLinus Torvalds 16821da177e4SLinus Torvalds /* This funciton returns unit geometry in cylinders/heads/sectors */ 16831da177e4SLinus Torvalds static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[]) 16841da177e4SLinus Torvalds { 16851da177e4SLinus Torvalds int heads, sectors, cylinders; 16861da177e4SLinus Torvalds TW_Device_Extension *tw_dev; 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds tw_dev = (TW_Device_Extension *)sdev->host->hostdata; 16891da177e4SLinus Torvalds 16901da177e4SLinus Torvalds if (capacity >= 0x200000) { 16911da177e4SLinus Torvalds heads = 255; 16921da177e4SLinus Torvalds sectors = 63; 16931da177e4SLinus Torvalds cylinders = sector_div(capacity, heads * sectors); 16941da177e4SLinus Torvalds } else { 16951da177e4SLinus Torvalds heads = 64; 16961da177e4SLinus Torvalds sectors = 32; 16971da177e4SLinus Torvalds cylinders = sector_div(capacity, heads * sectors); 16981da177e4SLinus Torvalds } 16991da177e4SLinus Torvalds 17001da177e4SLinus Torvalds geom[0] = heads; 17011da177e4SLinus Torvalds geom[1] = sectors; 17021da177e4SLinus Torvalds geom[2] = cylinders; 17031da177e4SLinus Torvalds 17041da177e4SLinus Torvalds return 0; 17051da177e4SLinus Torvalds } /* End twa_scsi_biosparam() */ 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds /* This is the new scsi eh reset function */ 17081da177e4SLinus Torvalds static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt) 17091da177e4SLinus Torvalds { 17101da177e4SLinus Torvalds TW_Device_Extension *tw_dev = NULL; 17111da177e4SLinus Torvalds int retval = FAILED; 17121da177e4SLinus Torvalds 17131da177e4SLinus Torvalds tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 17141da177e4SLinus Torvalds 17151da177e4SLinus Torvalds tw_dev->num_resets++; 17161da177e4SLinus Torvalds 1717017560fcSJeff Garzik sdev_printk(KERN_WARNING, SCpnt->device, 1718017560fcSJeff Garzik "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n", 1719017560fcSJeff Garzik TW_DRIVER, 0x2c, SCpnt->cmnd[0]); 17201da177e4SLinus Torvalds 17214039c30eSadam radford /* Make sure we are not issuing an ioctl or resetting from ioctl */ 17224039c30eSadam radford mutex_lock(&tw_dev->ioctl_lock); 17234039c30eSadam radford 17241da177e4SLinus Torvalds /* Now reset the card and some of the device extension data */ 17250e78d158Sadam radford if (twa_reset_device_extension(tw_dev)) { 17261da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset"); 17271da177e4SLinus Torvalds goto out; 17281da177e4SLinus Torvalds } 17291da177e4SLinus Torvalds 17301da177e4SLinus Torvalds retval = SUCCESS; 17311da177e4SLinus Torvalds out: 17324039c30eSadam radford mutex_unlock(&tw_dev->ioctl_lock); 17331da177e4SLinus Torvalds return retval; 17341da177e4SLinus Torvalds } /* End twa_scsi_eh_reset() */ 17351da177e4SLinus Torvalds 17361da177e4SLinus Torvalds /* This is the main scsi queue function to handle scsi opcodes */ 1737f281233dSJeff Garzik static int twa_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 17381da177e4SLinus Torvalds { 17391da177e4SLinus Torvalds int request_id, retval; 17401da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 17411da177e4SLinus Torvalds 17424039c30eSadam radford /* If we are resetting due to timed out ioctl, report as busy */ 17434039c30eSadam radford if (test_bit(TW_IN_RESET, &tw_dev->flags)) { 17444039c30eSadam radford retval = SCSI_MLQUEUE_HOST_BUSY; 17454039c30eSadam radford goto out; 17464039c30eSadam radford } 17474039c30eSadam radford 17481da177e4SLinus Torvalds /* Check if this FW supports luns */ 17494039c30eSadam radford if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) { 17501da177e4SLinus Torvalds SCpnt->result = (DID_BAD_TARGET << 16); 17511da177e4SLinus Torvalds done(SCpnt); 17521da177e4SLinus Torvalds retval = 0; 17531da177e4SLinus Torvalds goto out; 17541da177e4SLinus Torvalds } 17551da177e4SLinus Torvalds 17561da177e4SLinus Torvalds /* Save done function into scsi_cmnd struct */ 17571da177e4SLinus Torvalds SCpnt->scsi_done = done; 17581da177e4SLinus Torvalds 17591da177e4SLinus Torvalds /* Get a free request id */ 17601da177e4SLinus Torvalds twa_get_request_id(tw_dev, &request_id); 17611da177e4SLinus Torvalds 17621da177e4SLinus Torvalds /* Save the scsi command for use by the ISR */ 17631da177e4SLinus Torvalds tw_dev->srb[request_id] = SCpnt; 17641da177e4SLinus Torvalds 17651da177e4SLinus Torvalds retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL); 17661da177e4SLinus Torvalds switch (retval) { 17671da177e4SLinus Torvalds case SCSI_MLQUEUE_HOST_BUSY: 1768118c855bSChristoph Hellwig scsi_dma_unmap(SCpnt); 17691da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 17701da177e4SLinus Torvalds break; 17711da177e4SLinus Torvalds case 1: 1772118c855bSChristoph Hellwig SCpnt->result = (DID_ERROR << 16); 1773118c855bSChristoph Hellwig scsi_dma_unmap(SCpnt); 1774118c855bSChristoph Hellwig done(SCpnt); 17751da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 17761da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 17771da177e4SLinus Torvalds retval = 0; 17781da177e4SLinus Torvalds } 17791da177e4SLinus Torvalds out: 17801da177e4SLinus Torvalds return retval; 17811da177e4SLinus Torvalds } /* End twa_scsi_queue() */ 17821da177e4SLinus Torvalds 1783f281233dSJeff Garzik static DEF_SCSI_QCMD(twa_scsi_queue) 1784f281233dSJeff Garzik 17851da177e4SLinus Torvalds /* This function hands scsi cdb's to the firmware */ 17861da177e4SLinus Torvalds static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg) 17871da177e4SLinus Torvalds { 17881da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 17891da177e4SLinus Torvalds TW_Command_Apache *command_packet; 17901da177e4SLinus Torvalds u32 num_sectors = 0x0; 17911da177e4SLinus Torvalds int i, sg_count; 17921da177e4SLinus Torvalds struct scsi_cmnd *srb = NULL; 17930debe01dSFUJITA Tomonori struct scatterlist *sglist = NULL, *sg; 17941da177e4SLinus Torvalds int retval = 1; 17951da177e4SLinus Torvalds 17961da177e4SLinus Torvalds if (tw_dev->srb[request_id]) { 17971da177e4SLinus Torvalds srb = tw_dev->srb[request_id]; 17980debe01dSFUJITA Tomonori if (scsi_sglist(srb)) 17990debe01dSFUJITA Tomonori sglist = scsi_sglist(srb); 18001da177e4SLinus Torvalds } 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds /* Initialize command packet */ 18031da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 18041da177e4SLinus Torvalds full_command_packet->header.header_desc.size_header = 128; 18051da177e4SLinus Torvalds full_command_packet->header.status_block.error = 0; 18061da177e4SLinus Torvalds full_command_packet->header.status_block.severity__reserved = 0; 18071da177e4SLinus Torvalds 18081da177e4SLinus Torvalds command_packet = &full_command_packet->command.newcommand; 18091da177e4SLinus Torvalds command_packet->status = 0; 18101da177e4SLinus Torvalds command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI); 18111da177e4SLinus Torvalds 18121da177e4SLinus Torvalds /* We forced 16 byte cdb use earlier */ 18131da177e4SLinus Torvalds if (!cdb) 18141da177e4SLinus Torvalds memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN); 18151da177e4SLinus Torvalds else 18161da177e4SLinus Torvalds memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN); 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds if (srb) { 18191da177e4SLinus Torvalds command_packet->unit = srb->device->id; 18201da177e4SLinus Torvalds command_packet->request_id__lunl = 182175913d9bSadam radford cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id)); 18221da177e4SLinus Torvalds } else { 18231da177e4SLinus Torvalds command_packet->request_id__lunl = 182475913d9bSadam radford cpu_to_le16(TW_REQ_LUN_IN(0, request_id)); 18251da177e4SLinus Torvalds command_packet->unit = 0; 18261da177e4SLinus Torvalds } 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds command_packet->sgl_offset = 16; 18291da177e4SLinus Torvalds 18301da177e4SLinus Torvalds if (!sglistarg) { 18311da177e4SLinus Torvalds /* Map sglist from scsi layer to cmd packet */ 18321da177e4SLinus Torvalds 18330debe01dSFUJITA Tomonori if (scsi_sg_count(srb)) { 18340debe01dSFUJITA Tomonori if ((scsi_sg_count(srb) == 1) && 18350debe01dSFUJITA Tomonori (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) { 1836035f5e06SFUJITA Tomonori if (srb->sc_data_direction == DMA_TO_DEVICE || 1837035f5e06SFUJITA Tomonori srb->sc_data_direction == DMA_BIDIRECTIONAL) 1838035f5e06SFUJITA Tomonori scsi_sg_copy_to_buffer(srb, 1839035f5e06SFUJITA Tomonori tw_dev->generic_buffer_virt[request_id], 1840035f5e06SFUJITA Tomonori TW_SECTOR_SIZE); 184175913d9bSadam radford command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]); 184275913d9bSadam radford command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH); 18431da177e4SLinus Torvalds } else { 1844118c855bSChristoph Hellwig sg_count = scsi_dma_map(srb); 1845118c855bSChristoph Hellwig if (sg_count < 0) 18461da177e4SLinus Torvalds goto out; 18471da177e4SLinus Torvalds 18480debe01dSFUJITA Tomonori scsi_for_each_sg(srb, sg, sg_count, i) { 18490debe01dSFUJITA Tomonori command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg)); 18500debe01dSFUJITA Tomonori command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg)); 185175913d9bSadam radford if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) { 18521da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi"); 18531da177e4SLinus Torvalds goto out; 18541da177e4SLinus Torvalds } 18551da177e4SLinus Torvalds } 18561da177e4SLinus Torvalds } 18570debe01dSFUJITA Tomonori command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id]))); 18581da177e4SLinus Torvalds } 18591da177e4SLinus Torvalds } else { 18601da177e4SLinus Torvalds /* Internal cdb post */ 18611da177e4SLinus Torvalds for (i = 0; i < use_sg; i++) { 186275913d9bSadam radford command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address); 186375913d9bSadam radford command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length); 186475913d9bSadam radford if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) { 18651da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post"); 18661da177e4SLinus Torvalds goto out; 18671da177e4SLinus Torvalds } 18681da177e4SLinus Torvalds } 186975913d9bSadam radford command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg)); 18701da177e4SLinus Torvalds } 18711da177e4SLinus Torvalds 18721da177e4SLinus Torvalds if (srb) { 18731da177e4SLinus Torvalds if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) 18741da177e4SLinus Torvalds num_sectors = (u32)srb->cmnd[4]; 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10) 18771da177e4SLinus Torvalds num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8); 18781da177e4SLinus Torvalds } 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds /* Update sector statistic */ 18811da177e4SLinus Torvalds tw_dev->sector_count = num_sectors; 18821da177e4SLinus Torvalds if (tw_dev->sector_count > tw_dev->max_sector_count) 18831da177e4SLinus Torvalds tw_dev->max_sector_count = tw_dev->sector_count; 18841da177e4SLinus Torvalds 18851da177e4SLinus Torvalds /* Update SG statistics */ 18861da177e4SLinus Torvalds if (srb) { 18870debe01dSFUJITA Tomonori tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]); 18881da177e4SLinus Torvalds if (tw_dev->sgl_entries > tw_dev->max_sgl_entries) 18891da177e4SLinus Torvalds tw_dev->max_sgl_entries = tw_dev->sgl_entries; 18901da177e4SLinus Torvalds } 18911da177e4SLinus Torvalds 18921da177e4SLinus Torvalds /* Now post the command to the board */ 18931da177e4SLinus Torvalds if (srb) { 18941da177e4SLinus Torvalds retval = twa_post_command_packet(tw_dev, request_id, 0); 18951da177e4SLinus Torvalds } else { 18961da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 18971da177e4SLinus Torvalds retval = 0; 18981da177e4SLinus Torvalds } 18991da177e4SLinus Torvalds out: 19001da177e4SLinus Torvalds return retval; 19011da177e4SLinus Torvalds } /* End twa_scsiop_execute_scsi() */ 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds /* This function completes an execute scsi operation */ 19041da177e4SLinus Torvalds static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id) 19051da177e4SLinus Torvalds { 19060debe01dSFUJITA Tomonori struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 19070debe01dSFUJITA Tomonori 19080debe01dSFUJITA Tomonori if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH && 19090debe01dSFUJITA Tomonori (cmd->sc_data_direction == DMA_FROM_DEVICE || 19100debe01dSFUJITA Tomonori cmd->sc_data_direction == DMA_BIDIRECTIONAL)) { 1911b1192d5eSFUJITA Tomonori if (scsi_sg_count(cmd) == 1) { 1912035f5e06SFUJITA Tomonori void *buf = tw_dev->generic_buffer_virt[request_id]; 1913035f5e06SFUJITA Tomonori 1914035f5e06SFUJITA Tomonori scsi_sg_copy_from_buffer(cmd, buf, TW_SECTOR_SIZE); 1915d327d082Sadam radford } 1916d327d082Sadam radford } 19171da177e4SLinus Torvalds } /* End twa_scsiop_execute_scsi_complete() */ 19181da177e4SLinus Torvalds 19191da177e4SLinus Torvalds /* This function tells the controller to shut down */ 19201da177e4SLinus Torvalds static void __twa_shutdown(TW_Device_Extension *tw_dev) 19211da177e4SLinus Torvalds { 19221da177e4SLinus Torvalds /* Disable interrupts */ 19231da177e4SLinus Torvalds TW_DISABLE_INTERRUPTS(tw_dev); 19241da177e4SLinus Torvalds 19254039c30eSadam radford /* Free up the IRQ */ 19264039c30eSadam radford free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 19274039c30eSadam radford 19281da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no); 19291da177e4SLinus Torvalds 19301da177e4SLinus Torvalds /* Tell the card we are shutting down */ 19311da177e4SLinus Torvalds if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) { 19321da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed"); 19331da177e4SLinus Torvalds } else { 19341da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n"); 19351da177e4SLinus Torvalds } 19361da177e4SLinus Torvalds 19371da177e4SLinus Torvalds /* Clear all interrupts just before exit */ 19381da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 19391da177e4SLinus Torvalds } /* End __twa_shutdown() */ 19401da177e4SLinus Torvalds 19411da177e4SLinus Torvalds /* Wrapper for __twa_shutdown */ 1942d18c3db5SGreg Kroah-Hartman static void twa_shutdown(struct pci_dev *pdev) 19431da177e4SLinus Torvalds { 1944d18c3db5SGreg Kroah-Hartman struct Scsi_Host *host = pci_get_drvdata(pdev); 19451da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 19461da177e4SLinus Torvalds 19471da177e4SLinus Torvalds __twa_shutdown(tw_dev); 19481da177e4SLinus Torvalds } /* End twa_shutdown() */ 19491da177e4SLinus Torvalds 19501da177e4SLinus Torvalds /* This function will look up a string */ 19511da177e4SLinus Torvalds static char *twa_string_lookup(twa_message_type *table, unsigned int code) 19521da177e4SLinus Torvalds { 19531da177e4SLinus Torvalds int index; 19541da177e4SLinus Torvalds 19551da177e4SLinus Torvalds for (index = 0; ((code != table[index].code) && 19561da177e4SLinus Torvalds (table[index].text != (char *)0)); index++); 19571da177e4SLinus Torvalds return(table[index].text); 19581da177e4SLinus Torvalds } /* End twa_string_lookup() */ 19591da177e4SLinus Torvalds 19604deedd84Sadam radford /* This function gets called when a disk is coming on-line */ 19614deedd84Sadam radford static int twa_slave_configure(struct scsi_device *sdev) 19624deedd84Sadam radford { 19634deedd84Sadam radford /* Force 60 second timeout */ 19644deedd84Sadam radford blk_queue_rq_timeout(sdev->request_queue, 60 * HZ); 19654deedd84Sadam radford 19664deedd84Sadam radford return 0; 19674deedd84Sadam radford } /* End twa_slave_configure() */ 19684deedd84Sadam radford 19691da177e4SLinus Torvalds /* scsi_host_template initializer */ 19701da177e4SLinus Torvalds static struct scsi_host_template driver_template = { 19711da177e4SLinus Torvalds .module = THIS_MODULE, 19721da177e4SLinus Torvalds .name = "3ware 9000 Storage Controller", 19731da177e4SLinus Torvalds .queuecommand = twa_scsi_queue, 19741da177e4SLinus Torvalds .eh_host_reset_handler = twa_scsi_eh_reset, 19751da177e4SLinus Torvalds .bios_param = twa_scsi_biosparam, 1976db5ed4dfSChristoph Hellwig .change_queue_depth = scsi_change_queue_depth, 19771da177e4SLinus Torvalds .can_queue = TW_Q_LENGTH-2, 19784deedd84Sadam radford .slave_configure = twa_slave_configure, 19791da177e4SLinus Torvalds .this_id = -1, 19801da177e4SLinus Torvalds .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH, 19811da177e4SLinus Torvalds .max_sectors = TW_MAX_SECTORS, 19821da177e4SLinus Torvalds .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 19831da177e4SLinus Torvalds .use_clustering = ENABLE_CLUSTERING, 19841da177e4SLinus Torvalds .shost_attrs = twa_host_attrs, 198554b2b50cSMartin K. Petersen .emulated = 1, 198654b2b50cSMartin K. Petersen .no_write_same = 1, 19871da177e4SLinus Torvalds }; 19881da177e4SLinus Torvalds 19891da177e4SLinus Torvalds /* This function will probe and initialize a card */ 19906f039790SGreg Kroah-Hartman static int twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 19911da177e4SLinus Torvalds { 19921da177e4SLinus Torvalds struct Scsi_Host *host = NULL; 19931da177e4SLinus Torvalds TW_Device_Extension *tw_dev; 19943dabec71Sadam radford unsigned long mem_addr, mem_len; 19951da177e4SLinus Torvalds int retval = -ENODEV; 19961da177e4SLinus Torvalds 19971da177e4SLinus Torvalds retval = pci_enable_device(pdev); 19981da177e4SLinus Torvalds if (retval) { 19991da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device"); 20001da177e4SLinus Torvalds goto out_disable_device; 20011da177e4SLinus Torvalds } 20021da177e4SLinus Torvalds 20031da177e4SLinus Torvalds pci_set_master(pdev); 20041e6c38ceSTony Battersby pci_try_set_mwi(pdev); 20051da177e4SLinus Torvalds 20066a35528aSYang Hongyang if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) 20076a35528aSYang Hongyang || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) 2008284901a9SYang Hongyang if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) 2009284901a9SYang Hongyang || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) { 20101da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask"); 20110e78d158Sadam radford retval = -ENODEV; 20121da177e4SLinus Torvalds goto out_disable_device; 20131da177e4SLinus Torvalds } 20141da177e4SLinus Torvalds 20151da177e4SLinus Torvalds host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension)); 20161da177e4SLinus Torvalds if (!host) { 20171da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension"); 20181da177e4SLinus Torvalds retval = -ENOMEM; 20191da177e4SLinus Torvalds goto out_disable_device; 20201da177e4SLinus Torvalds } 20211da177e4SLinus Torvalds tw_dev = (TW_Device_Extension *)host->hostdata; 20221da177e4SLinus Torvalds 20231da177e4SLinus Torvalds /* Save values to device extension */ 20241da177e4SLinus Torvalds tw_dev->host = host; 20251da177e4SLinus Torvalds tw_dev->tw_pci_dev = pdev; 20261da177e4SLinus Torvalds 20271da177e4SLinus Torvalds if (twa_initialize_device_extension(tw_dev)) { 20281da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension"); 20291da177e4SLinus Torvalds goto out_free_device_extension; 20301da177e4SLinus Torvalds } 20311da177e4SLinus Torvalds 20321da177e4SLinus Torvalds /* Request IO regions */ 20331da177e4SLinus Torvalds retval = pci_request_regions(pdev, "3w-9xxx"); 20341da177e4SLinus Torvalds if (retval) { 20351da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region"); 20361da177e4SLinus Torvalds goto out_free_device_extension; 20371da177e4SLinus Torvalds } 20381da177e4SLinus Torvalds 20393dabec71Sadam radford if (pdev->device == PCI_DEVICE_ID_3WARE_9000) { 20401da177e4SLinus Torvalds mem_addr = pci_resource_start(pdev, 1); 20413dabec71Sadam radford mem_len = pci_resource_len(pdev, 1); 20423dabec71Sadam radford } else { 204349bfd8dbSadam radford mem_addr = pci_resource_start(pdev, 2); 20443dabec71Sadam radford mem_len = pci_resource_len(pdev, 2); 20453dabec71Sadam radford } 20461da177e4SLinus Torvalds 20471da177e4SLinus Torvalds /* Save base address */ 20483dabec71Sadam radford tw_dev->base_addr = ioremap(mem_addr, mem_len); 20491da177e4SLinus Torvalds if (!tw_dev->base_addr) { 20501da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap"); 20511da177e4SLinus Torvalds goto out_release_mem_region; 20521da177e4SLinus Torvalds } 20531da177e4SLinus Torvalds 20541da177e4SLinus Torvalds /* Disable interrupts on the card */ 20551da177e4SLinus Torvalds TW_DISABLE_INTERRUPTS(tw_dev); 20561da177e4SLinus Torvalds 20571da177e4SLinus Torvalds /* Initialize the card */ 20581da177e4SLinus Torvalds if (twa_reset_sequence(tw_dev, 0)) 20594039c30eSadam radford goto out_iounmap; 20601da177e4SLinus Torvalds 20611da177e4SLinus Torvalds /* Set host specific parameters */ 20620e78d158Sadam radford if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) || 20630e78d158Sadam radford (pdev->device == PCI_DEVICE_ID_3WARE_9690SA)) 20644039c30eSadam radford host->max_id = TW_MAX_UNITS_9650SE; 20654039c30eSadam radford else 20661da177e4SLinus Torvalds host->max_id = TW_MAX_UNITS; 20674039c30eSadam radford 20681da177e4SLinus Torvalds host->max_cmd_len = TW_MAX_CDB_LEN; 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds /* Channels aren't supported by adapter */ 20714039c30eSadam radford host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl); 20721da177e4SLinus Torvalds host->max_channel = 0; 20731da177e4SLinus Torvalds 20741da177e4SLinus Torvalds /* Register the card with the kernel SCSI layer */ 20751da177e4SLinus Torvalds retval = scsi_add_host(host, &pdev->dev); 20761da177e4SLinus Torvalds if (retval) { 20771da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed"); 20784039c30eSadam radford goto out_iounmap; 20791da177e4SLinus Torvalds } 20801da177e4SLinus Torvalds 20811da177e4SLinus Torvalds pci_set_drvdata(pdev, host); 20821da177e4SLinus Torvalds 20833dabec71Sadam radford printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%lx, IRQ: %d.\n", 20841da177e4SLinus Torvalds host->host_no, mem_addr, pdev->irq); 20851da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n", 20861da177e4SLinus Torvalds host->host_no, 20871da177e4SLinus Torvalds (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE, 20881da177e4SLinus Torvalds TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH), 20891da177e4SLinus Torvalds (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE, 20901da177e4SLinus Torvalds TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH), 209175913d9bSadam radford le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE, 209275913d9bSadam radford TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH))); 20931da177e4SLinus Torvalds 20943dabec71Sadam radford /* Try to enable MSI */ 20953dabec71Sadam radford if (use_msi && (pdev->device != PCI_DEVICE_ID_3WARE_9000) && 20963dabec71Sadam radford !pci_enable_msi(pdev)) 20973dabec71Sadam radford set_bit(TW_USING_MSI, &tw_dev->flags); 20983dabec71Sadam radford 20991da177e4SLinus Torvalds /* Now setup the interrupt handler */ 21001d6f359aSThomas Gleixner retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev); 21011da177e4SLinus Torvalds if (retval) { 21021da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ"); 21031da177e4SLinus Torvalds goto out_remove_host; 21041da177e4SLinus Torvalds } 21051da177e4SLinus Torvalds 21061da177e4SLinus Torvalds twa_device_extension_list[twa_device_extension_count] = tw_dev; 21071da177e4SLinus Torvalds twa_device_extension_count++; 21081da177e4SLinus Torvalds 21091da177e4SLinus Torvalds /* Re-enable interrupts on the card */ 21101da177e4SLinus Torvalds TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds /* Finally, scan the host */ 21131da177e4SLinus Torvalds scsi_scan_host(host); 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds if (twa_major == -1) { 21161da177e4SLinus Torvalds if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0) 21171da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device"); 21181da177e4SLinus Torvalds } 21191da177e4SLinus Torvalds return 0; 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds out_remove_host: 21223dabec71Sadam radford if (test_bit(TW_USING_MSI, &tw_dev->flags)) 21233dabec71Sadam radford pci_disable_msi(pdev); 21241da177e4SLinus Torvalds scsi_remove_host(host); 21254039c30eSadam radford out_iounmap: 21264039c30eSadam radford iounmap(tw_dev->base_addr); 21271da177e4SLinus Torvalds out_release_mem_region: 21281da177e4SLinus Torvalds pci_release_regions(pdev); 21291da177e4SLinus Torvalds out_free_device_extension: 21301da177e4SLinus Torvalds twa_free_device_extension(tw_dev); 21311da177e4SLinus Torvalds scsi_host_put(host); 21321da177e4SLinus Torvalds out_disable_device: 21331da177e4SLinus Torvalds pci_disable_device(pdev); 21341da177e4SLinus Torvalds 21351da177e4SLinus Torvalds return retval; 21361da177e4SLinus Torvalds } /* End twa_probe() */ 21371da177e4SLinus Torvalds 21381da177e4SLinus Torvalds /* This function is called to remove a device */ 21391da177e4SLinus Torvalds static void twa_remove(struct pci_dev *pdev) 21401da177e4SLinus Torvalds { 21411da177e4SLinus Torvalds struct Scsi_Host *host = pci_get_drvdata(pdev); 21421da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 21431da177e4SLinus Torvalds 21441da177e4SLinus Torvalds scsi_remove_host(tw_dev->host); 21451da177e4SLinus Torvalds 21461da177e4SLinus Torvalds /* Unregister character device */ 21471da177e4SLinus Torvalds if (twa_major >= 0) { 21481da177e4SLinus Torvalds unregister_chrdev(twa_major, "twa"); 21491da177e4SLinus Torvalds twa_major = -1; 21501da177e4SLinus Torvalds } 21511da177e4SLinus Torvalds 21521da177e4SLinus Torvalds /* Shutdown the card */ 21531da177e4SLinus Torvalds __twa_shutdown(tw_dev); 21541da177e4SLinus Torvalds 21553dabec71Sadam radford /* Disable MSI if enabled */ 21563dabec71Sadam radford if (test_bit(TW_USING_MSI, &tw_dev->flags)) 21573dabec71Sadam radford pci_disable_msi(pdev); 21583dabec71Sadam radford 21594039c30eSadam radford /* Free IO remapping */ 21604039c30eSadam radford iounmap(tw_dev->base_addr); 21614039c30eSadam radford 21621da177e4SLinus Torvalds /* Free up the mem region */ 21631da177e4SLinus Torvalds pci_release_regions(pdev); 21641da177e4SLinus Torvalds 21651da177e4SLinus Torvalds /* Free up device extension resources */ 21661da177e4SLinus Torvalds twa_free_device_extension(tw_dev); 21671da177e4SLinus Torvalds 21681da177e4SLinus Torvalds scsi_host_put(tw_dev->host); 21691da177e4SLinus Torvalds pci_disable_device(pdev); 21701da177e4SLinus Torvalds twa_device_extension_count--; 21711da177e4SLinus Torvalds } /* End twa_remove() */ 21721da177e4SLinus Torvalds 21737a252fe7Sadam radford #ifdef CONFIG_PM 21747a252fe7Sadam radford /* This function is called on PCI suspend */ 21757a252fe7Sadam radford static int twa_suspend(struct pci_dev *pdev, pm_message_t state) 21767a252fe7Sadam radford { 21777a252fe7Sadam radford struct Scsi_Host *host = pci_get_drvdata(pdev); 21787a252fe7Sadam radford TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 21797a252fe7Sadam radford 21807a252fe7Sadam radford printk(KERN_WARNING "3w-9xxx: Suspending host %d.\n", tw_dev->host->host_no); 21817a252fe7Sadam radford 21827a252fe7Sadam radford TW_DISABLE_INTERRUPTS(tw_dev); 21837a252fe7Sadam radford free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 21847a252fe7Sadam radford 21857a252fe7Sadam radford if (test_bit(TW_USING_MSI, &tw_dev->flags)) 21867a252fe7Sadam radford pci_disable_msi(pdev); 21877a252fe7Sadam radford 21887a252fe7Sadam radford /* Tell the card we are shutting down */ 21897a252fe7Sadam radford if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) { 21907a252fe7Sadam radford TW_PRINTK(tw_dev->host, TW_DRIVER, 0x38, "Connection shutdown failed during suspend"); 21917a252fe7Sadam radford } else { 21927a252fe7Sadam radford printk(KERN_WARNING "3w-9xxx: Suspend complete.\n"); 21937a252fe7Sadam radford } 21947a252fe7Sadam radford TW_CLEAR_ALL_INTERRUPTS(tw_dev); 21957a252fe7Sadam radford 21967a252fe7Sadam radford pci_save_state(pdev); 21977a252fe7Sadam radford pci_disable_device(pdev); 21987a252fe7Sadam radford pci_set_power_state(pdev, pci_choose_state(pdev, state)); 21997a252fe7Sadam radford 22007a252fe7Sadam radford return 0; 22017a252fe7Sadam radford } /* End twa_suspend() */ 22027a252fe7Sadam radford 22037a252fe7Sadam radford /* This function is called on PCI resume */ 22047a252fe7Sadam radford static int twa_resume(struct pci_dev *pdev) 22057a252fe7Sadam radford { 22067a252fe7Sadam radford int retval = 0; 22077a252fe7Sadam radford struct Scsi_Host *host = pci_get_drvdata(pdev); 22087a252fe7Sadam radford TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 22097a252fe7Sadam radford 22107a252fe7Sadam radford printk(KERN_WARNING "3w-9xxx: Resuming host %d.\n", tw_dev->host->host_no); 22117a252fe7Sadam radford pci_set_power_state(pdev, PCI_D0); 22127a252fe7Sadam radford pci_enable_wake(pdev, PCI_D0, 0); 22137a252fe7Sadam radford pci_restore_state(pdev); 22147a252fe7Sadam radford 22157a252fe7Sadam radford retval = pci_enable_device(pdev); 22167a252fe7Sadam radford if (retval) { 22177a252fe7Sadam radford TW_PRINTK(tw_dev->host, TW_DRIVER, 0x39, "Enable device failed during resume"); 22187a252fe7Sadam radford return retval; 22197a252fe7Sadam radford } 22207a252fe7Sadam radford 22217a252fe7Sadam radford pci_set_master(pdev); 22227a252fe7Sadam radford pci_try_set_mwi(pdev); 22237a252fe7Sadam radford 2224e930438cSYang Hongyang if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) 2225e930438cSYang Hongyang || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64))) 2226e930438cSYang Hongyang if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) 2227e930438cSYang Hongyang || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) { 22287a252fe7Sadam radford TW_PRINTK(host, TW_DRIVER, 0x40, "Failed to set dma mask during resume"); 22297a252fe7Sadam radford retval = -ENODEV; 22307a252fe7Sadam radford goto out_disable_device; 22317a252fe7Sadam radford } 22327a252fe7Sadam radford 22337a252fe7Sadam radford /* Initialize the card */ 22347a252fe7Sadam radford if (twa_reset_sequence(tw_dev, 0)) { 22357a252fe7Sadam radford retval = -ENODEV; 22367a252fe7Sadam radford goto out_disable_device; 22377a252fe7Sadam radford } 22387a252fe7Sadam radford 22397a252fe7Sadam radford /* Now setup the interrupt handler */ 22407a252fe7Sadam radford retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev); 22417a252fe7Sadam radford if (retval) { 22427a252fe7Sadam radford TW_PRINTK(tw_dev->host, TW_DRIVER, 0x42, "Error requesting IRQ during resume"); 22437a252fe7Sadam radford retval = -ENODEV; 22447a252fe7Sadam radford goto out_disable_device; 22457a252fe7Sadam radford } 22467a252fe7Sadam radford 22477a252fe7Sadam radford /* Now enable MSI if enabled */ 22487a252fe7Sadam radford if (test_bit(TW_USING_MSI, &tw_dev->flags)) 22497a252fe7Sadam radford pci_enable_msi(pdev); 22507a252fe7Sadam radford 22517a252fe7Sadam radford /* Re-enable interrupts on the card */ 22527a252fe7Sadam radford TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 22537a252fe7Sadam radford 22547a252fe7Sadam radford printk(KERN_WARNING "3w-9xxx: Resume complete.\n"); 22557a252fe7Sadam radford return 0; 22567a252fe7Sadam radford 22577a252fe7Sadam radford out_disable_device: 22587a252fe7Sadam radford scsi_remove_host(host); 22597a252fe7Sadam radford pci_disable_device(pdev); 22607a252fe7Sadam radford 22617a252fe7Sadam radford return retval; 22627a252fe7Sadam radford } /* End twa_resume() */ 22637a252fe7Sadam radford #endif 22647a252fe7Sadam radford 22651da177e4SLinus Torvalds /* PCI Devices supported by this driver */ 22666f039790SGreg Kroah-Hartman static struct pci_device_id twa_pci_tbl[] = { 22671da177e4SLinus Torvalds { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000, 22681da177e4SLinus Torvalds PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 226949bfd8dbSadam radford { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX, 227049bfd8dbSadam radford PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 22714039c30eSadam radford { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE, 22724039c30eSadam radford PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 22730e78d158Sadam radford { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA, 22740e78d158Sadam radford PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 22751da177e4SLinus Torvalds { } 22761da177e4SLinus Torvalds }; 22771da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, twa_pci_tbl); 22781da177e4SLinus Torvalds 22791da177e4SLinus Torvalds /* pci_driver initializer */ 22801da177e4SLinus Torvalds static struct pci_driver twa_driver = { 22811da177e4SLinus Torvalds .name = "3w-9xxx", 22821da177e4SLinus Torvalds .id_table = twa_pci_tbl, 22831da177e4SLinus Torvalds .probe = twa_probe, 22841da177e4SLinus Torvalds .remove = twa_remove, 22857a252fe7Sadam radford #ifdef CONFIG_PM 22867a252fe7Sadam radford .suspend = twa_suspend, 22877a252fe7Sadam radford .resume = twa_resume, 22887a252fe7Sadam radford #endif 22891da177e4SLinus Torvalds .shutdown = twa_shutdown 22901da177e4SLinus Torvalds }; 22911da177e4SLinus Torvalds 22921da177e4SLinus Torvalds /* This function is called on driver initialization */ 22931da177e4SLinus Torvalds static int __init twa_init(void) 22941da177e4SLinus Torvalds { 22951da177e4SLinus Torvalds printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION); 22961da177e4SLinus Torvalds 2297dcbccbdeSHenrik Kretzschmar return pci_register_driver(&twa_driver); 22981da177e4SLinus Torvalds } /* End twa_init() */ 22991da177e4SLinus Torvalds 23001da177e4SLinus Torvalds /* This function is called on driver exit */ 23011da177e4SLinus Torvalds static void __exit twa_exit(void) 23021da177e4SLinus Torvalds { 23031da177e4SLinus Torvalds pci_unregister_driver(&twa_driver); 23041da177e4SLinus Torvalds } /* End twa_exit() */ 23051da177e4SLinus Torvalds 23061da177e4SLinus Torvalds module_init(twa_init); 23071da177e4SLinus Torvalds module_exit(twa_exit); 23081da177e4SLinus Torvalds 2309