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] = kcalloc(TW_Q_LENGTH
, sizeof(TW_Event
), GFP_KERNEL
);
1167 if (!tw_dev
->event_queue
[0]) {
1168 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x18, "Event info memory allocation failed");
1173 for (i
= 0; i
< TW_Q_LENGTH
; i
++) {
1174 tw_dev
->event_queue
[i
] = (TW_Event
*)((unsigned char *)tw_dev
->event_queue
[0] + (i
* sizeof(TW_Event
)));
1175 tw_dev
->free_queue
[i
] = i
;
1176 tw_dev
->state
[i
] = TW_S_INITIAL
;
1179 tw_dev
->pending_head
= TW_Q_START
;
1180 tw_dev
->pending_tail
= TW_Q_START
;
1181 tw_dev
->free_head
= TW_Q_START
;
1182 tw_dev
->free_tail
= TW_Q_START
;
1183 tw_dev
->error_sequence_id
= 1;
1184 tw_dev
->chrdev_request_id
= TW_IOCTL_CHRDEV_FREE
;
1186 mutex_init(&tw_dev
->ioctl_lock
);
1187 init_waitqueue_head(&tw_dev
->ioctl_wqueue
);
1192 } /* End twa_initialize_device_extension() */
1194 /* This function is the interrupt service routine */
1195 static irqreturn_t
twa_interrupt(int irq
, void *dev_instance
)
1197 int request_id
, error
= 0;
1198 u32 status_reg_value
;
1199 TW_Response_Queue response_que
;
1200 TW_Command_Full
*full_command_packet
;
1201 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)dev_instance
;
1204 /* Get the per adapter lock */
1205 spin_lock(tw_dev
->host
->host_lock
);
1207 /* Read the registers */
1208 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1210 /* Check if this is our interrupt, otherwise bail */
1211 if (!(status_reg_value
& TW_STATUS_VALID_INTERRUPT
))
1212 goto twa_interrupt_bail
;
1216 /* If we are resetting, bail */
1217 if (test_bit(TW_IN_RESET
, &tw_dev
->flags
))
1218 goto twa_interrupt_bail
;
1220 /* Check controller for errors */
1221 if (twa_check_bits(status_reg_value
)) {
1222 if (twa_decode_bits(tw_dev
, status_reg_value
)) {
1223 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1224 goto twa_interrupt_bail
;
1228 /* Handle host interrupt */
1229 if (status_reg_value
& TW_STATUS_HOST_INTERRUPT
)
1230 TW_CLEAR_HOST_INTERRUPT(tw_dev
);
1232 /* Handle attention interrupt */
1233 if (status_reg_value
& TW_STATUS_ATTENTION_INTERRUPT
) {
1234 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev
);
1235 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP
, &tw_dev
->flags
))) {
1236 twa_get_request_id(tw_dev
, &request_id
);
1238 error
= twa_aen_read_queue(tw_dev
, request_id
);
1240 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
1241 twa_free_request_id(tw_dev
, request_id
);
1242 clear_bit(TW_IN_ATTENTION_LOOP
, &tw_dev
->flags
);
1247 /* Handle command interrupt */
1248 if (status_reg_value
& TW_STATUS_COMMAND_INTERRUPT
) {
1249 TW_MASK_COMMAND_INTERRUPT(tw_dev
);
1250 /* Drain as many pending commands as we can */
1251 while (tw_dev
->pending_request_count
> 0) {
1252 request_id
= tw_dev
->pending_queue
[tw_dev
->pending_head
];
1253 if (tw_dev
->state
[request_id
] != TW_S_PENDING
) {
1254 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x19, "Found request id that wasn't pending");
1255 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1256 goto twa_interrupt_bail
;
1258 if (twa_post_command_packet(tw_dev
, request_id
, 1)==0) {
1259 tw_dev
->pending_head
= (tw_dev
->pending_head
+ 1) % TW_Q_LENGTH
;
1260 tw_dev
->pending_request_count
--;
1262 /* If we get here, we will continue re-posting on the next command interrupt */
1268 /* Handle response interrupt */
1269 if (status_reg_value
& TW_STATUS_RESPONSE_INTERRUPT
) {
1271 /* Drain the response queue from the board */
1272 while ((status_reg_value
& TW_STATUS_RESPONSE_QUEUE_EMPTY
) == 0) {
1273 /* Complete the response */
1274 response_que
.value
= readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev
));
1275 request_id
= TW_RESID_OUT(response_que
.response_id
);
1276 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1278 /* Check for command packet errors */
1279 if (full_command_packet
->command
.newcommand
.status
!= 0) {
1280 if (tw_dev
->srb
[request_id
] != 0) {
1281 error
= twa_fill_sense(tw_dev
, request_id
, 1, 1);
1283 /* Skip ioctl error prints */
1284 if (request_id
!= tw_dev
->chrdev_request_id
) {
1285 error
= twa_fill_sense(tw_dev
, request_id
, 0, 1);
1290 /* Check for correct state */
1291 if (tw_dev
->state
[request_id
] != TW_S_POSTED
) {
1292 if (tw_dev
->srb
[request_id
] != 0) {
1293 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1a, "Received a request id that wasn't posted");
1294 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1295 goto twa_interrupt_bail
;
1299 /* Check for internal command completion */
1300 if (tw_dev
->srb
[request_id
] == 0) {
1301 if (request_id
!= tw_dev
->chrdev_request_id
) {
1302 if (twa_aen_complete(tw_dev
, request_id
))
1303 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1b, "Error completing AEN during attention interrupt");
1305 tw_dev
->chrdev_request_id
= TW_IOCTL_CHRDEV_FREE
;
1306 wake_up(&tw_dev
->ioctl_wqueue
);
1309 struct scsi_cmnd
*cmd
;
1311 cmd
= tw_dev
->srb
[request_id
];
1313 twa_scsiop_execute_scsi_complete(tw_dev
, request_id
);
1314 /* If no error command was a success */
1316 cmd
->result
= (DID_OK
<< 16);
1319 /* If error, command failed */
1321 /* Ask for a host reset */
1322 cmd
->result
= (DID_OK
<< 16) | (CHECK_CONDITION
<< 1);
1325 /* Report residual bytes for single sgl */
1326 if ((scsi_sg_count(cmd
) <= 1) && (full_command_packet
->command
.newcommand
.status
== 0)) {
1327 if (full_command_packet
->command
.newcommand
.sg_list
[0].length
< scsi_bufflen(tw_dev
->srb
[request_id
]))
1328 scsi_set_resid(cmd
, scsi_bufflen(cmd
) - full_command_packet
->command
.newcommand
.sg_list
[0].length
);
1331 /* Now complete the io */
1332 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
1333 twa_free_request_id(tw_dev
, request_id
);
1334 tw_dev
->posted_request_count
--;
1335 tw_dev
->srb
[request_id
]->scsi_done(tw_dev
->srb
[request_id
]);
1336 twa_unmap_scsi_data(tw_dev
, request_id
);
1339 /* Check for valid status after each drain */
1340 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1341 if (twa_check_bits(status_reg_value
)) {
1342 if (twa_decode_bits(tw_dev
, status_reg_value
)) {
1343 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1344 goto twa_interrupt_bail
;
1351 spin_unlock(tw_dev
->host
->host_lock
);
1352 return IRQ_RETVAL(handled
);
1353 } /* End twa_interrupt() */
1355 /* This function will load the request id and various sgls for ioctls */
1356 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
)
1358 TW_Command
*oldcommand
;
1359 TW_Command_Apache
*newcommand
;
1361 unsigned int pae
= 0;
1363 if ((sizeof(long) < 8) && (sizeof(dma_addr_t
) > 4))
1366 if (TW_OP_OUT(full_command_packet
->command
.newcommand
.opcode__reserved
) == TW_OP_EXECUTE_SCSI
) {
1367 newcommand
= &full_command_packet
->command
.newcommand
;
1368 newcommand
->request_id__lunl
=
1369 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand
->request_id__lunl
), request_id
));
1370 newcommand
->sg_list
[0].address
= TW_CPU_TO_SGL(dma_handle
+ sizeof(TW_Ioctl_Buf_Apache
) - 1);
1371 newcommand
->sg_list
[0].length
= cpu_to_le32(length
);
1372 newcommand
->sgl_entries__lunh
=
1373 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand
->sgl_entries__lunh
), 1));
1375 oldcommand
= &full_command_packet
->command
.oldcommand
;
1376 oldcommand
->request_id
= request_id
;
1378 if (TW_SGL_OUT(oldcommand
->opcode__sgloffset
)) {
1379 /* Load the sg list */
1380 if (tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9690SA
)
1381 sgl
= (TW_SG_Entry
*)((u32
*)oldcommand
+oldcommand
->size
- (sizeof(TW_SG_Entry
)/4) + pae
);
1383 sgl
= (TW_SG_Entry
*)((u32
*)oldcommand
+TW_SGL_OUT(oldcommand
->opcode__sgloffset
));
1384 sgl
->address
= TW_CPU_TO_SGL(dma_handle
+ sizeof(TW_Ioctl_Buf_Apache
) - 1);
1385 sgl
->length
= cpu_to_le32(length
);
1387 oldcommand
->size
+= pae
;
1390 } /* End twa_load_sgl() */
1392 /* This function will perform a pci-dma mapping for a scatter gather list */
1393 static int twa_map_scsi_sg_data(TW_Device_Extension
*tw_dev
, int request_id
)
1396 struct scsi_cmnd
*cmd
= tw_dev
->srb
[request_id
];
1398 use_sg
= scsi_dma_map(cmd
);
1401 else if (use_sg
< 0) {
1402 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1c, "Failed to map scatter gather list");
1406 cmd
->SCp
.phase
= TW_PHASE_SGLIST
;
1407 cmd
->SCp
.have_data_in
= use_sg
;
1410 } /* End twa_map_scsi_sg_data() */
1412 /* This function will poll for a response interrupt of a request */
1413 static int twa_poll_response(TW_Device_Extension
*tw_dev
, int request_id
, int seconds
)
1415 int retval
= 1, found
= 0, response_request_id
;
1416 TW_Response_Queue response_queue
;
1417 TW_Command_Full
*full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1419 if (twa_poll_status_gone(tw_dev
, TW_STATUS_RESPONSE_QUEUE_EMPTY
, seconds
) == 0) {
1420 response_queue
.value
= readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev
));
1421 response_request_id
= TW_RESID_OUT(response_queue
.response_id
);
1422 if (request_id
!= response_request_id
) {
1423 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1e, "Found unexpected request id while polling for response");
1426 if (TW_OP_OUT(full_command_packet
->command
.newcommand
.opcode__reserved
) == TW_OP_EXECUTE_SCSI
) {
1427 if (full_command_packet
->command
.newcommand
.status
!= 0) {
1429 twa_fill_sense(tw_dev
, request_id
, 0, 0);
1434 if (full_command_packet
->command
.oldcommand
.status
!= 0) {
1436 twa_fill_sense(tw_dev
, request_id
, 0, 0);
1447 } /* End twa_poll_response() */
1449 /* This function will poll the status register for a flag */
1450 static int twa_poll_status(TW_Device_Extension
*tw_dev
, u32 flag
, int seconds
)
1452 u32 status_reg_value
;
1453 unsigned long before
;
1456 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1459 if (twa_check_bits(status_reg_value
))
1460 twa_decode_bits(tw_dev
, status_reg_value
);
1462 while ((status_reg_value
& flag
) != flag
) {
1463 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1465 if (twa_check_bits(status_reg_value
))
1466 twa_decode_bits(tw_dev
, status_reg_value
);
1468 if (time_after(jiffies
, before
+ HZ
* seconds
))
1476 } /* End twa_poll_status() */
1478 /* This function will poll the status register for disappearance of a flag */
1479 static int twa_poll_status_gone(TW_Device_Extension
*tw_dev
, u32 flag
, int seconds
)
1481 u32 status_reg_value
;
1482 unsigned long before
;
1485 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1488 if (twa_check_bits(status_reg_value
))
1489 twa_decode_bits(tw_dev
, status_reg_value
);
1491 while ((status_reg_value
& flag
) != 0) {
1492 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1493 if (twa_check_bits(status_reg_value
))
1494 twa_decode_bits(tw_dev
, status_reg_value
);
1496 if (time_after(jiffies
, before
+ HZ
* seconds
))
1504 } /* End twa_poll_status_gone() */
1506 /* This function will attempt to post a command packet to the board */
1507 static int twa_post_command_packet(TW_Device_Extension
*tw_dev
, int request_id
, char internal
)
1509 u32 status_reg_value
;
1510 dma_addr_t command_que_value
;
1513 command_que_value
= tw_dev
->command_packet_phys
[request_id
];
1515 /* For 9650SE write low 4 bytes first */
1516 if ((tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9650SE
) ||
1517 (tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9690SA
)) {
1518 command_que_value
+= TW_COMMAND_OFFSET
;
1519 writel((u32
)command_que_value
, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev
));
1522 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1524 if (twa_check_bits(status_reg_value
))
1525 twa_decode_bits(tw_dev
, status_reg_value
);
1527 if (((tw_dev
->pending_request_count
> 0) && (tw_dev
->state
[request_id
] != TW_S_PENDING
)) || (status_reg_value
& TW_STATUS_COMMAND_QUEUE_FULL
)) {
1529 /* Only pend internal driver commands */
1531 retval
= SCSI_MLQUEUE_HOST_BUSY
;
1535 /* Couldn't post the command packet, so we do it later */
1536 if (tw_dev
->state
[request_id
] != TW_S_PENDING
) {
1537 tw_dev
->state
[request_id
] = TW_S_PENDING
;
1538 tw_dev
->pending_request_count
++;
1539 if (tw_dev
->pending_request_count
> tw_dev
->max_pending_request_count
) {
1540 tw_dev
->max_pending_request_count
= tw_dev
->pending_request_count
;
1542 tw_dev
->pending_queue
[tw_dev
->pending_tail
] = request_id
;
1543 tw_dev
->pending_tail
= (tw_dev
->pending_tail
+ 1) % TW_Q_LENGTH
;
1545 TW_UNMASK_COMMAND_INTERRUPT(tw_dev
);
1548 if ((tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9650SE
) ||
1549 (tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9690SA
)) {
1550 /* Now write upper 4 bytes */
1551 writel((u32
)((u64
)command_que_value
>> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev
) + 0x4);
1553 if (sizeof(dma_addr_t
) > 4) {
1554 command_que_value
+= TW_COMMAND_OFFSET
;
1555 writel((u32
)command_que_value
, TW_COMMAND_QUEUE_REG_ADDR(tw_dev
));
1556 writel((u32
)((u64
)command_que_value
>> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev
) + 0x4);
1558 writel(TW_COMMAND_OFFSET
+ command_que_value
, TW_COMMAND_QUEUE_REG_ADDR(tw_dev
));
1561 tw_dev
->state
[request_id
] = TW_S_POSTED
;
1562 tw_dev
->posted_request_count
++;
1563 if (tw_dev
->posted_request_count
> tw_dev
->max_posted_request_count
) {
1564 tw_dev
->max_posted_request_count
= tw_dev
->posted_request_count
;
1570 } /* End twa_post_command_packet() */
1572 /* This function will reset a device extension */
1573 static int twa_reset_device_extension(TW_Device_Extension
*tw_dev
)
1577 unsigned long flags
= 0;
1579 set_bit(TW_IN_RESET
, &tw_dev
->flags
);
1580 TW_DISABLE_INTERRUPTS(tw_dev
);
1581 TW_MASK_COMMAND_INTERRUPT(tw_dev
);
1582 spin_lock_irqsave(tw_dev
->host
->host_lock
, flags
);
1584 /* Abort all requests that are in progress */
1585 for (i
= 0; i
< TW_Q_LENGTH
; i
++) {
1586 if ((tw_dev
->state
[i
] != TW_S_FINISHED
) &&
1587 (tw_dev
->state
[i
] != TW_S_INITIAL
) &&
1588 (tw_dev
->state
[i
] != TW_S_COMPLETED
)) {
1589 if (tw_dev
->srb
[i
]) {
1590 tw_dev
->srb
[i
]->result
= (DID_RESET
<< 16);
1591 tw_dev
->srb
[i
]->scsi_done(tw_dev
->srb
[i
]);
1592 twa_unmap_scsi_data(tw_dev
, i
);
1597 /* Reset queues and counts */
1598 for (i
= 0; i
< TW_Q_LENGTH
; i
++) {
1599 tw_dev
->free_queue
[i
] = i
;
1600 tw_dev
->state
[i
] = TW_S_INITIAL
;
1602 tw_dev
->free_head
= TW_Q_START
;
1603 tw_dev
->free_tail
= TW_Q_START
;
1604 tw_dev
->posted_request_count
= 0;
1605 tw_dev
->pending_request_count
= 0;
1606 tw_dev
->pending_head
= TW_Q_START
;
1607 tw_dev
->pending_tail
= TW_Q_START
;
1608 tw_dev
->reset_print
= 0;
1610 spin_unlock_irqrestore(tw_dev
->host
->host_lock
, flags
);
1612 if (twa_reset_sequence(tw_dev
, 1))
1615 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev
);
1616 clear_bit(TW_IN_RESET
, &tw_dev
->flags
);
1617 tw_dev
->chrdev_request_id
= TW_IOCTL_CHRDEV_FREE
;
1622 } /* End twa_reset_device_extension() */
1624 /* This function will reset a controller */
1625 static int twa_reset_sequence(TW_Device_Extension
*tw_dev
, int soft_reset
)
1627 int tries
= 0, retval
= 1, flashed
= 0, do_soft_reset
= soft_reset
;
1629 while (tries
< TW_MAX_RESET_TRIES
) {
1630 if (do_soft_reset
) {
1631 TW_SOFT_RESET(tw_dev
);
1632 /* Clear pchip/response queue on 9550SX */
1633 if (twa_empty_response_queue_large(tw_dev
)) {
1634 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x36, "Response queue (large) empty failed during reset sequence");
1641 /* Make sure controller is in a good state */
1642 if (twa_poll_status(tw_dev
, TW_STATUS_MICROCONTROLLER_READY
| (do_soft_reset
== 1 ? TW_STATUS_ATTENTION_INTERRUPT
: 0), 60)) {
1643 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1f, "Microcontroller not ready during reset sequence");
1649 /* Empty response queue */
1650 if (twa_empty_response_queue(tw_dev
)) {
1651 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x20, "Response queue empty failed during reset sequence");
1659 /* Check for compatibility/flash */
1660 if (twa_check_srl(tw_dev
, &flashed
)) {
1661 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x21, "Compatibility check failed during reset sequence");
1672 /* Drain the AEN queue */
1673 if (twa_aen_drain_queue(tw_dev
, soft_reset
)) {
1674 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x22, "AEN drain failed during reset sequence");
1680 /* If we got here, controller is in a good state */
1686 } /* End twa_reset_sequence() */
1688 /* This funciton returns unit geometry in cylinders/heads/sectors */
1689 static int twa_scsi_biosparam(struct scsi_device
*sdev
, struct block_device
*bdev
, sector_t capacity
, int geom
[])
1691 int heads
, sectors
, cylinders
;
1692 TW_Device_Extension
*tw_dev
;
1694 tw_dev
= (TW_Device_Extension
*)sdev
->host
->hostdata
;
1696 if (capacity
>= 0x200000) {
1699 cylinders
= sector_div(capacity
, heads
* sectors
);
1703 cylinders
= sector_div(capacity
, heads
* sectors
);
1708 geom
[2] = cylinders
;
1711 } /* End twa_scsi_biosparam() */
1713 /* This is the new scsi eh reset function */
1714 static int twa_scsi_eh_reset(struct scsi_cmnd
*SCpnt
)
1716 TW_Device_Extension
*tw_dev
= NULL
;
1717 int retval
= FAILED
;
1719 tw_dev
= (TW_Device_Extension
*)SCpnt
->device
->host
->hostdata
;
1721 tw_dev
->num_resets
++;
1723 sdev_printk(KERN_WARNING
, SCpnt
->device
,
1724 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1725 TW_DRIVER
, 0x2c, SCpnt
->cmnd
[0]);
1727 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1728 mutex_lock(&tw_dev
->ioctl_lock
);
1730 /* Now reset the card and some of the device extension data */
1731 if (twa_reset_device_extension(tw_dev
)) {
1732 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x2b, "Controller reset failed during scsi host reset");
1738 mutex_unlock(&tw_dev
->ioctl_lock
);
1740 } /* End twa_scsi_eh_reset() */
1742 /* This is the main scsi queue function to handle scsi opcodes */
1743 static int twa_scsi_queue(struct scsi_cmnd
*SCpnt
, void (*done
)(struct scsi_cmnd
*))
1745 int request_id
, retval
;
1746 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)SCpnt
->device
->host
->hostdata
;
1748 /* If we are resetting due to timed out ioctl, report as busy */
1749 if (test_bit(TW_IN_RESET
, &tw_dev
->flags
)) {
1750 retval
= SCSI_MLQUEUE_HOST_BUSY
;
1754 /* Check if this FW supports luns */
1755 if ((SCpnt
->device
->lun
!= 0) && (tw_dev
->tw_compat_info
.working_srl
< TW_FW_SRL_LUNS_SUPPORTED
)) {
1756 SCpnt
->result
= (DID_BAD_TARGET
<< 16);
1762 /* Save done function into scsi_cmnd struct */
1763 SCpnt
->scsi_done
= done
;
1765 /* Get a free request id */
1766 twa_get_request_id(tw_dev
, &request_id
);
1768 /* Save the scsi command for use by the ISR */
1769 tw_dev
->srb
[request_id
] = SCpnt
;
1771 /* Initialize phase to zero */
1772 SCpnt
->SCp
.phase
= TW_PHASE_INITIAL
;
1774 retval
= twa_scsiop_execute_scsi(tw_dev
, request_id
, NULL
, 0, NULL
);
1776 case SCSI_MLQUEUE_HOST_BUSY
:
1777 twa_free_request_id(tw_dev
, request_id
);
1780 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
1781 twa_free_request_id(tw_dev
, request_id
);
1782 SCpnt
->result
= (DID_ERROR
<< 16);
1788 } /* End twa_scsi_queue() */
1790 /* This function hands scsi cdb's to the firmware */
1791 static int twa_scsiop_execute_scsi(TW_Device_Extension
*tw_dev
, int request_id
, char *cdb
, int use_sg
, TW_SG_Entry
*sglistarg
)
1793 TW_Command_Full
*full_command_packet
;
1794 TW_Command_Apache
*command_packet
;
1795 u32 num_sectors
= 0x0;
1797 struct scsi_cmnd
*srb
= NULL
;
1798 struct scatterlist
*sglist
= NULL
, *sg
;
1801 if (tw_dev
->srb
[request_id
]) {
1802 srb
= tw_dev
->srb
[request_id
];
1803 if (scsi_sglist(srb
))
1804 sglist
= scsi_sglist(srb
);
1807 /* Initialize command packet */
1808 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1809 full_command_packet
->header
.header_desc
.size_header
= 128;
1810 full_command_packet
->header
.status_block
.error
= 0;
1811 full_command_packet
->header
.status_block
.severity__reserved
= 0;
1813 command_packet
= &full_command_packet
->command
.newcommand
;
1814 command_packet
->status
= 0;
1815 command_packet
->opcode__reserved
= TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI
);
1817 /* We forced 16 byte cdb use earlier */
1819 memcpy(command_packet
->cdb
, srb
->cmnd
, TW_MAX_CDB_LEN
);
1821 memcpy(command_packet
->cdb
, cdb
, TW_MAX_CDB_LEN
);
1824 command_packet
->unit
= srb
->device
->id
;
1825 command_packet
->request_id__lunl
=
1826 cpu_to_le16(TW_REQ_LUN_IN(srb
->device
->lun
, request_id
));
1828 command_packet
->request_id__lunl
=
1829 cpu_to_le16(TW_REQ_LUN_IN(0, request_id
));
1830 command_packet
->unit
= 0;
1833 command_packet
->sgl_offset
= 16;
1836 /* Map sglist from scsi layer to cmd packet */
1838 if (scsi_sg_count(srb
)) {
1839 if ((scsi_sg_count(srb
) == 1) &&
1840 (scsi_bufflen(srb
) < TW_MIN_SGL_LENGTH
)) {
1841 if (srb
->sc_data_direction
== DMA_TO_DEVICE
|| srb
->sc_data_direction
== DMA_BIDIRECTIONAL
) {
1842 struct scatterlist
*sg
= scsi_sglist(srb
);
1843 char *buf
= kmap_atomic(sg
->page
, KM_IRQ0
) + sg
->offset
;
1844 memcpy(tw_dev
->generic_buffer_virt
[request_id
], buf
, sg
->length
);
1845 kunmap_atomic(buf
- sg
->offset
, KM_IRQ0
);
1847 command_packet
->sg_list
[0].address
= TW_CPU_TO_SGL(tw_dev
->generic_buffer_phys
[request_id
]);
1848 command_packet
->sg_list
[0].length
= cpu_to_le32(TW_MIN_SGL_LENGTH
);
1850 sg_count
= twa_map_scsi_sg_data(tw_dev
, request_id
);
1854 scsi_for_each_sg(srb
, sg
, sg_count
, i
) {
1855 command_packet
->sg_list
[i
].address
= TW_CPU_TO_SGL(sg_dma_address(sg
));
1856 command_packet
->sg_list
[i
].length
= cpu_to_le32(sg_dma_len(sg
));
1857 if (command_packet
->sg_list
[i
].address
& TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL
)) {
1858 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x2e, "Found unaligned sgl address during execute scsi");
1863 command_packet
->sgl_entries__lunh
= cpu_to_le16(TW_REQ_LUN_IN((srb
->device
->lun
>> 4), scsi_sg_count(tw_dev
->srb
[request_id
])));
1866 /* Internal cdb post */
1867 for (i
= 0; i
< use_sg
; i
++) {
1868 command_packet
->sg_list
[i
].address
= TW_CPU_TO_SGL(sglistarg
[i
].address
);
1869 command_packet
->sg_list
[i
].length
= cpu_to_le32(sglistarg
[i
].length
);
1870 if (command_packet
->sg_list
[i
].address
& TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL
)) {
1871 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x2f, "Found unaligned sgl address during internal post");
1875 command_packet
->sgl_entries__lunh
= cpu_to_le16(TW_REQ_LUN_IN(0, use_sg
));
1879 if (srb
->cmnd
[0] == READ_6
|| srb
->cmnd
[0] == WRITE_6
)
1880 num_sectors
= (u32
)srb
->cmnd
[4];
1882 if (srb
->cmnd
[0] == READ_10
|| srb
->cmnd
[0] == WRITE_10
)
1883 num_sectors
= (u32
)srb
->cmnd
[8] | ((u32
)srb
->cmnd
[7] << 8);
1886 /* Update sector statistic */
1887 tw_dev
->sector_count
= num_sectors
;
1888 if (tw_dev
->sector_count
> tw_dev
->max_sector_count
)
1889 tw_dev
->max_sector_count
= tw_dev
->sector_count
;
1891 /* Update SG statistics */
1893 tw_dev
->sgl_entries
= scsi_sg_count(tw_dev
->srb
[request_id
]);
1894 if (tw_dev
->sgl_entries
> tw_dev
->max_sgl_entries
)
1895 tw_dev
->max_sgl_entries
= tw_dev
->sgl_entries
;
1898 /* Now post the command to the board */
1900 retval
= twa_post_command_packet(tw_dev
, request_id
, 0);
1902 twa_post_command_packet(tw_dev
, request_id
, 1);
1907 } /* End twa_scsiop_execute_scsi() */
1909 /* This function completes an execute scsi operation */
1910 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension
*tw_dev
, int request_id
)
1912 struct scsi_cmnd
*cmd
= tw_dev
->srb
[request_id
];
1914 if (scsi_bufflen(cmd
) < TW_MIN_SGL_LENGTH
&&
1915 (cmd
->sc_data_direction
== DMA_FROM_DEVICE
||
1916 cmd
->sc_data_direction
== DMA_BIDIRECTIONAL
)) {
1917 if (scsi_sg_count(cmd
) == 1) {
1918 struct scatterlist
*sg
= scsi_sglist(tw_dev
->srb
[request_id
]);
1920 unsigned long flags
= 0;
1921 local_irq_save(flags
);
1922 buf
= kmap_atomic(sg
->page
, KM_IRQ0
) + sg
->offset
;
1923 memcpy(buf
, tw_dev
->generic_buffer_virt
[request_id
], sg
->length
);
1924 kunmap_atomic(buf
- sg
->offset
, KM_IRQ0
);
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 .use_sg_chaining
= ENABLE_SG_CHAINING
,
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
);