11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds 3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux. 31da177e4SLinus Torvalds 41da177e4SLinus Torvalds Written By: Adam Radford <linuxraid@amcc.com> 51da177e4SLinus Torvalds 61da177e4SLinus Torvalds Copyright (C) 2004-2005 Applied Micro Circuits Corporation. 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds it under the terms of the GNU General Public License as published by 101da177e4SLinus Torvalds the Free Software Foundation; version 2 of the License. 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds This program is distributed in the hope that it will be useful, 131da177e4SLinus Torvalds but WITHOUT ANY WARRANTY; without even the implied warranty of 141da177e4SLinus Torvalds MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 151da177e4SLinus Torvalds GNU General Public License for more details. 161da177e4SLinus Torvalds 171da177e4SLinus Torvalds NO WARRANTY 181da177e4SLinus Torvalds THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 191da177e4SLinus Torvalds CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 201da177e4SLinus Torvalds LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 211da177e4SLinus Torvalds MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 221da177e4SLinus Torvalds solely responsible for determining the appropriateness of using and 231da177e4SLinus Torvalds distributing the Program and assumes all risks associated with its 241da177e4SLinus Torvalds exercise of rights under this Agreement, including but not limited to 251da177e4SLinus Torvalds the risks and costs of program errors, damage to or loss of data, 261da177e4SLinus Torvalds programs or equipment, and unavailability or interruption of operations. 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds DISCLAIMER OF LIABILITY 291da177e4SLinus Torvalds NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 301da177e4SLinus Torvalds DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 311da177e4SLinus Torvalds DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 321da177e4SLinus Torvalds ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 331da177e4SLinus Torvalds TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 341da177e4SLinus Torvalds USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 351da177e4SLinus Torvalds HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds You should have received a copy of the GNU General Public License 381da177e4SLinus Torvalds along with this program; if not, write to the Free Software 391da177e4SLinus Torvalds Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds Bugs/Comments/Suggestions should be mailed to: 421da177e4SLinus Torvalds linuxraid@amcc.com 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds For more information, goto: 451da177e4SLinus Torvalds http://www.amcc.com 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds Note: This version of the driver does not contain a bundled firmware 481da177e4SLinus Torvalds image. 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds History 511da177e4SLinus Torvalds ------- 521da177e4SLinus Torvalds 2.26.02.000 - Driver cleanup for kernel submission. 531da177e4SLinus Torvalds 2.26.02.001 - Replace schedule_timeout() calls with msleep(). 541da177e4SLinus Torvalds 2.26.02.002 - Add support for PAE mode. 551da177e4SLinus Torvalds Add lun support. 561da177e4SLinus Torvalds Fix twa_remove() to free irq handler/unregister_chrdev() 571da177e4SLinus Torvalds before shutting down card. 581da177e4SLinus Torvalds Change to new 'change_queue_depth' api. 591da177e4SLinus Torvalds Fix 'handled=1' ISR usage, remove bogus IRQ check. 601da177e4SLinus Torvalds Remove un-needed eh_abort handler. 611da177e4SLinus Torvalds Add support for embedded firmware error strings. 62d327d082Sadam radford 2.26.02.003 - Correctly handle single sgl's with use_sg=1. 6349bfd8dbSadam radford 2.26.02.004 - Add support for 9550SX controllers. 6462288f10Sadam radford 2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher. 651da177e4SLinus Torvalds */ 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds #include <linux/module.h> 681da177e4SLinus Torvalds #include <linux/reboot.h> 691da177e4SLinus Torvalds #include <linux/spinlock.h> 701da177e4SLinus Torvalds #include <linux/interrupt.h> 711da177e4SLinus Torvalds #include <linux/moduleparam.h> 721da177e4SLinus Torvalds #include <linux/errno.h> 731da177e4SLinus Torvalds #include <linux/types.h> 741da177e4SLinus Torvalds #include <linux/delay.h> 751da177e4SLinus Torvalds #include <linux/pci.h> 761da177e4SLinus Torvalds #include <linux/time.h> 77a12e25bdSJes Sorensen #include <linux/mutex.h> 781da177e4SLinus Torvalds #include <asm/io.h> 791da177e4SLinus Torvalds #include <asm/irq.h> 801da177e4SLinus Torvalds #include <asm/uaccess.h> 811da177e4SLinus Torvalds #include <scsi/scsi.h> 821da177e4SLinus Torvalds #include <scsi/scsi_host.h> 831da177e4SLinus Torvalds #include <scsi/scsi_tcq.h> 841da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 851da177e4SLinus Torvalds #include "3w-9xxx.h" 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds /* Globals */ 8862288f10Sadam radford #define TW_DRIVER_VERSION "2.26.02.005" 891da177e4SLinus Torvalds static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT]; 901da177e4SLinus Torvalds static unsigned int twa_device_extension_count; 911da177e4SLinus Torvalds static int twa_major = -1; 921da177e4SLinus Torvalds extern struct timezone sys_tz; 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* Module parameters */ 951da177e4SLinus Torvalds MODULE_AUTHOR ("AMCC"); 961da177e4SLinus Torvalds MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver"); 971da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 981da177e4SLinus Torvalds MODULE_VERSION(TW_DRIVER_VERSION); 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds /* Function prototypes */ 1011da177e4SLinus Torvalds static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header); 1021da177e4SLinus Torvalds static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id); 1031da177e4SLinus Torvalds static char *twa_aen_severity_lookup(unsigned char severity_code); 1041da177e4SLinus Torvalds static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id); 1051da177e4SLinus Torvalds static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg); 1061da177e4SLinus Torvalds static int twa_chrdev_open(struct inode *inode, struct file *file); 1071da177e4SLinus Torvalds static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host); 1081da177e4SLinus Torvalds static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id); 1091da177e4SLinus Torvalds static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id); 1101da177e4SLinus Torvalds static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits, 1111da177e4SLinus Torvalds u32 set_features, unsigned short current_fw_srl, 1121da177e4SLinus Torvalds unsigned short current_fw_arch_id, 1131da177e4SLinus Torvalds unsigned short current_fw_branch, 1141da177e4SLinus Torvalds unsigned short current_fw_build, 1151da177e4SLinus Torvalds unsigned short *fw_on_ctlr_srl, 1161da177e4SLinus Torvalds unsigned short *fw_on_ctlr_arch_id, 1171da177e4SLinus Torvalds unsigned short *fw_on_ctlr_branch, 1181da177e4SLinus Torvalds unsigned short *fw_on_ctlr_build, 1191da177e4SLinus Torvalds u32 *init_connect_result); 1201da177e4SLinus Torvalds static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length); 1211da177e4SLinus Torvalds static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds); 1221da177e4SLinus Torvalds static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds); 1231da177e4SLinus Torvalds static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal); 1241da177e4SLinus Torvalds static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset); 1251da177e4SLinus Torvalds static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset); 1261da177e4SLinus Torvalds static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg); 1271da177e4SLinus Torvalds static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id); 1281da177e4SLinus Torvalds static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code); 1291da177e4SLinus Torvalds static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id); 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds /* Functions */ 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds /* Show some statistics about the card */ 1341da177e4SLinus Torvalds static ssize_t twa_show_stats(struct class_device *class_dev, char *buf) 1351da177e4SLinus Torvalds { 1361da177e4SLinus Torvalds struct Scsi_Host *host = class_to_shost(class_dev); 1371da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 1381da177e4SLinus Torvalds unsigned long flags = 0; 1391da177e4SLinus Torvalds ssize_t len; 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 1421da177e4SLinus Torvalds len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n" 1431da177e4SLinus Torvalds "Current commands posted: %4d\n" 1441da177e4SLinus Torvalds "Max commands posted: %4d\n" 1451da177e4SLinus Torvalds "Current pending commands: %4d\n" 1461da177e4SLinus Torvalds "Max pending commands: %4d\n" 1471da177e4SLinus Torvalds "Last sgl length: %4d\n" 1481da177e4SLinus Torvalds "Max sgl length: %4d\n" 1491da177e4SLinus Torvalds "Last sector count: %4d\n" 1501da177e4SLinus Torvalds "Max sector count: %4d\n" 1511da177e4SLinus Torvalds "SCSI Host Resets: %4d\n" 1521da177e4SLinus Torvalds "AEN's: %4d\n", 1531da177e4SLinus Torvalds TW_DRIVER_VERSION, 1541da177e4SLinus Torvalds tw_dev->posted_request_count, 1551da177e4SLinus Torvalds tw_dev->max_posted_request_count, 1561da177e4SLinus Torvalds tw_dev->pending_request_count, 1571da177e4SLinus Torvalds tw_dev->max_pending_request_count, 1581da177e4SLinus Torvalds tw_dev->sgl_entries, 1591da177e4SLinus Torvalds tw_dev->max_sgl_entries, 1601da177e4SLinus Torvalds tw_dev->sector_count, 1611da177e4SLinus Torvalds tw_dev->max_sector_count, 1621da177e4SLinus Torvalds tw_dev->num_resets, 1631da177e4SLinus Torvalds tw_dev->aen_count); 1641da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1651da177e4SLinus Torvalds return len; 1661da177e4SLinus Torvalds } /* End twa_show_stats() */ 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds /* This function will set a devices queue depth */ 1691da177e4SLinus Torvalds static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth) 1701da177e4SLinus Torvalds { 1711da177e4SLinus Torvalds if (queue_depth > TW_Q_LENGTH-2) 1721da177e4SLinus Torvalds queue_depth = TW_Q_LENGTH-2; 1731da177e4SLinus Torvalds scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth); 1741da177e4SLinus Torvalds return queue_depth; 1751da177e4SLinus Torvalds } /* End twa_change_queue_depth() */ 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds /* Create sysfs 'stats' entry */ 1781da177e4SLinus Torvalds static struct class_device_attribute twa_host_stats_attr = { 1791da177e4SLinus Torvalds .attr = { 1801da177e4SLinus Torvalds .name = "stats", 1811da177e4SLinus Torvalds .mode = S_IRUGO, 1821da177e4SLinus Torvalds }, 1831da177e4SLinus Torvalds .show = twa_show_stats 1841da177e4SLinus Torvalds }; 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds /* Host attributes initializer */ 1871da177e4SLinus Torvalds static struct class_device_attribute *twa_host_attrs[] = { 1881da177e4SLinus Torvalds &twa_host_stats_attr, 1891da177e4SLinus Torvalds NULL, 1901da177e4SLinus Torvalds }; 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds /* File operations struct for character device */ 1931da177e4SLinus Torvalds static struct file_operations twa_fops = { 1941da177e4SLinus Torvalds .owner = THIS_MODULE, 1951da177e4SLinus Torvalds .ioctl = twa_chrdev_ioctl, 1961da177e4SLinus Torvalds .open = twa_chrdev_open, 1971da177e4SLinus Torvalds .release = NULL 1981da177e4SLinus Torvalds }; 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* This function will complete an aen request from the isr */ 2011da177e4SLinus Torvalds static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id) 2021da177e4SLinus Torvalds { 2031da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 2041da177e4SLinus Torvalds TW_Command *command_packet; 2051da177e4SLinus Torvalds TW_Command_Apache_Header *header; 2061da177e4SLinus Torvalds unsigned short aen; 2071da177e4SLinus Torvalds int retval = 1; 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 2101da177e4SLinus Torvalds tw_dev->posted_request_count--; 2111da177e4SLinus Torvalds aen = header->status_block.error; 2121da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 2131da177e4SLinus Torvalds command_packet = &full_command_packet->command.oldcommand; 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds /* First check for internal completion of set param for time sync */ 2161da177e4SLinus Torvalds if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) { 2171da177e4SLinus Torvalds /* Keep reading the queue in case there are more aen's */ 2181da177e4SLinus Torvalds if (twa_aen_read_queue(tw_dev, request_id)) 2191da177e4SLinus Torvalds goto out2; 2201da177e4SLinus Torvalds else { 2211da177e4SLinus Torvalds retval = 0; 2221da177e4SLinus Torvalds goto out; 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds } 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds switch (aen) { 2271da177e4SLinus Torvalds case TW_AEN_QUEUE_EMPTY: 2281da177e4SLinus Torvalds /* Quit reading the queue if this is the last one */ 2291da177e4SLinus Torvalds break; 2301da177e4SLinus Torvalds case TW_AEN_SYNC_TIME_WITH_HOST: 2311da177e4SLinus Torvalds twa_aen_sync_time(tw_dev, request_id); 2321da177e4SLinus Torvalds retval = 0; 2331da177e4SLinus Torvalds goto out; 2341da177e4SLinus Torvalds default: 2351da177e4SLinus Torvalds twa_aen_queue_event(tw_dev, header); 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds /* If there are more aen's, keep reading the queue */ 2381da177e4SLinus Torvalds if (twa_aen_read_queue(tw_dev, request_id)) 2391da177e4SLinus Torvalds goto out2; 2401da177e4SLinus Torvalds else { 2411da177e4SLinus Torvalds retval = 0; 2421da177e4SLinus Torvalds goto out; 2431da177e4SLinus Torvalds } 2441da177e4SLinus Torvalds } 2451da177e4SLinus Torvalds retval = 0; 2461da177e4SLinus Torvalds out2: 2471da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 2481da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 2491da177e4SLinus Torvalds clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 2501da177e4SLinus Torvalds out: 2511da177e4SLinus Torvalds return retval; 2521da177e4SLinus Torvalds } /* End twa_aen_complete() */ 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds /* This function will drain aen queue */ 2551da177e4SLinus Torvalds static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset) 2561da177e4SLinus Torvalds { 2571da177e4SLinus Torvalds int request_id = 0; 2581da177e4SLinus Torvalds char cdb[TW_MAX_CDB_LEN]; 2591da177e4SLinus Torvalds TW_SG_Entry sglist[1]; 2601da177e4SLinus Torvalds int finished = 0, count = 0; 2611da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 2621da177e4SLinus Torvalds TW_Command_Apache_Header *header; 2631da177e4SLinus Torvalds unsigned short aen; 2641da177e4SLinus Torvalds int first_reset = 0, queue = 0, retval = 1; 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds if (no_check_reset) 2671da177e4SLinus Torvalds first_reset = 0; 2681da177e4SLinus Torvalds else 2691da177e4SLinus Torvalds first_reset = 1; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 2721da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds /* Initialize cdb */ 2751da177e4SLinus Torvalds memset(&cdb, 0, TW_MAX_CDB_LEN); 2761da177e4SLinus Torvalds cdb[0] = REQUEST_SENSE; /* opcode */ 2771da177e4SLinus Torvalds cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds /* Initialize sglist */ 2801da177e4SLinus Torvalds memset(&sglist, 0, sizeof(TW_SG_Entry)); 2811da177e4SLinus Torvalds sglist[0].length = TW_SECTOR_SIZE; 2821da177e4SLinus Torvalds sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds if (sglist[0].address & TW_ALIGNMENT_9000_SGL) { 2851da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain"); 2861da177e4SLinus Torvalds goto out; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds /* Mark internal command */ 2901da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds do { 2931da177e4SLinus Torvalds /* Send command to the board */ 2941da177e4SLinus Torvalds if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 2951da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense"); 2961da177e4SLinus Torvalds goto out; 2971da177e4SLinus Torvalds } 2981da177e4SLinus Torvalds 2991da177e4SLinus Torvalds /* Now poll for completion */ 3001da177e4SLinus Torvalds if (twa_poll_response(tw_dev, request_id, 30)) { 3011da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue"); 3021da177e4SLinus Torvalds tw_dev->posted_request_count--; 3031da177e4SLinus Torvalds goto out; 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds tw_dev->posted_request_count--; 3071da177e4SLinus Torvalds header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id]; 3081da177e4SLinus Torvalds aen = header->status_block.error; 3091da177e4SLinus Torvalds queue = 0; 3101da177e4SLinus Torvalds count++; 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds switch (aen) { 3131da177e4SLinus Torvalds case TW_AEN_QUEUE_EMPTY: 3141da177e4SLinus Torvalds if (first_reset != 1) 3151da177e4SLinus Torvalds goto out; 3161da177e4SLinus Torvalds else 3171da177e4SLinus Torvalds finished = 1; 3181da177e4SLinus Torvalds break; 3191da177e4SLinus Torvalds case TW_AEN_SOFT_RESET: 3201da177e4SLinus Torvalds if (first_reset == 0) 3211da177e4SLinus Torvalds first_reset = 1; 3221da177e4SLinus Torvalds else 3231da177e4SLinus Torvalds queue = 1; 3241da177e4SLinus Torvalds break; 3251da177e4SLinus Torvalds case TW_AEN_SYNC_TIME_WITH_HOST: 3261da177e4SLinus Torvalds break; 3271da177e4SLinus Torvalds default: 3281da177e4SLinus Torvalds queue = 1; 3291da177e4SLinus Torvalds } 3301da177e4SLinus Torvalds 3311da177e4SLinus Torvalds /* Now queue an event info */ 3321da177e4SLinus Torvalds if (queue) 3331da177e4SLinus Torvalds twa_aen_queue_event(tw_dev, header); 3341da177e4SLinus Torvalds } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN)); 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds if (count == TW_MAX_AEN_DRAIN) 3371da177e4SLinus Torvalds goto out; 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds retval = 0; 3401da177e4SLinus Torvalds out: 3411da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_INITIAL; 3421da177e4SLinus Torvalds return retval; 3431da177e4SLinus Torvalds } /* End twa_aen_drain_queue() */ 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds /* This function will queue an event */ 3461da177e4SLinus Torvalds static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header) 3471da177e4SLinus Torvalds { 3481da177e4SLinus Torvalds u32 local_time; 3491da177e4SLinus Torvalds struct timeval time; 3501da177e4SLinus Torvalds TW_Event *event; 3511da177e4SLinus Torvalds unsigned short aen; 3521da177e4SLinus Torvalds char host[16]; 3531da177e4SLinus Torvalds char *error_str; 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds tw_dev->aen_count++; 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds /* Fill out event info */ 3581da177e4SLinus Torvalds event = tw_dev->event_queue[tw_dev->error_index]; 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds /* Check for clobber */ 3611da177e4SLinus Torvalds host[0] = '\0'; 3621da177e4SLinus Torvalds if (tw_dev->host) { 3631da177e4SLinus Torvalds sprintf(host, " scsi%d:", tw_dev->host->host_no); 3641da177e4SLinus Torvalds if (event->retrieved == TW_AEN_NOT_RETRIEVED) 3651da177e4SLinus Torvalds tw_dev->aen_clobber = 1; 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds aen = header->status_block.error; 3691da177e4SLinus Torvalds memset(event, 0, sizeof(TW_Event)); 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds event->severity = TW_SEV_OUT(header->status_block.severity__reserved); 3721da177e4SLinus Torvalds do_gettimeofday(&time); 3731da177e4SLinus Torvalds local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60)); 3741da177e4SLinus Torvalds event->time_stamp_sec = local_time; 3751da177e4SLinus Torvalds event->aen_code = aen; 3761da177e4SLinus Torvalds event->retrieved = TW_AEN_NOT_RETRIEVED; 3771da177e4SLinus Torvalds event->sequence_id = tw_dev->error_sequence_id; 3781da177e4SLinus Torvalds tw_dev->error_sequence_id++; 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds /* Check for embedded error string */ 3811da177e4SLinus Torvalds error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]); 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0'; 3841da177e4SLinus Torvalds event->parameter_len = strlen(header->err_specific_desc); 3851da177e4SLinus Torvalds memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len); 3861da177e4SLinus Torvalds if (event->severity != TW_AEN_SEVERITY_DEBUG) 3871da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n", 3881da177e4SLinus Torvalds host, 3891da177e4SLinus Torvalds twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)), 3901da177e4SLinus Torvalds TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, 3911da177e4SLinus Torvalds error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str, 3921da177e4SLinus Torvalds header->err_specific_desc); 3931da177e4SLinus Torvalds else 3941da177e4SLinus Torvalds tw_dev->aen_count--; 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds if ((tw_dev->error_index + 1) == TW_Q_LENGTH) 3971da177e4SLinus Torvalds tw_dev->event_queue_wrapped = 1; 3981da177e4SLinus Torvalds tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH; 3991da177e4SLinus Torvalds } /* End twa_aen_queue_event() */ 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds /* This function will read the aen queue from the isr */ 4021da177e4SLinus Torvalds static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id) 4031da177e4SLinus Torvalds { 4041da177e4SLinus Torvalds char cdb[TW_MAX_CDB_LEN]; 4051da177e4SLinus Torvalds TW_SG_Entry sglist[1]; 4061da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 4071da177e4SLinus Torvalds int retval = 1; 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 4101da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds /* Initialize cdb */ 4131da177e4SLinus Torvalds memset(&cdb, 0, TW_MAX_CDB_LEN); 4141da177e4SLinus Torvalds cdb[0] = REQUEST_SENSE; /* opcode */ 4151da177e4SLinus Torvalds cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */ 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds /* Initialize sglist */ 4181da177e4SLinus Torvalds memset(&sglist, 0, sizeof(TW_SG_Entry)); 4191da177e4SLinus Torvalds sglist[0].length = TW_SECTOR_SIZE; 4201da177e4SLinus Torvalds sglist[0].address = tw_dev->generic_buffer_phys[request_id]; 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds /* Mark internal command */ 4231da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 4241da177e4SLinus Torvalds 4251da177e4SLinus Torvalds /* Now post the command packet */ 4261da177e4SLinus Torvalds if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) { 4271da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue"); 4281da177e4SLinus Torvalds goto out; 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds retval = 0; 4311da177e4SLinus Torvalds out: 4321da177e4SLinus Torvalds return retval; 4331da177e4SLinus Torvalds } /* End twa_aen_read_queue() */ 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds /* This function will look up an AEN severity string */ 4361da177e4SLinus Torvalds static char *twa_aen_severity_lookup(unsigned char severity_code) 4371da177e4SLinus Torvalds { 4381da177e4SLinus Torvalds char *retval = NULL; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) || 4411da177e4SLinus Torvalds (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG)) 4421da177e4SLinus Torvalds goto out; 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds retval = twa_aen_severity_table[severity_code]; 4451da177e4SLinus Torvalds out: 4461da177e4SLinus Torvalds return retval; 4471da177e4SLinus Torvalds } /* End twa_aen_severity_lookup() */ 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds /* This function will sync firmware time with the host time */ 4501da177e4SLinus Torvalds static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id) 4511da177e4SLinus Torvalds { 4521da177e4SLinus Torvalds u32 schedulertime; 4531da177e4SLinus Torvalds struct timeval utc; 4541da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 4551da177e4SLinus Torvalds TW_Command *command_packet; 4561da177e4SLinus Torvalds TW_Param_Apache *param; 4571da177e4SLinus Torvalds u32 local_time; 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds /* Fill out the command packet */ 4601da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 4611da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 4621da177e4SLinus Torvalds command_packet = &full_command_packet->command.oldcommand; 4631da177e4SLinus Torvalds command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM); 4641da177e4SLinus Torvalds command_packet->request_id = request_id; 4651da177e4SLinus Torvalds command_packet->byte8_offset.param.sgl[0].address = tw_dev->generic_buffer_phys[request_id]; 4661da177e4SLinus Torvalds command_packet->byte8_offset.param.sgl[0].length = TW_SECTOR_SIZE; 4671da177e4SLinus Torvalds command_packet->size = TW_COMMAND_SIZE; 4681da177e4SLinus Torvalds command_packet->byte6_offset.parameter_count = 1; 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds /* Setup the param */ 4711da177e4SLinus Torvalds param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 4721da177e4SLinus Torvalds memset(param, 0, TW_SECTOR_SIZE); 4731da177e4SLinus Torvalds param->table_id = TW_TIMEKEEP_TABLE | 0x8000; /* Controller time keep table */ 4741da177e4SLinus Torvalds param->parameter_id = 0x3; /* SchedulerTime */ 4751da177e4SLinus Torvalds param->parameter_size_bytes = 4; 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds /* Convert system time in UTC to local time seconds since last 4781da177e4SLinus Torvalds Sunday 12:00AM */ 4791da177e4SLinus Torvalds do_gettimeofday(&utc); 4801da177e4SLinus Torvalds local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60)); 4811da177e4SLinus Torvalds schedulertime = local_time - (3 * 86400); 4821da177e4SLinus Torvalds schedulertime = schedulertime % 604800; 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds memcpy(param->data, &schedulertime, sizeof(u32)); 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds /* Mark internal command */ 4871da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds /* Now post the command */ 4901da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 4911da177e4SLinus Torvalds } /* End twa_aen_sync_time() */ 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds /* This function will allocate memory and check if it is correctly aligned */ 4941da177e4SLinus Torvalds static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) 4951da177e4SLinus Torvalds { 4961da177e4SLinus Torvalds int i; 4971da177e4SLinus Torvalds dma_addr_t dma_handle; 4981da177e4SLinus Torvalds unsigned long *cpu_addr; 4991da177e4SLinus Torvalds int retval = 1; 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle); 5021da177e4SLinus Torvalds if (!cpu_addr) { 5031da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed"); 5041da177e4SLinus Torvalds goto out; 5051da177e4SLinus Torvalds } 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) { 5081da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory"); 5091da177e4SLinus Torvalds pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle); 5101da177e4SLinus Torvalds goto out; 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds memset(cpu_addr, 0, size*TW_Q_LENGTH); 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 5161da177e4SLinus Torvalds switch(which) { 5171da177e4SLinus Torvalds case 0: 5181da177e4SLinus Torvalds tw_dev->command_packet_phys[i] = dma_handle+(i*size); 5191da177e4SLinus Torvalds tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size)); 5201da177e4SLinus Torvalds break; 5211da177e4SLinus Torvalds case 1: 5221da177e4SLinus Torvalds tw_dev->generic_buffer_phys[i] = dma_handle+(i*size); 5231da177e4SLinus Torvalds tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 5241da177e4SLinus Torvalds break; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds } 5271da177e4SLinus Torvalds retval = 0; 5281da177e4SLinus Torvalds out: 5291da177e4SLinus Torvalds return retval; 5301da177e4SLinus Torvalds } /* End twa_allocate_memory() */ 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds /* This function will check the status register for unexpected bits */ 5331da177e4SLinus Torvalds static int twa_check_bits(u32 status_reg_value) 5341da177e4SLinus Torvalds { 5351da177e4SLinus Torvalds int retval = 1; 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) 5381da177e4SLinus Torvalds goto out; 5391da177e4SLinus Torvalds if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) 5401da177e4SLinus Torvalds goto out; 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds retval = 0; 5431da177e4SLinus Torvalds out: 5441da177e4SLinus Torvalds return retval; 5451da177e4SLinus Torvalds } /* End twa_check_bits() */ 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds /* This function will check the srl and decide if we are compatible */ 5481da177e4SLinus Torvalds static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed) 5491da177e4SLinus Torvalds { 5501da177e4SLinus Torvalds int retval = 1; 5511da177e4SLinus Torvalds unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0; 5521da177e4SLinus Torvalds unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0; 5531da177e4SLinus Torvalds u32 init_connect_result = 0; 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS, 5561da177e4SLinus Torvalds TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL, 5571da177e4SLinus Torvalds TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH, 5581da177e4SLinus Torvalds TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl, 5591da177e4SLinus Torvalds &fw_on_ctlr_arch_id, &fw_on_ctlr_branch, 5601da177e4SLinus Torvalds &fw_on_ctlr_build, &init_connect_result)) { 5611da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL"); 5621da177e4SLinus Torvalds goto out; 5631da177e4SLinus Torvalds } 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds tw_dev->working_srl = fw_on_ctlr_srl; 5661da177e4SLinus Torvalds tw_dev->working_branch = fw_on_ctlr_branch; 5671da177e4SLinus Torvalds tw_dev->working_build = fw_on_ctlr_build; 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* Try base mode compatibility */ 5701da177e4SLinus Torvalds if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) { 5711da177e4SLinus Torvalds if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS, 5721da177e4SLinus Torvalds TW_EXTENDED_INIT_CONNECT, 5731da177e4SLinus Torvalds TW_BASE_FW_SRL, TW_9000_ARCH_ID, 5741da177e4SLinus Torvalds TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD, 5751da177e4SLinus Torvalds &fw_on_ctlr_srl, &fw_on_ctlr_arch_id, 5761da177e4SLinus Torvalds &fw_on_ctlr_branch, &fw_on_ctlr_build, 5771da177e4SLinus Torvalds &init_connect_result)) { 5781da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL"); 5791da177e4SLinus Torvalds goto out; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) { 5821da177e4SLinus Torvalds if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) { 5831da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware"); 5841da177e4SLinus Torvalds } else { 5851da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver"); 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds goto out; 5881da177e4SLinus Torvalds } 5891da177e4SLinus Torvalds tw_dev->working_srl = TW_BASE_FW_SRL; 5901da177e4SLinus Torvalds tw_dev->working_branch = TW_BASE_FW_BRANCH; 5911da177e4SLinus Torvalds tw_dev->working_build = TW_BASE_FW_BUILD; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds retval = 0; 5941da177e4SLinus Torvalds out: 5951da177e4SLinus Torvalds return retval; 5961da177e4SLinus Torvalds } /* End twa_check_srl() */ 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds /* This function handles ioctl for the character device */ 5991da177e4SLinus Torvalds static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 6001da177e4SLinus Torvalds { 6011da177e4SLinus Torvalds long timeout; 6021da177e4SLinus Torvalds unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0; 6031da177e4SLinus Torvalds dma_addr_t dma_handle; 6041da177e4SLinus Torvalds int request_id = 0; 6051da177e4SLinus Torvalds unsigned int sequence_id = 0; 6061da177e4SLinus Torvalds unsigned char event_index, start_index; 6071da177e4SLinus Torvalds TW_Ioctl_Driver_Command driver_command; 6081da177e4SLinus Torvalds TW_Ioctl_Buf_Apache *tw_ioctl; 6091da177e4SLinus Torvalds TW_Lock *tw_lock; 6101da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 6111da177e4SLinus Torvalds TW_Compatibility_Info *tw_compat_info; 6121da177e4SLinus Torvalds TW_Event *event; 6131da177e4SLinus Torvalds struct timeval current_time; 6141da177e4SLinus Torvalds u32 current_time_ms; 6151da177e4SLinus Torvalds TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)]; 6161da177e4SLinus Torvalds int retval = TW_IOCTL_ERROR_OS_EFAULT; 6171da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* Only let one of these through at a time */ 620a12e25bdSJes Sorensen if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) { 6211da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_EINTR; 6221da177e4SLinus Torvalds goto out; 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds /* First copy down the driver command */ 6261da177e4SLinus Torvalds if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command))) 6271da177e4SLinus Torvalds goto out2; 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds /* Check data buffer size */ 6301da177e4SLinus Torvalds if (driver_command.buffer_length > TW_MAX_SECTORS * 512) { 6311da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_EINVAL; 6321da177e4SLinus Torvalds goto out2; 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds /* Hardware can only do multiple of 512 byte transfers */ 6361da177e4SLinus Torvalds data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511; 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds /* Now allocate ioctl buf memory */ 6391da177e4SLinus 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); 6401da177e4SLinus Torvalds if (!cpu_addr) { 6411da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_ENOMEM; 6421da177e4SLinus Torvalds goto out2; 6431da177e4SLinus Torvalds } 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr; 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds /* Now copy down the entire ioctl */ 6481da177e4SLinus Torvalds if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1)) 6491da177e4SLinus Torvalds goto out3; 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds /* See which ioctl we are doing */ 6521da177e4SLinus Torvalds switch (cmd) { 6531da177e4SLinus Torvalds case TW_IOCTL_FIRMWARE_PASS_THROUGH: 6541da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 6551da177e4SLinus Torvalds twa_get_request_id(tw_dev, &request_id); 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds /* Flag internal command */ 6581da177e4SLinus Torvalds tw_dev->srb[request_id] = NULL; 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds /* Flag chrdev ioctl */ 6611da177e4SLinus Torvalds tw_dev->chrdev_request_id = request_id; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds full_command_packet = &tw_ioctl->firmware_command; 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds /* Load request id and sglist for both command types */ 6661da177e4SLinus Torvalds twa_load_sgl(full_command_packet, request_id, dma_handle, data_buffer_length_adjusted); 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full)); 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds /* Now post the command packet to the controller */ 6711da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 6721da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ; 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds /* Now wait for command to complete */ 6771da177e4SLinus Torvalds timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout); 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds /* See if we reset while waiting for the ioctl to complete */ 6801da177e4SLinus Torvalds if (test_bit(TW_IN_RESET, &tw_dev->flags)) { 6811da177e4SLinus Torvalds clear_bit(TW_IN_RESET, &tw_dev->flags); 6821da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_ERESTARTSYS; 6831da177e4SLinus Torvalds goto out3; 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds /* We timed out, and didn't get an interrupt */ 6871da177e4SLinus Torvalds if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) { 6881da177e4SLinus Torvalds /* Now we need to reset the board */ 6891da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n", 6901da177e4SLinus Torvalds tw_dev->host->host_no, TW_DRIVER, 0xc, 6911da177e4SLinus Torvalds cmd); 6921da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_EIO; 6931da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 6941da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 6951da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 6961da177e4SLinus Torvalds tw_dev->posted_request_count--; 6971da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 6981da177e4SLinus Torvalds twa_reset_device_extension(tw_dev, 1); 6991da177e4SLinus Torvalds goto out3; 7001da177e4SLinus Torvalds } 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds /* Now copy in the command packet response */ 7031da177e4SLinus Torvalds memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full)); 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds /* Now complete the io */ 7061da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 7071da177e4SLinus Torvalds tw_dev->posted_request_count--; 7081da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 7091da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 7101da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 7111da177e4SLinus Torvalds break; 7121da177e4SLinus Torvalds case TW_IOCTL_GET_COMPATIBILITY_INFO: 7131da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7141da177e4SLinus Torvalds /* Copy compatiblity struct into ioctl data buffer */ 7151da177e4SLinus Torvalds tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer; 7161da177e4SLinus Torvalds strncpy(tw_compat_info->driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION)); 7171da177e4SLinus Torvalds tw_compat_info->working_srl = tw_dev->working_srl; 7181da177e4SLinus Torvalds tw_compat_info->working_branch = tw_dev->working_branch; 7191da177e4SLinus Torvalds tw_compat_info->working_build = tw_dev->working_build; 7201da177e4SLinus Torvalds tw_compat_info->driver_srl_high = TW_CURRENT_DRIVER_SRL; 7211da177e4SLinus Torvalds tw_compat_info->driver_branch_high = TW_CURRENT_DRIVER_BRANCH; 7221da177e4SLinus Torvalds tw_compat_info->driver_build_high = TW_CURRENT_DRIVER_BUILD; 7231da177e4SLinus Torvalds tw_compat_info->driver_srl_low = TW_BASE_FW_SRL; 7241da177e4SLinus Torvalds tw_compat_info->driver_branch_low = TW_BASE_FW_BRANCH; 7251da177e4SLinus Torvalds tw_compat_info->driver_build_low = TW_BASE_FW_BUILD; 7261da177e4SLinus Torvalds break; 7271da177e4SLinus Torvalds case TW_IOCTL_GET_LAST_EVENT: 7281da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 7291da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 7301da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 7311da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 7321da177e4SLinus Torvalds } else 7331da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7341da177e4SLinus Torvalds } else { 7351da177e4SLinus Torvalds if (!tw_dev->error_index) { 7361da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7371da177e4SLinus Torvalds break; 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH; 7421da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 7431da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 7441da177e4SLinus Torvalds break; 7451da177e4SLinus Torvalds case TW_IOCTL_GET_FIRST_EVENT: 7461da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 7471da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 7481da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 7491da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 7501da177e4SLinus Torvalds } else 7511da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7521da177e4SLinus Torvalds event_index = tw_dev->error_index; 7531da177e4SLinus Torvalds } else { 7541da177e4SLinus Torvalds if (!tw_dev->error_index) { 7551da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7561da177e4SLinus Torvalds break; 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7591da177e4SLinus Torvalds event_index = 0; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 7621da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 7631da177e4SLinus Torvalds break; 7641da177e4SLinus Torvalds case TW_IOCTL_GET_NEXT_EVENT: 7651da177e4SLinus Torvalds event = (TW_Event *)tw_ioctl->data_buffer; 7661da177e4SLinus Torvalds sequence_id = event->sequence_id; 7671da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 7701da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 7711da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 7721da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 7731da177e4SLinus Torvalds } 7741da177e4SLinus Torvalds start_index = tw_dev->error_index; 7751da177e4SLinus Torvalds } else { 7761da177e4SLinus Torvalds if (!tw_dev->error_index) { 7771da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7781da177e4SLinus Torvalds break; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds start_index = 0; 7811da177e4SLinus Torvalds } 7821da177e4SLinus Torvalds event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH; 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) { 7851da177e4SLinus Torvalds if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER) 7861da177e4SLinus Torvalds tw_dev->aen_clobber = 1; 7871da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 7881da177e4SLinus Torvalds break; 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 7911da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 7921da177e4SLinus Torvalds break; 7931da177e4SLinus Torvalds case TW_IOCTL_GET_PREVIOUS_EVENT: 7941da177e4SLinus Torvalds event = (TW_Event *)tw_ioctl->data_buffer; 7951da177e4SLinus Torvalds sequence_id = event->sequence_id; 7961da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds if (tw_dev->event_queue_wrapped) { 7991da177e4SLinus Torvalds if (tw_dev->aen_clobber) { 8001da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER; 8011da177e4SLinus Torvalds tw_dev->aen_clobber = 0; 8021da177e4SLinus Torvalds } 8031da177e4SLinus Torvalds start_index = tw_dev->error_index; 8041da177e4SLinus Torvalds } else { 8051da177e4SLinus Torvalds if (!tw_dev->error_index) { 8061da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 8071da177e4SLinus Torvalds break; 8081da177e4SLinus Torvalds } 8091da177e4SLinus Torvalds start_index = 0; 8101da177e4SLinus Torvalds } 8111da177e4SLinus Torvalds event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH; 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) { 8141da177e4SLinus Torvalds if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER) 8151da177e4SLinus Torvalds tw_dev->aen_clobber = 1; 8161da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS; 8171da177e4SLinus Torvalds break; 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event)); 8201da177e4SLinus Torvalds tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED; 8211da177e4SLinus Torvalds break; 8221da177e4SLinus Torvalds case TW_IOCTL_GET_LOCK: 8231da177e4SLinus Torvalds tw_lock = (TW_Lock *)tw_ioctl->data_buffer; 8241da177e4SLinus Torvalds do_gettimeofday(¤t_time); 8251da177e4SLinus Torvalds current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000); 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) { 8281da177e4SLinus Torvalds tw_dev->ioctl_sem_lock = 1; 8291da177e4SLinus Torvalds tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec; 8301da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 8311da177e4SLinus Torvalds tw_lock->time_remaining_msec = tw_lock->timeout_msec; 8321da177e4SLinus Torvalds } else { 8331da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED; 8341da177e4SLinus Torvalds tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms; 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds break; 8371da177e4SLinus Torvalds case TW_IOCTL_RELEASE_LOCK: 8381da177e4SLinus Torvalds if (tw_dev->ioctl_sem_lock == 1) { 8391da177e4SLinus Torvalds tw_dev->ioctl_sem_lock = 0; 8401da177e4SLinus Torvalds tw_ioctl->driver_command.status = 0; 8411da177e4SLinus Torvalds } else { 8421da177e4SLinus Torvalds tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED; 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds break; 8451da177e4SLinus Torvalds default: 8461da177e4SLinus Torvalds retval = TW_IOCTL_ERROR_OS_ENOTTY; 8471da177e4SLinus Torvalds goto out3; 8481da177e4SLinus Torvalds } 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds /* Now copy the entire response to userspace */ 8511da177e4SLinus Torvalds if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0) 8521da177e4SLinus Torvalds retval = 0; 8531da177e4SLinus Torvalds out3: 8541da177e4SLinus Torvalds /* Now free ioctl buf memory */ 8551da177e4SLinus Torvalds dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle); 8561da177e4SLinus Torvalds out2: 857a12e25bdSJes Sorensen mutex_unlock(&tw_dev->ioctl_lock); 8581da177e4SLinus Torvalds out: 8591da177e4SLinus Torvalds return retval; 8601da177e4SLinus Torvalds } /* End twa_chrdev_ioctl() */ 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds /* This function handles open for the character device */ 8631da177e4SLinus Torvalds static int twa_chrdev_open(struct inode *inode, struct file *file) 8641da177e4SLinus Torvalds { 8651da177e4SLinus Torvalds unsigned int minor_number; 8661da177e4SLinus Torvalds int retval = TW_IOCTL_ERROR_OS_ENODEV; 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds minor_number = iminor(inode); 8691da177e4SLinus Torvalds if (minor_number >= twa_device_extension_count) 8701da177e4SLinus Torvalds goto out; 8711da177e4SLinus Torvalds retval = 0; 8721da177e4SLinus Torvalds out: 8731da177e4SLinus Torvalds return retval; 8741da177e4SLinus Torvalds } /* End twa_chrdev_open() */ 8751da177e4SLinus Torvalds 8761da177e4SLinus Torvalds /* This function will print readable messages from status register errors */ 8771da177e4SLinus Torvalds static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value) 8781da177e4SLinus Torvalds { 8791da177e4SLinus Torvalds int retval = 1; 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds /* Check for various error conditions and handle them appropriately */ 8821da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) { 8831da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing"); 8841da177e4SLinus Torvalds writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 8851da177e4SLinus Torvalds } 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_PCI_ABORT) { 8881da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing"); 8891da177e4SLinus Torvalds writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev)); 8901da177e4SLinus Torvalds pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT); 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_QUEUE_ERROR) { 8941da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing"); 8951da177e4SLinus Torvalds writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) { 8991da177e4SLinus Torvalds if (tw_dev->reset_print == 0) { 9001da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing"); 9011da177e4SLinus Torvalds tw_dev->reset_print = 1; 9021da177e4SLinus Torvalds } 9031da177e4SLinus Torvalds goto out; 9041da177e4SLinus Torvalds } 9051da177e4SLinus Torvalds retval = 0; 9061da177e4SLinus Torvalds out: 9071da177e4SLinus Torvalds return retval; 9081da177e4SLinus Torvalds } /* End twa_decode_bits() */ 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds /* This function will empty the response queue */ 9111da177e4SLinus Torvalds static int twa_empty_response_queue(TW_Device_Extension *tw_dev) 9121da177e4SLinus Torvalds { 9131da177e4SLinus Torvalds u32 status_reg_value, response_que_value; 9141da177e4SLinus Torvalds int count = 0, retval = 1; 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 9171da177e4SLinus Torvalds 9181da177e4SLinus Torvalds while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) { 9191da177e4SLinus Torvalds response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 9201da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 9211da177e4SLinus Torvalds count++; 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds if (count == TW_MAX_RESPONSE_DRAIN) 9241da177e4SLinus Torvalds goto out; 9251da177e4SLinus Torvalds 9261da177e4SLinus Torvalds retval = 0; 9271da177e4SLinus Torvalds out: 9281da177e4SLinus Torvalds return retval; 9291da177e4SLinus Torvalds } /* End twa_empty_response_queue() */ 9301da177e4SLinus Torvalds 93149bfd8dbSadam radford /* This function will clear the pchip/response queue on 9550SX */ 93249bfd8dbSadam radford static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev) 93349bfd8dbSadam radford { 93449bfd8dbSadam radford u32 status_reg_value, response_que_value; 93549bfd8dbSadam radford int count = 0, retval = 1; 93649bfd8dbSadam radford 93749bfd8dbSadam radford if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9550SX) { 93849bfd8dbSadam radford status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 93949bfd8dbSadam radford 94049bfd8dbSadam radford while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) { 94149bfd8dbSadam radford response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev)); 94249bfd8dbSadam radford if ((response_que_value & TW_9550SX_DRAIN_COMPLETED) == TW_9550SX_DRAIN_COMPLETED) { 94349bfd8dbSadam radford /* P-chip settle time */ 94449bfd8dbSadam radford msleep(500); 94549bfd8dbSadam radford retval = 0; 94649bfd8dbSadam radford goto out; 94749bfd8dbSadam radford } 94849bfd8dbSadam radford status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 94949bfd8dbSadam radford count++; 95049bfd8dbSadam radford } 95149bfd8dbSadam radford if (count == TW_MAX_RESPONSE_DRAIN) 95249bfd8dbSadam radford goto out; 95349bfd8dbSadam radford 95449bfd8dbSadam radford retval = 0; 95549bfd8dbSadam radford } else 95649bfd8dbSadam radford retval = 0; 95749bfd8dbSadam radford out: 95849bfd8dbSadam radford return retval; 95949bfd8dbSadam radford } /* End twa_empty_response_queue_large() */ 96049bfd8dbSadam radford 9611da177e4SLinus Torvalds /* This function passes sense keys from firmware to scsi layer */ 9621da177e4SLinus Torvalds static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host) 9631da177e4SLinus Torvalds { 9641da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 9651da177e4SLinus Torvalds unsigned short error; 9661da177e4SLinus Torvalds int retval = 1; 9671da177e4SLinus Torvalds char *error_str; 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds /* Check for embedded error string */ 9721da177e4SLinus Torvalds error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]); 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds /* Don't print error for Logical unit not supported during rollcall */ 9751da177e4SLinus Torvalds error = full_command_packet->header.status_block.error; 9761da177e4SLinus Torvalds if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) { 9771da177e4SLinus Torvalds if (print_host) 9781da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n", 9791da177e4SLinus Torvalds tw_dev->host->host_no, 9801da177e4SLinus Torvalds TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 9811da177e4SLinus Torvalds full_command_packet->header.status_block.error, 9821da177e4SLinus Torvalds error_str[0] == '\0' ? 9831da177e4SLinus Torvalds twa_string_lookup(twa_error_table, 9841da177e4SLinus Torvalds full_command_packet->header.status_block.error) : error_str, 9851da177e4SLinus Torvalds full_command_packet->header.err_specific_desc); 9861da177e4SLinus Torvalds else 9871da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n", 9881da177e4SLinus Torvalds TW_MESSAGE_SOURCE_CONTROLLER_ERROR, 9891da177e4SLinus Torvalds full_command_packet->header.status_block.error, 9901da177e4SLinus Torvalds error_str[0] == '\0' ? 9911da177e4SLinus Torvalds twa_string_lookup(twa_error_table, 9921da177e4SLinus Torvalds full_command_packet->header.status_block.error) : error_str, 9931da177e4SLinus Torvalds full_command_packet->header.err_specific_desc); 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds if (copy_sense) { 9971da177e4SLinus Torvalds memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH); 9981da177e4SLinus Torvalds tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1); 9991da177e4SLinus Torvalds retval = TW_ISR_DONT_RESULT; 10001da177e4SLinus Torvalds goto out; 10011da177e4SLinus Torvalds } 10021da177e4SLinus Torvalds retval = 0; 10031da177e4SLinus Torvalds out: 10041da177e4SLinus Torvalds return retval; 10051da177e4SLinus Torvalds } /* End twa_fill_sense() */ 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds /* This function will free up device extension resources */ 10081da177e4SLinus Torvalds static void twa_free_device_extension(TW_Device_Extension *tw_dev) 10091da177e4SLinus Torvalds { 10101da177e4SLinus Torvalds if (tw_dev->command_packet_virt[0]) 10111da177e4SLinus Torvalds pci_free_consistent(tw_dev->tw_pci_dev, 10121da177e4SLinus Torvalds sizeof(TW_Command_Full)*TW_Q_LENGTH, 10131da177e4SLinus Torvalds tw_dev->command_packet_virt[0], 10141da177e4SLinus Torvalds tw_dev->command_packet_phys[0]); 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds if (tw_dev->generic_buffer_virt[0]) 10171da177e4SLinus Torvalds pci_free_consistent(tw_dev->tw_pci_dev, 10181da177e4SLinus Torvalds TW_SECTOR_SIZE*TW_Q_LENGTH, 10191da177e4SLinus Torvalds tw_dev->generic_buffer_virt[0], 10201da177e4SLinus Torvalds tw_dev->generic_buffer_phys[0]); 10211da177e4SLinus Torvalds 10221da177e4SLinus Torvalds kfree(tw_dev->event_queue[0]); 10231da177e4SLinus Torvalds } /* End twa_free_device_extension() */ 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds /* This function will free a request id */ 10261da177e4SLinus Torvalds static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id) 10271da177e4SLinus Torvalds { 10281da177e4SLinus Torvalds tw_dev->free_queue[tw_dev->free_tail] = request_id; 10291da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_FINISHED; 10301da177e4SLinus Torvalds tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH; 10311da177e4SLinus Torvalds } /* End twa_free_request_id() */ 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds /* This function will get parameter table entires from the firmware */ 10341da177e4SLinus Torvalds static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes) 10351da177e4SLinus Torvalds { 10361da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 10371da177e4SLinus Torvalds TW_Command *command_packet; 10381da177e4SLinus Torvalds TW_Param_Apache *param; 10391da177e4SLinus Torvalds unsigned long param_value; 10401da177e4SLinus Torvalds void *retval = NULL; 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds /* Setup the command packet */ 10431da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 10441da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 10451da177e4SLinus Torvalds command_packet = &full_command_packet->command.oldcommand; 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 10481da177e4SLinus Torvalds command_packet->size = TW_COMMAND_SIZE; 10491da177e4SLinus Torvalds command_packet->request_id = request_id; 10501da177e4SLinus Torvalds command_packet->byte6_offset.block_count = 1; 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds /* Now setup the param */ 10531da177e4SLinus Torvalds param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id]; 10541da177e4SLinus Torvalds memset(param, 0, TW_SECTOR_SIZE); 10551da177e4SLinus Torvalds param->table_id = table_id | 0x8000; 10561da177e4SLinus Torvalds param->parameter_id = parameter_id; 10571da177e4SLinus Torvalds param->parameter_size_bytes = parameter_size_bytes; 10581da177e4SLinus Torvalds param_value = tw_dev->generic_buffer_phys[request_id]; 10591da177e4SLinus Torvalds 10601da177e4SLinus Torvalds command_packet->byte8_offset.param.sgl[0].address = param_value; 10611da177e4SLinus Torvalds command_packet->byte8_offset.param.sgl[0].length = TW_SECTOR_SIZE; 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds /* Post the command packet to the board */ 10641da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 10651da177e4SLinus Torvalds 10661da177e4SLinus Torvalds /* Poll for completion */ 10671da177e4SLinus Torvalds if (twa_poll_response(tw_dev, request_id, 30)) 10681da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param") 10691da177e4SLinus Torvalds else 10701da177e4SLinus Torvalds retval = (void *)&(param->data[0]); 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds tw_dev->posted_request_count--; 10731da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_INITIAL; 10741da177e4SLinus Torvalds 10751da177e4SLinus Torvalds return retval; 10761da177e4SLinus Torvalds } /* End twa_get_param() */ 10771da177e4SLinus Torvalds 10781da177e4SLinus Torvalds /* This function will assign an available request id */ 10791da177e4SLinus Torvalds static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id) 10801da177e4SLinus Torvalds { 10811da177e4SLinus Torvalds *request_id = tw_dev->free_queue[tw_dev->free_head]; 10821da177e4SLinus Torvalds tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH; 10831da177e4SLinus Torvalds tw_dev->state[*request_id] = TW_S_STARTED; 10841da177e4SLinus Torvalds } /* End twa_get_request_id() */ 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds /* This function will send an initconnection command to controller */ 10871da177e4SLinus Torvalds static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits, 10881da177e4SLinus Torvalds u32 set_features, unsigned short current_fw_srl, 10891da177e4SLinus Torvalds unsigned short current_fw_arch_id, 10901da177e4SLinus Torvalds unsigned short current_fw_branch, 10911da177e4SLinus Torvalds unsigned short current_fw_build, 10921da177e4SLinus Torvalds unsigned short *fw_on_ctlr_srl, 10931da177e4SLinus Torvalds unsigned short *fw_on_ctlr_arch_id, 10941da177e4SLinus Torvalds unsigned short *fw_on_ctlr_branch, 10951da177e4SLinus Torvalds unsigned short *fw_on_ctlr_build, 10961da177e4SLinus Torvalds u32 *init_connect_result) 10971da177e4SLinus Torvalds { 10981da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 10991da177e4SLinus Torvalds TW_Initconnect *tw_initconnect; 11001da177e4SLinus Torvalds int request_id = 0, retval = 1; 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds /* Initialize InitConnection command packet */ 11031da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 11041da177e4SLinus Torvalds memset(full_command_packet, 0, sizeof(TW_Command_Full)); 11051da177e4SLinus Torvalds full_command_packet->header.header_desc.size_header = 128; 11061da177e4SLinus Torvalds 11071da177e4SLinus Torvalds tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand; 11081da177e4SLinus Torvalds tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION); 11091da177e4SLinus Torvalds tw_initconnect->request_id = request_id; 11101da177e4SLinus Torvalds tw_initconnect->message_credits = message_credits; 11111da177e4SLinus Torvalds tw_initconnect->features = set_features; 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds /* Turn on 64-bit sgl support if we need to */ 11141da177e4SLinus Torvalds tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0; 11151da177e4SLinus Torvalds 11161da177e4SLinus Torvalds if (set_features & TW_EXTENDED_INIT_CONNECT) { 11171da177e4SLinus Torvalds tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED; 11181da177e4SLinus Torvalds tw_initconnect->fw_srl = current_fw_srl; 11191da177e4SLinus Torvalds tw_initconnect->fw_arch_id = current_fw_arch_id; 11201da177e4SLinus Torvalds tw_initconnect->fw_branch = current_fw_branch; 11211da177e4SLinus Torvalds tw_initconnect->fw_build = current_fw_build; 11221da177e4SLinus Torvalds } else 11231da177e4SLinus Torvalds tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE; 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds /* Send command packet to the board */ 11261da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds /* Poll for completion */ 11291da177e4SLinus Torvalds if (twa_poll_response(tw_dev, request_id, 30)) { 11301da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection"); 11311da177e4SLinus Torvalds } else { 11321da177e4SLinus Torvalds if (set_features & TW_EXTENDED_INIT_CONNECT) { 11331da177e4SLinus Torvalds *fw_on_ctlr_srl = tw_initconnect->fw_srl; 11341da177e4SLinus Torvalds *fw_on_ctlr_arch_id = tw_initconnect->fw_arch_id; 11351da177e4SLinus Torvalds *fw_on_ctlr_branch = tw_initconnect->fw_branch; 11361da177e4SLinus Torvalds *fw_on_ctlr_build = tw_initconnect->fw_build; 11371da177e4SLinus Torvalds *init_connect_result = tw_initconnect->result; 11381da177e4SLinus Torvalds } 11391da177e4SLinus Torvalds retval = 0; 11401da177e4SLinus Torvalds } 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds tw_dev->posted_request_count--; 11431da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_INITIAL; 11441da177e4SLinus Torvalds 11451da177e4SLinus Torvalds return retval; 11461da177e4SLinus Torvalds } /* End twa_initconnection() */ 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds /* This function will initialize the fields of a device extension */ 11491da177e4SLinus Torvalds static int twa_initialize_device_extension(TW_Device_Extension *tw_dev) 11501da177e4SLinus Torvalds { 11511da177e4SLinus Torvalds int i, retval = 1; 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds /* Initialize command packet buffers */ 11541da177e4SLinus Torvalds if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) { 11551da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed"); 11561da177e4SLinus Torvalds goto out; 11571da177e4SLinus Torvalds } 11581da177e4SLinus Torvalds 11591da177e4SLinus Torvalds /* Initialize generic buffer */ 11601da177e4SLinus Torvalds if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) { 11611da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed"); 11621da177e4SLinus Torvalds goto out; 11631da177e4SLinus Torvalds } 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds /* Allocate event info space */ 11661da177e4SLinus Torvalds tw_dev->event_queue[0] = kmalloc(sizeof(TW_Event) * TW_Q_LENGTH, GFP_KERNEL); 11671da177e4SLinus Torvalds if (!tw_dev->event_queue[0]) { 11681da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed"); 11691da177e4SLinus Torvalds goto out; 11701da177e4SLinus Torvalds } 11711da177e4SLinus Torvalds 11721da177e4SLinus Torvalds memset(tw_dev->event_queue[0], 0, sizeof(TW_Event) * TW_Q_LENGTH); 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 11751da177e4SLinus Torvalds tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event))); 11761da177e4SLinus Torvalds tw_dev->free_queue[i] = i; 11771da177e4SLinus Torvalds tw_dev->state[i] = TW_S_INITIAL; 11781da177e4SLinus Torvalds } 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds tw_dev->pending_head = TW_Q_START; 11811da177e4SLinus Torvalds tw_dev->pending_tail = TW_Q_START; 11821da177e4SLinus Torvalds tw_dev->free_head = TW_Q_START; 11831da177e4SLinus Torvalds tw_dev->free_tail = TW_Q_START; 11841da177e4SLinus Torvalds tw_dev->error_sequence_id = 1; 11851da177e4SLinus Torvalds tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 11861da177e4SLinus Torvalds 1187a12e25bdSJes Sorensen mutex_init(&tw_dev->ioctl_lock); 11881da177e4SLinus Torvalds init_waitqueue_head(&tw_dev->ioctl_wqueue); 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds retval = 0; 11911da177e4SLinus Torvalds out: 11921da177e4SLinus Torvalds return retval; 11931da177e4SLinus Torvalds } /* End twa_initialize_device_extension() */ 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds /* This function is the interrupt service routine */ 11961da177e4SLinus Torvalds static irqreturn_t twa_interrupt(int irq, void *dev_instance, struct pt_regs *regs) 11971da177e4SLinus Torvalds { 11981da177e4SLinus Torvalds int request_id, error = 0; 11991da177e4SLinus Torvalds u32 status_reg_value; 12001da177e4SLinus Torvalds TW_Response_Queue response_que; 12011da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 12021da177e4SLinus Torvalds TW_Command *command_packet; 12031da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance; 12041da177e4SLinus Torvalds int handled = 0; 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds /* Get the per adapter lock */ 12071da177e4SLinus Torvalds spin_lock(tw_dev->host->host_lock); 12081da177e4SLinus Torvalds 12091da177e4SLinus Torvalds /* Read the registers */ 12101da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds /* Check if this is our interrupt, otherwise bail */ 12131da177e4SLinus Torvalds if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT)) 12141da177e4SLinus Torvalds goto twa_interrupt_bail; 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds handled = 1; 12171da177e4SLinus Torvalds 12181da177e4SLinus Torvalds /* Check controller for errors */ 12191da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) { 12201da177e4SLinus Torvalds if (twa_decode_bits(tw_dev, status_reg_value)) { 12211da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 12221da177e4SLinus Torvalds goto twa_interrupt_bail; 12231da177e4SLinus Torvalds } 12241da177e4SLinus Torvalds } 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds /* Handle host interrupt */ 12271da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_HOST_INTERRUPT) 12281da177e4SLinus Torvalds TW_CLEAR_HOST_INTERRUPT(tw_dev); 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds /* Handle attention interrupt */ 12311da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) { 12321da177e4SLinus Torvalds TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 12331da177e4SLinus Torvalds if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) { 12341da177e4SLinus Torvalds twa_get_request_id(tw_dev, &request_id); 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds error = twa_aen_read_queue(tw_dev, request_id); 12371da177e4SLinus Torvalds if (error) { 12381da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 12391da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 12401da177e4SLinus Torvalds clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags); 12411da177e4SLinus Torvalds } 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds } 12441da177e4SLinus Torvalds 12451da177e4SLinus Torvalds /* Handle command interrupt */ 12461da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) { 12471da177e4SLinus Torvalds TW_MASK_COMMAND_INTERRUPT(tw_dev); 12481da177e4SLinus Torvalds /* Drain as many pending commands as we can */ 12491da177e4SLinus Torvalds while (tw_dev->pending_request_count > 0) { 12501da177e4SLinus Torvalds request_id = tw_dev->pending_queue[tw_dev->pending_head]; 12511da177e4SLinus Torvalds if (tw_dev->state[request_id] != TW_S_PENDING) { 12521da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending"); 12531da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 12541da177e4SLinus Torvalds goto twa_interrupt_bail; 12551da177e4SLinus Torvalds } 12561da177e4SLinus Torvalds if (twa_post_command_packet(tw_dev, request_id, 1)==0) { 12571da177e4SLinus Torvalds tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH; 12581da177e4SLinus Torvalds tw_dev->pending_request_count--; 12591da177e4SLinus Torvalds } else { 12601da177e4SLinus Torvalds /* If we get here, we will continue re-posting on the next command interrupt */ 12611da177e4SLinus Torvalds break; 12621da177e4SLinus Torvalds } 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds } 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds /* Handle response interrupt */ 12671da177e4SLinus Torvalds if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) { 12681da177e4SLinus Torvalds 12691da177e4SLinus Torvalds /* Drain the response queue from the board */ 12701da177e4SLinus Torvalds while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 12711da177e4SLinus Torvalds /* Complete the response */ 12721da177e4SLinus Torvalds response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 12731da177e4SLinus Torvalds request_id = TW_RESID_OUT(response_que.response_id); 12741da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 12751da177e4SLinus Torvalds error = 0; 12761da177e4SLinus Torvalds command_packet = &full_command_packet->command.oldcommand; 12771da177e4SLinus Torvalds /* Check for command packet errors */ 12781da177e4SLinus Torvalds if (full_command_packet->command.newcommand.status != 0) { 12791da177e4SLinus Torvalds if (tw_dev->srb[request_id] != 0) { 12801da177e4SLinus Torvalds error = twa_fill_sense(tw_dev, request_id, 1, 1); 12811da177e4SLinus Torvalds } else { 12821da177e4SLinus Torvalds /* Skip ioctl error prints */ 12831da177e4SLinus Torvalds if (request_id != tw_dev->chrdev_request_id) { 12841da177e4SLinus Torvalds error = twa_fill_sense(tw_dev, request_id, 0, 1); 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds } 12871da177e4SLinus Torvalds } 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds /* Check for correct state */ 12901da177e4SLinus Torvalds if (tw_dev->state[request_id] != TW_S_POSTED) { 12911da177e4SLinus Torvalds if (tw_dev->srb[request_id] != 0) { 12921da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted"); 12931da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 12941da177e4SLinus Torvalds goto twa_interrupt_bail; 12951da177e4SLinus Torvalds } 12961da177e4SLinus Torvalds } 12971da177e4SLinus Torvalds 12981da177e4SLinus Torvalds /* Check for internal command completion */ 12991da177e4SLinus Torvalds if (tw_dev->srb[request_id] == 0) { 13001da177e4SLinus Torvalds if (request_id != tw_dev->chrdev_request_id) { 13011da177e4SLinus Torvalds if (twa_aen_complete(tw_dev, request_id)) 13021da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt"); 13031da177e4SLinus Torvalds } else { 13041da177e4SLinus Torvalds tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 13051da177e4SLinus Torvalds wake_up(&tw_dev->ioctl_wqueue); 13061da177e4SLinus Torvalds } 13071da177e4SLinus Torvalds } else { 13081da177e4SLinus Torvalds twa_scsiop_execute_scsi_complete(tw_dev, request_id); 13091da177e4SLinus Torvalds /* If no error command was a success */ 13101da177e4SLinus Torvalds if (error == 0) { 13111da177e4SLinus Torvalds tw_dev->srb[request_id]->result = (DID_OK << 16); 13121da177e4SLinus Torvalds } 13131da177e4SLinus Torvalds 13141da177e4SLinus Torvalds /* If error, command failed */ 13151da177e4SLinus Torvalds if (error == 1) { 13161da177e4SLinus Torvalds /* Ask for a host reset */ 13171da177e4SLinus Torvalds tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 13181da177e4SLinus Torvalds } 13191da177e4SLinus Torvalds 13201da177e4SLinus Torvalds /* Report residual bytes for single sgl */ 13211da177e4SLinus Torvalds if ((tw_dev->srb[request_id]->use_sg <= 1) && (full_command_packet->command.newcommand.status == 0)) { 13221da177e4SLinus Torvalds if (full_command_packet->command.newcommand.sg_list[0].length < tw_dev->srb[request_id]->request_bufflen) 13231da177e4SLinus Torvalds tw_dev->srb[request_id]->resid = tw_dev->srb[request_id]->request_bufflen - full_command_packet->command.newcommand.sg_list[0].length; 13241da177e4SLinus Torvalds } 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds /* Now complete the io */ 13271da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 13281da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 13291da177e4SLinus Torvalds tw_dev->posted_request_count--; 13301da177e4SLinus Torvalds tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 13311da177e4SLinus Torvalds twa_unmap_scsi_data(tw_dev, request_id); 13321da177e4SLinus Torvalds } 13331da177e4SLinus Torvalds 13341da177e4SLinus Torvalds /* Check for valid status after each drain */ 13351da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 13361da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) { 13371da177e4SLinus Torvalds if (twa_decode_bits(tw_dev, status_reg_value)) { 13381da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 13391da177e4SLinus Torvalds goto twa_interrupt_bail; 13401da177e4SLinus Torvalds } 13411da177e4SLinus Torvalds } 13421da177e4SLinus Torvalds } 13431da177e4SLinus Torvalds } 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds twa_interrupt_bail: 13461da177e4SLinus Torvalds spin_unlock(tw_dev->host->host_lock); 13471da177e4SLinus Torvalds return IRQ_RETVAL(handled); 13481da177e4SLinus Torvalds } /* End twa_interrupt() */ 13491da177e4SLinus Torvalds 13501da177e4SLinus Torvalds /* This function will load the request id and various sgls for ioctls */ 13511da177e4SLinus Torvalds static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length) 13521da177e4SLinus Torvalds { 13531da177e4SLinus Torvalds TW_Command *oldcommand; 13541da177e4SLinus Torvalds TW_Command_Apache *newcommand; 13551da177e4SLinus Torvalds TW_SG_Entry *sgl; 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) { 13581da177e4SLinus Torvalds newcommand = &full_command_packet->command.newcommand; 13591da177e4SLinus Torvalds newcommand->request_id__lunl = 13601da177e4SLinus Torvalds TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id); 13611da177e4SLinus Torvalds newcommand->sg_list[0].address = dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1; 13621da177e4SLinus Torvalds newcommand->sg_list[0].length = length; 13631da177e4SLinus Torvalds newcommand->sgl_entries__lunh = 13641da177e4SLinus Torvalds TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1); 13651da177e4SLinus Torvalds } else { 13661da177e4SLinus Torvalds oldcommand = &full_command_packet->command.oldcommand; 13671da177e4SLinus Torvalds oldcommand->request_id = request_id; 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) { 13701da177e4SLinus Torvalds /* Load the sg list */ 13711da177e4SLinus Torvalds sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset)); 13721da177e4SLinus Torvalds sgl->address = dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1; 13731da177e4SLinus Torvalds sgl->length = length; 13741da177e4SLinus Torvalds 13751da177e4SLinus Torvalds if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4)) 13761da177e4SLinus Torvalds oldcommand->size += 1; 13771da177e4SLinus Torvalds } 13781da177e4SLinus Torvalds } 13791da177e4SLinus Torvalds } /* End twa_load_sgl() */ 13801da177e4SLinus Torvalds 13811da177e4SLinus Torvalds /* This function will perform a pci-dma mapping for a scatter gather list */ 13821da177e4SLinus Torvalds static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id) 13831da177e4SLinus Torvalds { 13841da177e4SLinus Torvalds int use_sg; 13851da177e4SLinus Torvalds struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 13861da177e4SLinus Torvalds struct pci_dev *pdev = tw_dev->tw_pci_dev; 13871da177e4SLinus Torvalds int retval = 0; 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds if (cmd->use_sg == 0) 13901da177e4SLinus Torvalds goto out; 13911da177e4SLinus Torvalds 13921da177e4SLinus Torvalds use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 13931da177e4SLinus Torvalds 13941da177e4SLinus Torvalds if (use_sg == 0) { 13951da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list"); 13961da177e4SLinus Torvalds goto out; 13971da177e4SLinus Torvalds } 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds cmd->SCp.phase = TW_PHASE_SGLIST; 14001da177e4SLinus Torvalds cmd->SCp.have_data_in = use_sg; 14011da177e4SLinus Torvalds retval = use_sg; 14021da177e4SLinus Torvalds out: 14031da177e4SLinus Torvalds return retval; 14041da177e4SLinus Torvalds } /* End twa_map_scsi_sg_data() */ 14051da177e4SLinus Torvalds 14061da177e4SLinus Torvalds /* This function will perform a pci-dma map for a single buffer */ 14071da177e4SLinus Torvalds static dma_addr_t twa_map_scsi_single_data(TW_Device_Extension *tw_dev, int request_id) 14081da177e4SLinus Torvalds { 14091da177e4SLinus Torvalds dma_addr_t mapping; 14101da177e4SLinus Torvalds struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 14111da177e4SLinus Torvalds struct pci_dev *pdev = tw_dev->tw_pci_dev; 141262288f10Sadam radford dma_addr_t retval = 0; 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds if (cmd->request_bufflen == 0) { 14151da177e4SLinus Torvalds retval = 0; 14161da177e4SLinus Torvalds goto out; 14171da177e4SLinus Torvalds } 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds mapping = pci_map_single(pdev, cmd->request_buffer, cmd->request_bufflen, DMA_BIDIRECTIONAL); 14201da177e4SLinus Torvalds 14211da177e4SLinus Torvalds if (mapping == 0) { 14221da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Failed to map page"); 14231da177e4SLinus Torvalds goto out; 14241da177e4SLinus Torvalds } 14251da177e4SLinus Torvalds 14261da177e4SLinus Torvalds cmd->SCp.phase = TW_PHASE_SINGLE; 14271da177e4SLinus Torvalds cmd->SCp.have_data_in = mapping; 14281da177e4SLinus Torvalds retval = mapping; 14291da177e4SLinus Torvalds out: 14301da177e4SLinus Torvalds return retval; 14311da177e4SLinus Torvalds } /* End twa_map_scsi_single_data() */ 14321da177e4SLinus Torvalds 14331da177e4SLinus Torvalds /* This function will poll for a response interrupt of a request */ 14341da177e4SLinus Torvalds static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds) 14351da177e4SLinus Torvalds { 14361da177e4SLinus Torvalds int retval = 1, found = 0, response_request_id; 14371da177e4SLinus Torvalds TW_Response_Queue response_queue; 14381da177e4SLinus Torvalds TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id]; 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) { 14411da177e4SLinus Torvalds response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 14421da177e4SLinus Torvalds response_request_id = TW_RESID_OUT(response_queue.response_id); 14431da177e4SLinus Torvalds if (request_id != response_request_id) { 14441da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response"); 14451da177e4SLinus Torvalds goto out; 14461da177e4SLinus Torvalds } 14471da177e4SLinus Torvalds if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) { 14481da177e4SLinus Torvalds if (full_command_packet->command.newcommand.status != 0) { 14491da177e4SLinus Torvalds /* bad response */ 14501da177e4SLinus Torvalds twa_fill_sense(tw_dev, request_id, 0, 0); 14511da177e4SLinus Torvalds goto out; 14521da177e4SLinus Torvalds } 14531da177e4SLinus Torvalds found = 1; 14541da177e4SLinus Torvalds } else { 14551da177e4SLinus Torvalds if (full_command_packet->command.oldcommand.status != 0) { 14561da177e4SLinus Torvalds /* bad response */ 14571da177e4SLinus Torvalds twa_fill_sense(tw_dev, request_id, 0, 0); 14581da177e4SLinus Torvalds goto out; 14591da177e4SLinus Torvalds } 14601da177e4SLinus Torvalds found = 1; 14611da177e4SLinus Torvalds } 14621da177e4SLinus Torvalds } 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds if (found) 14651da177e4SLinus Torvalds retval = 0; 14661da177e4SLinus Torvalds out: 14671da177e4SLinus Torvalds return retval; 14681da177e4SLinus Torvalds } /* End twa_poll_response() */ 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds /* This function will poll the status register for a flag */ 14711da177e4SLinus Torvalds static int twa_poll_status(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) != flag) { 14841da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 14871da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds if (time_after(jiffies, before + HZ * seconds)) 14901da177e4SLinus Torvalds goto out; 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds msleep(50); 14931da177e4SLinus Torvalds } 14941da177e4SLinus Torvalds retval = 0; 14951da177e4SLinus Torvalds out: 14961da177e4SLinus Torvalds return retval; 14971da177e4SLinus Torvalds } /* End twa_poll_status() */ 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds /* This function will poll the status register for disappearance of a flag */ 15001da177e4SLinus Torvalds static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds) 15011da177e4SLinus Torvalds { 15021da177e4SLinus Torvalds u32 status_reg_value; 15031da177e4SLinus Torvalds unsigned long before; 15041da177e4SLinus Torvalds int retval = 1; 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 15071da177e4SLinus Torvalds before = jiffies; 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 15101da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 15111da177e4SLinus Torvalds 15121da177e4SLinus Torvalds while ((status_reg_value & flag) != 0) { 15131da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 15141da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 15151da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds if (time_after(jiffies, before + HZ * seconds)) 15181da177e4SLinus Torvalds goto out; 15191da177e4SLinus Torvalds 15201da177e4SLinus Torvalds msleep(50); 15211da177e4SLinus Torvalds } 15221da177e4SLinus Torvalds retval = 0; 15231da177e4SLinus Torvalds out: 15241da177e4SLinus Torvalds return retval; 15251da177e4SLinus Torvalds } /* End twa_poll_status_gone() */ 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds /* This function will attempt to post a command packet to the board */ 15281da177e4SLinus Torvalds static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal) 15291da177e4SLinus Torvalds { 15301da177e4SLinus Torvalds u32 status_reg_value; 15311da177e4SLinus Torvalds dma_addr_t command_que_value; 15321da177e4SLinus Torvalds int retval = 1; 15331da177e4SLinus Torvalds 15341da177e4SLinus Torvalds command_que_value = tw_dev->command_packet_phys[request_id]; 15351da177e4SLinus Torvalds status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev)); 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds if (twa_check_bits(status_reg_value)) 15381da177e4SLinus Torvalds twa_decode_bits(tw_dev, status_reg_value); 15391da177e4SLinus Torvalds 15401da177e4SLinus Torvalds if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) { 15411da177e4SLinus Torvalds 15421da177e4SLinus Torvalds /* Only pend internal driver commands */ 15431da177e4SLinus Torvalds if (!internal) { 15441da177e4SLinus Torvalds retval = SCSI_MLQUEUE_HOST_BUSY; 15451da177e4SLinus Torvalds goto out; 15461da177e4SLinus Torvalds } 15471da177e4SLinus Torvalds 15481da177e4SLinus Torvalds /* Couldn't post the command packet, so we do it later */ 15491da177e4SLinus Torvalds if (tw_dev->state[request_id] != TW_S_PENDING) { 15501da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_PENDING; 15511da177e4SLinus Torvalds tw_dev->pending_request_count++; 15521da177e4SLinus Torvalds if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) { 15531da177e4SLinus Torvalds tw_dev->max_pending_request_count = tw_dev->pending_request_count; 15541da177e4SLinus Torvalds } 15551da177e4SLinus Torvalds tw_dev->pending_queue[tw_dev->pending_tail] = request_id; 15561da177e4SLinus Torvalds tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH; 15571da177e4SLinus Torvalds } 15581da177e4SLinus Torvalds TW_UNMASK_COMMAND_INTERRUPT(tw_dev); 15591da177e4SLinus Torvalds goto out; 15601da177e4SLinus Torvalds } else { 15611da177e4SLinus Torvalds /* We successfully posted the command packet */ 15621da177e4SLinus Torvalds if (sizeof(dma_addr_t) > 4) { 15631da177e4SLinus Torvalds command_que_value += TW_COMMAND_OFFSET; 15641da177e4SLinus Torvalds writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 15651da177e4SLinus Torvalds writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4); 15661da177e4SLinus Torvalds } else { 15671da177e4SLinus Torvalds writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 15681da177e4SLinus Torvalds } 15691da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_POSTED; 15701da177e4SLinus Torvalds tw_dev->posted_request_count++; 15711da177e4SLinus Torvalds if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) { 15721da177e4SLinus Torvalds tw_dev->max_posted_request_count = tw_dev->posted_request_count; 15731da177e4SLinus Torvalds } 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvalds retval = 0; 15761da177e4SLinus Torvalds out: 15771da177e4SLinus Torvalds return retval; 15781da177e4SLinus Torvalds } /* End twa_post_command_packet() */ 15791da177e4SLinus Torvalds 15801da177e4SLinus Torvalds /* This function will reset a device extension */ 15811da177e4SLinus Torvalds static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset) 15821da177e4SLinus Torvalds { 15831da177e4SLinus Torvalds int i = 0; 15841da177e4SLinus Torvalds int retval = 1; 15851da177e4SLinus Torvalds unsigned long flags = 0; 15861da177e4SLinus Torvalds 15871da177e4SLinus Torvalds set_bit(TW_IN_RESET, &tw_dev->flags); 15881da177e4SLinus Torvalds TW_DISABLE_INTERRUPTS(tw_dev); 15891da177e4SLinus Torvalds TW_MASK_COMMAND_INTERRUPT(tw_dev); 15901da177e4SLinus Torvalds spin_lock_irqsave(tw_dev->host->host_lock, flags); 15911da177e4SLinus Torvalds 15921da177e4SLinus Torvalds /* Abort all requests that are in progress */ 15931da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 15941da177e4SLinus Torvalds if ((tw_dev->state[i] != TW_S_FINISHED) && 15951da177e4SLinus Torvalds (tw_dev->state[i] != TW_S_INITIAL) && 15961da177e4SLinus Torvalds (tw_dev->state[i] != TW_S_COMPLETED)) { 15971da177e4SLinus Torvalds if (tw_dev->srb[i]) { 15981da177e4SLinus Torvalds tw_dev->srb[i]->result = (DID_RESET << 16); 15991da177e4SLinus Torvalds tw_dev->srb[i]->scsi_done(tw_dev->srb[i]); 16001da177e4SLinus Torvalds twa_unmap_scsi_data(tw_dev, i); 16011da177e4SLinus Torvalds } 16021da177e4SLinus Torvalds } 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds /* Reset queues and counts */ 16061da177e4SLinus Torvalds for (i = 0; i < TW_Q_LENGTH; i++) { 16071da177e4SLinus Torvalds tw_dev->free_queue[i] = i; 16081da177e4SLinus Torvalds tw_dev->state[i] = TW_S_INITIAL; 16091da177e4SLinus Torvalds } 16101da177e4SLinus Torvalds tw_dev->free_head = TW_Q_START; 16111da177e4SLinus Torvalds tw_dev->free_tail = TW_Q_START; 16121da177e4SLinus Torvalds tw_dev->posted_request_count = 0; 16131da177e4SLinus Torvalds tw_dev->pending_request_count = 0; 16141da177e4SLinus Torvalds tw_dev->pending_head = TW_Q_START; 16151da177e4SLinus Torvalds tw_dev->pending_tail = TW_Q_START; 16161da177e4SLinus Torvalds tw_dev->reset_print = 0; 16171da177e4SLinus Torvalds 16181da177e4SLinus Torvalds spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 16191da177e4SLinus Torvalds 16201da177e4SLinus Torvalds if (twa_reset_sequence(tw_dev, 1)) 16211da177e4SLinus Torvalds goto out; 16221da177e4SLinus Torvalds 16231da177e4SLinus Torvalds TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 16241da177e4SLinus Torvalds 16251da177e4SLinus Torvalds /* Wake up any ioctl that was pending before the reset */ 16261da177e4SLinus Torvalds if ((tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE) || (ioctl_reset)) { 16271da177e4SLinus Torvalds clear_bit(TW_IN_RESET, &tw_dev->flags); 16281da177e4SLinus Torvalds } else { 16291da177e4SLinus Torvalds tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 16301da177e4SLinus Torvalds wake_up(&tw_dev->ioctl_wqueue); 16311da177e4SLinus Torvalds } 16321da177e4SLinus Torvalds retval = 0; 16331da177e4SLinus Torvalds out: 16341da177e4SLinus Torvalds return retval; 16351da177e4SLinus Torvalds } /* End twa_reset_device_extension() */ 16361da177e4SLinus Torvalds 16371da177e4SLinus Torvalds /* This function will reset a controller */ 16381da177e4SLinus Torvalds static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset) 16391da177e4SLinus Torvalds { 16401da177e4SLinus Torvalds int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset; 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds while (tries < TW_MAX_RESET_TRIES) { 164349bfd8dbSadam radford if (do_soft_reset) { 16441da177e4SLinus Torvalds TW_SOFT_RESET(tw_dev); 164549bfd8dbSadam radford /* Clear pchip/response queue on 9550SX */ 164649bfd8dbSadam radford if (twa_empty_response_queue_large(tw_dev)) { 164749bfd8dbSadam radford TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence"); 164849bfd8dbSadam radford do_soft_reset = 1; 164949bfd8dbSadam radford tries++; 165049bfd8dbSadam radford continue; 165149bfd8dbSadam radford } 165249bfd8dbSadam radford } 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds /* Make sure controller is in a good state */ 16551da177e4SLinus Torvalds if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) { 16561da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence"); 16571da177e4SLinus Torvalds do_soft_reset = 1; 16581da177e4SLinus Torvalds tries++; 16591da177e4SLinus Torvalds continue; 16601da177e4SLinus Torvalds } 16611da177e4SLinus Torvalds 16621da177e4SLinus Torvalds /* Empty response queue */ 16631da177e4SLinus Torvalds if (twa_empty_response_queue(tw_dev)) { 16641da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence"); 16651da177e4SLinus Torvalds do_soft_reset = 1; 16661da177e4SLinus Torvalds tries++; 16671da177e4SLinus Torvalds continue; 16681da177e4SLinus Torvalds } 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds flashed = 0; 16711da177e4SLinus Torvalds 16721da177e4SLinus Torvalds /* Check for compatibility/flash */ 16731da177e4SLinus Torvalds if (twa_check_srl(tw_dev, &flashed)) { 16741da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence"); 16751da177e4SLinus Torvalds do_soft_reset = 1; 16761da177e4SLinus Torvalds tries++; 16771da177e4SLinus Torvalds continue; 16781da177e4SLinus Torvalds } else { 16791da177e4SLinus Torvalds if (flashed) { 16801da177e4SLinus Torvalds tries++; 16811da177e4SLinus Torvalds continue; 16821da177e4SLinus Torvalds } 16831da177e4SLinus Torvalds } 16841da177e4SLinus Torvalds 16851da177e4SLinus Torvalds /* Drain the AEN queue */ 16861da177e4SLinus Torvalds if (twa_aen_drain_queue(tw_dev, soft_reset)) { 16871da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence"); 16881da177e4SLinus Torvalds do_soft_reset = 1; 16891da177e4SLinus Torvalds tries++; 16901da177e4SLinus Torvalds continue; 16911da177e4SLinus Torvalds } 16921da177e4SLinus Torvalds 16931da177e4SLinus Torvalds /* If we got here, controller is in a good state */ 16941da177e4SLinus Torvalds retval = 0; 16951da177e4SLinus Torvalds goto out; 16961da177e4SLinus Torvalds } 16971da177e4SLinus Torvalds out: 16981da177e4SLinus Torvalds return retval; 16991da177e4SLinus Torvalds } /* End twa_reset_sequence() */ 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds /* This funciton returns unit geometry in cylinders/heads/sectors */ 17021da177e4SLinus Torvalds static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[]) 17031da177e4SLinus Torvalds { 17041da177e4SLinus Torvalds int heads, sectors, cylinders; 17051da177e4SLinus Torvalds TW_Device_Extension *tw_dev; 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds tw_dev = (TW_Device_Extension *)sdev->host->hostdata; 17081da177e4SLinus Torvalds 17091da177e4SLinus Torvalds if (capacity >= 0x200000) { 17101da177e4SLinus Torvalds heads = 255; 17111da177e4SLinus Torvalds sectors = 63; 17121da177e4SLinus Torvalds cylinders = sector_div(capacity, heads * sectors); 17131da177e4SLinus Torvalds } else { 17141da177e4SLinus Torvalds heads = 64; 17151da177e4SLinus Torvalds sectors = 32; 17161da177e4SLinus Torvalds cylinders = sector_div(capacity, heads * sectors); 17171da177e4SLinus Torvalds } 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds geom[0] = heads; 17201da177e4SLinus Torvalds geom[1] = sectors; 17211da177e4SLinus Torvalds geom[2] = cylinders; 17221da177e4SLinus Torvalds 17231da177e4SLinus Torvalds return 0; 17241da177e4SLinus Torvalds } /* End twa_scsi_biosparam() */ 17251da177e4SLinus Torvalds 17261da177e4SLinus Torvalds /* This is the new scsi eh reset function */ 17271da177e4SLinus Torvalds static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt) 17281da177e4SLinus Torvalds { 17291da177e4SLinus Torvalds TW_Device_Extension *tw_dev = NULL; 17301da177e4SLinus Torvalds int retval = FAILED; 17311da177e4SLinus Torvalds 17321da177e4SLinus Torvalds tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 17331da177e4SLinus Torvalds 17341da177e4SLinus Torvalds tw_dev->num_resets++; 17351da177e4SLinus Torvalds 1736017560fcSJeff Garzik sdev_printk(KERN_WARNING, SCpnt->device, 1737017560fcSJeff Garzik "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n", 1738017560fcSJeff Garzik TW_DRIVER, 0x2c, SCpnt->cmnd[0]); 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds /* Now reset the card and some of the device extension data */ 17411da177e4SLinus Torvalds if (twa_reset_device_extension(tw_dev, 0)) { 17421da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset"); 17431da177e4SLinus Torvalds goto out; 17441da177e4SLinus Torvalds } 17451da177e4SLinus Torvalds 17461da177e4SLinus Torvalds retval = SUCCESS; 17471da177e4SLinus Torvalds out: 17481da177e4SLinus Torvalds return retval; 17491da177e4SLinus Torvalds } /* End twa_scsi_eh_reset() */ 17501da177e4SLinus Torvalds 17511da177e4SLinus Torvalds /* This is the main scsi queue function to handle scsi opcodes */ 17521da177e4SLinus Torvalds static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 17531da177e4SLinus Torvalds { 17541da177e4SLinus Torvalds int request_id, retval; 17551da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds /* Check if this FW supports luns */ 17581da177e4SLinus Torvalds if ((SCpnt->device->lun != 0) && (tw_dev->working_srl < TW_FW_SRL_LUNS_SUPPORTED)) { 17591da177e4SLinus Torvalds SCpnt->result = (DID_BAD_TARGET << 16); 17601da177e4SLinus Torvalds done(SCpnt); 17611da177e4SLinus Torvalds retval = 0; 17621da177e4SLinus Torvalds goto out; 17631da177e4SLinus Torvalds } 17641da177e4SLinus Torvalds 17651da177e4SLinus Torvalds /* Save done function into scsi_cmnd struct */ 17661da177e4SLinus Torvalds SCpnt->scsi_done = done; 17671da177e4SLinus Torvalds 17681da177e4SLinus Torvalds /* Get a free request id */ 17691da177e4SLinus Torvalds twa_get_request_id(tw_dev, &request_id); 17701da177e4SLinus Torvalds 17711da177e4SLinus Torvalds /* Save the scsi command for use by the ISR */ 17721da177e4SLinus Torvalds tw_dev->srb[request_id] = SCpnt; 17731da177e4SLinus Torvalds 17741da177e4SLinus Torvalds /* Initialize phase to zero */ 17751da177e4SLinus Torvalds SCpnt->SCp.phase = TW_PHASE_INITIAL; 17761da177e4SLinus Torvalds 17771da177e4SLinus Torvalds retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL); 17781da177e4SLinus Torvalds switch (retval) { 17791da177e4SLinus Torvalds case SCSI_MLQUEUE_HOST_BUSY: 17801da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 17811da177e4SLinus Torvalds break; 17821da177e4SLinus Torvalds case 1: 17831da177e4SLinus Torvalds tw_dev->state[request_id] = TW_S_COMPLETED; 17841da177e4SLinus Torvalds twa_free_request_id(tw_dev, request_id); 17851da177e4SLinus Torvalds SCpnt->result = (DID_ERROR << 16); 17861da177e4SLinus Torvalds done(SCpnt); 17871da177e4SLinus Torvalds retval = 0; 17881da177e4SLinus Torvalds } 17891da177e4SLinus Torvalds out: 17901da177e4SLinus Torvalds return retval; 17911da177e4SLinus Torvalds } /* End twa_scsi_queue() */ 17921da177e4SLinus Torvalds 17931da177e4SLinus Torvalds /* This function hands scsi cdb's to the firmware */ 17941da177e4SLinus Torvalds static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg) 17951da177e4SLinus Torvalds { 17961da177e4SLinus Torvalds TW_Command_Full *full_command_packet; 17971da177e4SLinus Torvalds TW_Command_Apache *command_packet; 17981da177e4SLinus Torvalds u32 num_sectors = 0x0; 17991da177e4SLinus Torvalds int i, sg_count; 18001da177e4SLinus Torvalds struct scsi_cmnd *srb = NULL; 18011da177e4SLinus Torvalds struct scatterlist *sglist = NULL; 180262288f10Sadam radford dma_addr_t buffaddr = 0x0; 18031da177e4SLinus Torvalds int retval = 1; 18041da177e4SLinus Torvalds 18051da177e4SLinus Torvalds if (tw_dev->srb[request_id]) { 18061da177e4SLinus Torvalds if (tw_dev->srb[request_id]->request_buffer) { 18071da177e4SLinus Torvalds sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 18081da177e4SLinus Torvalds } 18091da177e4SLinus Torvalds srb = tw_dev->srb[request_id]; 18101da177e4SLinus Torvalds } 18111da177e4SLinus Torvalds 18121da177e4SLinus Torvalds /* Initialize command packet */ 18131da177e4SLinus Torvalds full_command_packet = tw_dev->command_packet_virt[request_id]; 18141da177e4SLinus Torvalds full_command_packet->header.header_desc.size_header = 128; 18151da177e4SLinus Torvalds full_command_packet->header.status_block.error = 0; 18161da177e4SLinus Torvalds full_command_packet->header.status_block.severity__reserved = 0; 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds command_packet = &full_command_packet->command.newcommand; 18191da177e4SLinus Torvalds command_packet->status = 0; 18201da177e4SLinus Torvalds command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI); 18211da177e4SLinus Torvalds 18221da177e4SLinus Torvalds /* We forced 16 byte cdb use earlier */ 18231da177e4SLinus Torvalds if (!cdb) 18241da177e4SLinus Torvalds memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN); 18251da177e4SLinus Torvalds else 18261da177e4SLinus Torvalds memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN); 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds if (srb) { 18291da177e4SLinus Torvalds command_packet->unit = srb->device->id; 18301da177e4SLinus Torvalds command_packet->request_id__lunl = 18311da177e4SLinus Torvalds TW_REQ_LUN_IN(srb->device->lun, request_id); 18321da177e4SLinus Torvalds } else { 18331da177e4SLinus Torvalds command_packet->request_id__lunl = 18341da177e4SLinus Torvalds TW_REQ_LUN_IN(0, request_id); 18351da177e4SLinus Torvalds command_packet->unit = 0; 18361da177e4SLinus Torvalds } 18371da177e4SLinus Torvalds 18381da177e4SLinus Torvalds command_packet->sgl_offset = 16; 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds if (!sglistarg) { 18411da177e4SLinus Torvalds /* Map sglist from scsi layer to cmd packet */ 18421da177e4SLinus Torvalds if (tw_dev->srb[request_id]->use_sg == 0) { 18431da177e4SLinus Torvalds if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH) { 18441da177e4SLinus Torvalds command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id]; 18451da177e4SLinus Torvalds command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH; 1846d327d082Sadam radford if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL) 1847d327d082Sadam radford memcpy(tw_dev->generic_buffer_virt[request_id], tw_dev->srb[request_id]->request_buffer, tw_dev->srb[request_id]->request_bufflen); 18481da177e4SLinus Torvalds } else { 18491da177e4SLinus Torvalds buffaddr = twa_map_scsi_single_data(tw_dev, request_id); 18501da177e4SLinus Torvalds if (buffaddr == 0) 18511da177e4SLinus Torvalds goto out; 18521da177e4SLinus Torvalds 18531da177e4SLinus Torvalds command_packet->sg_list[0].address = buffaddr; 18541da177e4SLinus Torvalds command_packet->sg_list[0].length = tw_dev->srb[request_id]->request_bufflen; 18551da177e4SLinus Torvalds } 18561da177e4SLinus Torvalds command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), 1); 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds if (command_packet->sg_list[0].address & TW_ALIGNMENT_9000_SGL) { 18591da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2d, "Found unaligned address during execute scsi"); 18601da177e4SLinus Torvalds goto out; 18611da177e4SLinus Torvalds } 18621da177e4SLinus Torvalds } 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds if (tw_dev->srb[request_id]->use_sg > 0) { 18651da177e4SLinus Torvalds if ((tw_dev->srb[request_id]->use_sg == 1) && (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH)) { 1866d327d082Sadam radford if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL) { 1867d327d082Sadam radford struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 1868d327d082Sadam radford char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 1869d327d082Sadam radford memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length); 1870d327d082Sadam radford kunmap_atomic(buf - sg->offset, KM_IRQ0); 1871d327d082Sadam radford } 18721da177e4SLinus Torvalds command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id]; 18731da177e4SLinus Torvalds command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH; 18741da177e4SLinus Torvalds } else { 18751da177e4SLinus Torvalds sg_count = twa_map_scsi_sg_data(tw_dev, request_id); 18761da177e4SLinus Torvalds if (sg_count == 0) 18771da177e4SLinus Torvalds goto out; 18781da177e4SLinus Torvalds 18791da177e4SLinus Torvalds for (i = 0; i < sg_count; i++) { 18801da177e4SLinus Torvalds command_packet->sg_list[i].address = sg_dma_address(&sglist[i]); 18811da177e4SLinus Torvalds command_packet->sg_list[i].length = sg_dma_len(&sglist[i]); 18821da177e4SLinus Torvalds if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) { 18831da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi"); 18841da177e4SLinus Torvalds goto out; 18851da177e4SLinus Torvalds } 18861da177e4SLinus Torvalds } 18871da177e4SLinus Torvalds } 18881da177e4SLinus Torvalds command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), tw_dev->srb[request_id]->use_sg); 18891da177e4SLinus Torvalds } 18901da177e4SLinus Torvalds } else { 18911da177e4SLinus Torvalds /* Internal cdb post */ 18921da177e4SLinus Torvalds for (i = 0; i < use_sg; i++) { 18931da177e4SLinus Torvalds command_packet->sg_list[i].address = sglistarg[i].address; 18941da177e4SLinus Torvalds command_packet->sg_list[i].length = sglistarg[i].length; 18951da177e4SLinus Torvalds if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) { 18961da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post"); 18971da177e4SLinus Torvalds goto out; 18981da177e4SLinus Torvalds } 18991da177e4SLinus Torvalds } 19001da177e4SLinus Torvalds command_packet->sgl_entries__lunh = TW_REQ_LUN_IN(0, use_sg); 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds if (srb) { 19041da177e4SLinus Torvalds if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) 19051da177e4SLinus Torvalds num_sectors = (u32)srb->cmnd[4]; 19061da177e4SLinus Torvalds 19071da177e4SLinus Torvalds if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10) 19081da177e4SLinus Torvalds num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8); 19091da177e4SLinus Torvalds } 19101da177e4SLinus Torvalds 19111da177e4SLinus Torvalds /* Update sector statistic */ 19121da177e4SLinus Torvalds tw_dev->sector_count = num_sectors; 19131da177e4SLinus Torvalds if (tw_dev->sector_count > tw_dev->max_sector_count) 19141da177e4SLinus Torvalds tw_dev->max_sector_count = tw_dev->sector_count; 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds /* Update SG statistics */ 19171da177e4SLinus Torvalds if (srb) { 19181da177e4SLinus Torvalds tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg; 19191da177e4SLinus Torvalds if (tw_dev->sgl_entries > tw_dev->max_sgl_entries) 19201da177e4SLinus Torvalds tw_dev->max_sgl_entries = tw_dev->sgl_entries; 19211da177e4SLinus Torvalds } 19221da177e4SLinus Torvalds 19231da177e4SLinus Torvalds /* Now post the command to the board */ 19241da177e4SLinus Torvalds if (srb) { 19251da177e4SLinus Torvalds retval = twa_post_command_packet(tw_dev, request_id, 0); 19261da177e4SLinus Torvalds } else { 19271da177e4SLinus Torvalds twa_post_command_packet(tw_dev, request_id, 1); 19281da177e4SLinus Torvalds retval = 0; 19291da177e4SLinus Torvalds } 19301da177e4SLinus Torvalds out: 19311da177e4SLinus Torvalds return retval; 19321da177e4SLinus Torvalds } /* End twa_scsiop_execute_scsi() */ 19331da177e4SLinus Torvalds 19341da177e4SLinus Torvalds /* This function completes an execute scsi operation */ 19351da177e4SLinus Torvalds static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id) 19361da177e4SLinus Torvalds { 1937d327d082Sadam radford if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH && 1938d327d082Sadam radford (tw_dev->srb[request_id]->sc_data_direction == DMA_FROM_DEVICE || 1939d327d082Sadam radford tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)) { 1940d327d082Sadam radford if (tw_dev->srb[request_id]->use_sg == 0) { 19411da177e4SLinus Torvalds memcpy(tw_dev->srb[request_id]->request_buffer, 19421da177e4SLinus Torvalds tw_dev->generic_buffer_virt[request_id], 19431da177e4SLinus Torvalds tw_dev->srb[request_id]->request_bufflen); 19441da177e4SLinus Torvalds } 1945d327d082Sadam radford if (tw_dev->srb[request_id]->use_sg == 1) { 1946d327d082Sadam radford struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 1947d327d082Sadam radford char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 1948d327d082Sadam radford memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length); 1949d327d082Sadam radford kunmap_atomic(buf - sg->offset, KM_IRQ0); 1950d327d082Sadam radford } 1951d327d082Sadam radford } 19521da177e4SLinus Torvalds } /* End twa_scsiop_execute_scsi_complete() */ 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds /* This function tells the controller to shut down */ 19551da177e4SLinus Torvalds static void __twa_shutdown(TW_Device_Extension *tw_dev) 19561da177e4SLinus Torvalds { 19571da177e4SLinus Torvalds /* Disable interrupts */ 19581da177e4SLinus Torvalds TW_DISABLE_INTERRUPTS(tw_dev); 19591da177e4SLinus Torvalds 19601da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no); 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds /* Tell the card we are shutting down */ 19631da177e4SLinus Torvalds if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) { 19641da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed"); 19651da177e4SLinus Torvalds } else { 19661da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n"); 19671da177e4SLinus Torvalds } 19681da177e4SLinus Torvalds 19691da177e4SLinus Torvalds /* Clear all interrupts just before exit */ 19701da177e4SLinus Torvalds TW_CLEAR_ALL_INTERRUPTS(tw_dev); 19711da177e4SLinus Torvalds } /* End __twa_shutdown() */ 19721da177e4SLinus Torvalds 19731da177e4SLinus Torvalds /* Wrapper for __twa_shutdown */ 1974d18c3db5SGreg Kroah-Hartman static void twa_shutdown(struct pci_dev *pdev) 19751da177e4SLinus Torvalds { 1976d18c3db5SGreg Kroah-Hartman struct Scsi_Host *host = pci_get_drvdata(pdev); 19771da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 19781da177e4SLinus Torvalds 19791da177e4SLinus Torvalds __twa_shutdown(tw_dev); 19801da177e4SLinus Torvalds } /* End twa_shutdown() */ 19811da177e4SLinus Torvalds 19821da177e4SLinus Torvalds /* This function will look up a string */ 19831da177e4SLinus Torvalds static char *twa_string_lookup(twa_message_type *table, unsigned int code) 19841da177e4SLinus Torvalds { 19851da177e4SLinus Torvalds int index; 19861da177e4SLinus Torvalds 19871da177e4SLinus Torvalds for (index = 0; ((code != table[index].code) && 19881da177e4SLinus Torvalds (table[index].text != (char *)0)); index++); 19891da177e4SLinus Torvalds return(table[index].text); 19901da177e4SLinus Torvalds } /* End twa_string_lookup() */ 19911da177e4SLinus Torvalds 19921da177e4SLinus Torvalds /* This function will perform a pci-dma unmap */ 19931da177e4SLinus Torvalds static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id) 19941da177e4SLinus Torvalds { 19951da177e4SLinus Torvalds struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 19961da177e4SLinus Torvalds struct pci_dev *pdev = tw_dev->tw_pci_dev; 19971da177e4SLinus Torvalds 19981da177e4SLinus Torvalds switch(cmd->SCp.phase) { 19991da177e4SLinus Torvalds case TW_PHASE_SINGLE: 20001da177e4SLinus Torvalds pci_unmap_single(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL); 20011da177e4SLinus Torvalds break; 20021da177e4SLinus Torvalds case TW_PHASE_SGLIST: 20031da177e4SLinus Torvalds pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 20041da177e4SLinus Torvalds break; 20051da177e4SLinus Torvalds } 20061da177e4SLinus Torvalds } /* End twa_unmap_scsi_data() */ 20071da177e4SLinus Torvalds 20081da177e4SLinus Torvalds /* scsi_host_template initializer */ 20091da177e4SLinus Torvalds static struct scsi_host_template driver_template = { 20101da177e4SLinus Torvalds .module = THIS_MODULE, 20111da177e4SLinus Torvalds .name = "3ware 9000 Storage Controller", 20121da177e4SLinus Torvalds .queuecommand = twa_scsi_queue, 20131da177e4SLinus Torvalds .eh_host_reset_handler = twa_scsi_eh_reset, 20141da177e4SLinus Torvalds .bios_param = twa_scsi_biosparam, 20151da177e4SLinus Torvalds .change_queue_depth = twa_change_queue_depth, 20161da177e4SLinus Torvalds .can_queue = TW_Q_LENGTH-2, 20171da177e4SLinus Torvalds .this_id = -1, 20181da177e4SLinus Torvalds .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH, 20191da177e4SLinus Torvalds .max_sectors = TW_MAX_SECTORS, 20201da177e4SLinus Torvalds .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 20211da177e4SLinus Torvalds .use_clustering = ENABLE_CLUSTERING, 20221da177e4SLinus Torvalds .shost_attrs = twa_host_attrs, 20231da177e4SLinus Torvalds .emulated = 1 20241da177e4SLinus Torvalds }; 20251da177e4SLinus Torvalds 20261da177e4SLinus Torvalds /* This function will probe and initialize a card */ 20271da177e4SLinus Torvalds static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 20281da177e4SLinus Torvalds { 20291da177e4SLinus Torvalds struct Scsi_Host *host = NULL; 20301da177e4SLinus Torvalds TW_Device_Extension *tw_dev; 20311da177e4SLinus Torvalds u32 mem_addr; 20321da177e4SLinus Torvalds int retval = -ENODEV; 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds retval = pci_enable_device(pdev); 20351da177e4SLinus Torvalds if (retval) { 20361da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device"); 20371da177e4SLinus Torvalds goto out_disable_device; 20381da177e4SLinus Torvalds } 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds pci_set_master(pdev); 20411da177e4SLinus Torvalds 20421da177e4SLinus Torvalds retval = pci_set_dma_mask(pdev, sizeof(dma_addr_t) > 4 ? DMA_64BIT_MASK : DMA_32BIT_MASK); 20431da177e4SLinus Torvalds if (retval) { 20441da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask"); 20451da177e4SLinus Torvalds goto out_disable_device; 20461da177e4SLinus Torvalds } 20471da177e4SLinus Torvalds 20481da177e4SLinus Torvalds host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension)); 20491da177e4SLinus Torvalds if (!host) { 20501da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension"); 20511da177e4SLinus Torvalds retval = -ENOMEM; 20521da177e4SLinus Torvalds goto out_disable_device; 20531da177e4SLinus Torvalds } 20541da177e4SLinus Torvalds tw_dev = (TW_Device_Extension *)host->hostdata; 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds memset(tw_dev, 0, sizeof(TW_Device_Extension)); 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds /* Save values to device extension */ 20591da177e4SLinus Torvalds tw_dev->host = host; 20601da177e4SLinus Torvalds tw_dev->tw_pci_dev = pdev; 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds if (twa_initialize_device_extension(tw_dev)) { 20631da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension"); 20641da177e4SLinus Torvalds goto out_free_device_extension; 20651da177e4SLinus Torvalds } 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds /* Request IO regions */ 20681da177e4SLinus Torvalds retval = pci_request_regions(pdev, "3w-9xxx"); 20691da177e4SLinus Torvalds if (retval) { 20701da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region"); 20711da177e4SLinus Torvalds goto out_free_device_extension; 20721da177e4SLinus Torvalds } 20731da177e4SLinus Torvalds 207449bfd8dbSadam radford if (pdev->device == PCI_DEVICE_ID_3WARE_9000) 20751da177e4SLinus Torvalds mem_addr = pci_resource_start(pdev, 1); 207649bfd8dbSadam radford else 207749bfd8dbSadam radford mem_addr = pci_resource_start(pdev, 2); 20781da177e4SLinus Torvalds 20791da177e4SLinus Torvalds /* Save base address */ 20801da177e4SLinus Torvalds tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE); 20811da177e4SLinus Torvalds if (!tw_dev->base_addr) { 20821da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap"); 20831da177e4SLinus Torvalds goto out_release_mem_region; 20841da177e4SLinus Torvalds } 20851da177e4SLinus Torvalds 20861da177e4SLinus Torvalds /* Disable interrupts on the card */ 20871da177e4SLinus Torvalds TW_DISABLE_INTERRUPTS(tw_dev); 20881da177e4SLinus Torvalds 20891da177e4SLinus Torvalds /* Initialize the card */ 20901da177e4SLinus Torvalds if (twa_reset_sequence(tw_dev, 0)) 20911da177e4SLinus Torvalds goto out_release_mem_region; 20921da177e4SLinus Torvalds 20931da177e4SLinus Torvalds /* Set host specific parameters */ 20941da177e4SLinus Torvalds host->max_id = TW_MAX_UNITS; 20951da177e4SLinus Torvalds host->max_cmd_len = TW_MAX_CDB_LEN; 20961da177e4SLinus Torvalds 20971da177e4SLinus Torvalds /* Channels aren't supported by adapter */ 20981da177e4SLinus Torvalds host->max_lun = TW_MAX_LUNS(tw_dev->working_srl); 20991da177e4SLinus Torvalds host->max_channel = 0; 21001da177e4SLinus Torvalds 21011da177e4SLinus Torvalds /* Register the card with the kernel SCSI layer */ 21021da177e4SLinus Torvalds retval = scsi_add_host(host, &pdev->dev); 21031da177e4SLinus Torvalds if (retval) { 21041da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed"); 21051da177e4SLinus Torvalds goto out_release_mem_region; 21061da177e4SLinus Torvalds } 21071da177e4SLinus Torvalds 21081da177e4SLinus Torvalds pci_set_drvdata(pdev, host); 21091da177e4SLinus Torvalds 21101da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n", 21111da177e4SLinus Torvalds host->host_no, mem_addr, pdev->irq); 21121da177e4SLinus Torvalds printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n", 21131da177e4SLinus Torvalds host->host_no, 21141da177e4SLinus Torvalds (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE, 21151da177e4SLinus Torvalds TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH), 21161da177e4SLinus Torvalds (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE, 21171da177e4SLinus Torvalds TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH), 21181da177e4SLinus Torvalds *(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE, 21191da177e4SLinus Torvalds TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)); 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds /* Now setup the interrupt handler */ 21221da177e4SLinus Torvalds retval = request_irq(pdev->irq, twa_interrupt, SA_SHIRQ, "3w-9xxx", tw_dev); 21231da177e4SLinus Torvalds if (retval) { 21241da177e4SLinus Torvalds TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ"); 21251da177e4SLinus Torvalds goto out_remove_host; 21261da177e4SLinus Torvalds } 21271da177e4SLinus Torvalds 21281da177e4SLinus Torvalds twa_device_extension_list[twa_device_extension_count] = tw_dev; 21291da177e4SLinus Torvalds twa_device_extension_count++; 21301da177e4SLinus Torvalds 21311da177e4SLinus Torvalds /* Re-enable interrupts on the card */ 21321da177e4SLinus Torvalds TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 21331da177e4SLinus Torvalds 21341da177e4SLinus Torvalds /* Finally, scan the host */ 21351da177e4SLinus Torvalds scsi_scan_host(host); 21361da177e4SLinus Torvalds 21371da177e4SLinus Torvalds if (twa_major == -1) { 21381da177e4SLinus Torvalds if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0) 21391da177e4SLinus Torvalds TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device"); 21401da177e4SLinus Torvalds } 21411da177e4SLinus Torvalds return 0; 21421da177e4SLinus Torvalds 21431da177e4SLinus Torvalds out_remove_host: 21441da177e4SLinus Torvalds scsi_remove_host(host); 21451da177e4SLinus Torvalds out_release_mem_region: 21461da177e4SLinus Torvalds pci_release_regions(pdev); 21471da177e4SLinus Torvalds out_free_device_extension: 21481da177e4SLinus Torvalds twa_free_device_extension(tw_dev); 21491da177e4SLinus Torvalds scsi_host_put(host); 21501da177e4SLinus Torvalds out_disable_device: 21511da177e4SLinus Torvalds pci_disable_device(pdev); 21521da177e4SLinus Torvalds 21531da177e4SLinus Torvalds return retval; 21541da177e4SLinus Torvalds } /* End twa_probe() */ 21551da177e4SLinus Torvalds 21561da177e4SLinus Torvalds /* This function is called to remove a device */ 21571da177e4SLinus Torvalds static void twa_remove(struct pci_dev *pdev) 21581da177e4SLinus Torvalds { 21591da177e4SLinus Torvalds struct Scsi_Host *host = pci_get_drvdata(pdev); 21601da177e4SLinus Torvalds TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 21611da177e4SLinus Torvalds 21621da177e4SLinus Torvalds scsi_remove_host(tw_dev->host); 21631da177e4SLinus Torvalds 21641da177e4SLinus Torvalds /* Unregister character device */ 21651da177e4SLinus Torvalds if (twa_major >= 0) { 21661da177e4SLinus Torvalds unregister_chrdev(twa_major, "twa"); 21671da177e4SLinus Torvalds twa_major = -1; 21681da177e4SLinus Torvalds } 21691da177e4SLinus Torvalds 21701da177e4SLinus Torvalds /* Free up the IRQ */ 21711da177e4SLinus Torvalds free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 21721da177e4SLinus Torvalds 21731da177e4SLinus Torvalds /* Shutdown the card */ 21741da177e4SLinus Torvalds __twa_shutdown(tw_dev); 21751da177e4SLinus Torvalds 21761da177e4SLinus Torvalds /* Free up the mem region */ 21771da177e4SLinus Torvalds pci_release_regions(pdev); 21781da177e4SLinus Torvalds 21791da177e4SLinus Torvalds /* Free up device extension resources */ 21801da177e4SLinus Torvalds twa_free_device_extension(tw_dev); 21811da177e4SLinus Torvalds 21821da177e4SLinus Torvalds scsi_host_put(tw_dev->host); 21831da177e4SLinus Torvalds pci_disable_device(pdev); 21841da177e4SLinus Torvalds twa_device_extension_count--; 21851da177e4SLinus Torvalds } /* End twa_remove() */ 21861da177e4SLinus Torvalds 21871da177e4SLinus Torvalds /* PCI Devices supported by this driver */ 21881da177e4SLinus Torvalds static struct pci_device_id twa_pci_tbl[] __devinitdata = { 21891da177e4SLinus Torvalds { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000, 21901da177e4SLinus Torvalds PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 219149bfd8dbSadam radford { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX, 219249bfd8dbSadam radford PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 21931da177e4SLinus Torvalds { } 21941da177e4SLinus Torvalds }; 21951da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, twa_pci_tbl); 21961da177e4SLinus Torvalds 21971da177e4SLinus Torvalds /* pci_driver initializer */ 21981da177e4SLinus Torvalds static struct pci_driver twa_driver = { 21991da177e4SLinus Torvalds .name = "3w-9xxx", 22001da177e4SLinus Torvalds .id_table = twa_pci_tbl, 22011da177e4SLinus Torvalds .probe = twa_probe, 22021da177e4SLinus Torvalds .remove = twa_remove, 22031da177e4SLinus Torvalds .shutdown = twa_shutdown 22041da177e4SLinus Torvalds }; 22051da177e4SLinus Torvalds 22061da177e4SLinus Torvalds /* This function is called on driver initialization */ 22071da177e4SLinus Torvalds static int __init twa_init(void) 22081da177e4SLinus Torvalds { 22091da177e4SLinus Torvalds printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION); 22101da177e4SLinus Torvalds 22111da177e4SLinus Torvalds return pci_module_init(&twa_driver); 22121da177e4SLinus Torvalds } /* End twa_init() */ 22131da177e4SLinus Torvalds 22141da177e4SLinus Torvalds /* This function is called on driver exit */ 22151da177e4SLinus Torvalds static void __exit twa_exit(void) 22161da177e4SLinus Torvalds { 22171da177e4SLinus Torvalds pci_unregister_driver(&twa_driver); 22181da177e4SLinus Torvalds } /* End twa_exit() */ 22191da177e4SLinus Torvalds 22201da177e4SLinus Torvalds module_init(twa_init); 22211da177e4SLinus Torvalds module_exit(twa_exit); 22221da177e4SLinus Torvalds 2223