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 class_device *class_dev, char *buf)
145 struct Scsi_Host *host = class_to_shost(class_dev);
146 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
147 unsigned long flags = 0;
150 spin_lock_irqsave(tw_dev->host->host_lock, flags);
151 len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
152 "Current commands posted: %4d\n"
153 "Max commands posted: %4d\n"
154 "Current pending commands: %4d\n"
155 "Max pending commands: %4d\n"
156 "Last sgl length: %4d\n"
157 "Max sgl length: %4d\n"
158 "Last sector count: %4d\n"
159 "Max sector count: %4d\n"
160 "SCSI Host Resets: %4d\n"
163 tw_dev->posted_request_count,
164 tw_dev->max_posted_request_count,
165 tw_dev->pending_request_count,
166 tw_dev->max_pending_request_count,
168 tw_dev->max_sgl_entries,
169 tw_dev->sector_count,
170 tw_dev->max_sector_count,
173 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
175 } /* End twa_show_stats() */
177 /* This function will set a devices queue depth */
178 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
180 if (queue_depth > TW_Q_LENGTH-2)
181 queue_depth = TW_Q_LENGTH-2;
182 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
184 } /* End twa_change_queue_depth() */
186 /* Create sysfs 'stats' entry */
187 static struct class_device_attribute twa_host_stats_attr = {
192 .show = twa_show_stats
195 /* Host attributes initializer */
196 static struct class_device_attribute *twa_host_attrs[] = {
197 &twa_host_stats_attr,
201 /* File operations struct for character device */
202 static const struct file_operations twa_fops = {
203 .owner = THIS_MODULE,
204 .ioctl = twa_chrdev_ioctl,
205 .open = twa_chrdev_open,
209 /* This function will complete an aen request from the isr */
210 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
212 TW_Command_Full *full_command_packet;
213 TW_Command *command_packet;
214 TW_Command_Apache_Header *header;
218 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
219 tw_dev->posted_request_count--;
220 aen = le16_to_cpu(header->status_block.error);
221 full_command_packet = tw_dev->command_packet_virt[request_id];
222 command_packet = &full_command_packet->command.oldcommand;
224 /* First check for internal completion of set param for time sync */
225 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
226 /* Keep reading the queue in case there are more aen's */
227 if (twa_aen_read_queue(tw_dev, request_id))
236 case TW_AEN_QUEUE_EMPTY:
237 /* Quit reading the queue if this is the last one */
239 case TW_AEN_SYNC_TIME_WITH_HOST:
240 twa_aen_sync_time(tw_dev, request_id);
244 twa_aen_queue_event(tw_dev, header);
246 /* If there are more aen's, keep reading the queue */
247 if (twa_aen_read_queue(tw_dev, request_id))
256 tw_dev->state[request_id] = TW_S_COMPLETED;
257 twa_free_request_id(tw_dev, request_id);
258 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
261 } /* End twa_aen_complete() */
263 /* This function will drain aen queue */
264 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
267 char cdb[TW_MAX_CDB_LEN];
268 TW_SG_Entry sglist[1];
269 int finished = 0, count = 0;
270 TW_Command_Full *full_command_packet;
271 TW_Command_Apache_Header *header;
273 int first_reset = 0, queue = 0, retval = 1;
280 full_command_packet = tw_dev->command_packet_virt[request_id];
281 memset(full_command_packet, 0, sizeof(TW_Command_Full));
284 memset(&cdb, 0, TW_MAX_CDB_LEN);
285 cdb[0] = REQUEST_SENSE; /* opcode */
286 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
288 /* Initialize sglist */
289 memset(&sglist, 0, sizeof(TW_SG_Entry));
290 sglist[0].length = TW_SECTOR_SIZE;
291 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
293 if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
294 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
298 /* Mark internal command */
299 tw_dev->srb[request_id] = NULL;
302 /* Send command to the board */
303 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
304 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
308 /* Now poll for completion */
309 if (twa_poll_response(tw_dev, request_id, 30)) {
310 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
311 tw_dev->posted_request_count--;
315 tw_dev->posted_request_count--;
316 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
317 aen = le16_to_cpu(header->status_block.error);
322 case TW_AEN_QUEUE_EMPTY:
323 if (first_reset != 1)
328 case TW_AEN_SOFT_RESET:
329 if (first_reset == 0)
334 case TW_AEN_SYNC_TIME_WITH_HOST:
340 /* Now queue an event info */
342 twa_aen_queue_event(tw_dev, header);
343 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
345 if (count == TW_MAX_AEN_DRAIN)
350 tw_dev->state[request_id] = TW_S_INITIAL;
352 } /* End twa_aen_drain_queue() */
354 /* This function will queue an event */
355 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
366 /* Fill out event info */
367 event = tw_dev->event_queue[tw_dev->error_index];
369 /* Check for clobber */
372 sprintf(host, " scsi%d:", tw_dev->host->host_no);
373 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
374 tw_dev->aen_clobber = 1;
377 aen = le16_to_cpu(header->status_block.error);
378 memset(event, 0, sizeof(TW_Event));
380 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
381 do_gettimeofday(&time);
382 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
383 event->time_stamp_sec = local_time;
384 event->aen_code = aen;
385 event->retrieved = TW_AEN_NOT_RETRIEVED;
386 event->sequence_id = tw_dev->error_sequence_id;
387 tw_dev->error_sequence_id++;
389 /* Check for embedded error string */
390 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
392 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
393 event->parameter_len = strlen(header->err_specific_desc);
394 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
395 if (event->severity != TW_AEN_SEVERITY_DEBUG)
396 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
398 twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
399 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
400 error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
401 header->err_specific_desc);
405 if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
406 tw_dev->event_queue_wrapped = 1;
407 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
408 } /* End twa_aen_queue_event() */
410 /* This function will read the aen queue from the isr */
411 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
413 char cdb[TW_MAX_CDB_LEN];
414 TW_SG_Entry sglist[1];
415 TW_Command_Full *full_command_packet;
418 full_command_packet = tw_dev->command_packet_virt[request_id];
419 memset(full_command_packet, 0, sizeof(TW_Command_Full));
422 memset(&cdb, 0, TW_MAX_CDB_LEN);
423 cdb[0] = REQUEST_SENSE; /* opcode */
424 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
426 /* Initialize sglist */
427 memset(&sglist, 0, sizeof(TW_SG_Entry));
428 sglist[0].length = TW_SECTOR_SIZE;
429 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
431 /* Mark internal command */
432 tw_dev->srb[request_id] = NULL;
434 /* Now post the command packet */
435 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
436 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
442 } /* End twa_aen_read_queue() */
444 /* This function will look up an AEN severity string */
445 static char *twa_aen_severity_lookup(unsigned char severity_code)
449 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
450 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
453 retval = twa_aen_severity_table[severity_code];
456 } /* End twa_aen_severity_lookup() */
458 /* This function will sync firmware time with the host time */
459 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
463 TW_Command_Full *full_command_packet;
464 TW_Command *command_packet;
465 TW_Param_Apache *param;
468 /* Fill out the command packet */
469 full_command_packet = tw_dev->command_packet_virt[request_id];
470 memset(full_command_packet, 0, sizeof(TW_Command_Full));
471 command_packet = &full_command_packet->command.oldcommand;
472 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
473 command_packet->request_id = request_id;
474 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
475 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
476 command_packet->size = TW_COMMAND_SIZE;
477 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
479 /* Setup the param */
480 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
481 memset(param, 0, TW_SECTOR_SIZE);
482 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
483 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
484 param->parameter_size_bytes = cpu_to_le16(4);
486 /* Convert system time in UTC to local time seconds since last
488 do_gettimeofday(&utc);
489 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
490 schedulertime = local_time - (3 * 86400);
491 schedulertime = cpu_to_le32(schedulertime % 604800);
493 memcpy(param->data, &schedulertime, sizeof(u32));
495 /* Mark internal command */
496 tw_dev->srb[request_id] = NULL;
498 /* Now post the command */
499 twa_post_command_packet(tw_dev, request_id, 1);
500 } /* End twa_aen_sync_time() */
502 /* This function will allocate memory and check if it is correctly aligned */
503 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
506 dma_addr_t dma_handle;
507 unsigned long *cpu_addr;
510 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
512 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
516 if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
517 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
518 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
522 memset(cpu_addr, 0, size*TW_Q_LENGTH);
524 for (i = 0; i < TW_Q_LENGTH; i++) {
527 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
528 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
531 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
532 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
539 } /* End twa_allocate_memory() */
541 /* This function will check the status register for unexpected bits */
542 static int twa_check_bits(u32 status_reg_value)
546 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
548 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
554 } /* End twa_check_bits() */
556 /* This function will check the srl and decide if we are compatible */
557 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
560 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
561 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
562 u32 init_connect_result = 0;
564 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
565 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
566 TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
567 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
568 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
569 &fw_on_ctlr_build, &init_connect_result)) {
570 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
574 tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl;
575 tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch;
576 tw_dev->tw_compat_info.working_build = fw_on_ctlr_build;
578 /* Try base mode compatibility */
579 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
580 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
581 TW_EXTENDED_INIT_CONNECT,
582 TW_BASE_FW_SRL, TW_9000_ARCH_ID,
583 TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
584 &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
585 &fw_on_ctlr_branch, &fw_on_ctlr_build,
586 &init_connect_result)) {
587 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
590 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
591 if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
592 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
594 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
598 tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL;
599 tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH;
600 tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD;
603 /* Load rest of compatibility struct */
604 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
605 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
606 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
607 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
608 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
609 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
610 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
611 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
612 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
613 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
618 } /* End twa_check_srl() */
620 /* This function handles ioctl for the character device */
621 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
624 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
625 dma_addr_t dma_handle;
627 unsigned int sequence_id = 0;
628 unsigned char event_index, start_index;
629 TW_Ioctl_Driver_Command driver_command;
630 TW_Ioctl_Buf_Apache *tw_ioctl;
632 TW_Command_Full *full_command_packet;
633 TW_Compatibility_Info *tw_compat_info;
635 struct timeval current_time;
637 TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
638 int retval = TW_IOCTL_ERROR_OS_EFAULT;
639 void __user *argp = (void __user *)arg;
641 /* Only let one of these through at a time */
642 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
643 retval = TW_IOCTL_ERROR_OS_EINTR;
647 /* First copy down the driver command */
648 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
651 /* Check data buffer size */
652 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
653 retval = TW_IOCTL_ERROR_OS_EINVAL;
657 /* Hardware can only do multiple of 512 byte transfers */
658 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
660 /* Now allocate ioctl buf memory */
661 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);
663 retval = TW_IOCTL_ERROR_OS_ENOMEM;
667 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
669 /* Now copy down the entire ioctl */
670 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
673 /* See which ioctl we are doing */
675 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
676 spin_lock_irqsave(tw_dev->host->host_lock, flags);
677 twa_get_request_id(tw_dev, &request_id);
679 /* Flag internal command */
680 tw_dev->srb[request_id] = NULL;
682 /* Flag chrdev ioctl */
683 tw_dev->chrdev_request_id = request_id;
685 full_command_packet = &tw_ioctl->firmware_command;
687 /* Load request id and sglist for both command types */
688 twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
690 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
692 /* Now post the command packet to the controller */
693 twa_post_command_packet(tw_dev, request_id, 1);
694 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
696 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
698 /* Now wait for command to complete */
699 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
701 /* We timed out, and didn't get an interrupt */
702 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
703 /* Now we need to reset the board */
704 printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
705 tw_dev->host->host_no, TW_DRIVER, 0x37,
707 retval = TW_IOCTL_ERROR_OS_EIO;
708 twa_reset_device_extension(tw_dev);
712 /* Now copy in the command packet response */
713 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
715 /* Now complete the io */
716 spin_lock_irqsave(tw_dev->host->host_lock, flags);
717 tw_dev->posted_request_count--;
718 tw_dev->state[request_id] = TW_S_COMPLETED;
719 twa_free_request_id(tw_dev, request_id);
720 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
722 case TW_IOCTL_GET_COMPATIBILITY_INFO:
723 tw_ioctl->driver_command.status = 0;
724 /* Copy compatiblity struct into ioctl data buffer */
725 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
726 memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
728 case TW_IOCTL_GET_LAST_EVENT:
729 if (tw_dev->event_queue_wrapped) {
730 if (tw_dev->aen_clobber) {
731 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
732 tw_dev->aen_clobber = 0;
734 tw_ioctl->driver_command.status = 0;
736 if (!tw_dev->error_index) {
737 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
740 tw_ioctl->driver_command.status = 0;
742 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
743 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
744 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
746 case TW_IOCTL_GET_FIRST_EVENT:
747 if (tw_dev->event_queue_wrapped) {
748 if (tw_dev->aen_clobber) {
749 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
750 tw_dev->aen_clobber = 0;
752 tw_ioctl->driver_command.status = 0;
753 event_index = tw_dev->error_index;
755 if (!tw_dev->error_index) {
756 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
759 tw_ioctl->driver_command.status = 0;
762 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
763 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
765 case TW_IOCTL_GET_NEXT_EVENT:
766 event = (TW_Event *)tw_ioctl->data_buffer;
767 sequence_id = event->sequence_id;
768 tw_ioctl->driver_command.status = 0;
770 if (tw_dev->event_queue_wrapped) {
771 if (tw_dev->aen_clobber) {
772 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
773 tw_dev->aen_clobber = 0;
775 start_index = tw_dev->error_index;
777 if (!tw_dev->error_index) {
778 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
783 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
785 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
786 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
787 tw_dev->aen_clobber = 1;
788 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
791 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
792 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
794 case TW_IOCTL_GET_PREVIOUS_EVENT:
795 event = (TW_Event *)tw_ioctl->data_buffer;
796 sequence_id = event->sequence_id;
797 tw_ioctl->driver_command.status = 0;
799 if (tw_dev->event_queue_wrapped) {
800 if (tw_dev->aen_clobber) {
801 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
802 tw_dev->aen_clobber = 0;
804 start_index = tw_dev->error_index;
806 if (!tw_dev->error_index) {
807 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
812 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
814 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
815 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
816 tw_dev->aen_clobber = 1;
817 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
820 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
821 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
823 case TW_IOCTL_GET_LOCK:
824 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
825 do_gettimeofday(¤t_time);
826 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
828 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
829 tw_dev->ioctl_sem_lock = 1;
830 tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
831 tw_ioctl->driver_command.status = 0;
832 tw_lock->time_remaining_msec = tw_lock->timeout_msec;
834 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
835 tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
838 case TW_IOCTL_RELEASE_LOCK:
839 if (tw_dev->ioctl_sem_lock == 1) {
840 tw_dev->ioctl_sem_lock = 0;
841 tw_ioctl->driver_command.status = 0;
843 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
847 retval = TW_IOCTL_ERROR_OS_ENOTTY;
851 /* Now copy the entire response to userspace */
852 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
855 /* Now free ioctl buf memory */
856 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
858 mutex_unlock(&tw_dev->ioctl_lock);
861 } /* End twa_chrdev_ioctl() */
863 /* This function handles open for the character device */
864 static int twa_chrdev_open(struct inode *inode, struct file *file)
866 unsigned int minor_number;
867 int retval = TW_IOCTL_ERROR_OS_ENODEV;
869 minor_number = iminor(inode);
870 if (minor_number >= twa_device_extension_count)
875 } /* End twa_chrdev_open() */
877 /* This function will print readable messages from status register errors */
878 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
882 /* Check for various error conditions and handle them appropriately */
883 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
884 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
885 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
888 if (status_reg_value & TW_STATUS_PCI_ABORT) {
889 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
890 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
891 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
894 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
895 if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
896 (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
897 (!test_bit(TW_IN_RESET, &tw_dev->flags)))
898 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
899 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
902 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
903 if (tw_dev->reset_print == 0) {
904 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
905 tw_dev->reset_print = 1;
912 } /* End twa_decode_bits() */
914 /* This function will empty the response queue */
915 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
917 u32 status_reg_value, response_que_value;
918 int count = 0, retval = 1;
920 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
922 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
923 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
924 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
927 if (count == TW_MAX_RESPONSE_DRAIN)
933 } /* End twa_empty_response_queue() */
935 /* This function will clear the pchip/response queue on 9550SX */
936 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
938 u32 response_que_value = 0;
939 unsigned long before;
942 if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
944 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
945 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
947 if (time_after(jiffies, before + HZ * 30))
950 /* P-chip settle time */
957 } /* End twa_empty_response_queue_large() */
959 /* This function passes sense keys from firmware to scsi layer */
960 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
962 TW_Command_Full *full_command_packet;
963 unsigned short error;
967 full_command_packet = tw_dev->command_packet_virt[request_id];
969 /* Check for embedded error string */
970 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
972 /* Don't print error for Logical unit not supported during rollcall */
973 error = le16_to_cpu(full_command_packet->header.status_block.error);
974 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
976 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
977 tw_dev->host->host_no,
978 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
979 full_command_packet->header.status_block.error,
980 error_str[0] == '\0' ?
981 twa_string_lookup(twa_error_table,
982 full_command_packet->header.status_block.error) : error_str,
983 full_command_packet->header.err_specific_desc);
985 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
986 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
987 full_command_packet->header.status_block.error,
988 error_str[0] == '\0' ?
989 twa_string_lookup(twa_error_table,
990 full_command_packet->header.status_block.error) : error_str,
991 full_command_packet->header.err_specific_desc);
995 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
996 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
997 retval = TW_ISR_DONT_RESULT;
1003 } /* End twa_fill_sense() */
1005 /* This function will free up device extension resources */
1006 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1008 if (tw_dev->command_packet_virt[0])
1009 pci_free_consistent(tw_dev->tw_pci_dev,
1010 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1011 tw_dev->command_packet_virt[0],
1012 tw_dev->command_packet_phys[0]);
1014 if (tw_dev->generic_buffer_virt[0])
1015 pci_free_consistent(tw_dev->tw_pci_dev,
1016 TW_SECTOR_SIZE*TW_Q_LENGTH,
1017 tw_dev->generic_buffer_virt[0],
1018 tw_dev->generic_buffer_phys[0]);
1020 kfree(tw_dev->event_queue[0]);
1021 } /* End twa_free_device_extension() */
1023 /* This function will free a request id */
1024 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1026 tw_dev->free_queue[tw_dev->free_tail] = request_id;
1027 tw_dev->state[request_id] = TW_S_FINISHED;
1028 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1029 } /* End twa_free_request_id() */
1031 /* This function will get parameter table entries from the firmware */
1032 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1034 TW_Command_Full *full_command_packet;
1035 TW_Command *command_packet;
1036 TW_Param_Apache *param;
1037 unsigned long param_value;
1038 void *retval = NULL;
1040 /* Setup the command packet */
1041 full_command_packet = tw_dev->command_packet_virt[request_id];
1042 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1043 command_packet = &full_command_packet->command.oldcommand;
1045 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1046 command_packet->size = TW_COMMAND_SIZE;
1047 command_packet->request_id = request_id;
1048 command_packet->byte6_offset.block_count = cpu_to_le16(1);
1050 /* Now setup the param */
1051 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1052 memset(param, 0, TW_SECTOR_SIZE);
1053 param->table_id = cpu_to_le16(table_id | 0x8000);
1054 param->parameter_id = cpu_to_le16(parameter_id);
1055 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1056 param_value = tw_dev->generic_buffer_phys[request_id];
1058 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(param_value);
1059 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1061 /* Post the command packet to the board */
1062 twa_post_command_packet(tw_dev, request_id, 1);
1064 /* Poll for completion */
1065 if (twa_poll_response(tw_dev, request_id, 30))
1066 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1068 retval = (void *)&(param->data[0]);
1070 tw_dev->posted_request_count--;
1071 tw_dev->state[request_id] = TW_S_INITIAL;
1074 } /* End twa_get_param() */
1076 /* This function will assign an available request id */
1077 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1079 *request_id = tw_dev->free_queue[tw_dev->free_head];
1080 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1081 tw_dev->state[*request_id] = TW_S_STARTED;
1082 } /* End twa_get_request_id() */
1084 /* This function will send an initconnection command to controller */
1085 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1086 u32 set_features, unsigned short current_fw_srl,
1087 unsigned short current_fw_arch_id,
1088 unsigned short current_fw_branch,
1089 unsigned short current_fw_build,
1090 unsigned short *fw_on_ctlr_srl,
1091 unsigned short *fw_on_ctlr_arch_id,
1092 unsigned short *fw_on_ctlr_branch,
1093 unsigned short *fw_on_ctlr_build,
1094 u32 *init_connect_result)
1096 TW_Command_Full *full_command_packet;
1097 TW_Initconnect *tw_initconnect;
1098 int request_id = 0, retval = 1;
1100 /* Initialize InitConnection command packet */
1101 full_command_packet = tw_dev->command_packet_virt[request_id];
1102 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1103 full_command_packet->header.header_desc.size_header = 128;
1105 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1106 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1107 tw_initconnect->request_id = request_id;
1108 tw_initconnect->message_credits = cpu_to_le16(message_credits);
1109 tw_initconnect->features = set_features;
1111 /* Turn on 64-bit sgl support if we need to */
1112 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1114 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1116 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1117 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1118 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1119 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1120 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1121 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1123 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1125 /* Send command packet to the board */
1126 twa_post_command_packet(tw_dev, request_id, 1);
1128 /* Poll for completion */
1129 if (twa_poll_response(tw_dev, request_id, 30)) {
1130 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1132 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1133 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1134 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1135 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1136 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1137 *init_connect_result = le32_to_cpu(tw_initconnect->result);
1142 tw_dev->posted_request_count--;
1143 tw_dev->state[request_id] = TW_S_INITIAL;
1146 } /* End twa_initconnection() */
1148 /* This function will initialize the fields of a device extension */
1149 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1153 /* Initialize command packet buffers */
1154 if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1155 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1159 /* Initialize generic buffer */
1160 if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1161 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1165 /* Allocate event info space */
1166 tw_dev->event_queue[0] = kmalloc(sizeof(TW_Event) * TW_Q_LENGTH, GFP_KERNEL);
1167 if (!tw_dev->event_queue[0]) {
1168 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1172 memset(tw_dev->event_queue[0], 0, sizeof(TW_Event) * TW_Q_LENGTH);
1174 for (i = 0; i < TW_Q_LENGTH; i++) {
1175 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1176 tw_dev->free_queue[i] = i;
1177 tw_dev->state[i] = TW_S_INITIAL;
1180 tw_dev->pending_head = TW_Q_START;
1181 tw_dev->pending_tail = TW_Q_START;
1182 tw_dev->free_head = TW_Q_START;
1183 tw_dev->free_tail = TW_Q_START;
1184 tw_dev->error_sequence_id = 1;
1185 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1187 mutex_init(&tw_dev->ioctl_lock);
1188 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1193 } /* End twa_initialize_device_extension() */
1195 /* This function is the interrupt service routine */
1196 static irqreturn_t twa_interrupt(int irq, void *dev_instance)
1198 int request_id, error = 0;
1199 u32 status_reg_value;
1200 TW_Response_Queue response_que;
1201 TW_Command_Full *full_command_packet;
1202 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1205 /* Get the per adapter lock */
1206 spin_lock(tw_dev->host->host_lock);
1208 /* Read the registers */
1209 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1211 /* Check if this is our interrupt, otherwise bail */
1212 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1213 goto twa_interrupt_bail;
1217 /* If we are resetting, bail */
1218 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1219 goto twa_interrupt_bail;
1221 /* Check controller for errors */
1222 if (twa_check_bits(status_reg_value)) {
1223 if (twa_decode_bits(tw_dev, status_reg_value)) {
1224 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1225 goto twa_interrupt_bail;
1229 /* Handle host interrupt */
1230 if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1231 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1233 /* Handle attention interrupt */
1234 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1235 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1236 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1237 twa_get_request_id(tw_dev, &request_id);
1239 error = twa_aen_read_queue(tw_dev, request_id);
1241 tw_dev->state[request_id] = TW_S_COMPLETED;
1242 twa_free_request_id(tw_dev, request_id);
1243 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1248 /* Handle command interrupt */
1249 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1250 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1251 /* Drain as many pending commands as we can */
1252 while (tw_dev->pending_request_count > 0) {
1253 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1254 if (tw_dev->state[request_id] != TW_S_PENDING) {
1255 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1256 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1257 goto twa_interrupt_bail;
1259 if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1260 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1261 tw_dev->pending_request_count--;
1263 /* If we get here, we will continue re-posting on the next command interrupt */
1269 /* Handle response interrupt */
1270 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1272 /* Drain the response queue from the board */
1273 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1274 /* Complete the response */
1275 response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1276 request_id = TW_RESID_OUT(response_que.response_id);
1277 full_command_packet = tw_dev->command_packet_virt[request_id];
1279 /* Check for command packet errors */
1280 if (full_command_packet->command.newcommand.status != 0) {
1281 if (tw_dev->srb[request_id] != 0) {
1282 error = twa_fill_sense(tw_dev, request_id, 1, 1);
1284 /* Skip ioctl error prints */
1285 if (request_id != tw_dev->chrdev_request_id) {
1286 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1291 /* Check for correct state */
1292 if (tw_dev->state[request_id] != TW_S_POSTED) {
1293 if (tw_dev->srb[request_id] != 0) {
1294 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1295 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1296 goto twa_interrupt_bail;
1300 /* Check for internal command completion */
1301 if (tw_dev->srb[request_id] == 0) {
1302 if (request_id != tw_dev->chrdev_request_id) {
1303 if (twa_aen_complete(tw_dev, request_id))
1304 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1306 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1307 wake_up(&tw_dev->ioctl_wqueue);
1310 struct scsi_cmnd *cmd;
1312 cmd = tw_dev->srb[request_id];
1314 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1315 /* If no error command was a success */
1317 cmd->result = (DID_OK << 16);
1320 /* If error, command failed */
1322 /* Ask for a host reset */
1323 cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1326 /* Report residual bytes for single sgl */
1327 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1328 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1329 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1332 /* Now complete the io */
1333 tw_dev->state[request_id] = TW_S_COMPLETED;
1334 twa_free_request_id(tw_dev, request_id);
1335 tw_dev->posted_request_count--;
1336 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1337 twa_unmap_scsi_data(tw_dev, request_id);
1340 /* Check for valid status after each drain */
1341 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1342 if (twa_check_bits(status_reg_value)) {
1343 if (twa_decode_bits(tw_dev, status_reg_value)) {
1344 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1345 goto twa_interrupt_bail;
1352 spin_unlock(tw_dev->host->host_lock);
1353 return IRQ_RETVAL(handled);
1354 } /* End twa_interrupt() */
1356 /* This function will load the request id and various sgls for ioctls */
1357 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)
1359 TW_Command *oldcommand;
1360 TW_Command_Apache *newcommand;
1362 unsigned int pae = 0;
1364 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1367 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1368 newcommand = &full_command_packet->command.newcommand;
1369 newcommand->request_id__lunl =
1370 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
1371 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1372 newcommand->sg_list[0].length = cpu_to_le32(length);
1373 newcommand->sgl_entries__lunh =
1374 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1));
1376 oldcommand = &full_command_packet->command.oldcommand;
1377 oldcommand->request_id = request_id;
1379 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1380 /* Load the sg list */
1381 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1382 sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1384 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1385 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1386 sgl->length = cpu_to_le32(length);
1388 oldcommand->size += pae;
1391 } /* End twa_load_sgl() */
1393 /* This function will perform a pci-dma mapping for a scatter gather list */
1394 static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1397 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1399 use_sg = scsi_dma_map(cmd);
1402 else if (use_sg < 0) {
1403 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
1407 cmd->SCp.phase = TW_PHASE_SGLIST;
1408 cmd->SCp.have_data_in = use_sg;
1411 } /* End twa_map_scsi_sg_data() */
1413 /* This function will poll for a response interrupt of a request */
1414 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1416 int retval = 1, found = 0, response_request_id;
1417 TW_Response_Queue response_queue;
1418 TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1420 if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1421 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1422 response_request_id = TW_RESID_OUT(response_queue.response_id);
1423 if (request_id != response_request_id) {
1424 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1427 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1428 if (full_command_packet->command.newcommand.status != 0) {
1430 twa_fill_sense(tw_dev, request_id, 0, 0);
1435 if (full_command_packet->command.oldcommand.status != 0) {
1437 twa_fill_sense(tw_dev, request_id, 0, 0);
1448 } /* End twa_poll_response() */
1450 /* This function will poll the status register for a flag */
1451 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1453 u32 status_reg_value;
1454 unsigned long before;
1457 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1460 if (twa_check_bits(status_reg_value))
1461 twa_decode_bits(tw_dev, status_reg_value);
1463 while ((status_reg_value & flag) != flag) {
1464 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1466 if (twa_check_bits(status_reg_value))
1467 twa_decode_bits(tw_dev, status_reg_value);
1469 if (time_after(jiffies, before + HZ * seconds))
1477 } /* End twa_poll_status() */
1479 /* This function will poll the status register for disappearance of a flag */
1480 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1482 u32 status_reg_value;
1483 unsigned long before;
1486 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1489 if (twa_check_bits(status_reg_value))
1490 twa_decode_bits(tw_dev, status_reg_value);
1492 while ((status_reg_value & flag) != 0) {
1493 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1494 if (twa_check_bits(status_reg_value))
1495 twa_decode_bits(tw_dev, status_reg_value);
1497 if (time_after(jiffies, before + HZ * seconds))
1505 } /* End twa_poll_status_gone() */
1507 /* This function will attempt to post a command packet to the board */
1508 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1510 u32 status_reg_value;
1511 dma_addr_t command_que_value;
1514 command_que_value = tw_dev->command_packet_phys[request_id];
1516 /* For 9650SE write low 4 bytes first */
1517 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1518 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1519 command_que_value += TW_COMMAND_OFFSET;
1520 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1523 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1525 if (twa_check_bits(status_reg_value))
1526 twa_decode_bits(tw_dev, status_reg_value);
1528 if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1530 /* Only pend internal driver commands */
1532 retval = SCSI_MLQUEUE_HOST_BUSY;
1536 /* Couldn't post the command packet, so we do it later */
1537 if (tw_dev->state[request_id] != TW_S_PENDING) {
1538 tw_dev->state[request_id] = TW_S_PENDING;
1539 tw_dev->pending_request_count++;
1540 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1541 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1543 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1544 tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1546 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1549 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1550 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1551 /* Now write upper 4 bytes */
1552 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
1554 if (sizeof(dma_addr_t) > 4) {
1555 command_que_value += TW_COMMAND_OFFSET;
1556 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1557 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1559 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1562 tw_dev->state[request_id] = TW_S_POSTED;
1563 tw_dev->posted_request_count++;
1564 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1565 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1571 } /* End twa_post_command_packet() */
1573 /* This function will reset a device extension */
1574 static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
1578 unsigned long flags = 0;
1580 set_bit(TW_IN_RESET, &tw_dev->flags);
1581 TW_DISABLE_INTERRUPTS(tw_dev);
1582 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1583 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1585 /* Abort all requests that are in progress */
1586 for (i = 0; i < TW_Q_LENGTH; i++) {
1587 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1588 (tw_dev->state[i] != TW_S_INITIAL) &&
1589 (tw_dev->state[i] != TW_S_COMPLETED)) {
1590 if (tw_dev->srb[i]) {
1591 tw_dev->srb[i]->result = (DID_RESET << 16);
1592 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1593 twa_unmap_scsi_data(tw_dev, i);
1598 /* Reset queues and counts */
1599 for (i = 0; i < TW_Q_LENGTH; i++) {
1600 tw_dev->free_queue[i] = i;
1601 tw_dev->state[i] = TW_S_INITIAL;
1603 tw_dev->free_head = TW_Q_START;
1604 tw_dev->free_tail = TW_Q_START;
1605 tw_dev->posted_request_count = 0;
1606 tw_dev->pending_request_count = 0;
1607 tw_dev->pending_head = TW_Q_START;
1608 tw_dev->pending_tail = TW_Q_START;
1609 tw_dev->reset_print = 0;
1611 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1613 if (twa_reset_sequence(tw_dev, 1))
1616 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1617 clear_bit(TW_IN_RESET, &tw_dev->flags);
1618 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1623 } /* End twa_reset_device_extension() */
1625 /* This function will reset a controller */
1626 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1628 int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1630 while (tries < TW_MAX_RESET_TRIES) {
1631 if (do_soft_reset) {
1632 TW_SOFT_RESET(tw_dev);
1633 /* Clear pchip/response queue on 9550SX */
1634 if (twa_empty_response_queue_large(tw_dev)) {
1635 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1642 /* Make sure controller is in a good state */
1643 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1644 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1650 /* Empty response queue */
1651 if (twa_empty_response_queue(tw_dev)) {
1652 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1660 /* Check for compatibility/flash */
1661 if (twa_check_srl(tw_dev, &flashed)) {
1662 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1673 /* Drain the AEN queue */
1674 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1675 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1681 /* If we got here, controller is in a good state */
1687 } /* End twa_reset_sequence() */
1689 /* This funciton returns unit geometry in cylinders/heads/sectors */
1690 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1692 int heads, sectors, cylinders;
1693 TW_Device_Extension *tw_dev;
1695 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1697 if (capacity >= 0x200000) {
1700 cylinders = sector_div(capacity, heads * sectors);
1704 cylinders = sector_div(capacity, heads * sectors);
1709 geom[2] = cylinders;
1712 } /* End twa_scsi_biosparam() */
1714 /* This is the new scsi eh reset function */
1715 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1717 TW_Device_Extension *tw_dev = NULL;
1718 int retval = FAILED;
1720 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1722 tw_dev->num_resets++;
1724 sdev_printk(KERN_WARNING, SCpnt->device,
1725 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1726 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1728 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1729 mutex_lock(&tw_dev->ioctl_lock);
1731 /* Now reset the card and some of the device extension data */
1732 if (twa_reset_device_extension(tw_dev)) {
1733 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1739 mutex_unlock(&tw_dev->ioctl_lock);
1741 } /* End twa_scsi_eh_reset() */
1743 /* This is the main scsi queue function to handle scsi opcodes */
1744 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1746 int request_id, retval;
1747 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1749 /* If we are resetting due to timed out ioctl, report as busy */
1750 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1751 retval = SCSI_MLQUEUE_HOST_BUSY;
1755 /* Check if this FW supports luns */
1756 if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1757 SCpnt->result = (DID_BAD_TARGET << 16);
1763 /* Save done function into scsi_cmnd struct */
1764 SCpnt->scsi_done = done;
1766 /* Get a free request id */
1767 twa_get_request_id(tw_dev, &request_id);
1769 /* Save the scsi command for use by the ISR */
1770 tw_dev->srb[request_id] = SCpnt;
1772 /* Initialize phase to zero */
1773 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1775 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1777 case SCSI_MLQUEUE_HOST_BUSY:
1778 twa_free_request_id(tw_dev, request_id);
1781 tw_dev->state[request_id] = TW_S_COMPLETED;
1782 twa_free_request_id(tw_dev, request_id);
1783 SCpnt->result = (DID_ERROR << 16);
1789 } /* End twa_scsi_queue() */
1791 /* This function hands scsi cdb's to the firmware */
1792 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1794 TW_Command_Full *full_command_packet;
1795 TW_Command_Apache *command_packet;
1796 u32 num_sectors = 0x0;
1798 struct scsi_cmnd *srb = NULL;
1799 struct scatterlist *sglist = NULL, *sg;
1802 if (tw_dev->srb[request_id]) {
1803 srb = tw_dev->srb[request_id];
1804 if (scsi_sglist(srb))
1805 sglist = scsi_sglist(srb);
1808 /* Initialize command packet */
1809 full_command_packet = tw_dev->command_packet_virt[request_id];
1810 full_command_packet->header.header_desc.size_header = 128;
1811 full_command_packet->header.status_block.error = 0;
1812 full_command_packet->header.status_block.severity__reserved = 0;
1814 command_packet = &full_command_packet->command.newcommand;
1815 command_packet->status = 0;
1816 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1818 /* We forced 16 byte cdb use earlier */
1820 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1822 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1825 command_packet->unit = srb->device->id;
1826 command_packet->request_id__lunl =
1827 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
1829 command_packet->request_id__lunl =
1830 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
1831 command_packet->unit = 0;
1834 command_packet->sgl_offset = 16;
1837 /* Map sglist from scsi layer to cmd packet */
1839 if (scsi_sg_count(srb)) {
1840 if ((scsi_sg_count(srb) == 1) &&
1841 (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
1842 if (srb->sc_data_direction == DMA_TO_DEVICE || srb->sc_data_direction == DMA_BIDIRECTIONAL) {
1843 struct scatterlist *sg = scsi_sglist(srb);
1844 char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1845 memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length);
1846 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1848 command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1849 command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
1851 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1855 scsi_for_each_sg(srb, sg, sg_count, i) {
1856 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1857 command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
1858 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1859 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1864 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
1867 /* Internal cdb post */
1868 for (i = 0; i < use_sg; i++) {
1869 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1870 command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1871 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1872 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1876 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
1880 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1881 num_sectors = (u32)srb->cmnd[4];
1883 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1884 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1887 /* Update sector statistic */
1888 tw_dev->sector_count = num_sectors;
1889 if (tw_dev->sector_count > tw_dev->max_sector_count)
1890 tw_dev->max_sector_count = tw_dev->sector_count;
1892 /* Update SG statistics */
1894 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1895 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1896 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1899 /* Now post the command to the board */
1901 retval = twa_post_command_packet(tw_dev, request_id, 0);
1903 twa_post_command_packet(tw_dev, request_id, 1);
1908 } /* End twa_scsiop_execute_scsi() */
1910 /* This function completes an execute scsi operation */
1911 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1913 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1915 if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1916 (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1917 cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
1918 if (scsi_sg_count(cmd) == 1) {
1919 struct scatterlist *sg = scsi_sglist(tw_dev->srb[request_id]);
1921 unsigned long flags = 0;
1922 local_irq_save(flags);
1923 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1924 memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length);
1925 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1926 local_irq_restore(flags);
1929 } /* End twa_scsiop_execute_scsi_complete() */
1931 /* This function tells the controller to shut down */
1932 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1934 /* Disable interrupts */
1935 TW_DISABLE_INTERRUPTS(tw_dev);
1937 /* Free up the IRQ */
1938 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1940 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1942 /* Tell the card we are shutting down */
1943 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1944 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1946 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1949 /* Clear all interrupts just before exit */
1950 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1951 } /* End __twa_shutdown() */
1953 /* Wrapper for __twa_shutdown */
1954 static void twa_shutdown(struct pci_dev *pdev)
1956 struct Scsi_Host *host = pci_get_drvdata(pdev);
1957 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1959 __twa_shutdown(tw_dev);
1960 } /* End twa_shutdown() */
1962 /* This function will look up a string */
1963 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1967 for (index = 0; ((code != table[index].code) &&
1968 (table[index].text != (char *)0)); index++);
1969 return(table[index].text);
1970 } /* End twa_string_lookup() */
1972 /* This function will perform a pci-dma unmap */
1973 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1975 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1977 scsi_dma_unmap(cmd);
1978 } /* End twa_unmap_scsi_data() */
1980 /* scsi_host_template initializer */
1981 static struct scsi_host_template driver_template = {
1982 .module = THIS_MODULE,
1983 .name = "3ware 9000 Storage Controller",
1984 .queuecommand = twa_scsi_queue,
1985 .eh_host_reset_handler = twa_scsi_eh_reset,
1986 .bios_param = twa_scsi_biosparam,
1987 .change_queue_depth = twa_change_queue_depth,
1988 .can_queue = TW_Q_LENGTH-2,
1990 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH,
1991 .max_sectors = TW_MAX_SECTORS,
1992 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
1993 .use_clustering = ENABLE_CLUSTERING,
1994 .shost_attrs = twa_host_attrs,
1998 /* This function will probe and initialize a card */
1999 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2001 struct Scsi_Host *host = NULL;
2002 TW_Device_Extension *tw_dev;
2004 int retval = -ENODEV;
2006 retval = pci_enable_device(pdev);
2008 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2009 goto out_disable_device;
2012 pci_set_master(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 memset(tw_dev, 0, sizeof(TW_Device_Extension));
2033 /* Save values to device extension */
2034 tw_dev->host = host;
2035 tw_dev->tw_pci_dev = pdev;
2037 if (twa_initialize_device_extension(tw_dev)) {
2038 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2039 goto out_free_device_extension;
2042 /* Request IO regions */
2043 retval = pci_request_regions(pdev, "3w-9xxx");
2045 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2046 goto out_free_device_extension;
2049 if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2050 mem_addr = pci_resource_start(pdev, 1);
2052 mem_addr = pci_resource_start(pdev, 2);
2054 /* Save base address */
2055 tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2056 if (!tw_dev->base_addr) {
2057 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2058 goto out_release_mem_region;
2061 /* Disable interrupts on the card */
2062 TW_DISABLE_INTERRUPTS(tw_dev);
2064 /* Initialize the card */
2065 if (twa_reset_sequence(tw_dev, 0))
2068 /* Set host specific parameters */
2069 if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
2070 (pdev->device == PCI_DEVICE_ID_3WARE_9690SA))
2071 host->max_id = TW_MAX_UNITS_9650SE;
2073 host->max_id = TW_MAX_UNITS;
2075 host->max_cmd_len = TW_MAX_CDB_LEN;
2077 /* Channels aren't supported by adapter */
2078 host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
2079 host->max_channel = 0;
2081 /* Register the card with the kernel SCSI layer */
2082 retval = scsi_add_host(host, &pdev->dev);
2084 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2088 pci_set_drvdata(pdev, host);
2090 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2091 host->host_no, mem_addr, pdev->irq);
2092 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2094 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2095 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2096 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2097 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2098 le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2099 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
2101 /* Now setup the interrupt handler */
2102 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2104 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2105 goto out_remove_host;
2108 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2109 twa_device_extension_count++;
2111 /* Re-enable interrupts on the card */
2112 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2114 /* Finally, scan the host */
2115 scsi_scan_host(host);
2117 if (twa_major == -1) {
2118 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2119 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2124 scsi_remove_host(host);
2126 iounmap(tw_dev->base_addr);
2127 out_release_mem_region:
2128 pci_release_regions(pdev);
2129 out_free_device_extension:
2130 twa_free_device_extension(tw_dev);
2131 scsi_host_put(host);
2133 pci_disable_device(pdev);
2136 } /* End twa_probe() */
2138 /* This function is called to remove a device */
2139 static void twa_remove(struct pci_dev *pdev)
2141 struct Scsi_Host *host = pci_get_drvdata(pdev);
2142 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2144 scsi_remove_host(tw_dev->host);
2146 /* Unregister character device */
2147 if (twa_major >= 0) {
2148 unregister_chrdev(twa_major, "twa");
2152 /* Shutdown the card */
2153 __twa_shutdown(tw_dev);
2155 /* Free IO remapping */
2156 iounmap(tw_dev->base_addr);
2158 /* Free up the mem region */
2159 pci_release_regions(pdev);
2161 /* Free up device extension resources */
2162 twa_free_device_extension(tw_dev);
2164 scsi_host_put(tw_dev->host);
2165 pci_disable_device(pdev);
2166 twa_device_extension_count--;
2167 } /* End twa_remove() */
2169 /* PCI Devices supported by this driver */
2170 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2171 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2172 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2173 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2174 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2175 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2176 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2177 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA,
2178 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2181 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2183 /* pci_driver initializer */
2184 static struct pci_driver twa_driver = {
2186 .id_table = twa_pci_tbl,
2188 .remove = twa_remove,
2189 .shutdown = twa_shutdown
2192 /* This function is called on driver initialization */
2193 static int __init twa_init(void)
2195 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2197 return pci_register_driver(&twa_driver);
2198 } /* End twa_init() */
2200 /* This function is called on driver exit */
2201 static void __exit twa_exit(void)
2203 pci_unregister_driver(&twa_driver);
2204 } /* End twa_exit() */
2206 module_init(twa_init);
2207 module_exit(twa_exit);