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-2007 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.
72 2.26.02.009 - Fix dma mask setting to fallback to 32-bit if 64-bit fails.
73 2.26.02.010 - Add support for 9690SA controllers.
76 #include <linux/module.h>
77 #include <linux/reboot.h>
78 #include <linux/spinlock.h>
79 #include <linux/interrupt.h>
80 #include <linux/moduleparam.h>
81 #include <linux/errno.h>
82 #include <linux/types.h>
83 #include <linux/delay.h>
84 #include <linux/pci.h>
85 #include <linux/time.h>
86 #include <linux/mutex.h>
89 #include <asm/uaccess.h>
90 #include <scsi/scsi.h>
91 #include <scsi/scsi_host.h>
92 #include <scsi/scsi_tcq.h>
93 #include <scsi/scsi_cmnd.h>
97 #define TW_DRIVER_VERSION "2.26.02.010"
98 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
99 static unsigned int twa_device_extension_count;
100 static int twa_major = -1;
101 extern struct timezone sys_tz;
103 /* Module parameters */
104 MODULE_AUTHOR ("AMCC");
105 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
106 MODULE_LICENSE("GPL");
107 MODULE_VERSION(TW_DRIVER_VERSION);
109 /* Function prototypes */
110 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
111 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
112 static char *twa_aen_severity_lookup(unsigned char severity_code);
113 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
114 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
115 static int twa_chrdev_open(struct inode *inode, struct file *file);
116 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
117 static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
118 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
119 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
120 u32 set_features, unsigned short current_fw_srl,
121 unsigned short current_fw_arch_id,
122 unsigned short current_fw_branch,
123 unsigned short current_fw_build,
124 unsigned short *fw_on_ctlr_srl,
125 unsigned short *fw_on_ctlr_arch_id,
126 unsigned short *fw_on_ctlr_branch,
127 unsigned short *fw_on_ctlr_build,
128 u32 *init_connect_result);
129 static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length);
130 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
131 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
132 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
133 static int twa_reset_device_extension(TW_Device_Extension *tw_dev);
134 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
135 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg);
136 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
137 static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
138 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
142 /* Show some statistics about the card */
143 static ssize_t twa_show_stats(struct device *dev,
144 struct device_attribute *attr, char *buf)
146 struct Scsi_Host *host = class_to_shost(dev);
147 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
148 unsigned long flags = 0;
151 spin_lock_irqsave(tw_dev->host->host_lock, flags);
152 len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
153 "Current commands posted: %4d\n"
154 "Max commands posted: %4d\n"
155 "Current pending commands: %4d\n"
156 "Max pending commands: %4d\n"
157 "Last sgl length: %4d\n"
158 "Max sgl length: %4d\n"
159 "Last sector count: %4d\n"
160 "Max sector count: %4d\n"
161 "SCSI Host Resets: %4d\n"
164 tw_dev->posted_request_count,
165 tw_dev->max_posted_request_count,
166 tw_dev->pending_request_count,
167 tw_dev->max_pending_request_count,
169 tw_dev->max_sgl_entries,
170 tw_dev->sector_count,
171 tw_dev->max_sector_count,
174 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
176 } /* End twa_show_stats() */
178 /* This function will set a devices queue depth */
179 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
181 if (queue_depth > TW_Q_LENGTH-2)
182 queue_depth = TW_Q_LENGTH-2;
183 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
185 } /* End twa_change_queue_depth() */
187 /* Create sysfs 'stats' entry */
188 static struct device_attribute twa_host_stats_attr = {
193 .show = twa_show_stats
196 /* Host attributes initializer */
197 static struct device_attribute *twa_host_attrs[] = {
198 &twa_host_stats_attr,
202 /* File operations struct for character device */
203 static const struct file_operations twa_fops = {
204 .owner = THIS_MODULE,
205 .ioctl = twa_chrdev_ioctl,
206 .open = twa_chrdev_open,
210 /* This function will complete an aen request from the isr */
211 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
213 TW_Command_Full *full_command_packet;
214 TW_Command *command_packet;
215 TW_Command_Apache_Header *header;
219 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
220 tw_dev->posted_request_count--;
221 aen = le16_to_cpu(header->status_block.error);
222 full_command_packet = tw_dev->command_packet_virt[request_id];
223 command_packet = &full_command_packet->command.oldcommand;
225 /* First check for internal completion of set param for time sync */
226 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
227 /* Keep reading the queue in case there are more aen's */
228 if (twa_aen_read_queue(tw_dev, request_id))
237 case TW_AEN_QUEUE_EMPTY:
238 /* Quit reading the queue if this is the last one */
240 case TW_AEN_SYNC_TIME_WITH_HOST:
241 twa_aen_sync_time(tw_dev, request_id);
245 twa_aen_queue_event(tw_dev, header);
247 /* If there are more aen's, keep reading the queue */
248 if (twa_aen_read_queue(tw_dev, request_id))
257 tw_dev->state[request_id] = TW_S_COMPLETED;
258 twa_free_request_id(tw_dev, request_id);
259 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
262 } /* End twa_aen_complete() */
264 /* This function will drain aen queue */
265 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
268 char cdb[TW_MAX_CDB_LEN];
269 TW_SG_Entry sglist[1];
270 int finished = 0, count = 0;
271 TW_Command_Full *full_command_packet;
272 TW_Command_Apache_Header *header;
274 int first_reset = 0, queue = 0, retval = 1;
281 full_command_packet = tw_dev->command_packet_virt[request_id];
282 memset(full_command_packet, 0, sizeof(TW_Command_Full));
285 memset(&cdb, 0, TW_MAX_CDB_LEN);
286 cdb[0] = REQUEST_SENSE; /* opcode */
287 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
289 /* Initialize sglist */
290 memset(&sglist, 0, sizeof(TW_SG_Entry));
291 sglist[0].length = TW_SECTOR_SIZE;
292 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
294 if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
295 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
299 /* Mark internal command */
300 tw_dev->srb[request_id] = NULL;
303 /* Send command to the board */
304 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
305 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
309 /* Now poll for completion */
310 if (twa_poll_response(tw_dev, request_id, 30)) {
311 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
312 tw_dev->posted_request_count--;
316 tw_dev->posted_request_count--;
317 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
318 aen = le16_to_cpu(header->status_block.error);
323 case TW_AEN_QUEUE_EMPTY:
324 if (first_reset != 1)
329 case TW_AEN_SOFT_RESET:
330 if (first_reset == 0)
335 case TW_AEN_SYNC_TIME_WITH_HOST:
341 /* Now queue an event info */
343 twa_aen_queue_event(tw_dev, header);
344 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
346 if (count == TW_MAX_AEN_DRAIN)
351 tw_dev->state[request_id] = TW_S_INITIAL;
353 } /* End twa_aen_drain_queue() */
355 /* This function will queue an event */
356 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
367 /* Fill out event info */
368 event = tw_dev->event_queue[tw_dev->error_index];
370 /* Check for clobber */
373 sprintf(host, " scsi%d:", tw_dev->host->host_no);
374 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
375 tw_dev->aen_clobber = 1;
378 aen = le16_to_cpu(header->status_block.error);
379 memset(event, 0, sizeof(TW_Event));
381 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
382 do_gettimeofday(&time);
383 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
384 event->time_stamp_sec = local_time;
385 event->aen_code = aen;
386 event->retrieved = TW_AEN_NOT_RETRIEVED;
387 event->sequence_id = tw_dev->error_sequence_id;
388 tw_dev->error_sequence_id++;
390 /* Check for embedded error string */
391 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
393 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
394 event->parameter_len = strlen(header->err_specific_desc);
395 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
396 if (event->severity != TW_AEN_SEVERITY_DEBUG)
397 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
399 twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
400 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
401 error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
402 header->err_specific_desc);
406 if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
407 tw_dev->event_queue_wrapped = 1;
408 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
409 } /* End twa_aen_queue_event() */
411 /* This function will read the aen queue from the isr */
412 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
414 char cdb[TW_MAX_CDB_LEN];
415 TW_SG_Entry sglist[1];
416 TW_Command_Full *full_command_packet;
419 full_command_packet = tw_dev->command_packet_virt[request_id];
420 memset(full_command_packet, 0, sizeof(TW_Command_Full));
423 memset(&cdb, 0, TW_MAX_CDB_LEN);
424 cdb[0] = REQUEST_SENSE; /* opcode */
425 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
427 /* Initialize sglist */
428 memset(&sglist, 0, sizeof(TW_SG_Entry));
429 sglist[0].length = TW_SECTOR_SIZE;
430 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
432 /* Mark internal command */
433 tw_dev->srb[request_id] = NULL;
435 /* Now post the command packet */
436 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
437 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
443 } /* End twa_aen_read_queue() */
445 /* This function will look up an AEN severity string */
446 static char *twa_aen_severity_lookup(unsigned char severity_code)
450 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
451 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
454 retval = twa_aen_severity_table[severity_code];
457 } /* End twa_aen_severity_lookup() */
459 /* This function will sync firmware time with the host time */
460 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
464 TW_Command_Full *full_command_packet;
465 TW_Command *command_packet;
466 TW_Param_Apache *param;
469 /* Fill out the command packet */
470 full_command_packet = tw_dev->command_packet_virt[request_id];
471 memset(full_command_packet, 0, sizeof(TW_Command_Full));
472 command_packet = &full_command_packet->command.oldcommand;
473 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
474 command_packet->request_id = request_id;
475 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
476 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
477 command_packet->size = TW_COMMAND_SIZE;
478 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
480 /* Setup the param */
481 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
482 memset(param, 0, TW_SECTOR_SIZE);
483 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
484 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
485 param->parameter_size_bytes = cpu_to_le16(4);
487 /* Convert system time in UTC to local time seconds since last
489 do_gettimeofday(&utc);
490 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
491 schedulertime = local_time - (3 * 86400);
492 schedulertime = cpu_to_le32(schedulertime % 604800);
494 memcpy(param->data, &schedulertime, sizeof(u32));
496 /* Mark internal command */
497 tw_dev->srb[request_id] = NULL;
499 /* Now post the command */
500 twa_post_command_packet(tw_dev, request_id, 1);
501 } /* End twa_aen_sync_time() */
503 /* This function will allocate memory and check if it is correctly aligned */
504 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
507 dma_addr_t dma_handle;
508 unsigned long *cpu_addr;
511 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
513 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
517 if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
518 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
519 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
523 memset(cpu_addr, 0, size*TW_Q_LENGTH);
525 for (i = 0; i < TW_Q_LENGTH; i++) {
528 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
529 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
532 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
533 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
540 } /* End twa_allocate_memory() */
542 /* This function will check the status register for unexpected bits */
543 static int twa_check_bits(u32 status_reg_value)
547 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
549 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
555 } /* End twa_check_bits() */
557 /* This function will check the srl and decide if we are compatible */
558 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
561 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
562 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
563 u32 init_connect_result = 0;
565 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
566 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
567 TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
568 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
569 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
570 &fw_on_ctlr_build, &init_connect_result)) {
571 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
575 tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl;
576 tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch;
577 tw_dev->tw_compat_info.working_build = fw_on_ctlr_build;
579 /* Try base mode compatibility */
580 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
581 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
582 TW_EXTENDED_INIT_CONNECT,
583 TW_BASE_FW_SRL, TW_9000_ARCH_ID,
584 TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
585 &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
586 &fw_on_ctlr_branch, &fw_on_ctlr_build,
587 &init_connect_result)) {
588 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
591 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
592 if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
593 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
595 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
599 tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL;
600 tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH;
601 tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD;
604 /* Load rest of compatibility struct */
605 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
606 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
607 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
608 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
609 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
610 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
611 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
612 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
613 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
614 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
619 } /* End twa_check_srl() */
621 /* This function handles ioctl for the character device */
622 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
625 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
626 dma_addr_t dma_handle;
628 unsigned int sequence_id = 0;
629 unsigned char event_index, start_index;
630 TW_Ioctl_Driver_Command driver_command;
631 TW_Ioctl_Buf_Apache *tw_ioctl;
633 TW_Command_Full *full_command_packet;
634 TW_Compatibility_Info *tw_compat_info;
636 struct timeval current_time;
638 TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
639 int retval = TW_IOCTL_ERROR_OS_EFAULT;
640 void __user *argp = (void __user *)arg;
642 /* Only let one of these through at a time */
643 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
644 retval = TW_IOCTL_ERROR_OS_EINTR;
648 /* First copy down the driver command */
649 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
652 /* Check data buffer size */
653 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
654 retval = TW_IOCTL_ERROR_OS_EINVAL;
658 /* Hardware can only do multiple of 512 byte transfers */
659 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
661 /* Now allocate ioctl buf memory */
662 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);
664 retval = TW_IOCTL_ERROR_OS_ENOMEM;
668 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
670 /* Now copy down the entire ioctl */
671 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
674 /* See which ioctl we are doing */
676 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
677 spin_lock_irqsave(tw_dev->host->host_lock, flags);
678 twa_get_request_id(tw_dev, &request_id);
680 /* Flag internal command */
681 tw_dev->srb[request_id] = NULL;
683 /* Flag chrdev ioctl */
684 tw_dev->chrdev_request_id = request_id;
686 full_command_packet = &tw_ioctl->firmware_command;
688 /* Load request id and sglist for both command types */
689 twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
691 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
693 /* Now post the command packet to the controller */
694 twa_post_command_packet(tw_dev, request_id, 1);
695 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
697 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
699 /* Now wait for command to complete */
700 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
702 /* We timed out, and didn't get an interrupt */
703 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
704 /* Now we need to reset the board */
705 printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
706 tw_dev->host->host_no, TW_DRIVER, 0x37,
708 retval = TW_IOCTL_ERROR_OS_EIO;
709 twa_reset_device_extension(tw_dev);
713 /* Now copy in the command packet response */
714 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
716 /* Now complete the io */
717 spin_lock_irqsave(tw_dev->host->host_lock, flags);
718 tw_dev->posted_request_count--;
719 tw_dev->state[request_id] = TW_S_COMPLETED;
720 twa_free_request_id(tw_dev, request_id);
721 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
723 case TW_IOCTL_GET_COMPATIBILITY_INFO:
724 tw_ioctl->driver_command.status = 0;
725 /* Copy compatiblity struct into ioctl data buffer */
726 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
727 memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
729 case TW_IOCTL_GET_LAST_EVENT:
730 if (tw_dev->event_queue_wrapped) {
731 if (tw_dev->aen_clobber) {
732 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
733 tw_dev->aen_clobber = 0;
735 tw_ioctl->driver_command.status = 0;
737 if (!tw_dev->error_index) {
738 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
741 tw_ioctl->driver_command.status = 0;
743 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
744 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
745 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
747 case TW_IOCTL_GET_FIRST_EVENT:
748 if (tw_dev->event_queue_wrapped) {
749 if (tw_dev->aen_clobber) {
750 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
751 tw_dev->aen_clobber = 0;
753 tw_ioctl->driver_command.status = 0;
754 event_index = tw_dev->error_index;
756 if (!tw_dev->error_index) {
757 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
760 tw_ioctl->driver_command.status = 0;
763 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
764 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
766 case TW_IOCTL_GET_NEXT_EVENT:
767 event = (TW_Event *)tw_ioctl->data_buffer;
768 sequence_id = event->sequence_id;
769 tw_ioctl->driver_command.status = 0;
771 if (tw_dev->event_queue_wrapped) {
772 if (tw_dev->aen_clobber) {
773 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
774 tw_dev->aen_clobber = 0;
776 start_index = tw_dev->error_index;
778 if (!tw_dev->error_index) {
779 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
784 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
786 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
787 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
788 tw_dev->aen_clobber = 1;
789 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
792 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
793 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
795 case TW_IOCTL_GET_PREVIOUS_EVENT:
796 event = (TW_Event *)tw_ioctl->data_buffer;
797 sequence_id = event->sequence_id;
798 tw_ioctl->driver_command.status = 0;
800 if (tw_dev->event_queue_wrapped) {
801 if (tw_dev->aen_clobber) {
802 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
803 tw_dev->aen_clobber = 0;
805 start_index = tw_dev->error_index;
807 if (!tw_dev->error_index) {
808 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
813 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
815 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
816 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
817 tw_dev->aen_clobber = 1;
818 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
821 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
822 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
824 case TW_IOCTL_GET_LOCK:
825 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
826 do_gettimeofday(¤t_time);
827 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
829 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
830 tw_dev->ioctl_sem_lock = 1;
831 tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
832 tw_ioctl->driver_command.status = 0;
833 tw_lock->time_remaining_msec = tw_lock->timeout_msec;
835 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
836 tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
839 case TW_IOCTL_RELEASE_LOCK:
840 if (tw_dev->ioctl_sem_lock == 1) {
841 tw_dev->ioctl_sem_lock = 0;
842 tw_ioctl->driver_command.status = 0;
844 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
848 retval = TW_IOCTL_ERROR_OS_ENOTTY;
852 /* Now copy the entire response to userspace */
853 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
856 /* Now free ioctl buf memory */
857 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
859 mutex_unlock(&tw_dev->ioctl_lock);
862 } /* End twa_chrdev_ioctl() */
864 /* This function handles open for the character device */
865 /* NOTE that this function will race with remove; adding BKL
867 static int twa_chrdev_open(struct inode *inode, struct file *file)
869 unsigned int minor_number;
870 int retval = TW_IOCTL_ERROR_OS_ENODEV;
872 minor_number = iminor(inode);
873 if (minor_number >= twa_device_extension_count)
878 } /* End twa_chrdev_open() */
880 /* This function will print readable messages from status register errors */
881 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
885 /* Check for various error conditions and handle them appropriately */
886 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
887 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
888 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
891 if (status_reg_value & TW_STATUS_PCI_ABORT) {
892 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
893 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
894 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
897 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
898 if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
899 (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
900 (!test_bit(TW_IN_RESET, &tw_dev->flags)))
901 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
902 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
905 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
906 if (tw_dev->reset_print == 0) {
907 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
908 tw_dev->reset_print = 1;
915 } /* End twa_decode_bits() */
917 /* This function will empty the response queue */
918 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
920 u32 status_reg_value, response_que_value;
921 int count = 0, retval = 1;
923 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
925 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
926 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
927 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
930 if (count == TW_MAX_RESPONSE_DRAIN)
936 } /* End twa_empty_response_queue() */
938 /* This function will clear the pchip/response queue on 9550SX */
939 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
941 u32 response_que_value = 0;
942 unsigned long before;
945 if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
947 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
948 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
950 if (time_after(jiffies, before + HZ * 30))
953 /* P-chip settle time */
960 } /* End twa_empty_response_queue_large() */
962 /* This function passes sense keys from firmware to scsi layer */
963 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
965 TW_Command_Full *full_command_packet;
966 unsigned short error;
970 full_command_packet = tw_dev->command_packet_virt[request_id];
972 /* Check for embedded error string */
973 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
975 /* Don't print error for Logical unit not supported during rollcall */
976 error = le16_to_cpu(full_command_packet->header.status_block.error);
977 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
979 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
980 tw_dev->host->host_no,
981 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
982 full_command_packet->header.status_block.error,
983 error_str[0] == '\0' ?
984 twa_string_lookup(twa_error_table,
985 full_command_packet->header.status_block.error) : error_str,
986 full_command_packet->header.err_specific_desc);
988 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
989 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
990 full_command_packet->header.status_block.error,
991 error_str[0] == '\0' ?
992 twa_string_lookup(twa_error_table,
993 full_command_packet->header.status_block.error) : error_str,
994 full_command_packet->header.err_specific_desc);
998 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
999 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
1000 retval = TW_ISR_DONT_RESULT;
1006 } /* End twa_fill_sense() */
1008 /* This function will free up device extension resources */
1009 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1011 if (tw_dev->command_packet_virt[0])
1012 pci_free_consistent(tw_dev->tw_pci_dev,
1013 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1014 tw_dev->command_packet_virt[0],
1015 tw_dev->command_packet_phys[0]);
1017 if (tw_dev->generic_buffer_virt[0])
1018 pci_free_consistent(tw_dev->tw_pci_dev,
1019 TW_SECTOR_SIZE*TW_Q_LENGTH,
1020 tw_dev->generic_buffer_virt[0],
1021 tw_dev->generic_buffer_phys[0]);
1023 kfree(tw_dev->event_queue[0]);
1024 } /* End twa_free_device_extension() */
1026 /* This function will free a request id */
1027 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1029 tw_dev->free_queue[tw_dev->free_tail] = request_id;
1030 tw_dev->state[request_id] = TW_S_FINISHED;
1031 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1032 } /* End twa_free_request_id() */
1034 /* This function will get parameter table entries from the firmware */
1035 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1037 TW_Command_Full *full_command_packet;
1038 TW_Command *command_packet;
1039 TW_Param_Apache *param;
1040 unsigned long param_value;
1041 void *retval = NULL;
1043 /* Setup the command packet */
1044 full_command_packet = tw_dev->command_packet_virt[request_id];
1045 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1046 command_packet = &full_command_packet->command.oldcommand;
1048 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1049 command_packet->size = TW_COMMAND_SIZE;
1050 command_packet->request_id = request_id;
1051 command_packet->byte6_offset.block_count = cpu_to_le16(1);
1053 /* Now setup the param */
1054 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1055 memset(param, 0, TW_SECTOR_SIZE);
1056 param->table_id = cpu_to_le16(table_id | 0x8000);
1057 param->parameter_id = cpu_to_le16(parameter_id);
1058 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1059 param_value = tw_dev->generic_buffer_phys[request_id];
1061 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(param_value);
1062 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1064 /* Post the command packet to the board */
1065 twa_post_command_packet(tw_dev, request_id, 1);
1067 /* Poll for completion */
1068 if (twa_poll_response(tw_dev, request_id, 30))
1069 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1071 retval = (void *)&(param->data[0]);
1073 tw_dev->posted_request_count--;
1074 tw_dev->state[request_id] = TW_S_INITIAL;
1077 } /* End twa_get_param() */
1079 /* This function will assign an available request id */
1080 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1082 *request_id = tw_dev->free_queue[tw_dev->free_head];
1083 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1084 tw_dev->state[*request_id] = TW_S_STARTED;
1085 } /* End twa_get_request_id() */
1087 /* This function will send an initconnection command to controller */
1088 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1089 u32 set_features, unsigned short current_fw_srl,
1090 unsigned short current_fw_arch_id,
1091 unsigned short current_fw_branch,
1092 unsigned short current_fw_build,
1093 unsigned short *fw_on_ctlr_srl,
1094 unsigned short *fw_on_ctlr_arch_id,
1095 unsigned short *fw_on_ctlr_branch,
1096 unsigned short *fw_on_ctlr_build,
1097 u32 *init_connect_result)
1099 TW_Command_Full *full_command_packet;
1100 TW_Initconnect *tw_initconnect;
1101 int request_id = 0, retval = 1;
1103 /* Initialize InitConnection command packet */
1104 full_command_packet = tw_dev->command_packet_virt[request_id];
1105 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1106 full_command_packet->header.header_desc.size_header = 128;
1108 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1109 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1110 tw_initconnect->request_id = request_id;
1111 tw_initconnect->message_credits = cpu_to_le16(message_credits);
1112 tw_initconnect->features = set_features;
1114 /* Turn on 64-bit sgl support if we need to */
1115 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1117 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1119 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1120 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1121 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1122 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1123 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1124 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1126 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1128 /* Send command packet to the board */
1129 twa_post_command_packet(tw_dev, request_id, 1);
1131 /* Poll for completion */
1132 if (twa_poll_response(tw_dev, request_id, 30)) {
1133 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1135 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1136 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1137 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1138 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1139 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1140 *init_connect_result = le32_to_cpu(tw_initconnect->result);
1145 tw_dev->posted_request_count--;
1146 tw_dev->state[request_id] = TW_S_INITIAL;
1149 } /* End twa_initconnection() */
1151 /* This function will initialize the fields of a device extension */
1152 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1156 /* Initialize command packet buffers */
1157 if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1158 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1162 /* Initialize generic buffer */
1163 if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1164 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1168 /* Allocate event info space */
1169 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1170 if (!tw_dev->event_queue[0]) {
1171 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1176 for (i = 0; i < TW_Q_LENGTH; i++) {
1177 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1178 tw_dev->free_queue[i] = i;
1179 tw_dev->state[i] = TW_S_INITIAL;
1182 tw_dev->pending_head = TW_Q_START;
1183 tw_dev->pending_tail = TW_Q_START;
1184 tw_dev->free_head = TW_Q_START;
1185 tw_dev->free_tail = TW_Q_START;
1186 tw_dev->error_sequence_id = 1;
1187 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1189 mutex_init(&tw_dev->ioctl_lock);
1190 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1195 } /* End twa_initialize_device_extension() */
1197 /* This function is the interrupt service routine */
1198 static irqreturn_t twa_interrupt(int irq, void *dev_instance)
1200 int request_id, error = 0;
1201 u32 status_reg_value;
1202 TW_Response_Queue response_que;
1203 TW_Command_Full *full_command_packet;
1204 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1207 /* Get the per adapter lock */
1208 spin_lock(tw_dev->host->host_lock);
1210 /* Read the registers */
1211 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1213 /* Check if this is our interrupt, otherwise bail */
1214 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1215 goto twa_interrupt_bail;
1219 /* If we are resetting, bail */
1220 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1221 goto twa_interrupt_bail;
1223 /* Check controller for errors */
1224 if (twa_check_bits(status_reg_value)) {
1225 if (twa_decode_bits(tw_dev, status_reg_value)) {
1226 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1227 goto twa_interrupt_bail;
1231 /* Handle host interrupt */
1232 if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1233 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1235 /* Handle attention interrupt */
1236 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1237 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1238 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1239 twa_get_request_id(tw_dev, &request_id);
1241 error = twa_aen_read_queue(tw_dev, request_id);
1243 tw_dev->state[request_id] = TW_S_COMPLETED;
1244 twa_free_request_id(tw_dev, request_id);
1245 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1250 /* Handle command interrupt */
1251 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1252 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1253 /* Drain as many pending commands as we can */
1254 while (tw_dev->pending_request_count > 0) {
1255 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1256 if (tw_dev->state[request_id] != TW_S_PENDING) {
1257 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1258 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1259 goto twa_interrupt_bail;
1261 if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1262 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1263 tw_dev->pending_request_count--;
1265 /* If we get here, we will continue re-posting on the next command interrupt */
1271 /* Handle response interrupt */
1272 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1274 /* Drain the response queue from the board */
1275 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1276 /* Complete the response */
1277 response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1278 request_id = TW_RESID_OUT(response_que.response_id);
1279 full_command_packet = tw_dev->command_packet_virt[request_id];
1281 /* Check for command packet errors */
1282 if (full_command_packet->command.newcommand.status != 0) {
1283 if (tw_dev->srb[request_id] != 0) {
1284 error = twa_fill_sense(tw_dev, request_id, 1, 1);
1286 /* Skip ioctl error prints */
1287 if (request_id != tw_dev->chrdev_request_id) {
1288 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1293 /* Check for correct state */
1294 if (tw_dev->state[request_id] != TW_S_POSTED) {
1295 if (tw_dev->srb[request_id] != 0) {
1296 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1297 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1298 goto twa_interrupt_bail;
1302 /* Check for internal command completion */
1303 if (tw_dev->srb[request_id] == 0) {
1304 if (request_id != tw_dev->chrdev_request_id) {
1305 if (twa_aen_complete(tw_dev, request_id))
1306 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1308 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1309 wake_up(&tw_dev->ioctl_wqueue);
1312 struct scsi_cmnd *cmd;
1314 cmd = tw_dev->srb[request_id];
1316 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1317 /* If no error command was a success */
1319 cmd->result = (DID_OK << 16);
1322 /* If error, command failed */
1324 /* Ask for a host reset */
1325 cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1328 /* Report residual bytes for single sgl */
1329 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1330 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1331 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1334 /* Now complete the io */
1335 tw_dev->state[request_id] = TW_S_COMPLETED;
1336 twa_free_request_id(tw_dev, request_id);
1337 tw_dev->posted_request_count--;
1338 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1339 twa_unmap_scsi_data(tw_dev, request_id);
1342 /* Check for valid status after each drain */
1343 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1344 if (twa_check_bits(status_reg_value)) {
1345 if (twa_decode_bits(tw_dev, status_reg_value)) {
1346 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1347 goto twa_interrupt_bail;
1354 spin_unlock(tw_dev->host->host_lock);
1355 return IRQ_RETVAL(handled);
1356 } /* End twa_interrupt() */
1358 /* This function will load the request id and various sgls for ioctls */
1359 static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
1361 TW_Command *oldcommand;
1362 TW_Command_Apache *newcommand;
1364 unsigned int pae = 0;
1366 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1369 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1370 newcommand = &full_command_packet->command.newcommand;
1371 newcommand->request_id__lunl =
1372 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
1373 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1374 newcommand->sg_list[0].length = cpu_to_le32(length);
1375 newcommand->sgl_entries__lunh =
1376 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1));
1378 oldcommand = &full_command_packet->command.oldcommand;
1379 oldcommand->request_id = request_id;
1381 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1382 /* Load the sg list */
1383 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1384 sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1386 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1387 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1388 sgl->length = cpu_to_le32(length);
1390 oldcommand->size += pae;
1393 } /* End twa_load_sgl() */
1395 /* This function will perform a pci-dma mapping for a scatter gather list */
1396 static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1399 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1401 use_sg = scsi_dma_map(cmd);
1404 else if (use_sg < 0) {
1405 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
1409 cmd->SCp.phase = TW_PHASE_SGLIST;
1410 cmd->SCp.have_data_in = use_sg;
1413 } /* End twa_map_scsi_sg_data() */
1415 /* This function will poll for a response interrupt of a request */
1416 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1418 int retval = 1, found = 0, response_request_id;
1419 TW_Response_Queue response_queue;
1420 TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1422 if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1423 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1424 response_request_id = TW_RESID_OUT(response_queue.response_id);
1425 if (request_id != response_request_id) {
1426 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1429 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1430 if (full_command_packet->command.newcommand.status != 0) {
1432 twa_fill_sense(tw_dev, request_id, 0, 0);
1437 if (full_command_packet->command.oldcommand.status != 0) {
1439 twa_fill_sense(tw_dev, request_id, 0, 0);
1450 } /* End twa_poll_response() */
1452 /* This function will poll the status register for a flag */
1453 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1455 u32 status_reg_value;
1456 unsigned long before;
1459 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1462 if (twa_check_bits(status_reg_value))
1463 twa_decode_bits(tw_dev, status_reg_value);
1465 while ((status_reg_value & flag) != flag) {
1466 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1468 if (twa_check_bits(status_reg_value))
1469 twa_decode_bits(tw_dev, status_reg_value);
1471 if (time_after(jiffies, before + HZ * seconds))
1479 } /* End twa_poll_status() */
1481 /* This function will poll the status register for disappearance of a flag */
1482 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1484 u32 status_reg_value;
1485 unsigned long before;
1488 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1491 if (twa_check_bits(status_reg_value))
1492 twa_decode_bits(tw_dev, status_reg_value);
1494 while ((status_reg_value & flag) != 0) {
1495 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1496 if (twa_check_bits(status_reg_value))
1497 twa_decode_bits(tw_dev, status_reg_value);
1499 if (time_after(jiffies, before + HZ * seconds))
1507 } /* End twa_poll_status_gone() */
1509 /* This function will attempt to post a command packet to the board */
1510 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1512 u32 status_reg_value;
1513 dma_addr_t command_que_value;
1516 command_que_value = tw_dev->command_packet_phys[request_id];
1518 /* For 9650SE write low 4 bytes first */
1519 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1520 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1521 command_que_value += TW_COMMAND_OFFSET;
1522 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1525 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1527 if (twa_check_bits(status_reg_value))
1528 twa_decode_bits(tw_dev, status_reg_value);
1530 if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1532 /* Only pend internal driver commands */
1534 retval = SCSI_MLQUEUE_HOST_BUSY;
1538 /* Couldn't post the command packet, so we do it later */
1539 if (tw_dev->state[request_id] != TW_S_PENDING) {
1540 tw_dev->state[request_id] = TW_S_PENDING;
1541 tw_dev->pending_request_count++;
1542 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1543 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1545 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1546 tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1548 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1551 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1552 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1553 /* Now write upper 4 bytes */
1554 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
1556 if (sizeof(dma_addr_t) > 4) {
1557 command_que_value += TW_COMMAND_OFFSET;
1558 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1559 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1561 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1564 tw_dev->state[request_id] = TW_S_POSTED;
1565 tw_dev->posted_request_count++;
1566 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1567 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1573 } /* End twa_post_command_packet() */
1575 /* This function will reset a device extension */
1576 static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
1580 unsigned long flags = 0;
1582 set_bit(TW_IN_RESET, &tw_dev->flags);
1583 TW_DISABLE_INTERRUPTS(tw_dev);
1584 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1585 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1587 /* Abort all requests that are in progress */
1588 for (i = 0; i < TW_Q_LENGTH; i++) {
1589 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1590 (tw_dev->state[i] != TW_S_INITIAL) &&
1591 (tw_dev->state[i] != TW_S_COMPLETED)) {
1592 if (tw_dev->srb[i]) {
1593 tw_dev->srb[i]->result = (DID_RESET << 16);
1594 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1595 twa_unmap_scsi_data(tw_dev, i);
1600 /* Reset queues and counts */
1601 for (i = 0; i < TW_Q_LENGTH; i++) {
1602 tw_dev->free_queue[i] = i;
1603 tw_dev->state[i] = TW_S_INITIAL;
1605 tw_dev->free_head = TW_Q_START;
1606 tw_dev->free_tail = TW_Q_START;
1607 tw_dev->posted_request_count = 0;
1608 tw_dev->pending_request_count = 0;
1609 tw_dev->pending_head = TW_Q_START;
1610 tw_dev->pending_tail = TW_Q_START;
1611 tw_dev->reset_print = 0;
1613 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1615 if (twa_reset_sequence(tw_dev, 1))
1618 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1619 clear_bit(TW_IN_RESET, &tw_dev->flags);
1620 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1625 } /* End twa_reset_device_extension() */
1627 /* This function will reset a controller */
1628 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1630 int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1632 while (tries < TW_MAX_RESET_TRIES) {
1633 if (do_soft_reset) {
1634 TW_SOFT_RESET(tw_dev);
1635 /* Clear pchip/response queue on 9550SX */
1636 if (twa_empty_response_queue_large(tw_dev)) {
1637 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1644 /* Make sure controller is in a good state */
1645 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1646 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1652 /* Empty response queue */
1653 if (twa_empty_response_queue(tw_dev)) {
1654 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1662 /* Check for compatibility/flash */
1663 if (twa_check_srl(tw_dev, &flashed)) {
1664 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1675 /* Drain the AEN queue */
1676 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1677 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1683 /* If we got here, controller is in a good state */
1689 } /* End twa_reset_sequence() */
1691 /* This funciton returns unit geometry in cylinders/heads/sectors */
1692 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1694 int heads, sectors, cylinders;
1695 TW_Device_Extension *tw_dev;
1697 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1699 if (capacity >= 0x200000) {
1702 cylinders = sector_div(capacity, heads * sectors);
1706 cylinders = sector_div(capacity, heads * sectors);
1711 geom[2] = cylinders;
1714 } /* End twa_scsi_biosparam() */
1716 /* This is the new scsi eh reset function */
1717 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1719 TW_Device_Extension *tw_dev = NULL;
1720 int retval = FAILED;
1722 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1724 tw_dev->num_resets++;
1726 sdev_printk(KERN_WARNING, SCpnt->device,
1727 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1728 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1730 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1731 mutex_lock(&tw_dev->ioctl_lock);
1733 /* Now reset the card and some of the device extension data */
1734 if (twa_reset_device_extension(tw_dev)) {
1735 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1741 mutex_unlock(&tw_dev->ioctl_lock);
1743 } /* End twa_scsi_eh_reset() */
1745 /* This is the main scsi queue function to handle scsi opcodes */
1746 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1748 int request_id, retval;
1749 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1751 /* If we are resetting due to timed out ioctl, report as busy */
1752 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1753 retval = SCSI_MLQUEUE_HOST_BUSY;
1757 /* Check if this FW supports luns */
1758 if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1759 SCpnt->result = (DID_BAD_TARGET << 16);
1765 /* Save done function into scsi_cmnd struct */
1766 SCpnt->scsi_done = done;
1768 /* Get a free request id */
1769 twa_get_request_id(tw_dev, &request_id);
1771 /* Save the scsi command for use by the ISR */
1772 tw_dev->srb[request_id] = SCpnt;
1774 /* Initialize phase to zero */
1775 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1777 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1779 case SCSI_MLQUEUE_HOST_BUSY:
1780 twa_free_request_id(tw_dev, request_id);
1783 tw_dev->state[request_id] = TW_S_COMPLETED;
1784 twa_free_request_id(tw_dev, request_id);
1785 SCpnt->result = (DID_ERROR << 16);
1791 } /* End twa_scsi_queue() */
1793 /* This function hands scsi cdb's to the firmware */
1794 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1796 TW_Command_Full *full_command_packet;
1797 TW_Command_Apache *command_packet;
1798 u32 num_sectors = 0x0;
1800 struct scsi_cmnd *srb = NULL;
1801 struct scatterlist *sglist = NULL, *sg;
1804 if (tw_dev->srb[request_id]) {
1805 srb = tw_dev->srb[request_id];
1806 if (scsi_sglist(srb))
1807 sglist = scsi_sglist(srb);
1810 /* Initialize command packet */
1811 full_command_packet = tw_dev->command_packet_virt[request_id];
1812 full_command_packet->header.header_desc.size_header = 128;
1813 full_command_packet->header.status_block.error = 0;
1814 full_command_packet->header.status_block.severity__reserved = 0;
1816 command_packet = &full_command_packet->command.newcommand;
1817 command_packet->status = 0;
1818 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1820 /* We forced 16 byte cdb use earlier */
1822 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1824 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1827 command_packet->unit = srb->device->id;
1828 command_packet->request_id__lunl =
1829 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
1831 command_packet->request_id__lunl =
1832 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
1833 command_packet->unit = 0;
1836 command_packet->sgl_offset = 16;
1839 /* Map sglist from scsi layer to cmd packet */
1841 if (scsi_sg_count(srb)) {
1842 if ((scsi_sg_count(srb) == 1) &&
1843 (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
1844 if (srb->sc_data_direction == DMA_TO_DEVICE ||
1845 srb->sc_data_direction == DMA_BIDIRECTIONAL)
1846 scsi_sg_copy_to_buffer(srb,
1847 tw_dev->generic_buffer_virt[request_id],
1849 command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1850 command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
1852 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1856 scsi_for_each_sg(srb, sg, sg_count, i) {
1857 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1858 command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
1859 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1860 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1865 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
1868 /* Internal cdb post */
1869 for (i = 0; i < use_sg; i++) {
1870 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1871 command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1872 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1873 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1877 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
1881 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1882 num_sectors = (u32)srb->cmnd[4];
1884 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1885 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1888 /* Update sector statistic */
1889 tw_dev->sector_count = num_sectors;
1890 if (tw_dev->sector_count > tw_dev->max_sector_count)
1891 tw_dev->max_sector_count = tw_dev->sector_count;
1893 /* Update SG statistics */
1895 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1896 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1897 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1900 /* Now post the command to the board */
1902 retval = twa_post_command_packet(tw_dev, request_id, 0);
1904 twa_post_command_packet(tw_dev, request_id, 1);
1909 } /* End twa_scsiop_execute_scsi() */
1911 /* This function completes an execute scsi operation */
1912 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1914 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1916 if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1917 (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1918 cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
1919 if (scsi_sg_count(cmd) == 1) {
1920 unsigned long flags;
1921 void *buf = tw_dev->generic_buffer_virt[request_id];
1923 local_irq_save(flags);
1924 scsi_sg_copy_from_buffer(cmd, buf, TW_SECTOR_SIZE);
1925 local_irq_restore(flags);
1928 } /* End twa_scsiop_execute_scsi_complete() */
1930 /* This function tells the controller to shut down */
1931 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1933 /* Disable interrupts */
1934 TW_DISABLE_INTERRUPTS(tw_dev);
1936 /* Free up the IRQ */
1937 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1939 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1941 /* Tell the card we are shutting down */
1942 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1943 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1945 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1948 /* Clear all interrupts just before exit */
1949 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1950 } /* End __twa_shutdown() */
1952 /* Wrapper for __twa_shutdown */
1953 static void twa_shutdown(struct pci_dev *pdev)
1955 struct Scsi_Host *host = pci_get_drvdata(pdev);
1956 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1958 __twa_shutdown(tw_dev);
1959 } /* End twa_shutdown() */
1961 /* This function will look up a string */
1962 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1966 for (index = 0; ((code != table[index].code) &&
1967 (table[index].text != (char *)0)); index++);
1968 return(table[index].text);
1969 } /* End twa_string_lookup() */
1971 /* This function will perform a pci-dma unmap */
1972 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1974 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1976 scsi_dma_unmap(cmd);
1977 } /* End twa_unmap_scsi_data() */
1979 /* scsi_host_template initializer */
1980 static struct scsi_host_template driver_template = {
1981 .module = THIS_MODULE,
1982 .name = "3ware 9000 Storage Controller",
1983 .queuecommand = twa_scsi_queue,
1984 .eh_host_reset_handler = twa_scsi_eh_reset,
1985 .bios_param = twa_scsi_biosparam,
1986 .change_queue_depth = twa_change_queue_depth,
1987 .can_queue = TW_Q_LENGTH-2,
1989 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH,
1990 .max_sectors = TW_MAX_SECTORS,
1991 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
1992 .use_clustering = ENABLE_CLUSTERING,
1993 .shost_attrs = twa_host_attrs,
1997 /* This function will probe and initialize a card */
1998 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2000 struct Scsi_Host *host = NULL;
2001 TW_Device_Extension *tw_dev;
2003 int retval = -ENODEV;
2005 retval = pci_enable_device(pdev);
2007 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2008 goto out_disable_device;
2011 pci_set_master(pdev);
2012 pci_try_set_mwi(pdev);
2014 if (pci_set_dma_mask(pdev, DMA_64BIT_MASK)
2015 || pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
2016 if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)
2017 || pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
2018 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2020 goto out_disable_device;
2023 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2025 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2027 goto out_disable_device;
2029 tw_dev = (TW_Device_Extension *)host->hostdata;
2031 /* Save values to device extension */
2032 tw_dev->host = host;
2033 tw_dev->tw_pci_dev = pdev;
2035 if (twa_initialize_device_extension(tw_dev)) {
2036 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2037 goto out_free_device_extension;
2040 /* Request IO regions */
2041 retval = pci_request_regions(pdev, "3w-9xxx");
2043 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2044 goto out_free_device_extension;
2047 if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2048 mem_addr = pci_resource_start(pdev, 1);
2050 mem_addr = pci_resource_start(pdev, 2);
2052 /* Save base address */
2053 tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2054 if (!tw_dev->base_addr) {
2055 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2056 goto out_release_mem_region;
2059 /* Disable interrupts on the card */
2060 TW_DISABLE_INTERRUPTS(tw_dev);
2062 /* Initialize the card */
2063 if (twa_reset_sequence(tw_dev, 0))
2066 /* Set host specific parameters */
2067 if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
2068 (pdev->device == PCI_DEVICE_ID_3WARE_9690SA))
2069 host->max_id = TW_MAX_UNITS_9650SE;
2071 host->max_id = TW_MAX_UNITS;
2073 host->max_cmd_len = TW_MAX_CDB_LEN;
2075 /* Channels aren't supported by adapter */
2076 host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
2077 host->max_channel = 0;
2079 /* Register the card with the kernel SCSI layer */
2080 retval = scsi_add_host(host, &pdev->dev);
2082 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2086 pci_set_drvdata(pdev, host);
2088 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2089 host->host_no, mem_addr, pdev->irq);
2090 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2092 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2093 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2094 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2095 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2096 le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2097 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
2099 /* Now setup the interrupt handler */
2100 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2102 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2103 goto out_remove_host;
2106 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2107 twa_device_extension_count++;
2109 /* Re-enable interrupts on the card */
2110 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2112 /* Finally, scan the host */
2113 scsi_scan_host(host);
2115 if (twa_major == -1) {
2116 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2117 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2122 scsi_remove_host(host);
2124 iounmap(tw_dev->base_addr);
2125 out_release_mem_region:
2126 pci_release_regions(pdev);
2127 out_free_device_extension:
2128 twa_free_device_extension(tw_dev);
2129 scsi_host_put(host);
2131 pci_disable_device(pdev);
2134 } /* End twa_probe() */
2136 /* This function is called to remove a device */
2137 static void twa_remove(struct pci_dev *pdev)
2139 struct Scsi_Host *host = pci_get_drvdata(pdev);
2140 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2142 scsi_remove_host(tw_dev->host);
2144 /* Unregister character device */
2145 if (twa_major >= 0) {
2146 unregister_chrdev(twa_major, "twa");
2150 /* Shutdown the card */
2151 __twa_shutdown(tw_dev);
2153 /* Free IO remapping */
2154 iounmap(tw_dev->base_addr);
2156 /* Free up the mem region */
2157 pci_release_regions(pdev);
2159 /* Free up device extension resources */
2160 twa_free_device_extension(tw_dev);
2162 scsi_host_put(tw_dev->host);
2163 pci_disable_device(pdev);
2164 twa_device_extension_count--;
2165 } /* End twa_remove() */
2167 /* PCI Devices supported by this driver */
2168 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2169 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2170 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2171 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2172 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2173 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2174 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2175 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA,
2176 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2179 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2181 /* pci_driver initializer */
2182 static struct pci_driver twa_driver = {
2184 .id_table = twa_pci_tbl,
2186 .remove = twa_remove,
2187 .shutdown = twa_shutdown
2190 /* This function is called on driver initialization */
2191 static int __init twa_init(void)
2193 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2195 return pci_register_driver(&twa_driver);
2196 } /* End twa_init() */
2198 /* This function is called on driver exit */
2199 static void __exit twa_exit(void)
2201 pci_unregister_driver(&twa_driver);
2202 } /* End twa_exit() */
2204 module_init(twa_init);
2205 module_exit(twa_exit);