2 3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux.
4 Written By: Adam Radford <linuxraid@amcc.com>
5 Modifications By: Tom Couch <linuxraid@amcc.com>
7 Copyright (C) 2004-2006 Applied Micro Circuits Corporation.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; version 2 of the License.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
19 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
20 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
21 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
22 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
23 solely responsible for determining the appropriateness of using and
24 distributing the Program and assumes all risks associated with its
25 exercise of rights under this Agreement, including but not limited to
26 the risks and costs of program errors, damage to or loss of data,
27 programs or equipment, and unavailability or interruption of operations.
29 DISCLAIMER OF LIABILITY
30 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
31 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
33 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
34 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
35 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
36 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38 You should have received a copy of the GNU General Public License
39 along with this program; if not, write to the Free Software
40 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
42 Bugs/Comments/Suggestions should be mailed to:
45 For more information, goto:
48 Note: This version of the driver does not contain a bundled firmware
53 2.26.02.000 - Driver cleanup for kernel submission.
54 2.26.02.001 - Replace schedule_timeout() calls with msleep().
55 2.26.02.002 - Add support for PAE mode.
57 Fix twa_remove() to free irq handler/unregister_chrdev()
58 before shutting down card.
59 Change to new 'change_queue_depth' api.
60 Fix 'handled=1' ISR usage, remove bogus IRQ check.
61 Remove un-needed eh_abort handler.
62 Add support for embedded firmware error strings.
63 2.26.02.003 - Correctly handle single sgl's with use_sg=1.
64 2.26.02.004 - Add support for 9550SX controllers.
65 2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher.
66 2.26.02.006 - Fix 9550SX pchip reset timeout.
67 Add big endian support.
68 2.26.02.007 - Disable local interrupts during kmap/unmap_atomic().
69 2.26.02.008 - Free irq handler in __twa_shutdown().
71 Add support for 9650SE controllers.
74 #include <linux/module.h>
75 #include <linux/reboot.h>
76 #include <linux/spinlock.h>
77 #include <linux/interrupt.h>
78 #include <linux/moduleparam.h>
79 #include <linux/errno.h>
80 #include <linux/types.h>
81 #include <linux/delay.h>
82 #include <linux/pci.h>
83 #include <linux/time.h>
84 #include <linux/mutex.h>
87 #include <asm/uaccess.h>
88 #include <scsi/scsi.h>
89 #include <scsi/scsi_host.h>
90 #include <scsi/scsi_tcq.h>
91 #include <scsi/scsi_cmnd.h>
95 #define TW_DRIVER_VERSION "2.26.02.008"
96 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
97 static unsigned int twa_device_extension_count;
98 static int twa_major = -1;
99 extern struct timezone sys_tz;
101 /* Module parameters */
102 MODULE_AUTHOR ("AMCC");
103 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
104 MODULE_LICENSE("GPL");
105 MODULE_VERSION(TW_DRIVER_VERSION);
107 /* Function prototypes */
108 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
109 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
110 static char *twa_aen_severity_lookup(unsigned char severity_code);
111 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
112 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
113 static int twa_chrdev_open(struct inode *inode, struct file *file);
114 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
115 static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
116 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
117 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
118 u32 set_features, unsigned short current_fw_srl,
119 unsigned short current_fw_arch_id,
120 unsigned short current_fw_branch,
121 unsigned short current_fw_build,
122 unsigned short *fw_on_ctlr_srl,
123 unsigned short *fw_on_ctlr_arch_id,
124 unsigned short *fw_on_ctlr_branch,
125 unsigned short *fw_on_ctlr_build,
126 u32 *init_connect_result);
127 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length);
128 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
129 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
130 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
131 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
132 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
133 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg);
134 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
135 static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
136 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
140 /* Show some statistics about the card */
141 static ssize_t twa_show_stats(struct class_device *class_dev, char *buf)
143 struct Scsi_Host *host = class_to_shost(class_dev);
144 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
145 unsigned long flags = 0;
148 spin_lock_irqsave(tw_dev->host->host_lock, flags);
149 len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
150 "Current commands posted: %4d\n"
151 "Max commands posted: %4d\n"
152 "Current pending commands: %4d\n"
153 "Max pending commands: %4d\n"
154 "Last sgl length: %4d\n"
155 "Max sgl length: %4d\n"
156 "Last sector count: %4d\n"
157 "Max sector count: %4d\n"
158 "SCSI Host Resets: %4d\n"
161 tw_dev->posted_request_count,
162 tw_dev->max_posted_request_count,
163 tw_dev->pending_request_count,
164 tw_dev->max_pending_request_count,
166 tw_dev->max_sgl_entries,
167 tw_dev->sector_count,
168 tw_dev->max_sector_count,
171 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
173 } /* End twa_show_stats() */
175 /* This function will set a devices queue depth */
176 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
178 if (queue_depth > TW_Q_LENGTH-2)
179 queue_depth = TW_Q_LENGTH-2;
180 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
182 } /* End twa_change_queue_depth() */
184 /* Create sysfs 'stats' entry */
185 static struct class_device_attribute twa_host_stats_attr = {
190 .show = twa_show_stats
193 /* Host attributes initializer */
194 static struct class_device_attribute *twa_host_attrs[] = {
195 &twa_host_stats_attr,
199 /* File operations struct for character device */
200 static const struct file_operations twa_fops = {
201 .owner = THIS_MODULE,
202 .ioctl = twa_chrdev_ioctl,
203 .open = twa_chrdev_open,
207 /* This function will complete an aen request from the isr */
208 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
210 TW_Command_Full *full_command_packet;
211 TW_Command *command_packet;
212 TW_Command_Apache_Header *header;
216 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
217 tw_dev->posted_request_count--;
218 aen = le16_to_cpu(header->status_block.error);
219 full_command_packet = tw_dev->command_packet_virt[request_id];
220 command_packet = &full_command_packet->command.oldcommand;
222 /* First check for internal completion of set param for time sync */
223 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
224 /* Keep reading the queue in case there are more aen's */
225 if (twa_aen_read_queue(tw_dev, request_id))
234 case TW_AEN_QUEUE_EMPTY:
235 /* Quit reading the queue if this is the last one */
237 case TW_AEN_SYNC_TIME_WITH_HOST:
238 twa_aen_sync_time(tw_dev, request_id);
242 twa_aen_queue_event(tw_dev, header);
244 /* If there are more aen's, keep reading the queue */
245 if (twa_aen_read_queue(tw_dev, request_id))
254 tw_dev->state[request_id] = TW_S_COMPLETED;
255 twa_free_request_id(tw_dev, request_id);
256 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
259 } /* End twa_aen_complete() */
261 /* This function will drain aen queue */
262 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
265 char cdb[TW_MAX_CDB_LEN];
266 TW_SG_Entry sglist[1];
267 int finished = 0, count = 0;
268 TW_Command_Full *full_command_packet;
269 TW_Command_Apache_Header *header;
271 int first_reset = 0, queue = 0, retval = 1;
278 full_command_packet = tw_dev->command_packet_virt[request_id];
279 memset(full_command_packet, 0, sizeof(TW_Command_Full));
282 memset(&cdb, 0, TW_MAX_CDB_LEN);
283 cdb[0] = REQUEST_SENSE; /* opcode */
284 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
286 /* Initialize sglist */
287 memset(&sglist, 0, sizeof(TW_SG_Entry));
288 sglist[0].length = TW_SECTOR_SIZE;
289 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
291 if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
292 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
296 /* Mark internal command */
297 tw_dev->srb[request_id] = NULL;
300 /* Send command to the board */
301 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
302 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
306 /* Now poll for completion */
307 if (twa_poll_response(tw_dev, request_id, 30)) {
308 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
309 tw_dev->posted_request_count--;
313 tw_dev->posted_request_count--;
314 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
315 aen = le16_to_cpu(header->status_block.error);
320 case TW_AEN_QUEUE_EMPTY:
321 if (first_reset != 1)
326 case TW_AEN_SOFT_RESET:
327 if (first_reset == 0)
332 case TW_AEN_SYNC_TIME_WITH_HOST:
338 /* Now queue an event info */
340 twa_aen_queue_event(tw_dev, header);
341 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
343 if (count == TW_MAX_AEN_DRAIN)
348 tw_dev->state[request_id] = TW_S_INITIAL;
350 } /* End twa_aen_drain_queue() */
352 /* This function will queue an event */
353 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
364 /* Fill out event info */
365 event = tw_dev->event_queue[tw_dev->error_index];
367 /* Check for clobber */
370 sprintf(host, " scsi%d:", tw_dev->host->host_no);
371 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
372 tw_dev->aen_clobber = 1;
375 aen = le16_to_cpu(header->status_block.error);
376 memset(event, 0, sizeof(TW_Event));
378 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
379 do_gettimeofday(&time);
380 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
381 event->time_stamp_sec = local_time;
382 event->aen_code = aen;
383 event->retrieved = TW_AEN_NOT_RETRIEVED;
384 event->sequence_id = tw_dev->error_sequence_id;
385 tw_dev->error_sequence_id++;
387 /* Check for embedded error string */
388 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
390 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
391 event->parameter_len = strlen(header->err_specific_desc);
392 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
393 if (event->severity != TW_AEN_SEVERITY_DEBUG)
394 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
396 twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
397 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
398 error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
399 header->err_specific_desc);
403 if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
404 tw_dev->event_queue_wrapped = 1;
405 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
406 } /* End twa_aen_queue_event() */
408 /* This function will read the aen queue from the isr */
409 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
411 char cdb[TW_MAX_CDB_LEN];
412 TW_SG_Entry sglist[1];
413 TW_Command_Full *full_command_packet;
416 full_command_packet = tw_dev->command_packet_virt[request_id];
417 memset(full_command_packet, 0, sizeof(TW_Command_Full));
420 memset(&cdb, 0, TW_MAX_CDB_LEN);
421 cdb[0] = REQUEST_SENSE; /* opcode */
422 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
424 /* Initialize sglist */
425 memset(&sglist, 0, sizeof(TW_SG_Entry));
426 sglist[0].length = TW_SECTOR_SIZE;
427 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
429 /* Mark internal command */
430 tw_dev->srb[request_id] = NULL;
432 /* Now post the command packet */
433 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
434 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
440 } /* End twa_aen_read_queue() */
442 /* This function will look up an AEN severity string */
443 static char *twa_aen_severity_lookup(unsigned char severity_code)
447 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
448 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
451 retval = twa_aen_severity_table[severity_code];
454 } /* End twa_aen_severity_lookup() */
456 /* This function will sync firmware time with the host time */
457 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
461 TW_Command_Full *full_command_packet;
462 TW_Command *command_packet;
463 TW_Param_Apache *param;
466 /* Fill out the command packet */
467 full_command_packet = tw_dev->command_packet_virt[request_id];
468 memset(full_command_packet, 0, sizeof(TW_Command_Full));
469 command_packet = &full_command_packet->command.oldcommand;
470 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
471 command_packet->request_id = request_id;
472 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
473 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
474 command_packet->size = TW_COMMAND_SIZE;
475 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
477 /* Setup the param */
478 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
479 memset(param, 0, TW_SECTOR_SIZE);
480 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
481 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
482 param->parameter_size_bytes = cpu_to_le16(4);
484 /* Convert system time in UTC to local time seconds since last
486 do_gettimeofday(&utc);
487 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
488 schedulertime = local_time - (3 * 86400);
489 schedulertime = cpu_to_le32(schedulertime % 604800);
491 memcpy(param->data, &schedulertime, sizeof(u32));
493 /* Mark internal command */
494 tw_dev->srb[request_id] = NULL;
496 /* Now post the command */
497 twa_post_command_packet(tw_dev, request_id, 1);
498 } /* End twa_aen_sync_time() */
500 /* This function will allocate memory and check if it is correctly aligned */
501 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
504 dma_addr_t dma_handle;
505 unsigned long *cpu_addr;
508 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
510 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
514 if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
515 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
516 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
520 memset(cpu_addr, 0, size*TW_Q_LENGTH);
522 for (i = 0; i < TW_Q_LENGTH; i++) {
525 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
526 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
529 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
530 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
537 } /* End twa_allocate_memory() */
539 /* This function will check the status register for unexpected bits */
540 static int twa_check_bits(u32 status_reg_value)
544 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
546 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
552 } /* End twa_check_bits() */
554 /* This function will check the srl and decide if we are compatible */
555 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
558 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
559 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
560 u32 init_connect_result = 0;
562 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
563 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
564 TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
565 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
566 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
567 &fw_on_ctlr_build, &init_connect_result)) {
568 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
572 tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl;
573 tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch;
574 tw_dev->tw_compat_info.working_build = fw_on_ctlr_build;
576 /* Try base mode compatibility */
577 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
578 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
579 TW_EXTENDED_INIT_CONNECT,
580 TW_BASE_FW_SRL, TW_9000_ARCH_ID,
581 TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
582 &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
583 &fw_on_ctlr_branch, &fw_on_ctlr_build,
584 &init_connect_result)) {
585 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
588 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
589 if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
590 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
592 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
596 tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL;
597 tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH;
598 tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD;
601 /* Load rest of compatibility struct */
602 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
603 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
604 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
605 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
606 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
607 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
608 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
609 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
610 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
611 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
616 } /* End twa_check_srl() */
618 /* This function handles ioctl for the character device */
619 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
622 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
623 dma_addr_t dma_handle;
625 unsigned int sequence_id = 0;
626 unsigned char event_index, start_index;
627 TW_Ioctl_Driver_Command driver_command;
628 TW_Ioctl_Buf_Apache *tw_ioctl;
630 TW_Command_Full *full_command_packet;
631 TW_Compatibility_Info *tw_compat_info;
633 struct timeval current_time;
635 TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
636 int retval = TW_IOCTL_ERROR_OS_EFAULT;
637 void __user *argp = (void __user *)arg;
639 /* Only let one of these through at a time */
640 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
641 retval = TW_IOCTL_ERROR_OS_EINTR;
645 /* First copy down the driver command */
646 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
649 /* Check data buffer size */
650 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
651 retval = TW_IOCTL_ERROR_OS_EINVAL;
655 /* Hardware can only do multiple of 512 byte transfers */
656 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
658 /* Now allocate ioctl buf memory */
659 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);
661 retval = TW_IOCTL_ERROR_OS_ENOMEM;
665 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
667 /* Now copy down the entire ioctl */
668 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
671 /* See which ioctl we are doing */
673 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
674 spin_lock_irqsave(tw_dev->host->host_lock, flags);
675 twa_get_request_id(tw_dev, &request_id);
677 /* Flag internal command */
678 tw_dev->srb[request_id] = NULL;
680 /* Flag chrdev ioctl */
681 tw_dev->chrdev_request_id = request_id;
683 full_command_packet = &tw_ioctl->firmware_command;
685 /* Load request id and sglist for both command types */
686 twa_load_sgl(full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
688 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
690 /* Now post the command packet to the controller */
691 twa_post_command_packet(tw_dev, request_id, 1);
692 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
694 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
696 /* Now wait for command to complete */
697 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
699 /* We timed out, and didn't get an interrupt */
700 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
701 /* Now we need to reset the board */
702 printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
703 tw_dev->host->host_no, TW_DRIVER, 0xc,
705 retval = TW_IOCTL_ERROR_OS_EIO;
706 twa_reset_device_extension(tw_dev, 1);
710 /* Now copy in the command packet response */
711 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
713 /* Now complete the io */
714 spin_lock_irqsave(tw_dev->host->host_lock, flags);
715 tw_dev->posted_request_count--;
716 tw_dev->state[request_id] = TW_S_COMPLETED;
717 twa_free_request_id(tw_dev, request_id);
718 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
720 case TW_IOCTL_GET_COMPATIBILITY_INFO:
721 tw_ioctl->driver_command.status = 0;
722 /* Copy compatiblity struct into ioctl data buffer */
723 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
724 memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
726 case TW_IOCTL_GET_LAST_EVENT:
727 if (tw_dev->event_queue_wrapped) {
728 if (tw_dev->aen_clobber) {
729 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
730 tw_dev->aen_clobber = 0;
732 tw_ioctl->driver_command.status = 0;
734 if (!tw_dev->error_index) {
735 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
738 tw_ioctl->driver_command.status = 0;
740 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
741 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
742 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
744 case TW_IOCTL_GET_FIRST_EVENT:
745 if (tw_dev->event_queue_wrapped) {
746 if (tw_dev->aen_clobber) {
747 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
748 tw_dev->aen_clobber = 0;
750 tw_ioctl->driver_command.status = 0;
751 event_index = tw_dev->error_index;
753 if (!tw_dev->error_index) {
754 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
757 tw_ioctl->driver_command.status = 0;
760 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
761 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
763 case TW_IOCTL_GET_NEXT_EVENT:
764 event = (TW_Event *)tw_ioctl->data_buffer;
765 sequence_id = event->sequence_id;
766 tw_ioctl->driver_command.status = 0;
768 if (tw_dev->event_queue_wrapped) {
769 if (tw_dev->aen_clobber) {
770 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
771 tw_dev->aen_clobber = 0;
773 start_index = tw_dev->error_index;
775 if (!tw_dev->error_index) {
776 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
781 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
783 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
784 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
785 tw_dev->aen_clobber = 1;
786 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
789 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
790 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
792 case TW_IOCTL_GET_PREVIOUS_EVENT:
793 event = (TW_Event *)tw_ioctl->data_buffer;
794 sequence_id = event->sequence_id;
795 tw_ioctl->driver_command.status = 0;
797 if (tw_dev->event_queue_wrapped) {
798 if (tw_dev->aen_clobber) {
799 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
800 tw_dev->aen_clobber = 0;
802 start_index = tw_dev->error_index;
804 if (!tw_dev->error_index) {
805 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
810 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
812 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
813 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
814 tw_dev->aen_clobber = 1;
815 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
818 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
819 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
821 case TW_IOCTL_GET_LOCK:
822 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
823 do_gettimeofday(¤t_time);
824 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
826 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
827 tw_dev->ioctl_sem_lock = 1;
828 tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
829 tw_ioctl->driver_command.status = 0;
830 tw_lock->time_remaining_msec = tw_lock->timeout_msec;
832 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
833 tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
836 case TW_IOCTL_RELEASE_LOCK:
837 if (tw_dev->ioctl_sem_lock == 1) {
838 tw_dev->ioctl_sem_lock = 0;
839 tw_ioctl->driver_command.status = 0;
841 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
845 retval = TW_IOCTL_ERROR_OS_ENOTTY;
849 /* Now copy the entire response to userspace */
850 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
853 /* Now free ioctl buf memory */
854 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
856 mutex_unlock(&tw_dev->ioctl_lock);
859 } /* End twa_chrdev_ioctl() */
861 /* This function handles open for the character device */
862 static int twa_chrdev_open(struct inode *inode, struct file *file)
864 unsigned int minor_number;
865 int retval = TW_IOCTL_ERROR_OS_ENODEV;
867 minor_number = iminor(inode);
868 if (minor_number >= twa_device_extension_count)
873 } /* End twa_chrdev_open() */
875 /* This function will print readable messages from status register errors */
876 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
880 /* Check for various error conditions and handle them appropriately */
881 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
882 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
883 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
886 if (status_reg_value & TW_STATUS_PCI_ABORT) {
887 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
888 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
889 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
892 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
893 if ((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) || (!test_bit(TW_IN_RESET, &tw_dev->flags)))
894 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
895 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
898 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
899 if (tw_dev->reset_print == 0) {
900 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
901 tw_dev->reset_print = 1;
908 } /* End twa_decode_bits() */
910 /* This function will empty the response queue */
911 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
913 u32 status_reg_value, response_que_value;
914 int count = 0, retval = 1;
916 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
918 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
919 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
920 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
923 if (count == TW_MAX_RESPONSE_DRAIN)
929 } /* End twa_empty_response_queue() */
931 /* This function will clear the pchip/response queue on 9550SX */
932 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
934 u32 response_que_value = 0;
935 unsigned long before;
938 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9550SX) ||
939 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE)) {
941 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
942 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
944 if (time_after(jiffies, before + HZ * 30))
947 /* P-chip settle time */
954 } /* End twa_empty_response_queue_large() */
956 /* This function passes sense keys from firmware to scsi layer */
957 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
959 TW_Command_Full *full_command_packet;
960 unsigned short error;
964 full_command_packet = tw_dev->command_packet_virt[request_id];
966 /* Check for embedded error string */
967 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
969 /* Don't print error for Logical unit not supported during rollcall */
970 error = le16_to_cpu(full_command_packet->header.status_block.error);
971 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
973 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
974 tw_dev->host->host_no,
975 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
976 full_command_packet->header.status_block.error,
977 error_str[0] == '\0' ?
978 twa_string_lookup(twa_error_table,
979 full_command_packet->header.status_block.error) : error_str,
980 full_command_packet->header.err_specific_desc);
982 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
983 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
984 full_command_packet->header.status_block.error,
985 error_str[0] == '\0' ?
986 twa_string_lookup(twa_error_table,
987 full_command_packet->header.status_block.error) : error_str,
988 full_command_packet->header.err_specific_desc);
992 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
993 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
994 retval = TW_ISR_DONT_RESULT;
1000 } /* End twa_fill_sense() */
1002 /* This function will free up device extension resources */
1003 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1005 if (tw_dev->command_packet_virt[0])
1006 pci_free_consistent(tw_dev->tw_pci_dev,
1007 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1008 tw_dev->command_packet_virt[0],
1009 tw_dev->command_packet_phys[0]);
1011 if (tw_dev->generic_buffer_virt[0])
1012 pci_free_consistent(tw_dev->tw_pci_dev,
1013 TW_SECTOR_SIZE*TW_Q_LENGTH,
1014 tw_dev->generic_buffer_virt[0],
1015 tw_dev->generic_buffer_phys[0]);
1017 kfree(tw_dev->event_queue[0]);
1018 } /* End twa_free_device_extension() */
1020 /* This function will free a request id */
1021 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1023 tw_dev->free_queue[tw_dev->free_tail] = request_id;
1024 tw_dev->state[request_id] = TW_S_FINISHED;
1025 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1026 } /* End twa_free_request_id() */
1028 /* This function will get parameter table entries from the firmware */
1029 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1031 TW_Command_Full *full_command_packet;
1032 TW_Command *command_packet;
1033 TW_Param_Apache *param;
1034 unsigned long param_value;
1035 void *retval = NULL;
1037 /* Setup the command packet */
1038 full_command_packet = tw_dev->command_packet_virt[request_id];
1039 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1040 command_packet = &full_command_packet->command.oldcommand;
1042 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1043 command_packet->size = TW_COMMAND_SIZE;
1044 command_packet->request_id = request_id;
1045 command_packet->byte6_offset.block_count = cpu_to_le16(1);
1047 /* Now setup the param */
1048 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1049 memset(param, 0, TW_SECTOR_SIZE);
1050 param->table_id = cpu_to_le16(table_id | 0x8000);
1051 param->parameter_id = cpu_to_le16(parameter_id);
1052 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1053 param_value = tw_dev->generic_buffer_phys[request_id];
1055 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(param_value);
1056 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1058 /* Post the command packet to the board */
1059 twa_post_command_packet(tw_dev, request_id, 1);
1061 /* Poll for completion */
1062 if (twa_poll_response(tw_dev, request_id, 30))
1063 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1065 retval = (void *)&(param->data[0]);
1067 tw_dev->posted_request_count--;
1068 tw_dev->state[request_id] = TW_S_INITIAL;
1071 } /* End twa_get_param() */
1073 /* This function will assign an available request id */
1074 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1076 *request_id = tw_dev->free_queue[tw_dev->free_head];
1077 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1078 tw_dev->state[*request_id] = TW_S_STARTED;
1079 } /* End twa_get_request_id() */
1081 /* This function will send an initconnection command to controller */
1082 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1083 u32 set_features, unsigned short current_fw_srl,
1084 unsigned short current_fw_arch_id,
1085 unsigned short current_fw_branch,
1086 unsigned short current_fw_build,
1087 unsigned short *fw_on_ctlr_srl,
1088 unsigned short *fw_on_ctlr_arch_id,
1089 unsigned short *fw_on_ctlr_branch,
1090 unsigned short *fw_on_ctlr_build,
1091 u32 *init_connect_result)
1093 TW_Command_Full *full_command_packet;
1094 TW_Initconnect *tw_initconnect;
1095 int request_id = 0, retval = 1;
1097 /* Initialize InitConnection command packet */
1098 full_command_packet = tw_dev->command_packet_virt[request_id];
1099 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1100 full_command_packet->header.header_desc.size_header = 128;
1102 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1103 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1104 tw_initconnect->request_id = request_id;
1105 tw_initconnect->message_credits = cpu_to_le16(message_credits);
1106 tw_initconnect->features = set_features;
1108 /* Turn on 64-bit sgl support if we need to */
1109 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1111 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1113 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1114 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1115 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1116 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1117 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1118 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1120 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1122 /* Send command packet to the board */
1123 twa_post_command_packet(tw_dev, request_id, 1);
1125 /* Poll for completion */
1126 if (twa_poll_response(tw_dev, request_id, 30)) {
1127 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1129 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1130 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1131 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1132 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1133 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1134 *init_connect_result = le32_to_cpu(tw_initconnect->result);
1139 tw_dev->posted_request_count--;
1140 tw_dev->state[request_id] = TW_S_INITIAL;
1143 } /* End twa_initconnection() */
1145 /* This function will initialize the fields of a device extension */
1146 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1150 /* Initialize command packet buffers */
1151 if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1152 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1156 /* Initialize generic buffer */
1157 if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1158 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1162 /* Allocate event info space */
1163 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1164 if (!tw_dev->event_queue[0]) {
1165 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1170 for (i = 0; i < TW_Q_LENGTH; i++) {
1171 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1172 tw_dev->free_queue[i] = i;
1173 tw_dev->state[i] = TW_S_INITIAL;
1176 tw_dev->pending_head = TW_Q_START;
1177 tw_dev->pending_tail = TW_Q_START;
1178 tw_dev->free_head = TW_Q_START;
1179 tw_dev->free_tail = TW_Q_START;
1180 tw_dev->error_sequence_id = 1;
1181 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1183 mutex_init(&tw_dev->ioctl_lock);
1184 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1189 } /* End twa_initialize_device_extension() */
1191 /* This function is the interrupt service routine */
1192 static irqreturn_t twa_interrupt(int irq, void *dev_instance)
1194 int request_id, error = 0;
1195 u32 status_reg_value;
1196 TW_Response_Queue response_que;
1197 TW_Command_Full *full_command_packet;
1198 TW_Command *command_packet;
1199 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1202 /* Get the per adapter lock */
1203 spin_lock(tw_dev->host->host_lock);
1205 /* Read the registers */
1206 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1208 /* Check if this is our interrupt, otherwise bail */
1209 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1210 goto twa_interrupt_bail;
1214 /* If we are resetting, bail */
1215 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1216 goto twa_interrupt_bail;
1218 /* Check controller for errors */
1219 if (twa_check_bits(status_reg_value)) {
1220 if (twa_decode_bits(tw_dev, status_reg_value)) {
1221 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1222 goto twa_interrupt_bail;
1226 /* Handle host interrupt */
1227 if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1228 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1230 /* Handle attention interrupt */
1231 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1232 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1233 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1234 twa_get_request_id(tw_dev, &request_id);
1236 error = twa_aen_read_queue(tw_dev, request_id);
1238 tw_dev->state[request_id] = TW_S_COMPLETED;
1239 twa_free_request_id(tw_dev, request_id);
1240 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1245 /* Handle command interrupt */
1246 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1247 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1248 /* Drain as many pending commands as we can */
1249 while (tw_dev->pending_request_count > 0) {
1250 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1251 if (tw_dev->state[request_id] != TW_S_PENDING) {
1252 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1253 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1254 goto twa_interrupt_bail;
1256 if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1257 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1258 tw_dev->pending_request_count--;
1260 /* If we get here, we will continue re-posting on the next command interrupt */
1266 /* Handle response interrupt */
1267 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1269 /* Drain the response queue from the board */
1270 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1271 /* Complete the response */
1272 response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1273 request_id = TW_RESID_OUT(response_que.response_id);
1274 full_command_packet = tw_dev->command_packet_virt[request_id];
1276 command_packet = &full_command_packet->command.oldcommand;
1277 /* Check for command packet errors */
1278 if (full_command_packet->command.newcommand.status != 0) {
1279 if (tw_dev->srb[request_id] != 0) {
1280 error = twa_fill_sense(tw_dev, request_id, 1, 1);
1282 /* Skip ioctl error prints */
1283 if (request_id != tw_dev->chrdev_request_id) {
1284 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1289 /* Check for correct state */
1290 if (tw_dev->state[request_id] != TW_S_POSTED) {
1291 if (tw_dev->srb[request_id] != 0) {
1292 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1293 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1294 goto twa_interrupt_bail;
1298 /* Check for internal command completion */
1299 if (tw_dev->srb[request_id] == 0) {
1300 if (request_id != tw_dev->chrdev_request_id) {
1301 if (twa_aen_complete(tw_dev, request_id))
1302 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1304 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1305 wake_up(&tw_dev->ioctl_wqueue);
1308 struct scsi_cmnd *cmd;
1310 cmd = tw_dev->srb[request_id];
1312 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1313 /* If no error command was a success */
1315 cmd->result = (DID_OK << 16);
1318 /* If error, command failed */
1320 /* Ask for a host reset */
1321 cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1324 /* Report residual bytes for single sgl */
1325 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1326 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1327 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1330 /* Now complete the io */
1331 tw_dev->state[request_id] = TW_S_COMPLETED;
1332 twa_free_request_id(tw_dev, request_id);
1333 tw_dev->posted_request_count--;
1334 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1335 twa_unmap_scsi_data(tw_dev, request_id);
1338 /* Check for valid status after each drain */
1339 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1340 if (twa_check_bits(status_reg_value)) {
1341 if (twa_decode_bits(tw_dev, status_reg_value)) {
1342 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1343 goto twa_interrupt_bail;
1350 spin_unlock(tw_dev->host->host_lock);
1351 return IRQ_RETVAL(handled);
1352 } /* End twa_interrupt() */
1354 /* This function will load the request id and various sgls for ioctls */
1355 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
1357 TW_Command *oldcommand;
1358 TW_Command_Apache *newcommand;
1361 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1362 newcommand = &full_command_packet->command.newcommand;
1363 newcommand->request_id__lunl =
1364 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
1365 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1366 newcommand->sg_list[0].length = cpu_to_le32(length);
1367 newcommand->sgl_entries__lunh =
1368 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1));
1370 oldcommand = &full_command_packet->command.oldcommand;
1371 oldcommand->request_id = request_id;
1373 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1374 /* Load the sg list */
1375 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1376 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1377 sgl->length = cpu_to_le32(length);
1379 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1380 oldcommand->size += 1;
1383 } /* End twa_load_sgl() */
1385 /* This function will perform a pci-dma mapping for a scatter gather list */
1386 static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1389 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1391 use_sg = scsi_dma_map(cmd);
1394 else if (use_sg < 0) {
1395 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
1399 cmd->SCp.phase = TW_PHASE_SGLIST;
1400 cmd->SCp.have_data_in = use_sg;
1403 } /* End twa_map_scsi_sg_data() */
1405 /* This function will poll for a response interrupt of a request */
1406 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1408 int retval = 1, found = 0, response_request_id;
1409 TW_Response_Queue response_queue;
1410 TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1412 if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1413 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1414 response_request_id = TW_RESID_OUT(response_queue.response_id);
1415 if (request_id != response_request_id) {
1416 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1419 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1420 if (full_command_packet->command.newcommand.status != 0) {
1422 twa_fill_sense(tw_dev, request_id, 0, 0);
1427 if (full_command_packet->command.oldcommand.status != 0) {
1429 twa_fill_sense(tw_dev, request_id, 0, 0);
1440 } /* End twa_poll_response() */
1442 /* This function will poll the status register for a flag */
1443 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1445 u32 status_reg_value;
1446 unsigned long before;
1449 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1452 if (twa_check_bits(status_reg_value))
1453 twa_decode_bits(tw_dev, status_reg_value);
1455 while ((status_reg_value & flag) != flag) {
1456 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1458 if (twa_check_bits(status_reg_value))
1459 twa_decode_bits(tw_dev, status_reg_value);
1461 if (time_after(jiffies, before + HZ * seconds))
1469 } /* End twa_poll_status() */
1471 /* This function will poll the status register for disappearance of a flag */
1472 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1474 u32 status_reg_value;
1475 unsigned long before;
1478 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1481 if (twa_check_bits(status_reg_value))
1482 twa_decode_bits(tw_dev, status_reg_value);
1484 while ((status_reg_value & flag) != 0) {
1485 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1486 if (twa_check_bits(status_reg_value))
1487 twa_decode_bits(tw_dev, status_reg_value);
1489 if (time_after(jiffies, before + HZ * seconds))
1497 } /* End twa_poll_status_gone() */
1499 /* This function will attempt to post a command packet to the board */
1500 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1502 u32 status_reg_value;
1503 dma_addr_t command_que_value;
1506 command_que_value = tw_dev->command_packet_phys[request_id];
1508 /* For 9650SE write low 4 bytes first */
1509 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) {
1510 command_que_value += TW_COMMAND_OFFSET;
1511 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1514 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1516 if (twa_check_bits(status_reg_value))
1517 twa_decode_bits(tw_dev, status_reg_value);
1519 if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1521 /* Only pend internal driver commands */
1523 retval = SCSI_MLQUEUE_HOST_BUSY;
1527 /* Couldn't post the command packet, so we do it later */
1528 if (tw_dev->state[request_id] != TW_S_PENDING) {
1529 tw_dev->state[request_id] = TW_S_PENDING;
1530 tw_dev->pending_request_count++;
1531 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1532 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1534 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1535 tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1537 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1540 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) {
1541 /* Now write upper 4 bytes */
1542 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
1544 if (sizeof(dma_addr_t) > 4) {
1545 command_que_value += TW_COMMAND_OFFSET;
1546 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1547 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1549 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1552 tw_dev->state[request_id] = TW_S_POSTED;
1553 tw_dev->posted_request_count++;
1554 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1555 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1561 } /* End twa_post_command_packet() */
1563 /* This function will reset a device extension */
1564 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1568 unsigned long flags = 0;
1570 set_bit(TW_IN_RESET, &tw_dev->flags);
1571 TW_DISABLE_INTERRUPTS(tw_dev);
1572 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1573 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1575 /* Abort all requests that are in progress */
1576 for (i = 0; i < TW_Q_LENGTH; i++) {
1577 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1578 (tw_dev->state[i] != TW_S_INITIAL) &&
1579 (tw_dev->state[i] != TW_S_COMPLETED)) {
1580 if (tw_dev->srb[i]) {
1581 tw_dev->srb[i]->result = (DID_RESET << 16);
1582 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1583 twa_unmap_scsi_data(tw_dev, i);
1588 /* Reset queues and counts */
1589 for (i = 0; i < TW_Q_LENGTH; i++) {
1590 tw_dev->free_queue[i] = i;
1591 tw_dev->state[i] = TW_S_INITIAL;
1593 tw_dev->free_head = TW_Q_START;
1594 tw_dev->free_tail = TW_Q_START;
1595 tw_dev->posted_request_count = 0;
1596 tw_dev->pending_request_count = 0;
1597 tw_dev->pending_head = TW_Q_START;
1598 tw_dev->pending_tail = TW_Q_START;
1599 tw_dev->reset_print = 0;
1601 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1603 if (twa_reset_sequence(tw_dev, 1))
1606 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1607 clear_bit(TW_IN_RESET, &tw_dev->flags);
1608 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1613 } /* End twa_reset_device_extension() */
1615 /* This function will reset a controller */
1616 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1618 int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1620 while (tries < TW_MAX_RESET_TRIES) {
1621 if (do_soft_reset) {
1622 TW_SOFT_RESET(tw_dev);
1623 /* Clear pchip/response queue on 9550SX */
1624 if (twa_empty_response_queue_large(tw_dev)) {
1625 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1632 /* Make sure controller is in a good state */
1633 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1634 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1640 /* Empty response queue */
1641 if (twa_empty_response_queue(tw_dev)) {
1642 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1650 /* Check for compatibility/flash */
1651 if (twa_check_srl(tw_dev, &flashed)) {
1652 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1663 /* Drain the AEN queue */
1664 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1665 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1671 /* If we got here, controller is in a good state */
1677 } /* End twa_reset_sequence() */
1679 /* This funciton returns unit geometry in cylinders/heads/sectors */
1680 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1682 int heads, sectors, cylinders;
1683 TW_Device_Extension *tw_dev;
1685 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1687 if (capacity >= 0x200000) {
1690 cylinders = sector_div(capacity, heads * sectors);
1694 cylinders = sector_div(capacity, heads * sectors);
1699 geom[2] = cylinders;
1702 } /* End twa_scsi_biosparam() */
1704 /* This is the new scsi eh reset function */
1705 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1707 TW_Device_Extension *tw_dev = NULL;
1708 int retval = FAILED;
1710 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1712 tw_dev->num_resets++;
1714 sdev_printk(KERN_WARNING, SCpnt->device,
1715 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1716 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1718 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1719 mutex_lock(&tw_dev->ioctl_lock);
1721 /* Now reset the card and some of the device extension data */
1722 if (twa_reset_device_extension(tw_dev, 0)) {
1723 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1729 mutex_unlock(&tw_dev->ioctl_lock);
1731 } /* End twa_scsi_eh_reset() */
1733 /* This is the main scsi queue function to handle scsi opcodes */
1734 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1736 int request_id, retval;
1737 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1739 /* If we are resetting due to timed out ioctl, report as busy */
1740 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1741 retval = SCSI_MLQUEUE_HOST_BUSY;
1745 /* Check if this FW supports luns */
1746 if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1747 SCpnt->result = (DID_BAD_TARGET << 16);
1753 /* Save done function into scsi_cmnd struct */
1754 SCpnt->scsi_done = done;
1756 /* Get a free request id */
1757 twa_get_request_id(tw_dev, &request_id);
1759 /* Save the scsi command for use by the ISR */
1760 tw_dev->srb[request_id] = SCpnt;
1762 /* Initialize phase to zero */
1763 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1765 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1767 case SCSI_MLQUEUE_HOST_BUSY:
1768 twa_free_request_id(tw_dev, request_id);
1771 tw_dev->state[request_id] = TW_S_COMPLETED;
1772 twa_free_request_id(tw_dev, request_id);
1773 SCpnt->result = (DID_ERROR << 16);
1779 } /* End twa_scsi_queue() */
1781 /* This function hands scsi cdb's to the firmware */
1782 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1784 TW_Command_Full *full_command_packet;
1785 TW_Command_Apache *command_packet;
1786 u32 num_sectors = 0x0;
1788 struct scsi_cmnd *srb = NULL;
1789 struct scatterlist *sglist = NULL, *sg;
1792 if (tw_dev->srb[request_id]) {
1793 srb = tw_dev->srb[request_id];
1794 if (scsi_sglist(srb))
1795 sglist = scsi_sglist(srb);
1798 /* Initialize command packet */
1799 full_command_packet = tw_dev->command_packet_virt[request_id];
1800 full_command_packet->header.header_desc.size_header = 128;
1801 full_command_packet->header.status_block.error = 0;
1802 full_command_packet->header.status_block.severity__reserved = 0;
1804 command_packet = &full_command_packet->command.newcommand;
1805 command_packet->status = 0;
1806 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1808 /* We forced 16 byte cdb use earlier */
1810 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1812 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1815 command_packet->unit = srb->device->id;
1816 command_packet->request_id__lunl =
1817 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
1819 command_packet->request_id__lunl =
1820 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
1821 command_packet->unit = 0;
1824 command_packet->sgl_offset = 16;
1827 /* Map sglist from scsi layer to cmd packet */
1829 if (scsi_sg_count(srb)) {
1830 if ((scsi_sg_count(srb) == 1) &&
1831 (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
1832 if (srb->sc_data_direction == DMA_TO_DEVICE || srb->sc_data_direction == DMA_BIDIRECTIONAL) {
1833 struct scatterlist *sg = scsi_sglist(srb);
1834 char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1835 memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length);
1836 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1838 command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1839 command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
1841 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1845 scsi_for_each_sg(srb, sg, sg_count, i) {
1846 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1847 command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
1848 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1849 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1854 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
1857 /* Internal cdb post */
1858 for (i = 0; i < use_sg; i++) {
1859 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1860 command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1861 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1862 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1866 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
1870 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1871 num_sectors = (u32)srb->cmnd[4];
1873 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1874 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1877 /* Update sector statistic */
1878 tw_dev->sector_count = num_sectors;
1879 if (tw_dev->sector_count > tw_dev->max_sector_count)
1880 tw_dev->max_sector_count = tw_dev->sector_count;
1882 /* Update SG statistics */
1884 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1885 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1886 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1889 /* Now post the command to the board */
1891 retval = twa_post_command_packet(tw_dev, request_id, 0);
1893 twa_post_command_packet(tw_dev, request_id, 1);
1898 } /* End twa_scsiop_execute_scsi() */
1900 /* This function completes an execute scsi operation */
1901 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1903 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1905 if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1906 (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1907 cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
1908 if (scsi_sg_count(cmd) == 1) {
1909 struct scatterlist *sg = scsi_sglist(tw_dev->srb[request_id]);
1911 unsigned long flags = 0;
1912 local_irq_save(flags);
1913 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1914 memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length);
1915 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1916 local_irq_restore(flags);
1919 } /* End twa_scsiop_execute_scsi_complete() */
1921 /* This function tells the controller to shut down */
1922 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1924 /* Disable interrupts */
1925 TW_DISABLE_INTERRUPTS(tw_dev);
1927 /* Free up the IRQ */
1928 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1930 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1932 /* Tell the card we are shutting down */
1933 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1934 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1936 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1939 /* Clear all interrupts just before exit */
1940 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1941 } /* End __twa_shutdown() */
1943 /* Wrapper for __twa_shutdown */
1944 static void twa_shutdown(struct pci_dev *pdev)
1946 struct Scsi_Host *host = pci_get_drvdata(pdev);
1947 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1949 __twa_shutdown(tw_dev);
1950 } /* End twa_shutdown() */
1952 /* This function will look up a string */
1953 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1957 for (index = 0; ((code != table[index].code) &&
1958 (table[index].text != (char *)0)); index++);
1959 return(table[index].text);
1960 } /* End twa_string_lookup() */
1962 /* This function will perform a pci-dma unmap */
1963 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1965 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1967 scsi_dma_unmap(cmd);
1968 } /* End twa_unmap_scsi_data() */
1970 /* scsi_host_template initializer */
1971 static struct scsi_host_template driver_template = {
1972 .module = THIS_MODULE,
1973 .name = "3ware 9000 Storage Controller",
1974 .queuecommand = twa_scsi_queue,
1975 .eh_host_reset_handler = twa_scsi_eh_reset,
1976 .bios_param = twa_scsi_biosparam,
1977 .change_queue_depth = twa_change_queue_depth,
1978 .can_queue = TW_Q_LENGTH-2,
1980 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH,
1981 .max_sectors = TW_MAX_SECTORS,
1982 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
1983 .use_clustering = ENABLE_CLUSTERING,
1984 .shost_attrs = twa_host_attrs,
1988 /* This function will probe and initialize a card */
1989 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1991 struct Scsi_Host *host = NULL;
1992 TW_Device_Extension *tw_dev;
1994 int retval = -ENODEV;
1996 retval = pci_enable_device(pdev);
1998 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
1999 goto out_disable_device;
2002 pci_set_master(pdev);
2004 retval = pci_set_dma_mask(pdev, sizeof(dma_addr_t) > 4 ? DMA_64BIT_MASK : DMA_32BIT_MASK);
2006 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2007 goto out_disable_device;
2010 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2012 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2014 goto out_disable_device;
2016 tw_dev = (TW_Device_Extension *)host->hostdata;
2018 memset(tw_dev, 0, sizeof(TW_Device_Extension));
2020 /* Save values to device extension */
2021 tw_dev->host = host;
2022 tw_dev->tw_pci_dev = pdev;
2024 if (twa_initialize_device_extension(tw_dev)) {
2025 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2026 goto out_free_device_extension;
2029 /* Request IO regions */
2030 retval = pci_request_regions(pdev, "3w-9xxx");
2032 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2033 goto out_free_device_extension;
2036 if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2037 mem_addr = pci_resource_start(pdev, 1);
2039 mem_addr = pci_resource_start(pdev, 2);
2041 /* Save base address */
2042 tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2043 if (!tw_dev->base_addr) {
2044 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2045 goto out_release_mem_region;
2048 /* Disable interrupts on the card */
2049 TW_DISABLE_INTERRUPTS(tw_dev);
2051 /* Initialize the card */
2052 if (twa_reset_sequence(tw_dev, 0))
2055 /* Set host specific parameters */
2056 if (pdev->device == PCI_DEVICE_ID_3WARE_9650SE)
2057 host->max_id = TW_MAX_UNITS_9650SE;
2059 host->max_id = TW_MAX_UNITS;
2061 host->max_cmd_len = TW_MAX_CDB_LEN;
2063 /* Channels aren't supported by adapter */
2064 host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
2065 host->max_channel = 0;
2067 /* Register the card with the kernel SCSI layer */
2068 retval = scsi_add_host(host, &pdev->dev);
2070 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2074 pci_set_drvdata(pdev, host);
2076 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2077 host->host_no, mem_addr, pdev->irq);
2078 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2080 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2081 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2082 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2083 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2084 le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2085 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
2087 /* Now setup the interrupt handler */
2088 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2090 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2091 goto out_remove_host;
2094 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2095 twa_device_extension_count++;
2097 /* Re-enable interrupts on the card */
2098 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2100 /* Finally, scan the host */
2101 scsi_scan_host(host);
2103 if (twa_major == -1) {
2104 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2105 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2110 scsi_remove_host(host);
2112 iounmap(tw_dev->base_addr);
2113 out_release_mem_region:
2114 pci_release_regions(pdev);
2115 out_free_device_extension:
2116 twa_free_device_extension(tw_dev);
2117 scsi_host_put(host);
2119 pci_disable_device(pdev);
2122 } /* End twa_probe() */
2124 /* This function is called to remove a device */
2125 static void twa_remove(struct pci_dev *pdev)
2127 struct Scsi_Host *host = pci_get_drvdata(pdev);
2128 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2130 scsi_remove_host(tw_dev->host);
2132 /* Unregister character device */
2133 if (twa_major >= 0) {
2134 unregister_chrdev(twa_major, "twa");
2138 /* Shutdown the card */
2139 __twa_shutdown(tw_dev);
2141 /* Free IO remapping */
2142 iounmap(tw_dev->base_addr);
2144 /* Free up the mem region */
2145 pci_release_regions(pdev);
2147 /* Free up device extension resources */
2148 twa_free_device_extension(tw_dev);
2150 scsi_host_put(tw_dev->host);
2151 pci_disable_device(pdev);
2152 twa_device_extension_count--;
2153 } /* End twa_remove() */
2155 /* PCI Devices supported by this driver */
2156 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2157 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2158 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2159 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2160 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2161 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2162 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2165 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2167 /* pci_driver initializer */
2168 static struct pci_driver twa_driver = {
2170 .id_table = twa_pci_tbl,
2172 .remove = twa_remove,
2173 .shutdown = twa_shutdown
2176 /* This function is called on driver initialization */
2177 static int __init twa_init(void)
2179 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2181 return pci_register_driver(&twa_driver);
2182 } /* End twa_init() */
2184 /* This function is called on driver exit */
2185 static void __exit twa_exit(void)
2187 pci_unregister_driver(&twa_driver);
2188 } /* End twa_exit() */
2190 module_init(twa_init);
2191 module_exit(twa_exit);