2 3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux.
4 Written By: Adam Radford <linuxraid@lsi.com>
5 Modifications By: Tom Couch <linuxraid@lsi.com>
7 Copyright (C) 2004-2009 Applied Micro Circuits Corporation.
8 Copyright (C) 2010 LSI Corporation.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; version 2 of the License.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
20 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24 solely responsible for determining the appropriateness of using and
25 distributing the Program and assumes all risks associated with its
26 exercise of rights under this Agreement, including but not limited to
27 the risks and costs of program errors, damage to or loss of data,
28 programs or equipment, and unavailability or interruption of operations.
30 DISCLAIMER OF LIABILITY
31 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
39 You should have received a copy of the GNU General Public License
40 along with this program; if not, write to the Free Software
41 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
43 Bugs/Comments/Suggestions should be mailed to:
46 For more information, goto:
49 Note: This version of the driver does not contain a bundled firmware
54 2.26.02.000 - Driver cleanup for kernel submission.
55 2.26.02.001 - Replace schedule_timeout() calls with msleep().
56 2.26.02.002 - Add support for PAE mode.
58 Fix twa_remove() to free irq handler/unregister_chrdev()
59 before shutting down card.
60 Change to new 'change_queue_depth' api.
61 Fix 'handled=1' ISR usage, remove bogus IRQ check.
62 Remove un-needed eh_abort handler.
63 Add support for embedded firmware error strings.
64 2.26.02.003 - Correctly handle single sgl's with use_sg=1.
65 2.26.02.004 - Add support for 9550SX controllers.
66 2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher.
67 2.26.02.006 - Fix 9550SX pchip reset timeout.
68 Add big endian support.
69 2.26.02.007 - Disable local interrupts during kmap/unmap_atomic().
70 2.26.02.008 - Free irq handler in __twa_shutdown().
72 Add support for 9650SE controllers.
73 2.26.02.009 - Fix dma mask setting to fallback to 32-bit if 64-bit fails.
74 2.26.02.010 - Add support for 9690SA controllers.
75 2.26.02.011 - Increase max AENs drained to 256.
76 Add MSI support and "use_msi" module parameter.
77 Fix bug in twa_get_param() on 4GB+.
78 Use pci_resource_len() for ioremap().
79 2.26.02.012 - Add power management support.
80 2.26.02.013 - Fix bug in twa_load_sgl().
81 2.26.02.014 - Force 60 second timeout default.
84 #include <linux/module.h>
85 #include <linux/reboot.h>
86 #include <linux/spinlock.h>
87 #include <linux/interrupt.h>
88 #include <linux/moduleparam.h>
89 #include <linux/errno.h>
90 #include <linux/types.h>
91 #include <linux/delay.h>
92 #include <linux/pci.h>
93 #include <linux/time.h>
94 #include <linux/mutex.h>
95 #include <linux/smp_lock.h>
96 #include <linux/slab.h>
99 #include <asm/uaccess.h>
100 #include <scsi/scsi.h>
101 #include <scsi/scsi_host.h>
102 #include <scsi/scsi_tcq.h>
103 #include <scsi/scsi_cmnd.h>
107 #define TW_DRIVER_VERSION "2.26.02.014"
108 static TW_Device_Extension
*twa_device_extension_list
[TW_MAX_SLOT
];
109 static unsigned int twa_device_extension_count
;
110 static int twa_major
= -1;
111 extern struct timezone sys_tz
;
113 /* Module parameters */
114 MODULE_AUTHOR ("LSI");
115 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
116 MODULE_LICENSE("GPL");
117 MODULE_VERSION(TW_DRIVER_VERSION
);
119 static int use_msi
= 0;
120 module_param(use_msi
, int, S_IRUGO
);
121 MODULE_PARM_DESC(use_msi
, "Use Message Signaled Interrupts. Default: 0");
123 /* Function prototypes */
124 static void twa_aen_queue_event(TW_Device_Extension
*tw_dev
, TW_Command_Apache_Header
*header
);
125 static int twa_aen_read_queue(TW_Device_Extension
*tw_dev
, int request_id
);
126 static char *twa_aen_severity_lookup(unsigned char severity_code
);
127 static void twa_aen_sync_time(TW_Device_Extension
*tw_dev
, int request_id
);
128 static int twa_chrdev_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
);
129 static int twa_chrdev_open(struct inode
*inode
, struct file
*file
);
130 static int twa_fill_sense(TW_Device_Extension
*tw_dev
, int request_id
, int copy_sense
, int print_host
);
131 static void twa_free_request_id(TW_Device_Extension
*tw_dev
,int request_id
);
132 static void twa_get_request_id(TW_Device_Extension
*tw_dev
, int *request_id
);
133 static int twa_initconnection(TW_Device_Extension
*tw_dev
, int message_credits
,
134 u32 set_features
, unsigned short current_fw_srl
,
135 unsigned short current_fw_arch_id
,
136 unsigned short current_fw_branch
,
137 unsigned short current_fw_build
,
138 unsigned short *fw_on_ctlr_srl
,
139 unsigned short *fw_on_ctlr_arch_id
,
140 unsigned short *fw_on_ctlr_branch
,
141 unsigned short *fw_on_ctlr_build
,
142 u32
*init_connect_result
);
143 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
);
144 static int twa_poll_response(TW_Device_Extension
*tw_dev
, int request_id
, int seconds
);
145 static int twa_poll_status_gone(TW_Device_Extension
*tw_dev
, u32 flag
, int seconds
);
146 static int twa_post_command_packet(TW_Device_Extension
*tw_dev
, int request_id
, char internal
);
147 static int twa_reset_device_extension(TW_Device_Extension
*tw_dev
);
148 static int twa_reset_sequence(TW_Device_Extension
*tw_dev
, int soft_reset
);
149 static int twa_scsiop_execute_scsi(TW_Device_Extension
*tw_dev
, int request_id
, char *cdb
, int use_sg
, TW_SG_Entry
*sglistarg
);
150 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension
*tw_dev
, int request_id
);
151 static char *twa_string_lookup(twa_message_type
*table
, unsigned int aen_code
);
152 static void twa_unmap_scsi_data(TW_Device_Extension
*tw_dev
, int request_id
);
156 /* Show some statistics about the card */
157 static ssize_t
twa_show_stats(struct device
*dev
,
158 struct device_attribute
*attr
, char *buf
)
160 struct Scsi_Host
*host
= class_to_shost(dev
);
161 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)host
->hostdata
;
162 unsigned long flags
= 0;
165 spin_lock_irqsave(tw_dev
->host
->host_lock
, flags
);
166 len
= snprintf(buf
, PAGE_SIZE
, "3w-9xxx Driver version: %s\n"
167 "Current commands posted: %4d\n"
168 "Max commands posted: %4d\n"
169 "Current pending commands: %4d\n"
170 "Max pending commands: %4d\n"
171 "Last sgl length: %4d\n"
172 "Max sgl length: %4d\n"
173 "Last sector count: %4d\n"
174 "Max sector count: %4d\n"
175 "SCSI Host Resets: %4d\n"
178 tw_dev
->posted_request_count
,
179 tw_dev
->max_posted_request_count
,
180 tw_dev
->pending_request_count
,
181 tw_dev
->max_pending_request_count
,
183 tw_dev
->max_sgl_entries
,
184 tw_dev
->sector_count
,
185 tw_dev
->max_sector_count
,
188 spin_unlock_irqrestore(tw_dev
->host
->host_lock
, flags
);
190 } /* End twa_show_stats() */
192 /* This function will set a devices queue depth */
193 static int twa_change_queue_depth(struct scsi_device
*sdev
, int queue_depth
,
196 if (reason
!= SCSI_QDEPTH_DEFAULT
)
199 if (queue_depth
> TW_Q_LENGTH
-2)
200 queue_depth
= TW_Q_LENGTH
-2;
201 scsi_adjust_queue_depth(sdev
, MSG_ORDERED_TAG
, queue_depth
);
203 } /* End twa_change_queue_depth() */
205 /* Create sysfs 'stats' entry */
206 static struct device_attribute twa_host_stats_attr
= {
211 .show
= twa_show_stats
214 /* Host attributes initializer */
215 static struct device_attribute
*twa_host_attrs
[] = {
216 &twa_host_stats_attr
,
220 /* File operations struct for character device */
221 static const struct file_operations twa_fops
= {
222 .owner
= THIS_MODULE
,
223 .ioctl
= twa_chrdev_ioctl
,
224 .open
= twa_chrdev_open
,
228 /* This function will complete an aen request from the isr */
229 static int twa_aen_complete(TW_Device_Extension
*tw_dev
, int request_id
)
231 TW_Command_Full
*full_command_packet
;
232 TW_Command
*command_packet
;
233 TW_Command_Apache_Header
*header
;
237 header
= (TW_Command_Apache_Header
*)tw_dev
->generic_buffer_virt
[request_id
];
238 tw_dev
->posted_request_count
--;
239 aen
= le16_to_cpu(header
->status_block
.error
);
240 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
241 command_packet
= &full_command_packet
->command
.oldcommand
;
243 /* First check for internal completion of set param for time sync */
244 if (TW_OP_OUT(command_packet
->opcode__sgloffset
) == TW_OP_SET_PARAM
) {
245 /* Keep reading the queue in case there are more aen's */
246 if (twa_aen_read_queue(tw_dev
, request_id
))
255 case TW_AEN_QUEUE_EMPTY
:
256 /* Quit reading the queue if this is the last one */
258 case TW_AEN_SYNC_TIME_WITH_HOST
:
259 twa_aen_sync_time(tw_dev
, request_id
);
263 twa_aen_queue_event(tw_dev
, header
);
265 /* If there are more aen's, keep reading the queue */
266 if (twa_aen_read_queue(tw_dev
, request_id
))
275 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
276 twa_free_request_id(tw_dev
, request_id
);
277 clear_bit(TW_IN_ATTENTION_LOOP
, &tw_dev
->flags
);
280 } /* End twa_aen_complete() */
282 /* This function will drain aen queue */
283 static int twa_aen_drain_queue(TW_Device_Extension
*tw_dev
, int no_check_reset
)
286 char cdb
[TW_MAX_CDB_LEN
];
287 TW_SG_Entry sglist
[1];
288 int finished
= 0, count
= 0;
289 TW_Command_Full
*full_command_packet
;
290 TW_Command_Apache_Header
*header
;
292 int first_reset
= 0, queue
= 0, retval
= 1;
299 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
300 memset(full_command_packet
, 0, sizeof(TW_Command_Full
));
303 memset(&cdb
, 0, TW_MAX_CDB_LEN
);
304 cdb
[0] = REQUEST_SENSE
; /* opcode */
305 cdb
[4] = TW_ALLOCATION_LENGTH
; /* allocation length */
307 /* Initialize sglist */
308 memset(&sglist
, 0, sizeof(TW_SG_Entry
));
309 sglist
[0].length
= TW_SECTOR_SIZE
;
310 sglist
[0].address
= tw_dev
->generic_buffer_phys
[request_id
];
312 if (sglist
[0].address
& TW_ALIGNMENT_9000_SGL
) {
313 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1, "Found unaligned address during AEN drain");
317 /* Mark internal command */
318 tw_dev
->srb
[request_id
] = NULL
;
321 /* Send command to the board */
322 if (twa_scsiop_execute_scsi(tw_dev
, request_id
, cdb
, 1, sglist
)) {
323 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x2, "Error posting request sense");
327 /* Now poll for completion */
328 if (twa_poll_response(tw_dev
, request_id
, 30)) {
329 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x3, "No valid response while draining AEN queue");
330 tw_dev
->posted_request_count
--;
334 tw_dev
->posted_request_count
--;
335 header
= (TW_Command_Apache_Header
*)tw_dev
->generic_buffer_virt
[request_id
];
336 aen
= le16_to_cpu(header
->status_block
.error
);
341 case TW_AEN_QUEUE_EMPTY
:
342 if (first_reset
!= 1)
347 case TW_AEN_SOFT_RESET
:
348 if (first_reset
== 0)
353 case TW_AEN_SYNC_TIME_WITH_HOST
:
359 /* Now queue an event info */
361 twa_aen_queue_event(tw_dev
, header
);
362 } while ((finished
== 0) && (count
< TW_MAX_AEN_DRAIN
));
364 if (count
== TW_MAX_AEN_DRAIN
)
369 tw_dev
->state
[request_id
] = TW_S_INITIAL
;
371 } /* End twa_aen_drain_queue() */
373 /* This function will queue an event */
374 static void twa_aen_queue_event(TW_Device_Extension
*tw_dev
, TW_Command_Apache_Header
*header
)
385 /* Fill out event info */
386 event
= tw_dev
->event_queue
[tw_dev
->error_index
];
388 /* Check for clobber */
391 sprintf(host
, " scsi%d:", tw_dev
->host
->host_no
);
392 if (event
->retrieved
== TW_AEN_NOT_RETRIEVED
)
393 tw_dev
->aen_clobber
= 1;
396 aen
= le16_to_cpu(header
->status_block
.error
);
397 memset(event
, 0, sizeof(TW_Event
));
399 event
->severity
= TW_SEV_OUT(header
->status_block
.severity__reserved
);
400 do_gettimeofday(&time
);
401 local_time
= (u32
)(time
.tv_sec
- (sys_tz
.tz_minuteswest
* 60));
402 event
->time_stamp_sec
= local_time
;
403 event
->aen_code
= aen
;
404 event
->retrieved
= TW_AEN_NOT_RETRIEVED
;
405 event
->sequence_id
= tw_dev
->error_sequence_id
;
406 tw_dev
->error_sequence_id
++;
408 /* Check for embedded error string */
409 error_str
= &(header
->err_specific_desc
[strlen(header
->err_specific_desc
)+1]);
411 header
->err_specific_desc
[sizeof(header
->err_specific_desc
) - 1] = '\0';
412 event
->parameter_len
= strlen(header
->err_specific_desc
);
413 memcpy(event
->parameter_data
, header
->err_specific_desc
, event
->parameter_len
+ (error_str
[0] == '\0' ? 0 : (1 + strlen(error_str
))));
414 if (event
->severity
!= TW_AEN_SEVERITY_DEBUG
)
415 printk(KERN_WARNING
"3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
417 twa_aen_severity_lookup(TW_SEV_OUT(header
->status_block
.severity__reserved
)),
418 TW_MESSAGE_SOURCE_CONTROLLER_EVENT
, aen
,
419 error_str
[0] == '\0' ? twa_string_lookup(twa_aen_table
, aen
) : error_str
,
420 header
->err_specific_desc
);
424 if ((tw_dev
->error_index
+ 1) == TW_Q_LENGTH
)
425 tw_dev
->event_queue_wrapped
= 1;
426 tw_dev
->error_index
= (tw_dev
->error_index
+ 1 ) % TW_Q_LENGTH
;
427 } /* End twa_aen_queue_event() */
429 /* This function will read the aen queue from the isr */
430 static int twa_aen_read_queue(TW_Device_Extension
*tw_dev
, int request_id
)
432 char cdb
[TW_MAX_CDB_LEN
];
433 TW_SG_Entry sglist
[1];
434 TW_Command_Full
*full_command_packet
;
437 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
438 memset(full_command_packet
, 0, sizeof(TW_Command_Full
));
441 memset(&cdb
, 0, TW_MAX_CDB_LEN
);
442 cdb
[0] = REQUEST_SENSE
; /* opcode */
443 cdb
[4] = TW_ALLOCATION_LENGTH
; /* allocation length */
445 /* Initialize sglist */
446 memset(&sglist
, 0, sizeof(TW_SG_Entry
));
447 sglist
[0].length
= TW_SECTOR_SIZE
;
448 sglist
[0].address
= tw_dev
->generic_buffer_phys
[request_id
];
450 /* Mark internal command */
451 tw_dev
->srb
[request_id
] = NULL
;
453 /* Now post the command packet */
454 if (twa_scsiop_execute_scsi(tw_dev
, request_id
, cdb
, 1, sglist
)) {
455 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x4, "Post failed while reading AEN queue");
461 } /* End twa_aen_read_queue() */
463 /* This function will look up an AEN severity string */
464 static char *twa_aen_severity_lookup(unsigned char severity_code
)
468 if ((severity_code
< (unsigned char) TW_AEN_SEVERITY_ERROR
) ||
469 (severity_code
> (unsigned char) TW_AEN_SEVERITY_DEBUG
))
472 retval
= twa_aen_severity_table
[severity_code
];
475 } /* End twa_aen_severity_lookup() */
477 /* This function will sync firmware time with the host time */
478 static void twa_aen_sync_time(TW_Device_Extension
*tw_dev
, int request_id
)
482 TW_Command_Full
*full_command_packet
;
483 TW_Command
*command_packet
;
484 TW_Param_Apache
*param
;
487 /* Fill out the command packet */
488 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
489 memset(full_command_packet
, 0, sizeof(TW_Command_Full
));
490 command_packet
= &full_command_packet
->command
.oldcommand
;
491 command_packet
->opcode__sgloffset
= TW_OPSGL_IN(2, TW_OP_SET_PARAM
);
492 command_packet
->request_id
= request_id
;
493 command_packet
->byte8_offset
.param
.sgl
[0].address
= TW_CPU_TO_SGL(tw_dev
->generic_buffer_phys
[request_id
]);
494 command_packet
->byte8_offset
.param
.sgl
[0].length
= cpu_to_le32(TW_SECTOR_SIZE
);
495 command_packet
->size
= TW_COMMAND_SIZE
;
496 command_packet
->byte6_offset
.parameter_count
= cpu_to_le16(1);
498 /* Setup the param */
499 param
= (TW_Param_Apache
*)tw_dev
->generic_buffer_virt
[request_id
];
500 memset(param
, 0, TW_SECTOR_SIZE
);
501 param
->table_id
= cpu_to_le16(TW_TIMEKEEP_TABLE
| 0x8000); /* Controller time keep table */
502 param
->parameter_id
= cpu_to_le16(0x3); /* SchedulerTime */
503 param
->parameter_size_bytes
= cpu_to_le16(4);
505 /* Convert system time in UTC to local time seconds since last
507 do_gettimeofday(&utc
);
508 local_time
= (u32
)(utc
.tv_sec
- (sys_tz
.tz_minuteswest
* 60));
509 schedulertime
= local_time
- (3 * 86400);
510 schedulertime
= cpu_to_le32(schedulertime
% 604800);
512 memcpy(param
->data
, &schedulertime
, sizeof(u32
));
514 /* Mark internal command */
515 tw_dev
->srb
[request_id
] = NULL
;
517 /* Now post the command */
518 twa_post_command_packet(tw_dev
, request_id
, 1);
519 } /* End twa_aen_sync_time() */
521 /* This function will allocate memory and check if it is correctly aligned */
522 static int twa_allocate_memory(TW_Device_Extension
*tw_dev
, int size
, int which
)
525 dma_addr_t dma_handle
;
526 unsigned long *cpu_addr
;
529 cpu_addr
= pci_alloc_consistent(tw_dev
->tw_pci_dev
, size
*TW_Q_LENGTH
, &dma_handle
);
531 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x5, "Memory allocation failed");
535 if ((unsigned long)cpu_addr
% (TW_ALIGNMENT_9000
)) {
536 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x6, "Failed to allocate correctly aligned memory");
537 pci_free_consistent(tw_dev
->tw_pci_dev
, size
*TW_Q_LENGTH
, cpu_addr
, dma_handle
);
541 memset(cpu_addr
, 0, size
*TW_Q_LENGTH
);
543 for (i
= 0; i
< TW_Q_LENGTH
; i
++) {
546 tw_dev
->command_packet_phys
[i
] = dma_handle
+(i
*size
);
547 tw_dev
->command_packet_virt
[i
] = (TW_Command_Full
*)((unsigned char *)cpu_addr
+ (i
*size
));
550 tw_dev
->generic_buffer_phys
[i
] = dma_handle
+(i
*size
);
551 tw_dev
->generic_buffer_virt
[i
] = (unsigned long *)((unsigned char *)cpu_addr
+ (i
*size
));
558 } /* End twa_allocate_memory() */
560 /* This function will check the status register for unexpected bits */
561 static int twa_check_bits(u32 status_reg_value
)
565 if ((status_reg_value
& TW_STATUS_EXPECTED_BITS
) != TW_STATUS_EXPECTED_BITS
)
567 if ((status_reg_value
& TW_STATUS_UNEXPECTED_BITS
) != 0)
573 } /* End twa_check_bits() */
575 /* This function will check the srl and decide if we are compatible */
576 static int twa_check_srl(TW_Device_Extension
*tw_dev
, int *flashed
)
579 unsigned short fw_on_ctlr_srl
= 0, fw_on_ctlr_arch_id
= 0;
580 unsigned short fw_on_ctlr_branch
= 0, fw_on_ctlr_build
= 0;
581 u32 init_connect_result
= 0;
583 if (twa_initconnection(tw_dev
, TW_INIT_MESSAGE_CREDITS
,
584 TW_EXTENDED_INIT_CONNECT
, TW_CURRENT_DRIVER_SRL
,
585 TW_9000_ARCH_ID
, TW_CURRENT_DRIVER_BRANCH
,
586 TW_CURRENT_DRIVER_BUILD
, &fw_on_ctlr_srl
,
587 &fw_on_ctlr_arch_id
, &fw_on_ctlr_branch
,
588 &fw_on_ctlr_build
, &init_connect_result
)) {
589 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x7, "Initconnection failed while checking SRL");
593 tw_dev
->tw_compat_info
.working_srl
= fw_on_ctlr_srl
;
594 tw_dev
->tw_compat_info
.working_branch
= fw_on_ctlr_branch
;
595 tw_dev
->tw_compat_info
.working_build
= fw_on_ctlr_build
;
597 /* Try base mode compatibility */
598 if (!(init_connect_result
& TW_CTLR_FW_COMPATIBLE
)) {
599 if (twa_initconnection(tw_dev
, TW_INIT_MESSAGE_CREDITS
,
600 TW_EXTENDED_INIT_CONNECT
,
601 TW_BASE_FW_SRL
, TW_9000_ARCH_ID
,
602 TW_BASE_FW_BRANCH
, TW_BASE_FW_BUILD
,
603 &fw_on_ctlr_srl
, &fw_on_ctlr_arch_id
,
604 &fw_on_ctlr_branch
, &fw_on_ctlr_build
,
605 &init_connect_result
)) {
606 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0xa, "Initconnection (base mode) failed while checking SRL");
609 if (!(init_connect_result
& TW_CTLR_FW_COMPATIBLE
)) {
610 if (TW_CURRENT_DRIVER_SRL
> fw_on_ctlr_srl
) {
611 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
613 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x33, "Firmware and driver incompatibility: please upgrade driver");
617 tw_dev
->tw_compat_info
.working_srl
= TW_BASE_FW_SRL
;
618 tw_dev
->tw_compat_info
.working_branch
= TW_BASE_FW_BRANCH
;
619 tw_dev
->tw_compat_info
.working_build
= TW_BASE_FW_BUILD
;
622 /* Load rest of compatibility struct */
623 strncpy(tw_dev
->tw_compat_info
.driver_version
, TW_DRIVER_VERSION
, strlen(TW_DRIVER_VERSION
));
624 tw_dev
->tw_compat_info
.driver_srl_high
= TW_CURRENT_DRIVER_SRL
;
625 tw_dev
->tw_compat_info
.driver_branch_high
= TW_CURRENT_DRIVER_BRANCH
;
626 tw_dev
->tw_compat_info
.driver_build_high
= TW_CURRENT_DRIVER_BUILD
;
627 tw_dev
->tw_compat_info
.driver_srl_low
= TW_BASE_FW_SRL
;
628 tw_dev
->tw_compat_info
.driver_branch_low
= TW_BASE_FW_BRANCH
;
629 tw_dev
->tw_compat_info
.driver_build_low
= TW_BASE_FW_BUILD
;
630 tw_dev
->tw_compat_info
.fw_on_ctlr_srl
= fw_on_ctlr_srl
;
631 tw_dev
->tw_compat_info
.fw_on_ctlr_branch
= fw_on_ctlr_branch
;
632 tw_dev
->tw_compat_info
.fw_on_ctlr_build
= fw_on_ctlr_build
;
637 } /* End twa_check_srl() */
639 /* This function handles ioctl for the character device */
640 static int twa_chrdev_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
643 unsigned long *cpu_addr
, data_buffer_length_adjusted
= 0, flags
= 0;
644 dma_addr_t dma_handle
;
646 unsigned int sequence_id
= 0;
647 unsigned char event_index
, start_index
;
648 TW_Ioctl_Driver_Command driver_command
;
649 TW_Ioctl_Buf_Apache
*tw_ioctl
;
651 TW_Command_Full
*full_command_packet
;
652 TW_Compatibility_Info
*tw_compat_info
;
654 struct timeval current_time
;
656 TW_Device_Extension
*tw_dev
= twa_device_extension_list
[iminor(inode
)];
657 int retval
= TW_IOCTL_ERROR_OS_EFAULT
;
658 void __user
*argp
= (void __user
*)arg
;
660 /* Only let one of these through at a time */
661 if (mutex_lock_interruptible(&tw_dev
->ioctl_lock
)) {
662 retval
= TW_IOCTL_ERROR_OS_EINTR
;
666 /* First copy down the driver command */
667 if (copy_from_user(&driver_command
, argp
, sizeof(TW_Ioctl_Driver_Command
)))
670 /* Check data buffer size */
671 if (driver_command
.buffer_length
> TW_MAX_SECTORS
* 2048) {
672 retval
= TW_IOCTL_ERROR_OS_EINVAL
;
676 /* Hardware can only do multiple of 512 byte transfers */
677 data_buffer_length_adjusted
= (driver_command
.buffer_length
+ 511) & ~511;
679 /* Now allocate ioctl buf memory */
680 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
);
682 retval
= TW_IOCTL_ERROR_OS_ENOMEM
;
686 tw_ioctl
= (TW_Ioctl_Buf_Apache
*)cpu_addr
;
688 /* Now copy down the entire ioctl */
689 if (copy_from_user(tw_ioctl
, argp
, driver_command
.buffer_length
+ sizeof(TW_Ioctl_Buf_Apache
) - 1))
692 /* See which ioctl we are doing */
694 case TW_IOCTL_FIRMWARE_PASS_THROUGH
:
695 spin_lock_irqsave(tw_dev
->host
->host_lock
, flags
);
696 twa_get_request_id(tw_dev
, &request_id
);
698 /* Flag internal command */
699 tw_dev
->srb
[request_id
] = NULL
;
701 /* Flag chrdev ioctl */
702 tw_dev
->chrdev_request_id
= request_id
;
704 full_command_packet
= &tw_ioctl
->firmware_command
;
706 /* Load request id and sglist for both command types */
707 twa_load_sgl(tw_dev
, full_command_packet
, request_id
, dma_handle
, data_buffer_length_adjusted
);
709 memcpy(tw_dev
->command_packet_virt
[request_id
], &(tw_ioctl
->firmware_command
), sizeof(TW_Command_Full
));
711 /* Now post the command packet to the controller */
712 twa_post_command_packet(tw_dev
, request_id
, 1);
713 spin_unlock_irqrestore(tw_dev
->host
->host_lock
, flags
);
715 timeout
= TW_IOCTL_CHRDEV_TIMEOUT
*HZ
;
717 /* Now wait for command to complete */
718 timeout
= wait_event_timeout(tw_dev
->ioctl_wqueue
, tw_dev
->chrdev_request_id
== TW_IOCTL_CHRDEV_FREE
, timeout
);
720 /* We timed out, and didn't get an interrupt */
721 if (tw_dev
->chrdev_request_id
!= TW_IOCTL_CHRDEV_FREE
) {
722 /* Now we need to reset the board */
723 printk(KERN_WARNING
"3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
724 tw_dev
->host
->host_no
, TW_DRIVER
, 0x37,
726 retval
= TW_IOCTL_ERROR_OS_EIO
;
727 twa_reset_device_extension(tw_dev
);
731 /* Now copy in the command packet response */
732 memcpy(&(tw_ioctl
->firmware_command
), tw_dev
->command_packet_virt
[request_id
], sizeof(TW_Command_Full
));
734 /* Now complete the io */
735 spin_lock_irqsave(tw_dev
->host
->host_lock
, flags
);
736 tw_dev
->posted_request_count
--;
737 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
738 twa_free_request_id(tw_dev
, request_id
);
739 spin_unlock_irqrestore(tw_dev
->host
->host_lock
, flags
);
741 case TW_IOCTL_GET_COMPATIBILITY_INFO
:
742 tw_ioctl
->driver_command
.status
= 0;
743 /* Copy compatibility struct into ioctl data buffer */
744 tw_compat_info
= (TW_Compatibility_Info
*)tw_ioctl
->data_buffer
;
745 memcpy(tw_compat_info
, &tw_dev
->tw_compat_info
, sizeof(TW_Compatibility_Info
));
747 case TW_IOCTL_GET_LAST_EVENT
:
748 if (tw_dev
->event_queue_wrapped
) {
749 if (tw_dev
->aen_clobber
) {
750 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_AEN_CLOBBER
;
751 tw_dev
->aen_clobber
= 0;
753 tw_ioctl
->driver_command
.status
= 0;
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;
761 event_index
= (tw_dev
->error_index
- 1 + TW_Q_LENGTH
) % TW_Q_LENGTH
;
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_FIRST_EVENT
:
766 if (tw_dev
->event_queue_wrapped
) {
767 if (tw_dev
->aen_clobber
) {
768 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_AEN_CLOBBER
;
769 tw_dev
->aen_clobber
= 0;
771 tw_ioctl
->driver_command
.status
= 0;
772 event_index
= tw_dev
->error_index
;
774 if (!tw_dev
->error_index
) {
775 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS
;
778 tw_ioctl
->driver_command
.status
= 0;
781 memcpy(tw_ioctl
->data_buffer
, tw_dev
->event_queue
[event_index
], sizeof(TW_Event
));
782 tw_dev
->event_queue
[event_index
]->retrieved
= TW_AEN_RETRIEVED
;
784 case TW_IOCTL_GET_NEXT_EVENT
:
785 event
= (TW_Event
*)tw_ioctl
->data_buffer
;
786 sequence_id
= event
->sequence_id
;
787 tw_ioctl
->driver_command
.status
= 0;
789 if (tw_dev
->event_queue_wrapped
) {
790 if (tw_dev
->aen_clobber
) {
791 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_AEN_CLOBBER
;
792 tw_dev
->aen_clobber
= 0;
794 start_index
= tw_dev
->error_index
;
796 if (!tw_dev
->error_index
) {
797 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS
;
802 event_index
= (start_index
+ sequence_id
- tw_dev
->event_queue
[start_index
]->sequence_id
+ 1) % TW_Q_LENGTH
;
804 if (!(tw_dev
->event_queue
[event_index
]->sequence_id
> sequence_id
)) {
805 if (tw_ioctl
->driver_command
.status
== TW_IOCTL_ERROR_STATUS_AEN_CLOBBER
)
806 tw_dev
->aen_clobber
= 1;
807 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS
;
810 memcpy(tw_ioctl
->data_buffer
, tw_dev
->event_queue
[event_index
], sizeof(TW_Event
));
811 tw_dev
->event_queue
[event_index
]->retrieved
= TW_AEN_RETRIEVED
;
813 case TW_IOCTL_GET_PREVIOUS_EVENT
:
814 event
= (TW_Event
*)tw_ioctl
->data_buffer
;
815 sequence_id
= event
->sequence_id
;
816 tw_ioctl
->driver_command
.status
= 0;
818 if (tw_dev
->event_queue_wrapped
) {
819 if (tw_dev
->aen_clobber
) {
820 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_AEN_CLOBBER
;
821 tw_dev
->aen_clobber
= 0;
823 start_index
= tw_dev
->error_index
;
825 if (!tw_dev
->error_index
) {
826 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS
;
831 event_index
= (start_index
+ sequence_id
- tw_dev
->event_queue
[start_index
]->sequence_id
- 1) % TW_Q_LENGTH
;
833 if (!(tw_dev
->event_queue
[event_index
]->sequence_id
< sequence_id
)) {
834 if (tw_ioctl
->driver_command
.status
== TW_IOCTL_ERROR_STATUS_AEN_CLOBBER
)
835 tw_dev
->aen_clobber
= 1;
836 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS
;
839 memcpy(tw_ioctl
->data_buffer
, tw_dev
->event_queue
[event_index
], sizeof(TW_Event
));
840 tw_dev
->event_queue
[event_index
]->retrieved
= TW_AEN_RETRIEVED
;
842 case TW_IOCTL_GET_LOCK
:
843 tw_lock
= (TW_Lock
*)tw_ioctl
->data_buffer
;
844 do_gettimeofday(¤t_time
);
845 current_time_ms
= (current_time
.tv_sec
* 1000) + (current_time
.tv_usec
/ 1000);
847 if ((tw_lock
->force_flag
== 1) || (tw_dev
->ioctl_sem_lock
== 0) || (current_time_ms
>= tw_dev
->ioctl_msec
)) {
848 tw_dev
->ioctl_sem_lock
= 1;
849 tw_dev
->ioctl_msec
= current_time_ms
+ tw_lock
->timeout_msec
;
850 tw_ioctl
->driver_command
.status
= 0;
851 tw_lock
->time_remaining_msec
= tw_lock
->timeout_msec
;
853 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_LOCKED
;
854 tw_lock
->time_remaining_msec
= tw_dev
->ioctl_msec
- current_time_ms
;
857 case TW_IOCTL_RELEASE_LOCK
:
858 if (tw_dev
->ioctl_sem_lock
== 1) {
859 tw_dev
->ioctl_sem_lock
= 0;
860 tw_ioctl
->driver_command
.status
= 0;
862 tw_ioctl
->driver_command
.status
= TW_IOCTL_ERROR_STATUS_NOT_LOCKED
;
866 retval
= TW_IOCTL_ERROR_OS_ENOTTY
;
870 /* Now copy the entire response to userspace */
871 if (copy_to_user(argp
, tw_ioctl
, sizeof(TW_Ioctl_Buf_Apache
) + driver_command
.buffer_length
- 1) == 0)
874 /* Now free ioctl buf memory */
875 dma_free_coherent(&tw_dev
->tw_pci_dev
->dev
, data_buffer_length_adjusted
+sizeof(TW_Ioctl_Buf_Apache
) - 1, cpu_addr
, dma_handle
);
877 mutex_unlock(&tw_dev
->ioctl_lock
);
880 } /* End twa_chrdev_ioctl() */
882 /* This function handles open for the character device */
883 /* NOTE that this function will race with remove. */
884 static int twa_chrdev_open(struct inode
*inode
, struct file
*file
)
886 unsigned int minor_number
;
887 int retval
= TW_IOCTL_ERROR_OS_ENODEV
;
890 minor_number
= iminor(inode
);
891 if (minor_number
>= twa_device_extension_count
)
896 } /* End twa_chrdev_open() */
898 /* This function will print readable messages from status register errors */
899 static int twa_decode_bits(TW_Device_Extension
*tw_dev
, u32 status_reg_value
)
903 /* Check for various error conditions and handle them appropriately */
904 if (status_reg_value
& TW_STATUS_PCI_PARITY_ERROR
) {
905 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0xc, "PCI Parity Error: clearing");
906 writel(TW_CONTROL_CLEAR_PARITY_ERROR
, TW_CONTROL_REG_ADDR(tw_dev
));
909 if (status_reg_value
& TW_STATUS_PCI_ABORT
) {
910 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0xd, "PCI Abort: clearing");
911 writel(TW_CONTROL_CLEAR_PCI_ABORT
, TW_CONTROL_REG_ADDR(tw_dev
));
912 pci_write_config_word(tw_dev
->tw_pci_dev
, PCI_STATUS
, TW_PCI_CLEAR_PCI_ABORT
);
915 if (status_reg_value
& TW_STATUS_QUEUE_ERROR
) {
916 if (((tw_dev
->tw_pci_dev
->device
!= PCI_DEVICE_ID_3WARE_9650SE
) &&
917 (tw_dev
->tw_pci_dev
->device
!= PCI_DEVICE_ID_3WARE_9690SA
)) ||
918 (!test_bit(TW_IN_RESET
, &tw_dev
->flags
)))
919 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0xe, "Controller Queue Error: clearing");
920 writel(TW_CONTROL_CLEAR_QUEUE_ERROR
, TW_CONTROL_REG_ADDR(tw_dev
));
923 if (status_reg_value
& TW_STATUS_MICROCONTROLLER_ERROR
) {
924 if (tw_dev
->reset_print
== 0) {
925 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x10, "Microcontroller Error: clearing");
926 tw_dev
->reset_print
= 1;
933 } /* End twa_decode_bits() */
935 /* This function will empty the response queue */
936 static int twa_empty_response_queue(TW_Device_Extension
*tw_dev
)
938 u32 status_reg_value
, response_que_value
;
939 int count
= 0, retval
= 1;
941 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
943 while (((status_reg_value
& TW_STATUS_RESPONSE_QUEUE_EMPTY
) == 0) && (count
< TW_MAX_RESPONSE_DRAIN
)) {
944 response_que_value
= readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev
));
945 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
948 if (count
== TW_MAX_RESPONSE_DRAIN
)
954 } /* End twa_empty_response_queue() */
956 /* This function will clear the pchip/response queue on 9550SX */
957 static int twa_empty_response_queue_large(TW_Device_Extension
*tw_dev
)
959 u32 response_que_value
= 0;
960 unsigned long before
;
963 if (tw_dev
->tw_pci_dev
->device
!= PCI_DEVICE_ID_3WARE_9000
) {
965 while ((response_que_value
& TW_9550SX_DRAIN_COMPLETED
) != TW_9550SX_DRAIN_COMPLETED
) {
966 response_que_value
= readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev
));
968 if (time_after(jiffies
, before
+ HZ
* 30))
971 /* P-chip settle time */
978 } /* End twa_empty_response_queue_large() */
980 /* This function passes sense keys from firmware to scsi layer */
981 static int twa_fill_sense(TW_Device_Extension
*tw_dev
, int request_id
, int copy_sense
, int print_host
)
983 TW_Command_Full
*full_command_packet
;
984 unsigned short error
;
988 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
990 /* Check for embedded error string */
991 error_str
= &(full_command_packet
->header
.err_specific_desc
[strlen(full_command_packet
->header
.err_specific_desc
) + 1]);
993 /* Don't print error for Logical unit not supported during rollcall */
994 error
= le16_to_cpu(full_command_packet
->header
.status_block
.error
);
995 if ((error
!= TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED
) && (error
!= TW_ERROR_UNIT_OFFLINE
)) {
997 printk(KERN_WARNING
"3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
998 tw_dev
->host
->host_no
,
999 TW_MESSAGE_SOURCE_CONTROLLER_ERROR
,
1000 full_command_packet
->header
.status_block
.error
,
1001 error_str
[0] == '\0' ?
1002 twa_string_lookup(twa_error_table
,
1003 full_command_packet
->header
.status_block
.error
) : error_str
,
1004 full_command_packet
->header
.err_specific_desc
);
1006 printk(KERN_WARNING
"3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
1007 TW_MESSAGE_SOURCE_CONTROLLER_ERROR
,
1008 full_command_packet
->header
.status_block
.error
,
1009 error_str
[0] == '\0' ?
1010 twa_string_lookup(twa_error_table
,
1011 full_command_packet
->header
.status_block
.error
) : error_str
,
1012 full_command_packet
->header
.err_specific_desc
);
1016 memcpy(tw_dev
->srb
[request_id
]->sense_buffer
, full_command_packet
->header
.sense_data
, TW_SENSE_DATA_LENGTH
);
1017 tw_dev
->srb
[request_id
]->result
= (full_command_packet
->command
.newcommand
.status
<< 1);
1018 retval
= TW_ISR_DONT_RESULT
;
1024 } /* End twa_fill_sense() */
1026 /* This function will free up device extension resources */
1027 static void twa_free_device_extension(TW_Device_Extension
*tw_dev
)
1029 if (tw_dev
->command_packet_virt
[0])
1030 pci_free_consistent(tw_dev
->tw_pci_dev
,
1031 sizeof(TW_Command_Full
)*TW_Q_LENGTH
,
1032 tw_dev
->command_packet_virt
[0],
1033 tw_dev
->command_packet_phys
[0]);
1035 if (tw_dev
->generic_buffer_virt
[0])
1036 pci_free_consistent(tw_dev
->tw_pci_dev
,
1037 TW_SECTOR_SIZE
*TW_Q_LENGTH
,
1038 tw_dev
->generic_buffer_virt
[0],
1039 tw_dev
->generic_buffer_phys
[0]);
1041 kfree(tw_dev
->event_queue
[0]);
1042 } /* End twa_free_device_extension() */
1044 /* This function will free a request id */
1045 static void twa_free_request_id(TW_Device_Extension
*tw_dev
, int request_id
)
1047 tw_dev
->free_queue
[tw_dev
->free_tail
] = request_id
;
1048 tw_dev
->state
[request_id
] = TW_S_FINISHED
;
1049 tw_dev
->free_tail
= (tw_dev
->free_tail
+ 1) % TW_Q_LENGTH
;
1050 } /* End twa_free_request_id() */
1052 /* This function will get parameter table entries from the firmware */
1053 static void *twa_get_param(TW_Device_Extension
*tw_dev
, int request_id
, int table_id
, int parameter_id
, int parameter_size_bytes
)
1055 TW_Command_Full
*full_command_packet
;
1056 TW_Command
*command_packet
;
1057 TW_Param_Apache
*param
;
1058 void *retval
= NULL
;
1060 /* Setup the command packet */
1061 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1062 memset(full_command_packet
, 0, sizeof(TW_Command_Full
));
1063 command_packet
= &full_command_packet
->command
.oldcommand
;
1065 command_packet
->opcode__sgloffset
= TW_OPSGL_IN(2, TW_OP_GET_PARAM
);
1066 command_packet
->size
= TW_COMMAND_SIZE
;
1067 command_packet
->request_id
= request_id
;
1068 command_packet
->byte6_offset
.block_count
= cpu_to_le16(1);
1070 /* Now setup the param */
1071 param
= (TW_Param_Apache
*)tw_dev
->generic_buffer_virt
[request_id
];
1072 memset(param
, 0, TW_SECTOR_SIZE
);
1073 param
->table_id
= cpu_to_le16(table_id
| 0x8000);
1074 param
->parameter_id
= cpu_to_le16(parameter_id
);
1075 param
->parameter_size_bytes
= cpu_to_le16(parameter_size_bytes
);
1077 command_packet
->byte8_offset
.param
.sgl
[0].address
= TW_CPU_TO_SGL(tw_dev
->generic_buffer_phys
[request_id
]);
1078 command_packet
->byte8_offset
.param
.sgl
[0].length
= cpu_to_le32(TW_SECTOR_SIZE
);
1080 /* Post the command packet to the board */
1081 twa_post_command_packet(tw_dev
, request_id
, 1);
1083 /* Poll for completion */
1084 if (twa_poll_response(tw_dev
, request_id
, 30))
1085 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x13, "No valid response during get param")
1087 retval
= (void *)&(param
->data
[0]);
1089 tw_dev
->posted_request_count
--;
1090 tw_dev
->state
[request_id
] = TW_S_INITIAL
;
1093 } /* End twa_get_param() */
1095 /* This function will assign an available request id */
1096 static void twa_get_request_id(TW_Device_Extension
*tw_dev
, int *request_id
)
1098 *request_id
= tw_dev
->free_queue
[tw_dev
->free_head
];
1099 tw_dev
->free_head
= (tw_dev
->free_head
+ 1) % TW_Q_LENGTH
;
1100 tw_dev
->state
[*request_id
] = TW_S_STARTED
;
1101 } /* End twa_get_request_id() */
1103 /* This function will send an initconnection command to controller */
1104 static int twa_initconnection(TW_Device_Extension
*tw_dev
, int message_credits
,
1105 u32 set_features
, unsigned short current_fw_srl
,
1106 unsigned short current_fw_arch_id
,
1107 unsigned short current_fw_branch
,
1108 unsigned short current_fw_build
,
1109 unsigned short *fw_on_ctlr_srl
,
1110 unsigned short *fw_on_ctlr_arch_id
,
1111 unsigned short *fw_on_ctlr_branch
,
1112 unsigned short *fw_on_ctlr_build
,
1113 u32
*init_connect_result
)
1115 TW_Command_Full
*full_command_packet
;
1116 TW_Initconnect
*tw_initconnect
;
1117 int request_id
= 0, retval
= 1;
1119 /* Initialize InitConnection command packet */
1120 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1121 memset(full_command_packet
, 0, sizeof(TW_Command_Full
));
1122 full_command_packet
->header
.header_desc
.size_header
= 128;
1124 tw_initconnect
= (TW_Initconnect
*)&full_command_packet
->command
.oldcommand
;
1125 tw_initconnect
->opcode__reserved
= TW_OPRES_IN(0, TW_OP_INIT_CONNECTION
);
1126 tw_initconnect
->request_id
= request_id
;
1127 tw_initconnect
->message_credits
= cpu_to_le16(message_credits
);
1128 tw_initconnect
->features
= set_features
;
1130 /* Turn on 64-bit sgl support if we need to */
1131 tw_initconnect
->features
|= sizeof(dma_addr_t
) > 4 ? 1 : 0;
1133 tw_initconnect
->features
= cpu_to_le32(tw_initconnect
->features
);
1135 if (set_features
& TW_EXTENDED_INIT_CONNECT
) {
1136 tw_initconnect
->size
= TW_INIT_COMMAND_PACKET_SIZE_EXTENDED
;
1137 tw_initconnect
->fw_srl
= cpu_to_le16(current_fw_srl
);
1138 tw_initconnect
->fw_arch_id
= cpu_to_le16(current_fw_arch_id
);
1139 tw_initconnect
->fw_branch
= cpu_to_le16(current_fw_branch
);
1140 tw_initconnect
->fw_build
= cpu_to_le16(current_fw_build
);
1142 tw_initconnect
->size
= TW_INIT_COMMAND_PACKET_SIZE
;
1144 /* Send command packet to the board */
1145 twa_post_command_packet(tw_dev
, request_id
, 1);
1147 /* Poll for completion */
1148 if (twa_poll_response(tw_dev
, request_id
, 30)) {
1149 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x15, "No valid response during init connection");
1151 if (set_features
& TW_EXTENDED_INIT_CONNECT
) {
1152 *fw_on_ctlr_srl
= le16_to_cpu(tw_initconnect
->fw_srl
);
1153 *fw_on_ctlr_arch_id
= le16_to_cpu(tw_initconnect
->fw_arch_id
);
1154 *fw_on_ctlr_branch
= le16_to_cpu(tw_initconnect
->fw_branch
);
1155 *fw_on_ctlr_build
= le16_to_cpu(tw_initconnect
->fw_build
);
1156 *init_connect_result
= le32_to_cpu(tw_initconnect
->result
);
1161 tw_dev
->posted_request_count
--;
1162 tw_dev
->state
[request_id
] = TW_S_INITIAL
;
1165 } /* End twa_initconnection() */
1167 /* This function will initialize the fields of a device extension */
1168 static int twa_initialize_device_extension(TW_Device_Extension
*tw_dev
)
1172 /* Initialize command packet buffers */
1173 if (twa_allocate_memory(tw_dev
, sizeof(TW_Command_Full
), 0)) {
1174 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x16, "Command packet memory allocation failed");
1178 /* Initialize generic buffer */
1179 if (twa_allocate_memory(tw_dev
, TW_SECTOR_SIZE
, 1)) {
1180 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x17, "Generic memory allocation failed");
1184 /* Allocate event info space */
1185 tw_dev
->event_queue
[0] = kcalloc(TW_Q_LENGTH
, sizeof(TW_Event
), GFP_KERNEL
);
1186 if (!tw_dev
->event_queue
[0]) {
1187 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x18, "Event info memory allocation failed");
1192 for (i
= 0; i
< TW_Q_LENGTH
; i
++) {
1193 tw_dev
->event_queue
[i
] = (TW_Event
*)((unsigned char *)tw_dev
->event_queue
[0] + (i
* sizeof(TW_Event
)));
1194 tw_dev
->free_queue
[i
] = i
;
1195 tw_dev
->state
[i
] = TW_S_INITIAL
;
1198 tw_dev
->pending_head
= TW_Q_START
;
1199 tw_dev
->pending_tail
= TW_Q_START
;
1200 tw_dev
->free_head
= TW_Q_START
;
1201 tw_dev
->free_tail
= TW_Q_START
;
1202 tw_dev
->error_sequence_id
= 1;
1203 tw_dev
->chrdev_request_id
= TW_IOCTL_CHRDEV_FREE
;
1205 mutex_init(&tw_dev
->ioctl_lock
);
1206 init_waitqueue_head(&tw_dev
->ioctl_wqueue
);
1211 } /* End twa_initialize_device_extension() */
1213 /* This function is the interrupt service routine */
1214 static irqreturn_t
twa_interrupt(int irq
, void *dev_instance
)
1216 int request_id
, error
= 0;
1217 u32 status_reg_value
;
1218 TW_Response_Queue response_que
;
1219 TW_Command_Full
*full_command_packet
;
1220 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)dev_instance
;
1223 /* Get the per adapter lock */
1224 spin_lock(tw_dev
->host
->host_lock
);
1226 /* Read the registers */
1227 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1229 /* Check if this is our interrupt, otherwise bail */
1230 if (!(status_reg_value
& TW_STATUS_VALID_INTERRUPT
))
1231 goto twa_interrupt_bail
;
1235 /* If we are resetting, bail */
1236 if (test_bit(TW_IN_RESET
, &tw_dev
->flags
))
1237 goto twa_interrupt_bail
;
1239 /* Check controller for errors */
1240 if (twa_check_bits(status_reg_value
)) {
1241 if (twa_decode_bits(tw_dev
, status_reg_value
)) {
1242 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1243 goto twa_interrupt_bail
;
1247 /* Handle host interrupt */
1248 if (status_reg_value
& TW_STATUS_HOST_INTERRUPT
)
1249 TW_CLEAR_HOST_INTERRUPT(tw_dev
);
1251 /* Handle attention interrupt */
1252 if (status_reg_value
& TW_STATUS_ATTENTION_INTERRUPT
) {
1253 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev
);
1254 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP
, &tw_dev
->flags
))) {
1255 twa_get_request_id(tw_dev
, &request_id
);
1257 error
= twa_aen_read_queue(tw_dev
, request_id
);
1259 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
1260 twa_free_request_id(tw_dev
, request_id
);
1261 clear_bit(TW_IN_ATTENTION_LOOP
, &tw_dev
->flags
);
1266 /* Handle command interrupt */
1267 if (status_reg_value
& TW_STATUS_COMMAND_INTERRUPT
) {
1268 TW_MASK_COMMAND_INTERRUPT(tw_dev
);
1269 /* Drain as many pending commands as we can */
1270 while (tw_dev
->pending_request_count
> 0) {
1271 request_id
= tw_dev
->pending_queue
[tw_dev
->pending_head
];
1272 if (tw_dev
->state
[request_id
] != TW_S_PENDING
) {
1273 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x19, "Found request id that wasn't pending");
1274 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1275 goto twa_interrupt_bail
;
1277 if (twa_post_command_packet(tw_dev
, request_id
, 1)==0) {
1278 tw_dev
->pending_head
= (tw_dev
->pending_head
+ 1) % TW_Q_LENGTH
;
1279 tw_dev
->pending_request_count
--;
1281 /* If we get here, we will continue re-posting on the next command interrupt */
1287 /* Handle response interrupt */
1288 if (status_reg_value
& TW_STATUS_RESPONSE_INTERRUPT
) {
1290 /* Drain the response queue from the board */
1291 while ((status_reg_value
& TW_STATUS_RESPONSE_QUEUE_EMPTY
) == 0) {
1292 /* Complete the response */
1293 response_que
.value
= readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev
));
1294 request_id
= TW_RESID_OUT(response_que
.response_id
);
1295 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1297 /* Check for command packet errors */
1298 if (full_command_packet
->command
.newcommand
.status
!= 0) {
1299 if (tw_dev
->srb
[request_id
] != NULL
) {
1300 error
= twa_fill_sense(tw_dev
, request_id
, 1, 1);
1302 /* Skip ioctl error prints */
1303 if (request_id
!= tw_dev
->chrdev_request_id
) {
1304 error
= twa_fill_sense(tw_dev
, request_id
, 0, 1);
1309 /* Check for correct state */
1310 if (tw_dev
->state
[request_id
] != TW_S_POSTED
) {
1311 if (tw_dev
->srb
[request_id
] != NULL
) {
1312 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1a, "Received a request id that wasn't posted");
1313 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1314 goto twa_interrupt_bail
;
1318 /* Check for internal command completion */
1319 if (tw_dev
->srb
[request_id
] == NULL
) {
1320 if (request_id
!= tw_dev
->chrdev_request_id
) {
1321 if (twa_aen_complete(tw_dev
, request_id
))
1322 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1b, "Error completing AEN during attention interrupt");
1324 tw_dev
->chrdev_request_id
= TW_IOCTL_CHRDEV_FREE
;
1325 wake_up(&tw_dev
->ioctl_wqueue
);
1328 struct scsi_cmnd
*cmd
;
1330 cmd
= tw_dev
->srb
[request_id
];
1332 twa_scsiop_execute_scsi_complete(tw_dev
, request_id
);
1333 /* If no error command was a success */
1335 cmd
->result
= (DID_OK
<< 16);
1338 /* If error, command failed */
1340 /* Ask for a host reset */
1341 cmd
->result
= (DID_OK
<< 16) | (CHECK_CONDITION
<< 1);
1344 /* Report residual bytes for single sgl */
1345 if ((scsi_sg_count(cmd
) <= 1) && (full_command_packet
->command
.newcommand
.status
== 0)) {
1346 if (full_command_packet
->command
.newcommand
.sg_list
[0].length
< scsi_bufflen(tw_dev
->srb
[request_id
]))
1347 scsi_set_resid(cmd
, scsi_bufflen(cmd
) - full_command_packet
->command
.newcommand
.sg_list
[0].length
);
1350 /* Now complete the io */
1351 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
1352 twa_free_request_id(tw_dev
, request_id
);
1353 tw_dev
->posted_request_count
--;
1354 tw_dev
->srb
[request_id
]->scsi_done(tw_dev
->srb
[request_id
]);
1355 twa_unmap_scsi_data(tw_dev
, request_id
);
1358 /* Check for valid status after each drain */
1359 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1360 if (twa_check_bits(status_reg_value
)) {
1361 if (twa_decode_bits(tw_dev
, status_reg_value
)) {
1362 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1363 goto twa_interrupt_bail
;
1370 spin_unlock(tw_dev
->host
->host_lock
);
1371 return IRQ_RETVAL(handled
);
1372 } /* End twa_interrupt() */
1374 /* This function will load the request id and various sgls for ioctls */
1375 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
)
1377 TW_Command
*oldcommand
;
1378 TW_Command_Apache
*newcommand
;
1380 unsigned int pae
= 0;
1382 if ((sizeof(long) < 8) && (sizeof(dma_addr_t
) > 4))
1385 if (TW_OP_OUT(full_command_packet
->command
.newcommand
.opcode__reserved
) == TW_OP_EXECUTE_SCSI
) {
1386 newcommand
= &full_command_packet
->command
.newcommand
;
1387 newcommand
->request_id__lunl
=
1388 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand
->request_id__lunl
), request_id
));
1390 newcommand
->sg_list
[0].address
= TW_CPU_TO_SGL(dma_handle
+ sizeof(TW_Ioctl_Buf_Apache
) - 1);
1391 newcommand
->sg_list
[0].length
= cpu_to_le32(length
);
1393 newcommand
->sgl_entries__lunh
=
1394 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand
->sgl_entries__lunh
), length
? 1 : 0));
1396 oldcommand
= &full_command_packet
->command
.oldcommand
;
1397 oldcommand
->request_id
= request_id
;
1399 if (TW_SGL_OUT(oldcommand
->opcode__sgloffset
)) {
1400 /* Load the sg list */
1401 if (tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9690SA
)
1402 sgl
= (TW_SG_Entry
*)((u32
*)oldcommand
+oldcommand
->size
- (sizeof(TW_SG_Entry
)/4) + pae
);
1404 sgl
= (TW_SG_Entry
*)((u32
*)oldcommand
+TW_SGL_OUT(oldcommand
->opcode__sgloffset
));
1405 sgl
->address
= TW_CPU_TO_SGL(dma_handle
+ sizeof(TW_Ioctl_Buf_Apache
) - 1);
1406 sgl
->length
= cpu_to_le32(length
);
1408 oldcommand
->size
+= pae
;
1411 } /* End twa_load_sgl() */
1413 /* This function will perform a pci-dma mapping for a scatter gather list */
1414 static int twa_map_scsi_sg_data(TW_Device_Extension
*tw_dev
, int request_id
)
1417 struct scsi_cmnd
*cmd
= tw_dev
->srb
[request_id
];
1419 use_sg
= scsi_dma_map(cmd
);
1422 else if (use_sg
< 0) {
1423 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1c, "Failed to map scatter gather list");
1427 cmd
->SCp
.phase
= TW_PHASE_SGLIST
;
1428 cmd
->SCp
.have_data_in
= use_sg
;
1431 } /* End twa_map_scsi_sg_data() */
1433 /* This function will poll for a response interrupt of a request */
1434 static int twa_poll_response(TW_Device_Extension
*tw_dev
, int request_id
, int seconds
)
1436 int retval
= 1, found
= 0, response_request_id
;
1437 TW_Response_Queue response_queue
;
1438 TW_Command_Full
*full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1440 if (twa_poll_status_gone(tw_dev
, TW_STATUS_RESPONSE_QUEUE_EMPTY
, seconds
) == 0) {
1441 response_queue
.value
= readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev
));
1442 response_request_id
= TW_RESID_OUT(response_queue
.response_id
);
1443 if (request_id
!= response_request_id
) {
1444 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1e, "Found unexpected request id while polling for response");
1447 if (TW_OP_OUT(full_command_packet
->command
.newcommand
.opcode__reserved
) == TW_OP_EXECUTE_SCSI
) {
1448 if (full_command_packet
->command
.newcommand
.status
!= 0) {
1450 twa_fill_sense(tw_dev
, request_id
, 0, 0);
1455 if (full_command_packet
->command
.oldcommand
.status
!= 0) {
1457 twa_fill_sense(tw_dev
, request_id
, 0, 0);
1468 } /* End twa_poll_response() */
1470 /* This function will poll the status register for a flag */
1471 static int twa_poll_status(TW_Device_Extension
*tw_dev
, u32 flag
, int seconds
)
1473 u32 status_reg_value
;
1474 unsigned long before
;
1477 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1480 if (twa_check_bits(status_reg_value
))
1481 twa_decode_bits(tw_dev
, status_reg_value
);
1483 while ((status_reg_value
& flag
) != flag
) {
1484 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1486 if (twa_check_bits(status_reg_value
))
1487 twa_decode_bits(tw_dev
, status_reg_value
);
1489 if (time_after(jiffies
, before
+ HZ
* seconds
))
1497 } /* End twa_poll_status() */
1499 /* This function will poll the status register for disappearance of a flag */
1500 static int twa_poll_status_gone(TW_Device_Extension
*tw_dev
, u32 flag
, int seconds
)
1502 u32 status_reg_value
;
1503 unsigned long before
;
1506 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1509 if (twa_check_bits(status_reg_value
))
1510 twa_decode_bits(tw_dev
, status_reg_value
);
1512 while ((status_reg_value
& flag
) != 0) {
1513 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1514 if (twa_check_bits(status_reg_value
))
1515 twa_decode_bits(tw_dev
, status_reg_value
);
1517 if (time_after(jiffies
, before
+ HZ
* seconds
))
1525 } /* End twa_poll_status_gone() */
1527 /* This function will attempt to post a command packet to the board */
1528 static int twa_post_command_packet(TW_Device_Extension
*tw_dev
, int request_id
, char internal
)
1530 u32 status_reg_value
;
1531 dma_addr_t command_que_value
;
1534 command_que_value
= tw_dev
->command_packet_phys
[request_id
];
1536 /* For 9650SE write low 4 bytes first */
1537 if ((tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9650SE
) ||
1538 (tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9690SA
)) {
1539 command_que_value
+= TW_COMMAND_OFFSET
;
1540 writel((u32
)command_que_value
, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev
));
1543 status_reg_value
= readl(TW_STATUS_REG_ADDR(tw_dev
));
1545 if (twa_check_bits(status_reg_value
))
1546 twa_decode_bits(tw_dev
, status_reg_value
);
1548 if (((tw_dev
->pending_request_count
> 0) && (tw_dev
->state
[request_id
] != TW_S_PENDING
)) || (status_reg_value
& TW_STATUS_COMMAND_QUEUE_FULL
)) {
1550 /* Only pend internal driver commands */
1552 retval
= SCSI_MLQUEUE_HOST_BUSY
;
1556 /* Couldn't post the command packet, so we do it later */
1557 if (tw_dev
->state
[request_id
] != TW_S_PENDING
) {
1558 tw_dev
->state
[request_id
] = TW_S_PENDING
;
1559 tw_dev
->pending_request_count
++;
1560 if (tw_dev
->pending_request_count
> tw_dev
->max_pending_request_count
) {
1561 tw_dev
->max_pending_request_count
= tw_dev
->pending_request_count
;
1563 tw_dev
->pending_queue
[tw_dev
->pending_tail
] = request_id
;
1564 tw_dev
->pending_tail
= (tw_dev
->pending_tail
+ 1) % TW_Q_LENGTH
;
1566 TW_UNMASK_COMMAND_INTERRUPT(tw_dev
);
1569 if ((tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9650SE
) ||
1570 (tw_dev
->tw_pci_dev
->device
== PCI_DEVICE_ID_3WARE_9690SA
)) {
1571 /* Now write upper 4 bytes */
1572 writel((u32
)((u64
)command_que_value
>> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev
) + 0x4);
1574 if (sizeof(dma_addr_t
) > 4) {
1575 command_que_value
+= TW_COMMAND_OFFSET
;
1576 writel((u32
)command_que_value
, TW_COMMAND_QUEUE_REG_ADDR(tw_dev
));
1577 writel((u32
)((u64
)command_que_value
>> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev
) + 0x4);
1579 writel(TW_COMMAND_OFFSET
+ command_que_value
, TW_COMMAND_QUEUE_REG_ADDR(tw_dev
));
1582 tw_dev
->state
[request_id
] = TW_S_POSTED
;
1583 tw_dev
->posted_request_count
++;
1584 if (tw_dev
->posted_request_count
> tw_dev
->max_posted_request_count
) {
1585 tw_dev
->max_posted_request_count
= tw_dev
->posted_request_count
;
1591 } /* End twa_post_command_packet() */
1593 /* This function will reset a device extension */
1594 static int twa_reset_device_extension(TW_Device_Extension
*tw_dev
)
1598 unsigned long flags
= 0;
1600 set_bit(TW_IN_RESET
, &tw_dev
->flags
);
1601 TW_DISABLE_INTERRUPTS(tw_dev
);
1602 TW_MASK_COMMAND_INTERRUPT(tw_dev
);
1603 spin_lock_irqsave(tw_dev
->host
->host_lock
, flags
);
1605 /* Abort all requests that are in progress */
1606 for (i
= 0; i
< TW_Q_LENGTH
; i
++) {
1607 if ((tw_dev
->state
[i
] != TW_S_FINISHED
) &&
1608 (tw_dev
->state
[i
] != TW_S_INITIAL
) &&
1609 (tw_dev
->state
[i
] != TW_S_COMPLETED
)) {
1610 if (tw_dev
->srb
[i
]) {
1611 tw_dev
->srb
[i
]->result
= (DID_RESET
<< 16);
1612 tw_dev
->srb
[i
]->scsi_done(tw_dev
->srb
[i
]);
1613 twa_unmap_scsi_data(tw_dev
, i
);
1618 /* Reset queues and counts */
1619 for (i
= 0; i
< TW_Q_LENGTH
; i
++) {
1620 tw_dev
->free_queue
[i
] = i
;
1621 tw_dev
->state
[i
] = TW_S_INITIAL
;
1623 tw_dev
->free_head
= TW_Q_START
;
1624 tw_dev
->free_tail
= TW_Q_START
;
1625 tw_dev
->posted_request_count
= 0;
1626 tw_dev
->pending_request_count
= 0;
1627 tw_dev
->pending_head
= TW_Q_START
;
1628 tw_dev
->pending_tail
= TW_Q_START
;
1629 tw_dev
->reset_print
= 0;
1631 spin_unlock_irqrestore(tw_dev
->host
->host_lock
, flags
);
1633 if (twa_reset_sequence(tw_dev
, 1))
1636 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev
);
1637 clear_bit(TW_IN_RESET
, &tw_dev
->flags
);
1638 tw_dev
->chrdev_request_id
= TW_IOCTL_CHRDEV_FREE
;
1643 } /* End twa_reset_device_extension() */
1645 /* This function will reset a controller */
1646 static int twa_reset_sequence(TW_Device_Extension
*tw_dev
, int soft_reset
)
1648 int tries
= 0, retval
= 1, flashed
= 0, do_soft_reset
= soft_reset
;
1650 while (tries
< TW_MAX_RESET_TRIES
) {
1651 if (do_soft_reset
) {
1652 TW_SOFT_RESET(tw_dev
);
1653 /* Clear pchip/response queue on 9550SX */
1654 if (twa_empty_response_queue_large(tw_dev
)) {
1655 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x36, "Response queue (large) empty failed during reset sequence");
1662 /* Make sure controller is in a good state */
1663 if (twa_poll_status(tw_dev
, TW_STATUS_MICROCONTROLLER_READY
| (do_soft_reset
== 1 ? TW_STATUS_ATTENTION_INTERRUPT
: 0), 60)) {
1664 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x1f, "Microcontroller not ready during reset sequence");
1670 /* Empty response queue */
1671 if (twa_empty_response_queue(tw_dev
)) {
1672 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x20, "Response queue empty failed during reset sequence");
1680 /* Check for compatibility/flash */
1681 if (twa_check_srl(tw_dev
, &flashed
)) {
1682 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x21, "Compatibility check failed during reset sequence");
1693 /* Drain the AEN queue */
1694 if (twa_aen_drain_queue(tw_dev
, soft_reset
)) {
1695 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x22, "AEN drain failed during reset sequence");
1701 /* If we got here, controller is in a good state */
1707 } /* End twa_reset_sequence() */
1709 /* This funciton returns unit geometry in cylinders/heads/sectors */
1710 static int twa_scsi_biosparam(struct scsi_device
*sdev
, struct block_device
*bdev
, sector_t capacity
, int geom
[])
1712 int heads
, sectors
, cylinders
;
1713 TW_Device_Extension
*tw_dev
;
1715 tw_dev
= (TW_Device_Extension
*)sdev
->host
->hostdata
;
1717 if (capacity
>= 0x200000) {
1720 cylinders
= sector_div(capacity
, heads
* sectors
);
1724 cylinders
= sector_div(capacity
, heads
* sectors
);
1729 geom
[2] = cylinders
;
1732 } /* End twa_scsi_biosparam() */
1734 /* This is the new scsi eh reset function */
1735 static int twa_scsi_eh_reset(struct scsi_cmnd
*SCpnt
)
1737 TW_Device_Extension
*tw_dev
= NULL
;
1738 int retval
= FAILED
;
1740 tw_dev
= (TW_Device_Extension
*)SCpnt
->device
->host
->hostdata
;
1742 tw_dev
->num_resets
++;
1744 sdev_printk(KERN_WARNING
, SCpnt
->device
,
1745 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1746 TW_DRIVER
, 0x2c, SCpnt
->cmnd
[0]);
1748 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1749 mutex_lock(&tw_dev
->ioctl_lock
);
1751 /* Now reset the card and some of the device extension data */
1752 if (twa_reset_device_extension(tw_dev
)) {
1753 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x2b, "Controller reset failed during scsi host reset");
1759 mutex_unlock(&tw_dev
->ioctl_lock
);
1761 } /* End twa_scsi_eh_reset() */
1763 /* This is the main scsi queue function to handle scsi opcodes */
1764 static int twa_scsi_queue(struct scsi_cmnd
*SCpnt
, void (*done
)(struct scsi_cmnd
*))
1766 int request_id
, retval
;
1767 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)SCpnt
->device
->host
->hostdata
;
1769 /* If we are resetting due to timed out ioctl, report as busy */
1770 if (test_bit(TW_IN_RESET
, &tw_dev
->flags
)) {
1771 retval
= SCSI_MLQUEUE_HOST_BUSY
;
1775 /* Check if this FW supports luns */
1776 if ((SCpnt
->device
->lun
!= 0) && (tw_dev
->tw_compat_info
.working_srl
< TW_FW_SRL_LUNS_SUPPORTED
)) {
1777 SCpnt
->result
= (DID_BAD_TARGET
<< 16);
1783 /* Save done function into scsi_cmnd struct */
1784 SCpnt
->scsi_done
= done
;
1786 /* Get a free request id */
1787 twa_get_request_id(tw_dev
, &request_id
);
1789 /* Save the scsi command for use by the ISR */
1790 tw_dev
->srb
[request_id
] = SCpnt
;
1792 /* Initialize phase to zero */
1793 SCpnt
->SCp
.phase
= TW_PHASE_INITIAL
;
1795 retval
= twa_scsiop_execute_scsi(tw_dev
, request_id
, NULL
, 0, NULL
);
1797 case SCSI_MLQUEUE_HOST_BUSY
:
1798 twa_free_request_id(tw_dev
, request_id
);
1801 tw_dev
->state
[request_id
] = TW_S_COMPLETED
;
1802 twa_free_request_id(tw_dev
, request_id
);
1803 SCpnt
->result
= (DID_ERROR
<< 16);
1809 } /* End twa_scsi_queue() */
1811 /* This function hands scsi cdb's to the firmware */
1812 static int twa_scsiop_execute_scsi(TW_Device_Extension
*tw_dev
, int request_id
, char *cdb
, int use_sg
, TW_SG_Entry
*sglistarg
)
1814 TW_Command_Full
*full_command_packet
;
1815 TW_Command_Apache
*command_packet
;
1816 u32 num_sectors
= 0x0;
1818 struct scsi_cmnd
*srb
= NULL
;
1819 struct scatterlist
*sglist
= NULL
, *sg
;
1822 if (tw_dev
->srb
[request_id
]) {
1823 srb
= tw_dev
->srb
[request_id
];
1824 if (scsi_sglist(srb
))
1825 sglist
= scsi_sglist(srb
);
1828 /* Initialize command packet */
1829 full_command_packet
= tw_dev
->command_packet_virt
[request_id
];
1830 full_command_packet
->header
.header_desc
.size_header
= 128;
1831 full_command_packet
->header
.status_block
.error
= 0;
1832 full_command_packet
->header
.status_block
.severity__reserved
= 0;
1834 command_packet
= &full_command_packet
->command
.newcommand
;
1835 command_packet
->status
= 0;
1836 command_packet
->opcode__reserved
= TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI
);
1838 /* We forced 16 byte cdb use earlier */
1840 memcpy(command_packet
->cdb
, srb
->cmnd
, TW_MAX_CDB_LEN
);
1842 memcpy(command_packet
->cdb
, cdb
, TW_MAX_CDB_LEN
);
1845 command_packet
->unit
= srb
->device
->id
;
1846 command_packet
->request_id__lunl
=
1847 cpu_to_le16(TW_REQ_LUN_IN(srb
->device
->lun
, request_id
));
1849 command_packet
->request_id__lunl
=
1850 cpu_to_le16(TW_REQ_LUN_IN(0, request_id
));
1851 command_packet
->unit
= 0;
1854 command_packet
->sgl_offset
= 16;
1857 /* Map sglist from scsi layer to cmd packet */
1859 if (scsi_sg_count(srb
)) {
1860 if ((scsi_sg_count(srb
) == 1) &&
1861 (scsi_bufflen(srb
) < TW_MIN_SGL_LENGTH
)) {
1862 if (srb
->sc_data_direction
== DMA_TO_DEVICE
||
1863 srb
->sc_data_direction
== DMA_BIDIRECTIONAL
)
1864 scsi_sg_copy_to_buffer(srb
,
1865 tw_dev
->generic_buffer_virt
[request_id
],
1867 command_packet
->sg_list
[0].address
= TW_CPU_TO_SGL(tw_dev
->generic_buffer_phys
[request_id
]);
1868 command_packet
->sg_list
[0].length
= cpu_to_le32(TW_MIN_SGL_LENGTH
);
1870 sg_count
= twa_map_scsi_sg_data(tw_dev
, request_id
);
1874 scsi_for_each_sg(srb
, sg
, sg_count
, i
) {
1875 command_packet
->sg_list
[i
].address
= TW_CPU_TO_SGL(sg_dma_address(sg
));
1876 command_packet
->sg_list
[i
].length
= cpu_to_le32(sg_dma_len(sg
));
1877 if (command_packet
->sg_list
[i
].address
& TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL
)) {
1878 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x2e, "Found unaligned sgl address during execute scsi");
1883 command_packet
->sgl_entries__lunh
= cpu_to_le16(TW_REQ_LUN_IN((srb
->device
->lun
>> 4), scsi_sg_count(tw_dev
->srb
[request_id
])));
1886 /* Internal cdb post */
1887 for (i
= 0; i
< use_sg
; i
++) {
1888 command_packet
->sg_list
[i
].address
= TW_CPU_TO_SGL(sglistarg
[i
].address
);
1889 command_packet
->sg_list
[i
].length
= cpu_to_le32(sglistarg
[i
].length
);
1890 if (command_packet
->sg_list
[i
].address
& TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL
)) {
1891 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x2f, "Found unaligned sgl address during internal post");
1895 command_packet
->sgl_entries__lunh
= cpu_to_le16(TW_REQ_LUN_IN(0, use_sg
));
1899 if (srb
->cmnd
[0] == READ_6
|| srb
->cmnd
[0] == WRITE_6
)
1900 num_sectors
= (u32
)srb
->cmnd
[4];
1902 if (srb
->cmnd
[0] == READ_10
|| srb
->cmnd
[0] == WRITE_10
)
1903 num_sectors
= (u32
)srb
->cmnd
[8] | ((u32
)srb
->cmnd
[7] << 8);
1906 /* Update sector statistic */
1907 tw_dev
->sector_count
= num_sectors
;
1908 if (tw_dev
->sector_count
> tw_dev
->max_sector_count
)
1909 tw_dev
->max_sector_count
= tw_dev
->sector_count
;
1911 /* Update SG statistics */
1913 tw_dev
->sgl_entries
= scsi_sg_count(tw_dev
->srb
[request_id
]);
1914 if (tw_dev
->sgl_entries
> tw_dev
->max_sgl_entries
)
1915 tw_dev
->max_sgl_entries
= tw_dev
->sgl_entries
;
1918 /* Now post the command to the board */
1920 retval
= twa_post_command_packet(tw_dev
, request_id
, 0);
1922 twa_post_command_packet(tw_dev
, request_id
, 1);
1927 } /* End twa_scsiop_execute_scsi() */
1929 /* This function completes an execute scsi operation */
1930 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension
*tw_dev
, int request_id
)
1932 struct scsi_cmnd
*cmd
= tw_dev
->srb
[request_id
];
1934 if (scsi_bufflen(cmd
) < TW_MIN_SGL_LENGTH
&&
1935 (cmd
->sc_data_direction
== DMA_FROM_DEVICE
||
1936 cmd
->sc_data_direction
== DMA_BIDIRECTIONAL
)) {
1937 if (scsi_sg_count(cmd
) == 1) {
1938 void *buf
= tw_dev
->generic_buffer_virt
[request_id
];
1940 scsi_sg_copy_from_buffer(cmd
, buf
, TW_SECTOR_SIZE
);
1943 } /* End twa_scsiop_execute_scsi_complete() */
1945 /* This function tells the controller to shut down */
1946 static void __twa_shutdown(TW_Device_Extension
*tw_dev
)
1948 /* Disable interrupts */
1949 TW_DISABLE_INTERRUPTS(tw_dev
);
1951 /* Free up the IRQ */
1952 free_irq(tw_dev
->tw_pci_dev
->irq
, tw_dev
);
1954 printk(KERN_WARNING
"3w-9xxx: Shutting down host %d.\n", tw_dev
->host
->host_no
);
1956 /* Tell the card we are shutting down */
1957 if (twa_initconnection(tw_dev
, 1, 0, 0, 0, 0, 0, NULL
, NULL
, NULL
, NULL
, NULL
)) {
1958 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x31, "Connection shutdown failed");
1960 printk(KERN_WARNING
"3w-9xxx: Shutdown complete.\n");
1963 /* Clear all interrupts just before exit */
1964 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
1965 } /* End __twa_shutdown() */
1967 /* Wrapper for __twa_shutdown */
1968 static void twa_shutdown(struct pci_dev
*pdev
)
1970 struct Scsi_Host
*host
= pci_get_drvdata(pdev
);
1971 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)host
->hostdata
;
1973 __twa_shutdown(tw_dev
);
1974 } /* End twa_shutdown() */
1976 /* This function will look up a string */
1977 static char *twa_string_lookup(twa_message_type
*table
, unsigned int code
)
1981 for (index
= 0; ((code
!= table
[index
].code
) &&
1982 (table
[index
].text
!= (char *)0)); index
++);
1983 return(table
[index
].text
);
1984 } /* End twa_string_lookup() */
1986 /* This function will perform a pci-dma unmap */
1987 static void twa_unmap_scsi_data(TW_Device_Extension
*tw_dev
, int request_id
)
1989 struct scsi_cmnd
*cmd
= tw_dev
->srb
[request_id
];
1991 if (cmd
->SCp
.phase
== TW_PHASE_SGLIST
)
1992 scsi_dma_unmap(cmd
);
1993 } /* End twa_unmap_scsi_data() */
1995 /* This function gets called when a disk is coming on-line */
1996 static int twa_slave_configure(struct scsi_device
*sdev
)
1998 /* Force 60 second timeout */
1999 blk_queue_rq_timeout(sdev
->request_queue
, 60 * HZ
);
2002 } /* End twa_slave_configure() */
2004 /* scsi_host_template initializer */
2005 static struct scsi_host_template driver_template
= {
2006 .module
= THIS_MODULE
,
2007 .name
= "3ware 9000 Storage Controller",
2008 .queuecommand
= twa_scsi_queue
,
2009 .eh_host_reset_handler
= twa_scsi_eh_reset
,
2010 .bios_param
= twa_scsi_biosparam
,
2011 .change_queue_depth
= twa_change_queue_depth
,
2012 .can_queue
= TW_Q_LENGTH
-2,
2013 .slave_configure
= twa_slave_configure
,
2015 .sg_tablesize
= TW_APACHE_MAX_SGL_LENGTH
,
2016 .max_sectors
= TW_MAX_SECTORS
,
2017 .cmd_per_lun
= TW_MAX_CMDS_PER_LUN
,
2018 .use_clustering
= ENABLE_CLUSTERING
,
2019 .shost_attrs
= twa_host_attrs
,
2023 /* This function will probe and initialize a card */
2024 static int __devinit
twa_probe(struct pci_dev
*pdev
, const struct pci_device_id
*dev_id
)
2026 struct Scsi_Host
*host
= NULL
;
2027 TW_Device_Extension
*tw_dev
;
2028 unsigned long mem_addr
, mem_len
;
2029 int retval
= -ENODEV
;
2031 retval
= pci_enable_device(pdev
);
2033 TW_PRINTK(host
, TW_DRIVER
, 0x34, "Failed to enable pci device");
2034 goto out_disable_device
;
2037 pci_set_master(pdev
);
2038 pci_try_set_mwi(pdev
);
2040 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(64))
2041 || pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64)))
2042 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32))
2043 || pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32))) {
2044 TW_PRINTK(host
, TW_DRIVER
, 0x23, "Failed to set dma mask");
2046 goto out_disable_device
;
2049 host
= scsi_host_alloc(&driver_template
, sizeof(TW_Device_Extension
));
2051 TW_PRINTK(host
, TW_DRIVER
, 0x24, "Failed to allocate memory for device extension");
2053 goto out_disable_device
;
2055 tw_dev
= (TW_Device_Extension
*)host
->hostdata
;
2057 /* Save values to device extension */
2058 tw_dev
->host
= host
;
2059 tw_dev
->tw_pci_dev
= pdev
;
2061 if (twa_initialize_device_extension(tw_dev
)) {
2062 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x25, "Failed to initialize device extension");
2063 goto out_free_device_extension
;
2066 /* Request IO regions */
2067 retval
= pci_request_regions(pdev
, "3w-9xxx");
2069 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x26, "Failed to get mem region");
2070 goto out_free_device_extension
;
2073 if (pdev
->device
== PCI_DEVICE_ID_3WARE_9000
) {
2074 mem_addr
= pci_resource_start(pdev
, 1);
2075 mem_len
= pci_resource_len(pdev
, 1);
2077 mem_addr
= pci_resource_start(pdev
, 2);
2078 mem_len
= pci_resource_len(pdev
, 2);
2081 /* Save base address */
2082 tw_dev
->base_addr
= ioremap(mem_addr
, mem_len
);
2083 if (!tw_dev
->base_addr
) {
2084 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x35, "Failed to ioremap");
2085 goto out_release_mem_region
;
2088 /* Disable interrupts on the card */
2089 TW_DISABLE_INTERRUPTS(tw_dev
);
2091 /* Initialize the card */
2092 if (twa_reset_sequence(tw_dev
, 0))
2095 /* Set host specific parameters */
2096 if ((pdev
->device
== PCI_DEVICE_ID_3WARE_9650SE
) ||
2097 (pdev
->device
== PCI_DEVICE_ID_3WARE_9690SA
))
2098 host
->max_id
= TW_MAX_UNITS_9650SE
;
2100 host
->max_id
= TW_MAX_UNITS
;
2102 host
->max_cmd_len
= TW_MAX_CDB_LEN
;
2104 /* Channels aren't supported by adapter */
2105 host
->max_lun
= TW_MAX_LUNS(tw_dev
->tw_compat_info
.working_srl
);
2106 host
->max_channel
= 0;
2108 /* Register the card with the kernel SCSI layer */
2109 retval
= scsi_add_host(host
, &pdev
->dev
);
2111 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x27, "scsi add host failed");
2115 pci_set_drvdata(pdev
, host
);
2117 printk(KERN_WARNING
"3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%lx, IRQ: %d.\n",
2118 host
->host_no
, mem_addr
, pdev
->irq
);
2119 printk(KERN_WARNING
"3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2121 (char *)twa_get_param(tw_dev
, 0, TW_VERSION_TABLE
,
2122 TW_PARAM_FWVER
, TW_PARAM_FWVER_LENGTH
),
2123 (char *)twa_get_param(tw_dev
, 1, TW_VERSION_TABLE
,
2124 TW_PARAM_BIOSVER
, TW_PARAM_BIOSVER_LENGTH
),
2125 le32_to_cpu(*(int *)twa_get_param(tw_dev
, 2, TW_INFORMATION_TABLE
,
2126 TW_PARAM_PORTCOUNT
, TW_PARAM_PORTCOUNT_LENGTH
)));
2128 /* Try to enable MSI */
2129 if (use_msi
&& (pdev
->device
!= PCI_DEVICE_ID_3WARE_9000
) &&
2130 !pci_enable_msi(pdev
))
2131 set_bit(TW_USING_MSI
, &tw_dev
->flags
);
2133 /* Now setup the interrupt handler */
2134 retval
= request_irq(pdev
->irq
, twa_interrupt
, IRQF_SHARED
, "3w-9xxx", tw_dev
);
2136 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x30, "Error requesting IRQ");
2137 goto out_remove_host
;
2140 twa_device_extension_list
[twa_device_extension_count
] = tw_dev
;
2141 twa_device_extension_count
++;
2143 /* Re-enable interrupts on the card */
2144 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev
);
2146 /* Finally, scan the host */
2147 scsi_scan_host(host
);
2149 if (twa_major
== -1) {
2150 if ((twa_major
= register_chrdev (0, "twa", &twa_fops
)) < 0)
2151 TW_PRINTK(host
, TW_DRIVER
, 0x29, "Failed to register character device");
2156 if (test_bit(TW_USING_MSI
, &tw_dev
->flags
))
2157 pci_disable_msi(pdev
);
2158 scsi_remove_host(host
);
2160 iounmap(tw_dev
->base_addr
);
2161 out_release_mem_region
:
2162 pci_release_regions(pdev
);
2163 out_free_device_extension
:
2164 twa_free_device_extension(tw_dev
);
2165 scsi_host_put(host
);
2167 pci_disable_device(pdev
);
2170 } /* End twa_probe() */
2172 /* This function is called to remove a device */
2173 static void twa_remove(struct pci_dev
*pdev
)
2175 struct Scsi_Host
*host
= pci_get_drvdata(pdev
);
2176 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)host
->hostdata
;
2178 scsi_remove_host(tw_dev
->host
);
2180 /* Unregister character device */
2181 if (twa_major
>= 0) {
2182 unregister_chrdev(twa_major
, "twa");
2186 /* Shutdown the card */
2187 __twa_shutdown(tw_dev
);
2189 /* Disable MSI if enabled */
2190 if (test_bit(TW_USING_MSI
, &tw_dev
->flags
))
2191 pci_disable_msi(pdev
);
2193 /* Free IO remapping */
2194 iounmap(tw_dev
->base_addr
);
2196 /* Free up the mem region */
2197 pci_release_regions(pdev
);
2199 /* Free up device extension resources */
2200 twa_free_device_extension(tw_dev
);
2202 scsi_host_put(tw_dev
->host
);
2203 pci_disable_device(pdev
);
2204 twa_device_extension_count
--;
2205 } /* End twa_remove() */
2208 /* This function is called on PCI suspend */
2209 static int twa_suspend(struct pci_dev
*pdev
, pm_message_t state
)
2211 struct Scsi_Host
*host
= pci_get_drvdata(pdev
);
2212 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)host
->hostdata
;
2214 printk(KERN_WARNING
"3w-9xxx: Suspending host %d.\n", tw_dev
->host
->host_no
);
2216 TW_DISABLE_INTERRUPTS(tw_dev
);
2217 free_irq(tw_dev
->tw_pci_dev
->irq
, tw_dev
);
2219 if (test_bit(TW_USING_MSI
, &tw_dev
->flags
))
2220 pci_disable_msi(pdev
);
2222 /* Tell the card we are shutting down */
2223 if (twa_initconnection(tw_dev
, 1, 0, 0, 0, 0, 0, NULL
, NULL
, NULL
, NULL
, NULL
)) {
2224 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x38, "Connection shutdown failed during suspend");
2226 printk(KERN_WARNING
"3w-9xxx: Suspend complete.\n");
2228 TW_CLEAR_ALL_INTERRUPTS(tw_dev
);
2230 pci_save_state(pdev
);
2231 pci_disable_device(pdev
);
2232 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
2235 } /* End twa_suspend() */
2237 /* This function is called on PCI resume */
2238 static int twa_resume(struct pci_dev
*pdev
)
2241 struct Scsi_Host
*host
= pci_get_drvdata(pdev
);
2242 TW_Device_Extension
*tw_dev
= (TW_Device_Extension
*)host
->hostdata
;
2244 printk(KERN_WARNING
"3w-9xxx: Resuming host %d.\n", tw_dev
->host
->host_no
);
2245 pci_set_power_state(pdev
, PCI_D0
);
2246 pci_enable_wake(pdev
, PCI_D0
, 0);
2247 pci_restore_state(pdev
);
2249 retval
= pci_enable_device(pdev
);
2251 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x39, "Enable device failed during resume");
2255 pci_set_master(pdev
);
2256 pci_try_set_mwi(pdev
);
2258 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(64))
2259 || pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64)))
2260 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32))
2261 || pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32))) {
2262 TW_PRINTK(host
, TW_DRIVER
, 0x40, "Failed to set dma mask during resume");
2264 goto out_disable_device
;
2267 /* Initialize the card */
2268 if (twa_reset_sequence(tw_dev
, 0)) {
2270 goto out_disable_device
;
2273 /* Now setup the interrupt handler */
2274 retval
= request_irq(pdev
->irq
, twa_interrupt
, IRQF_SHARED
, "3w-9xxx", tw_dev
);
2276 TW_PRINTK(tw_dev
->host
, TW_DRIVER
, 0x42, "Error requesting IRQ during resume");
2278 goto out_disable_device
;
2281 /* Now enable MSI if enabled */
2282 if (test_bit(TW_USING_MSI
, &tw_dev
->flags
))
2283 pci_enable_msi(pdev
);
2285 /* Re-enable interrupts on the card */
2286 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev
);
2288 printk(KERN_WARNING
"3w-9xxx: Resume complete.\n");
2292 scsi_remove_host(host
);
2293 pci_disable_device(pdev
);
2296 } /* End twa_resume() */
2299 /* PCI Devices supported by this driver */
2300 static struct pci_device_id twa_pci_tbl
[] __devinitdata
= {
2301 { PCI_VENDOR_ID_3WARE
, PCI_DEVICE_ID_3WARE_9000
,
2302 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2303 { PCI_VENDOR_ID_3WARE
, PCI_DEVICE_ID_3WARE_9550SX
,
2304 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2305 { PCI_VENDOR_ID_3WARE
, PCI_DEVICE_ID_3WARE_9650SE
,
2306 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2307 { PCI_VENDOR_ID_3WARE
, PCI_DEVICE_ID_3WARE_9690SA
,
2308 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
2311 MODULE_DEVICE_TABLE(pci
, twa_pci_tbl
);
2313 /* pci_driver initializer */
2314 static struct pci_driver twa_driver
= {
2316 .id_table
= twa_pci_tbl
,
2318 .remove
= twa_remove
,
2320 .suspend
= twa_suspend
,
2321 .resume
= twa_resume
,
2323 .shutdown
= twa_shutdown
2326 /* This function is called on driver initialization */
2327 static int __init
twa_init(void)
2329 printk(KERN_WARNING
"3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION
);
2331 return pci_register_driver(&twa_driver
);
2332 } /* End twa_init() */
2334 /* This function is called on driver exit */
2335 static void __exit
twa_exit(void)
2337 pci_unregister_driver(&twa_driver
);
2338 } /* End twa_exit() */
2340 module_init(twa_init
);
2341 module_exit(twa_exit
);